Number sense training: numerical sense, relational reasoning, active numerical manipulation and semantic conclusion synthesis.
Eucalculia trains numerical cognition through two currently active modes: Numerical Sense and Relational Reasoning. Numerical Sense trains rapid recognition of numerical value across visual and symbolic representations. It includes true subitizing, but also structured value recognition in formats such as abaci, coins, Roman numerals, clocks and digits. Relational Reasoning trains the ability to encode values, retain them briefly, evaluate relations between them, compute derived values, and compare or synthesize conclusions across multiple episodes.
The current v6 architecture is deliberately narrower than older multi-mode versions: it keeps Mode A and Mode D because they are the two most coherent strands of the program. Mode A targets fast value recognition across perceptual, structured and symbolic number formats. Mode D implements a Posner-style delayed-question paradigm and adds hierarchical relational integration: L0, L1, L2 and L3. In the current build, Relational Reasoning defaults to Auto integration: the app introduces L1, L2 and L3 according to performance, with low-frequency preview probes before full activation.
Auto is the recommended setting for Relational Reasoning. In Auto, the user does not manually decide whether the block should reach L1, L2 or L3. The app starts from L0 and unlocks higher integration layers from recent performance. The value range in Relational Reasoning still stops at 10 per side; later Mode-D levels are used as curriculum steps for harder relation families, Boolean/conditional prompts and compound synthesis checks.
Each meta level has three possible states:
Auto state is intentionally not advertised during play. The HUD keeps only the basic mode/level label, while the Training Log gives the detailed status for L1, L2 and L3, including the reason for each state. When a new Auto layer first becomes available, the app opens a fresh memory window silently: it does not immediately ask a question based on episodes shown before the transition.
Manual L0/L1/L2/L3 settings remain available for targeted practice, debugging or deliberate isolation of one layer. Manual mode applies the chosen ceiling directly and does not use Preview gating.
Response time is measured in milliseconds with performance.now(). Numerical Sense accepts answers only after the stimulus and mask have finished. Relational L0 also accepts answers only after the two represented values and the mask have finished; at that moment the delayed question, answer controls and RT start together. For L1, L2 and L3, RT starts as soon as the question and answer controls appear. Reading and comprehension are therefore part of the measured relational task.
Do not treat every slow answer as failure. At L1–L3, slower correct answers can still be useful because the task involves retention, computation and language. The adaptive system uses both accuracy and speed, but accuracy remains the first requirement.
ET means exposure time: how long the stimulus remains visible. Earlier versions measured this in display frames, which produced different durations on 60 Hz, 90 Hz and 120 Hz screens. v6 measures prep, flash, mask and review phases in wall-clock milliseconds.
Prep: a short preparation phase before the stimulus. Flash: the visual stimulus is shown. Mask: a brief procedural noise mask interrupts visual persistence so the user cannot rely on afterimages. Input: the app accepts a response. Review: after errors, the app shows corrective feedback.
During Input, a very subtle blue halo and bottom line mark that responses are currently accepted. This cue is intentionally peripheral and non-green, so it signals readiness without being confused with correct-answer feedback. The adaptive training focus is deliberately not shown during active trials, because semantic labels such as equality, comparison or threshold relations can bias encoding in a delayed-question task.
In Relational Reasoning, a memory cue appears only when a later meta-question has already been probabilistically scheduled. On mobile, the cue is centered near the top of the frame rather than compressed into the corner, so it is visible without covering either stimulus. When a new MEM state appears or advances, the cue gives a brief visual ping and then remains still. It uses the target level and chain position: 🧠¹ MEM 1/2 for a pair feeding META, 🧠² MEM 1/2 for a META result feeding META², and 🧠³ MEM 1/2 for a META² question feeding META³. If a marked prerequisite is answered incorrectly, the review does not cancel the chain; it shows a compact semantic repair card with the corrected unit to retain. If the nominal block limit is reached while a MEM chain is active or due, the block enters a short drain phase and continues until the promised META / META² / META³ question has been answered.
The mask is not part of the answer. It is a visual interruption. It is generated dynamically with fine-grain noise so it is less blocky and less unpleasant than earlier masks while still preventing the stimulus from lingering visually.
Every stimulus represents a number. The core rule is: answer or reason about the quantity represented, not about whether the pictures look identical, unless the question explicitly asks about format or representation.
Discrete dots arranged as an ungrouped quantity field. Use this representation for direct numerosity recognition: the answer is the total number of visible dots.
Dots separated into compact, color-coded chunks. The chunks are there to support groupitizing: perceiving a total through subgroups in the subitizing range (typically 2–4 dots per group, 2–4 groups). Subgroup color is now stable across stimuli: 1 = light gray, 2 = green, 3 = purple, 4 = yellow and 5 = blue. When all groups have the same size — for example 3+3+3 or 4+4+4 — they share both color and shape, so the total can be read off as a multiplication (3×3, 3×4) rather than a sum. When groups differ in size, colors and shapes diverge so the additive structure (4+3+2) stays visible. The whole cluster may still rotate, because orientation variation helps transfer without changing the meaning of color. The answer is always the total number of dots, not the number of clusters.
A ten-frame, twenty-frame or thirty-frame layout. Filled cells represent the quantity. The fill pattern is no longer always left-to-right: it varies among stable, canonical, symmetric and complement-to-10 arrangements while keeping the same visual frame. Useful for seeing numbers as structured parts of 5, 10 and 20.
Standard pip patterns. These support rapid recognition through familiar spatial configurations.
Two grouped halves. Read the total across both halves unless a relational question asks you to compare two separate displayed quantities.
Vertical marks grouped in fives. Four vertical strokes plus a diagonal stroke represent five.
Raised fingers represent the quantity. One hand usually covers 1–5; two hands can represent larger values.
A simplified positional representation. Pink/red beads on the upper rod = 5; green beads on the lower rod = 1. Combine them to obtain the displayed value: for example, two upper beads and three lower beads represent 10+3 = 13.
Playing-card style pips. Interpret the total number of pips, not the card suit.
Isometric blocks arranged in a spatial layout. The target is the count of cubes, even when perspective makes the display less flat.
Coins use visual differences to encode value classes. Copper = 1, silver = 2, and gold = 5. Silver and gold coins have a reeded rim, and denomination also receives a mild non-numeric size cue: copper is slightly smaller, gold slightly larger. Gold adds a single inner ring. Denominations are not printed as numbers; infer the values from color, rim and size coding and add them. For example, one gold, one silver and two copper coins represent 5+2+1+1 = 9.
Roman notation such as I, IV, V, IX and X. These are symbolic rather than pictorial, but useful for transfer to real-world notations.
A clock face or hour-hand style display. Read the indicated hour/number.
Canonical and near-rectangular cell arrangements that support subitizing, factor, area and multiplication intuitions. Filled cells are no longer always added in row-by-row order; the value is the number of filled cells or units.
Arabic numerals. This option removes visual quantity decoding and lets the user focus on relational logic or symbolic magnitude.
Mode A shows a single represented numerical value. Type the number it encodes. The ideal strategy is to recognize value from structure, pattern or notation, not count item by item. With dots, dice or ten-frames this often means subitizing or groupitizing; with abaci, coins, clocks, Roman numerals or digits it means fast value recognition from a learned numerical code.
L0 is the base Posner-style task. Two quantities flash side by side. The question is hidden during the flash, then appears after the mask. Because the question is delayed, you must encode both quantities abstractly before knowing which relation will be tested. Each side is capped at 10 in Relational Reasoning, so the task remains a two-sided relational encoding problem rather than a high-numerosity visual-counting problem.
Examples: “Are the two numbers the same?”, “Is the left number greater than the right number?”, “Are both numbers both even or both odd?”, “Do the two numbers add up to more than 10?”, “Is the larger number even?”, “Is the difference between the two numbers prime?”, “Can one number be divided exactly by the other?”. The current build includes explicit value-format relations (“same value, different format?”), quantifiers (“exactly one value is prime?”), range-half membership, one-step counterfactuals, proportional checks, dynamic-center distance relations and compact compound frame checks. This build also adds advanced transformation checks such as “if the smaller number increased by 2...”, structural-divisibility checks such as “do the two numbers share a divisor other than 1?”, and carefully limited compound-frame prompts that combine comparison with parity, gap or multiplicative conditions. Answer YES or NO.
L0 categories are not all equally likely from the beginning. The app uses soft relational frontiers: direct comparisons appear first, then joint numerical properties, explicit set-membership questions, role/property binding, metric and factor relations, and finally compound relations. User-facing wording avoids internal terms such as “case”, “in/out”, “NAND”, “NOR” or “vacuous truth”; those labels remain internal only. The current value range still matters, but recent accuracy, response time, relational-frame weaknesses and recent sampling concentration also shape which categories are emphasized.
L1 appears after two L0 trials. It asks for a numeric answer computed from the two retained pairs. You must use the values from both previous pairs, not just the last pair. Current L1 deliberately avoids pure property-count answers: properties, sets, intervals, transformations, proportions, remainders and virtual before/after trajectories are used to select or transform values before computing a non-negative integer.
Typical L1 operations include: sum of all four values; largest or smallest of all four; second-largest or second-smallest; sum of the larger value from each pair; sum of the smaller value from each pair; difference between pair totals; left-column and right-column totals; range across all four; side-transfer operations such as “use the side of pair 2 that matched a role in pair 1”; filters such as “add only values that appeared once”, “add the prime values” or “add the values inside the central interval”; quantified filters such as “add values satisfying at least one / both / exactly one / neither condition”; and high-ceiling two-step operations such as “choose the pair with the higher sum, then enter its value closest to 10” or “from the pair with exactly one prime value, write the only even value”. Pure property-count tasks are kept only as deprecated test objects and are no longer sampled in ordinary play. Properties and quantifiers now select values, select a pair, select a side, or define a role transfer; the final L1 answer remains a calculated non-negative integer.
All L1 answers are non-negative. Difference questions are framed as gaps or distances unless the wording explicitly defines an order. Type the numeric result on the numpad.
This build adds a contained ATOM-inspired layer inside Relational Reasoning. It does not use sensory magnitude cues such as real duration, physical size, brightness or sound volume. Instead, it treats the two retained L0 pairs as ordered episodes: pair 1 is the before state and pair 2 is the after state.
The new L1 trajectory operations use the same remembered numbers to ask about pair-to-pair change, movement toward an anchor and interval transfer. Examples include: “In pair 2, enter the value from the side that changed more since pair 1”, “In pair 2, enter the value from the side that moved closer to 10 the most”, and “In pair 2, enter the value that fell between the two values of pair 1.” These tasks are late-stage material because they require retaining left/right position, pair order and a derived magnitude relation at the same time.
L2 and L3 can now refer publicly to these operations as before/after trajectory, movement toward an anchor, or using one pair as an interval for the other. The labels are intentionally semantic and visible; hidden implementation tags are still not used as user-facing L3 content.
This build adds a contained P-FIT-inspired executive-control layer to Relational Reasoning. It does not add generic Stroop tasks, colors, sounds or arbitrary memory exercises. Instead, the app annotates existing numerical-relational trials by the kind of selection, inhibition and integration they require. These adaptations are silent during play: no executive diagnosis, adaptive weakness label or micro-repair target is shown in the game interface.
The tracked executive dimensions include rule switching, raw value versus transformed value, visual side versus abstract role, quantifier inhibition, set membership versus magnitude, anchor/distance versus size, source-rule identification and before/after reconfiguration. Four-option META² and META³ trials also record which plausible distractor type was selected, such as a primary-relation flip, a secondary-relation flip, a Boolean bucket flip, a conditional branch flip or a source-rule flip.
These data are used as training metadata, not as clinical diagnostics. If a user repeatedly struggles with one conflict type or integration bridge, adaptive sampling can gently increase related material while preserving the current L0→L1→L2→L3 architecture. The game interface remains quiet: no adaptive weakness, executive focus, integration-load label or micro-repair target is shown during play. Detailed figures are available only in the Training Log.
Relational Reasoning now treats set membership and quantifiers as explicit families. A value may be even, prime, composite, square, a power of 2, a multiple of 3, or inside the central interval. L0 may ask whether both values, at least one value, no value, exactly one value, or not both values satisfy a condition.
L1 does not ask for pure counts of properties. Properties and quantifiers are used to select values, select a pair, transfer a side, or compute a numeric result. For example, the task may ask for the sum of values satisfying at least one of two conditions, or the total of the pair that matches an if/else branch rule.
Boolean connectors: the app now uses a shared internal Boolean layer for AND, OR, XOR, NAND and NOR. In ordinary play these are rendered as natural-language prompts such as “at least one”, “exactly one”, “not both” or “both false”. Mixed Boolean L0 prompts combine two different predicates only when the wording remains short and legible.
Conditional branches: ordinary practice no longer relies on formal implication or vacuous truth. Conditional prompts are phrased as two-branch numeric rules: for example, “if the left number is even, the right must be greater than 5; otherwise, the right must be 5 or less.” The answer is correct only when the condition selected by the first branch matches the displayed number.
These Boolean and conditional prompts are deliberately late-stage material. Simple OR/AND combinations can appear before the most difficult connective cases; XOR, NAND, NOR and explicit if/else branch rules are held back until higher relational levels. They remain numerically grounded: each truth value is computed from parity, primality, size, gap or sum properties of the displayed numbers.
L2 appears after two L1 trials. Instead of typing a number, you select the only fully correct conclusion from four options. The options refer to the two L1 answers and sometimes to how those answers were obtained.
Pure answer relations ask whether answer 1 was greater than answer 2, whether both answers were equal, whether they had the same parity, or whether their combined total had a property. Threshold relations ask whether the answers were close enough, whether their sum exceeded a calibrated limit, whether both answers exceeded a calibrated limit, or whether both answers stayed at most at a calibrated limit. This build also adds explicit set-membership and quantifier classifications: for a chosen set or condition, the four options state whether both, only the first, only the second or neither META answer satisfied it. Advanced L2 can also ask for the actual branch outcome of an if/else rule or the actual case of a mixed Boolean connective such as AND, OR, XOR, NAND or NOR, but those cases are sampled only after simpler answer, threshold and membership relations have had room to stabilize.
More advanced L2 variants bind answer relations to the previous calculation type. v6.3.5 also adds structural multiplicative checks between the two META answers, such as coprimality, product divisibility and whether the smaller answer divides the combined total. It can also ask for the ordinal pattern of the four values that fed one previous META question: one pair inside the other, interleaved pairs, or one pair entirely lower than the other. For example, the correct conclusion may involve both the size of the answers and whether a prior calculation used a role-based operation, a threshold, a gap, a position rule, a side-transfer rule or a conditional rule. Distractors are not random: they are controlled flips of comparison, parity, threshold or calculation provenance.
L3 appears after two L2 trials. It presents four compact statements or rules about the two previous META² questions. Exactly one statement is correct.
Each retained META² question stores only public information: the corrected L2 conclusion, the difference between the two META answers, the visible kind of question, whether a number limit was used, whether the question referred to how the META answers were calculated, and the relevant public pattern: set membership, quantifier bucket, if/else branch case, virtual transformation, proportional relation, structural divisibility, ordinal pattern, modular class or interval membership. If you selected the wrong L2 option, L3 still uses the corrected L2 conclusion. The REVIEW screen gives that corrected conclusion so you can update memory before L3 appears.
L3 is therefore not a memory test of your own mistakes. It is a synthesis task over corrected semantic questions. During L3, the frame no longer shows an auxiliary summary strip of the previous META² questions; the user must rely on the memory chain and select among the four visible statements. Current templates use public labels such as “number limit”, “how the META answers were calculated”, “left/right position” and “difference between the two META answers”, while hidden implementation tags and opaque internal task-type comparisons are suppressed.
Auto uses the previous layer as evidence for the next layer. L1 depends on L0 readiness; L2 depends on L1 readiness; L3 depends on L2 readiness. The thresholds are intentionally a little earlier for Preview and still strict for Active, so progress feels continuous without making advanced prompts flood a block before the prerequisite layer is stable.
Preview states are intentionally conservative. They are not rewards and not diagnosis; they are adaptive probes. If the user performs well, the level can become Active. If performance is weak, the level remains rare while the app reinforces prerequisite layers. The current build uses gradual Auto decay: once META, META² or META³ has appeared, it can pass through reduced-presence retention and decaying Preview before locking again, so isolated errors or rolling-window noise do not make levels flicker.
Correct answers usually advance quickly. Errors enter REVIEW. The review screen shows the correct answer, or for four-option tasks, your selected option against the correct one. The current delays are intentionally generous: approximately 1.5 s for L0, 2.6 s for L1, 4.0 s for L2 and 5.0 s for L3. These delays are meant to keep corrective feedback readable, especially in relational and memory-repair reviews.
On small touch devices, you can now tap anywhere during REVIEW to continue early. This does not affect scoring; it only shortens the visible review time after you have seen enough.
Numerical Sense: the app adapts exposure time by value and representation. Fast correct responses shorten future exposure; errors increase it. Very fast responses (<300 ms) reduce exposure more than merely correct responses. For cell mastery, the strict baseline remains demanding, but a cell can earn limited extra tolerance from repeated fast evidence. Errors degrade this tolerance gradually. Global level-up is now separated from local representation frontiers: the range can open earlier, while weaker representations continue to train lower values and receive only probabilistic previews above their current frontier.
Relational mode: L0 uses a protected global exposure time rather than separate exposure times for each value. This avoids making the display too fast before new relational categories are learnable. Novel categories receive temporary exposure floors.
Auto integration: in Relational Reasoning, Auto computes a current ceiling from L0/L1/L2 readiness. Higher layers are not simply on or off: they can be Locked, Preview, Reduced or Active. Preview gives low-frequency probes just below the full unlock threshold. If a layer loses support after appearing, it now decays through reduced-presence retention and decaying Preview before locking.
Relational frontiers: L0 categories, L1 operations, L2 conclusion types and L3 synthesis dimensions are staged by difficulty. The highest internal stages now include two-step L1 rule composition, structural divisibility and four-value ordinal-pattern summaries. The system does not permanently exclude harder families, but it gives easier families more probability until the evidence supports the next stage.
Sampling balance: the generator balances YES and NO structurally. It first chooses the intended truth value, then builds a pair that satisfies it. Categories are filtered by value range, weighted by recent accuracy and speed, and softly adjusted by relational-frame weaknesses such as coordination, opposition, comparison, reversal, role-binding, conditionality, metric reasoning and threshold reasoning.
Anti-concentration safeguards: adaptive weights are compressed with a temperature transform and capped relative to the median weight so one category cannot become a probability black hole. A recent-window concentration monitor checks whether one family or category is dominating L0; if dominance is excessive, it now applies a temporary corrective bias against that family or category and reports the correction in the browser console.
At the end of a block, the summary shows accuracy, average RT, fast responses and best streak. It does not expose adaptive weakness labels or executive-control diagnostics.
Mode A summaries report visible progress even when no level-up occurs: strengthened cells, newly mastered cells and newly global-ready cells. Mode D summaries use a compact relational momentum card: relation types practiced, stable relation types, trained layers and the next Auto/tier target. Detailed adaptive focus, executive-control and integration-efficiency diagnostics are kept in the Training Log.
The final summary is not a diagnostic report. Detailed family, frame and layer breakdowns are kept in the Training Log so the block-complete screen stays readable.
The progress indicator is now a pre-block orientation cue. At the start of each block, before the first stimulus appears, it shows labelled progress toward the next range or relational tier without exposing the adaptive focus. During this readable intro, the game frame and three small lights move through a red/amber/green sequence, like a restrained F1-style start signal. Each color has a very short local sound cue when sound feedback is enabled. This tells the user to wait, register the upcoming block and prepare. Once the first trial begins, the progress bar disappears so it does not add visual or semantic noise during stimulus encoding.
Sound feedback is continuous and stratified. Correct responses receive a very short confirmation cue; fast responses receive a brighter cue; very short automatic responses receive a small mastery cue; errors receive a brief low cue. Larger achievements still have distinct sounds: level-ups, streak milestones, milestone unlocks and strong block completion. Auto integration transitions are silent. The pre-block red/amber/green semaphore also has three brief preparation cues. Transition cues are now lightly serialized, so clicking Continue before a new block cannot mask the red semaphore cue. Streak sounds are subtly graded by streak length: every five correct responses can add a capped higher harmonic, so longer streaks feel different without becoming intrusive.
Continue Training and Take a Break also use different short cues. Continue has a small celebratory lift; Take a Break uses a calmer disconnect sound. Pressing Escape during an active block now uses this same calmer break cue before opening the menu, so deliberate exits from play are sonically consistent. All sounds are generated locally through the Web Audio API; no external audio files are loaded.
Use Sound feedback in the menu to switch sounds on or off. The setting is saved with progress export/import. The block summary, collapsible Training Log, Progress History chart and Milestones panel use lightweight visual structure to make progress easier to read without turning the app into a diagnostic dashboard. The Training Log is hidden by default and can be opened when detailed adaptation information is useful. Qualitative end-of-block comments, milestone text, detailed next-range status and adaptive diagnostics are kept in the Training Log; the summary card itself stays focused on metrics, compact progress momentum and the dedicated milestone popup.
The menu now includes a collapsed Progress History panel. It stores only compact block summaries, not trial-by-trial data. The chart can show accuracy by block, average response time, and the reached value range in Numerical Sense or active/reached meta-level in Relational Reasoning. The panel now opens and closes with a short, non-intrusive animation so the menu feels less abrupt.
The RT view is mode-aware. In Numerical Sense it shows average block RT. In Relational Reasoning it can draw separate lines for L0, L1, L2 and L3 when those levels were present in saved blocks. The chart now includes restrained reference lines and can show the exact saved block under the pointer or touch position.
The menu also includes optional Milestones. They are checked only after a block ends and are stored in the local profile. They do not change scoring, level-up criteria, exposure time, sampling weights or Auto progression. They are displayed as a compact icon grid, with short-, medium- and long-term goals such as block volume, perfect blocks, long automatic-response totals, representation choices, range milestones and reaching Meta/Meta²/Meta³. Locked milestones show partial progress where it is meaningful, and the nearest targets are repeated at the top of the panel so it acts as a short- and medium-term target list rather than only as a trophy shelf. Newly unlocked milestones also appear as a dedicated popup in the block summary, then remain visible in the Milestones panel. Like Progress History, this panel opens and closes with a brief animation.
This appendix is closed by default because it is meant for audit, debugging and advanced users. The main guide above explains how to play; this section documents the core catalogue and operating parameters. v6.3.5.3 keeps the v6.3.5 relational catalogue and adds behavioural Frame correction plus audit-hardening fixes: ten-frame, twenty-frame and thirty-frame cells no longer fill only as a fixed row-by-row prefix, but use varied structured patterns while preserving the same visual design and rotation behaviour. The in-code catalogue is the authoritative source for the full expanded set.
| Representation | Allowed value range | Interpretation |
|---|---|---|
| dots | 1–20 | Ungrouped dot field. Answer the total dot count. |
| cluster | 1–15 | Separated color-coded chunks using varied 2–5 sized partitions where possible. Answer the total dot count, not the number of groups. |
| ten / frame | 1–30 | Ten-frame / twenty-frame / thirty-frame grid depending on value; filled cells use varied structured patterns rather than a fixed row-by-row prefix. |
| dice | 1–24 | Up to four dice; each die contributes 1–6 pips. |
| domino | 1–36 | Up to three dominoes; each half ranges 0–6. |
| tally | 1–20+ | Tally marks grouped by fives; no explicit upper filter in allowedReps. |
| finger | 1–10 | One or two hands; raised fingers encode the value. |
| abacus | 1–20+ | Upper pink/red beads = 5 each; lower green beads = 1 each; no explicit upper filter in allowedReps. |
| card | 1–39 | Up to three playing cards; A=1, J=11, Q=12, K=13. |
| cube | 1–20+ | Isometric cube array; no explicit upper filter in allowedReps. |
| coins | 1–20+ | Copper = 1, silver = 2, gold = 5; denominations encoded by color, mild size, reeded rim and gold inner ring. |
| roman | 1–20+ | Roman numerals; symbolic, not a pure visual quantity. |
| clock | 1–12 | Clock hand points to the value; numerals are not printed on the clock. |
| grid | 1–40 | Varied canonical or near-rectangular grid of filled cells; not a row-by-row fill. |
| digit | 1–20+ | Arabic numeral; use this to isolate relational logic from visual decoding. |
For representations without an explicit upper filter, the practical upper value is normally bounded by the current training level and by the global value ladder. Mode A can progress through 4, 5, 6, 7, 8, 9, 10, 12, 15, 18 and 20. Relational Reasoning caps each displayed side at 10, because two simultaneous values already create a natural combined range up to 20 before META operations add further load.
| Parameter | Value | Meaning |
|---|---|---|
| prepMs | 250 ms | Preparation phase before the stimulus. |
| maskMs | 150 ms | Procedural mask after the stimulus. |
| reviewMsByLevel[0] | 1500 ms | L0 / Numerical Sense review delay. |
| reviewMsByLevel[1] | 2600 ms | L1 review delay. |
| reviewMsByLevel[2] | 4000 ms | L2 review delay. |
| reviewMsByLevel[3] | 5000 ms | L3 review delay. |
| reviewSkipGuardMs | 100 ms | Minimum delay before touch/keyboard can close REVIEW early. |
| autoMs | 250 ms | Short automatic transition delay. |
| blockIntroMs | 1650 ms | Readable pre-block orientation phase before the first stimulus. The progress indicator and red/amber/green frame semaphore appear only during this phase; each color can trigger one short local audio cue when sound is enabled. Start cues are serialized behind transition sounds such as Continue so they remain audible. |
| metaUnlockNoticeMs | 1200 ms | Legacy timing value retained for compatibility. Auto META / META² / META³ transitions are now silent during play. A new Auto layer still opens a fresh memory window, so the first question at that layer uses newly encoded prerequisite items rather than material shown before the transition. |
| metaUnlockSummaryMs | 1400 ms | Summary delay when a block ends immediately after a level or Auto meta transition, so the transition remains readable. |
| relational input onset | Immediate after mask for L0; immediate on question render for L1–L3 | No unscored reading phase. The question, answer controls and RT start together. Input remains blocked during PREP, FLASH and MASK. |
| memory cue | 🧠¹/²/³ MEM 1/2 → 2/2 | Memory cue shown only after the app has already scheduled a future meta question. On mobile it is centered near the top of the frame; on larger screens it remains compact. It gives one brief onset ping when the retained item changes, then stays still. The superscript marks the target meta layer and the fraction marks progress through the memory chain. Marked errors produce a semantic repair card rather than cancelling the chain. |
| startETByMode.A | 750 ms | Initial exposure time in Numerical Sense. |
| startETByMode.D | 1330 ms | Initial exposure time in Relational Reasoning. |
| minETByMode.A | 70 ms | Exposure floor for Numerical Sense. |
| minETByMode.D | 600 ms | Protected exposure floor for L0 relational encoding. |
| speedStepByMode.A | 34 ms | Exposure reduction after strong Numerical Sense performance; this is just above two 60 Hz frames. |
| Numerical Sense mastery threshold | Adaptive: base minET + 2 speed steps = 138 ms; max functional tolerance minET + 6 speed steps = 274 ms | A value×representation cell counts as mastered if its ET reaches the strict base threshold, or if repeated fast evidence earns limited extra tolerance. Slow correct answers add a small amount of confidence; errors reduce it gradually. |
| Numerical Sense level-up rule | Dynamic: ≥45% first tier / ≥60% early / ≥75% middle / ≥85% late globally-ready active cells + every active value covered + current top value ready in a small core of 2–3 representations | Unlocks the next value tier as a motivational global range increase. Local per-representation frontiers still decide which formats may show the new value normally; lagging formats continue lower values and receive only staged previews. |
| speedStepByMode.D | 17 ms | Slower exposure reduction for relational mode. |
| penalty | 170 ms (damped by cell evidence) | Exposure increase after errors. In Mode A, cells with high accumulated score receive up to 40% damping so a single error on a near-mastered cell does not erase several blocks of progress. |
| dNovelCatETFloors | 930 ms first 4 trials; 770 ms first 8 trials | Temporary exposure floor for newly introduced L0 categories. |
| RT targets | 300 / 600 / 900 / 1800 / 3800 / 6500 / 9000 ms | Numerical Sense automatic, Numerical Sense fast, fast L0, good L0, good L1, good L2, good L3. |
| Control / state | Meaning |
|---|---|
| Numpad / digits | Number entry for Numerical Sense and L1. The on-screen 0 key is hidden in early Numerical Sense ranges and restored when the active range or task can require it. |
| YES / NO | Touch buttons, Y/N keys, or left/right arrows for L0. |
| 1–4 | Four-option tasks show all answers in the frame. Use touch buttons 1–4 or number keys 1–4; A–D remain aliases for compatibility. |
| Escape | Pause during gameplay with the Take-a-Break cue; closes the guide first if the guide is open; from the block summary, triggers Take a Break. |
| Tap during REVIEW | Skips the remaining review delay without changing scoring. |
| Start Block / Space | Applies menu changes and starts a new block. Space works from the menu when the guide is closed. |
| Block Size Auto | Recommended for Relational Reasoning. Uses 20 trials by default and 30 when Meta³ is active or in preview, so upper meta levels are not accidentally blocked by 10-trial blocks. If the nominal limit is reached while a MEM chain is active or due, the block drains that pending chain before showing the summary. |
| Resume Block | Continues the paused block without applying menu changes. |
| Reset All | Removes local saved state, including adaptive progress, progress history and milestones, and reloads the app. |
| Training Log | Collapsed detailed menu log with current settings, recent performance, adaptive status, pending cells/categories, historical/milestone counts and the last block note. Qualitative comments are kept here instead of occupying the block-complete report. |
| Progress History | Collapsed menu chart showing saved block summaries for accuracy, RT and level/range. It opens/closes with a brief animation and is informational only. |
| Milestones | Collapsed menu collection of optional achievement markers. Newly unlocked milestones also appear as a block-summary popup. The panel never affects progression or trial selection. |
| Meta sequence | Trigger | Meaning |
|---|---|---|
| L0 | Every base relational trial | Two quantities flash; a delayed relation is answered YES/NO. |
| L1 | After 2 L0 trials | Combines both retained L0 pairs into a numeric answer. |
| L2 | After 2 L1 trials | Selects the only valid semantic conclusion about the two L1 answers. |
| L3 | After 2 L2 trials | Synthesizes two previous META² questions. |
| Full Meta³ cycle | 15 trials | L0, L0, L1 repeated twice → L2; repeated twice → L3. A nominal block can extend beyond its selected size only to discharge already-marked memory chains. |
Each category has several wording variants. The table lists the internal ID, the first canonical wording, its unlock tier and its functional family.
| Tier | ID | Canonical prompt | Family | RFT tags |
|---|---|---|---|---|
| 1 | identical | Same number? | direct | coordination |
| 1 | left_gt | Is the left number greater than the right number? | direct | comparison, reversal |
| 1 | diff_one | Are the two numbers exactly 1 apart? | direct | comparison, metric_relation |
| 1 | same_rep | Same format? | direct | coordination, source_relation |
| 2 | same_parity | Are both numbers both even or both odd? | joint | coordination, opposition |
| 2 | both_gt_5 | Are both numbers greater than 5? | joint | comparison, threshold_relation |
| 2 | both_small | Are both numbers 4 or less? | joint | comparison, threshold_relation |
| 2 | sum_gt_10 | Do the two numbers add up to more than 10? | joint | comparison, threshold_relation |
| 2 | sum_eq_10 | Do the two numbers add up to exactly 10? | joint | coordination, metric_relation |
| 3 | diff_gt_3 | Is the difference between the numbers greater than 3? | joint | comparison, threshold_relation, metric_relation |
| 3 | sum_even | Sum is even? | joint | metric_relation |
| 3 | left_double | Is the left number exactly twice the right number? | role | comparison, reversal |
| 3 | both_prime | Both prime? | joint | coordination, metric_relation |
| 3 | product_gt_20 | Do the two numbers multiply to more than 20? | joint | comparison, threshold_relation |
| 3 | diff_even | Is the difference between the two numbers even? | joint | metric_relation |
| 3 | both_mult3 | Both multiples of 3? | joint | coordination, metric_relation |
| 2 | larger_even | Larger value is even? | role | role_binding, metric_relation |
| 2 | smaller_odd | Smaller value is odd? | role | role_binding, metric_relation |
| 2 | diff_two | Differ by 2? | role | coordination, metric_relation |
| 2 | gap_prime | Is the difference between the two numbers prime? | role | metric_relation |
| 2 | smaller_divides_larger | Can the larger number be divided exactly by the smaller number? | role | role_binding, metric_relation |
| 2 | larger_square | Is the larger number a square number? | role | role_binding, metric_relation |
| 2 | left_closer_5 | Is the left number closer to 5 than the right number? | role | comparison, reversal, metric_relation |
| 3 | larger_closer_10 | Is the larger number closer to 10 than the smaller number? | role | role_binding, metric_relation |
| 3 | smaller_closer_10 | Is the smaller number closer to 10 than the larger number? | role | role_binding, metric_relation |
| 4 | gap_equals_smaller | Is the difference equal to the smaller number? | role | role_binding, metric_relation |
| 3 | larger_one_more_double_smaller | Is the larger number one more than twice the smaller number? | role | role_binding, comparison, metric_relation |
| 3 | closer10_even | Is the number closer to 10 even? | role | role_binding, metric_relation |
| 3 | larger_prime_smaller_even | Is the larger number prime and the smaller number even? | role | role_binding, metric_relation |
| 3 | one_divides | Can one number be divided exactly by the other? | role | metric_relation |
| 3 | left_divides_right | Can the right number be divided exactly by the left number? | role | comparison, reversal, metric_relation |
| 4 | sum_prime | Do the two numbers add up to a prime number? | joint | metric_relation |
| 4 | xor_even | Exactly one even? | joint | opposition, metric_relation |
| 4 | diff_gt_half | Is the difference greater than half of the larger number? | role | comparison, threshold_relation, metric_relation |
| 4 | both_square | Both perfect squares? | joint | coordination, metric_relation |
| 4 | left_triple | Is the left number at least three times the right number? | role | comparison, reversal, threshold_relation |
| 4 | smaller_plus2_reaches_larger | If the smaller number increased by 2, would it reach or pass the larger number? | role | counterfactual_relation, transformation_relation, role_binding, comparison, threshold_relation |
| 4 | double_smaller_gt_larger | If the smaller number were doubled, would it be greater than the larger number? | role | counterfactual_relation, transformation_relation, role_binding, comparison, proportional_relation |
| 4 | larger_minus1_still_gt | If the larger number went down by 1, would it still be greater? | role | counterfactual_relation, transformation_relation, role_binding, comparison |
| 4 | left_gt_and_both_even | Is the left number greater, and are both numbers even? | compound | comparison, coordination, metric_relation, quantifier_relation |
| 4 | larger_even_and_gap_gt2 | Is the larger number even AND is the gap more than 2? | compound | role_binding, comparison, metric_relation, threshold_relation, coordination |
| 4 | bool_left_prime_or_right_gt5 | Is the left number prime OR is the right number greater than 5? | boolean | boolean_relation, quantifier_relation, metric_relation, threshold_relation |
| 4 | bool_left_even_xor_right_gt5 | Is exactly one true: left number even, or right number greater than 5? | boolean | boolean_relation, opposition, quantifier_relation, metric_relation, threshold_relation |
| 4 | bool_left_even_nand_right_gt5 | Are they NOT both true: left number even and right number greater than 5? | boolean | boolean_relation, opposition, quantifier_relation, metric_relation, threshold_relation |
| 4 | bool_left_prime_nor_right_odd | Are neither true: left number prime nor right number odd? | boolean | boolean_relation, opposition, quantifier_relation, metric_relation |
| 4 | bool_larger_even_or_gap_gt2 | Is the larger value even OR is the gap more than 2? | boolean | boolean_relation, role_binding, metric_relation, threshold_relation |
| 4 | bool_larger_even_xor_gap_gt2 | Is exactly one true: larger value even, or gap more than 2? | boolean | boolean_relation, opposition, role_binding, metric_relation, threshold_relation |
| 4 | bool_left_gt_and_sum_gt10 | Is the left number greater AND is the sum greater than 10? | boolean | boolean_relation, coordination, comparison, threshold_relation, metric_relation |
L1 appears after two L0 trials and computes one numeric answer from the four retained values. The minLevel column is the current value-level gate used by the generator.
| ID | Family | minLevel | Canonical prompt |
|---|---|---|---|
| sum_all | sum4 | 0 | Sum of all four values? |
| max_all | global_extreme | 0 | Largest of all four values? |
| min_all | global_extreme | 0 | Smallest of all four values? |
| sum_maxima | role_sum | 0 | Add the larger of each pair? |
| sum_minima | role_sum | 0 | Add the smaller of each pair? |
| sum_diff | directional_diff | 0 | Difference between the two pair totals? |
| max_diff | directional_diff | 0 | Gap between the two pair maxima? |
| min_diff | directional_diff | 0 | Gap between the two pair minima? |
| same_side_as_p1_max | role_transfer | 3 | Which value in pair 2 was on the same side as pair 1's larger value? |
| same_side_as_p1_min | role_transfer | 3 | Which value in pair 2 was on the same side as pair 1's smaller value? |
| opposite_side_from_p1_min | role_transfer | 3 | Which value in pair 2 was on the opposite side from pair 1's smaller value? |
| same_side_as_p1_even | property_position_transfer | 3 | Which value in pair 2 was on the same side as pair 1's even value? |
| opposite_side_from_p1_even | property_position_transfer | 3 | Which value in pair 2 was on the opposite side from pair 1's even value? |
| same_side_as_p1_closer10 | anchor_role_transfer | 4 | Which value in pair 2 was on the same side as pair 1's value closer to 10? |
| same_side_as_p1_closer_center | anchor_role_transfer | 4 | Which value in pair 2 was on the same side as pair 1's value closer to the current range center? |
| opposite_side_from_p1_closer_center | anchor_role_transfer | 4 | Which value in pair 2 was on the opposite side from pair 1's value closer to the current range center? |
| min1_plus_max2 | cross_role | 1 | Smaller of pair 1 plus larger of pair 2? |
| max1_plus_min2 | cross_role | 1 | Larger of pair 1 plus smaller of pair 2? |
| cross_role_gap_1 | cross_role_gap | 2 | Difference between pair 1's smaller value and pair 2's larger value? |
| cross_role_gap_2 | cross_role_gap | 2 | Difference between pair 1's larger value and pair 2's smaller value? |
| gap_sum | gap | 1 | Add the two within-pair differences? |
| gap_diff | gap_diff | 1 | Difference between the two within-pair differences? |
| max_gap | gap | 2 | Larger of the two within-pair differences? |
| min_gap | gap | 2 | Smaller of the two within-pair differences? |
| left_total | position | 1 | Add the two left-side values? |
| right_total | position | 1 | Add the two right-side values? |
| side_total_diff | position | 2 | Difference between left-side and right-side totals? |
| left_values_gap | position_gap | 2 | Difference between the two left-side values? |
| right_values_gap | position_gap | 2 | Difference between the two right-side values? |
| range_all | global_order | 1 | Largest minus smallest across all four? |
| extremes_sum | global_order | 2 | Largest plus smallest across all four? |
| middle_sum | global_order | 2 | Add the two middle values? |
| middle_gap | global_order | 3 | Difference between the two middle values? |
| minima_distance_10 | base10 | 2 | How far is the sum of the two smaller values from 10? |
| maxima_distance_10 | base10 | 2 | How far is the sum of the two larger values from 10? |
| left_total_distance_10 | base10_position | 3 | How far is the left-side total from 10? |
| right_total_distance_10 | base10_position | 3 | How far is the right-side total from 10? |
| min_from_higher_total | conditional | 3 | Smaller value from the higher-total pair? (tie: pair 1) |
| max_from_lower_total | conditional | 3 | Larger value from the lower-total pair? (tie: pair 1) |
| gap_from_higher_total | conditional | 3 | Gap from the higher-total pair? (tie: pair 1) |
| total_from_closer_pair | conditional | 4 | Total of the closer-together pair? (tie: pair 1) |
| max_from_wider_gap | conditional | 4 | Larger value from the wider-gap pair? (tie: pair 1) |
| sum_unique_only | property_filter | 4 | Add only the values that appeared once. |
| sum_repeated_values | property_filter_compute | 3 | Add the values that appeared more than once. |
| sum_primes | property_filter | 3 | Add the prime values. |
| sum_even_values | property_filter | 3 | Add the even values. |
| sum_prime_or_gt5_values | property_filter_compute | 3 | Add the values that are prime, greater than 5, or both. |
| sum_multiples_3 | property_filter_compute | 3 | Add the values that are multiples of 3. |
| sum_power2_values | property_filter_compute | 4 | Add the values that are powers of 2. |
| sum_composite_values | property_filter_compute | 4 | Add the composite values. |
| sum_triangular_values | property_filter_compute | 4 | Add the triangular-number values. |
| sum_inside_center_interval | property_filter_compute | 4 | Add the values inside the central interval. |
| sum_non_extreme_values | global_order | 4 | Add the values that were neither the smallest nor the largest. |
| total_from_pair_with_same_parity | property_selected_pair | 4 | Enter the total of the pair whose two values had the same parity. |
| same_side_as_p1_unique_prime | set_role_transfer | 4 | Use the side of the unique prime in pair 1 to select a value from pair 2. |
| double_min_higher_total | composition | 4 | Double the smaller value from the higher-total pair. (tie: pair 1) |
| gap1_plus_min2 | composition | 4 | Pair 1 gap plus pair 2's smaller value? |
| gap2_plus_min1 | composition | 4 | Pair 2 gap plus pair 1's smaller value? |
| side_changed_more_value_p2 | temporal_change | 4 | In pair 2, enter the value from the side that changed more since pair 1. |
| side_approached_10_more_value_p2 | approach_anchor | 4 | In pair 2, enter the value from the side that moved closer to 10 the most. |
| side_approached_center_more_value_p2 | approach_anchor | 4 | In pair 2, enter the value from the side that moved closer to the range center the most. |
| p2_value_inside_p1_interval | between_interval_transfer | 4 | In pair 2, enter the value that fell between the two values of pair 1. |
L2 compares two previous L1 answers. Pure categories use direct logical predicates; threshold categories compute a calibrated threshold before rendering the question.
| ID | Family | minLevel | Kind | Canonical prompt |
|---|---|---|---|---|
| l2_gt | answer | 0 | pure | Was the first result greater than the second result? |
| l2_eq | answer | 0 | pure | Were the two results equal? |
| l2_parity | answer | 0 | pure | Were both results the same type: both even or both odd? |
| l2_sum_even | answer | 1 | pure | Do the two results add up to an even number? |
| l2_close | threshold | 0 | threshold | Are the two results at most {N} apart? |
| l2_sum_gt | threshold | 1 | threshold | Do the two results add up to more than {N}? |
| l2_both_large | threshold | 1 | threshold | Are both results greater than {N}? |
| l2_gap_even | metric | 1 | pure | Is the difference between the two results even? |
| l2_gap_prime | metric | 2 | pure | Is the difference between the two results prime? |
| l2_larger_double | metric | 2 | pure | Is the larger result at least twice the smaller result? |
| l2_strict_factor | metric | 2 | pure | Can the larger result be divided exactly by the smaller result? |
| l2_same_distance_10 | metric | 2 | pure | Are both results equally far from 10? |
| l2_closer_10 | metric | 3 | pure | Is the first result closer to 10 than the second result? |
| l2_same_op_group | source | 3 | pure | Were the last two META questions the same kind of task? |
| l2_same_gap_dependency | source | 3 | pure | Did both last META questions use a difference within a pair? |
| l2_same_position_dependency | source | 3 | pure | Did both last META questions use left/right position? |
| l2_gap_rule_larger | source | 4 | pure | Did the calculation using a difference within a pair produce the larger answer? |
| l2_position_rule_larger | source | 4 | pure | Did the left/right-position task produce the larger result? |
| l2_same_transfer_dependency | source | 4 | pure | Did both previous META questions use pair 1 to choose a side in pair 2? |
| l2_transfer_task_larger | source | 4 | pure | Did the side-transfer META question produce the larger answer? |
| l2_bool_first_even_and_second_gt10 | boolean | 5 | pure | For the AND statement “the first result was even / the second result was greater than 10”, choose the actual case. |
| l2_bool_first_prime_or_second_odd | boolean | 5 | pure | For the OR statement “the first result was prime / the second result was odd”, choose the actual case. |
| l2_bool_first_multiple3_xor_second_composite | boolean | 5 | pure | For the EXACTLY-ONE statement “the first result was a multiple of 3 / the second result was composite”, choose the actual case. |
| l2_bool_first_even_nand_second_gt10 | boolean | 5 | pure | For the NOT-BOTH statement “the first result was even / the second result was greater than 10”, choose the actual case. |
| l2_bool_first_prime_nor_second_odd | boolean | 5 | pure | For the NEITHER statement “the first result was prime / the second result was odd”, choose the actual case. |
| l2_same_trajectory_dependency | source | 4 | pure | Did both META questions match on before/after change use? |
| l2_trajectory_task_larger | source | 4 | pure | Did the before/after trajectory META question produce the larger answer? |
| l2_same_approach_anchor_dependency | source | 4 | pure | Did both META questions match on movement-toward-anchor use? |
| l2_interval_transfer_task_larger | source | 4 | pure | Did the META question using pair 1 as an interval produce the larger answer? |
L3 is generated dynamically from two prior META² questions. It does not use a fixed question bank; it builds four-option summaries from the features below and then inserts controlled distractors.
| Family | Feature ID / pattern | Meaning |
|---|---|---|
| question fact | same_winner | Whether the larger META answer appeared in the same position in both META² questions. |
| question fact | same_gap_parity | Whether the two answer differences had the same even/odd type. |
| question fact | episode1_larger_gap | Whether the first META² question had the larger answer difference. |
| structure | same_family | Whether both META² questions asked the same kind of visible question. |
| structure | same_threshold_use | Whether both matched in number-limit use. |
| structure | same_source_use | Whether both matched in asking how the META answers were calculated. |
| bound synthesis | family_gap_bind | Binds visible question kind to larger/smaller answer difference. |
| bound synthesis | threshold_gap_bind | Binds number-limit use to larger/smaller answer difference. |
| bound synthesis | source_gap_bind | Binds calculation-source use to larger/smaller answer difference. |
| bound synthesis | relation_gap_bind | Binds what the META² question was about to larger/smaller answer difference. |
| Tag | Meaning |
|---|---|
| coordination | same/equal/matching relations. |
| opposition | not/different/exactly-one relations. |
| comparison | greater/less/larger/smaller relations. |
| reversal | same relation expressed from the opposite side. |
| role_binding | relations bound to larger, smaller, closer or selected values. |
| conditional | choose a pair by one rule, then compute another property. |
| source_relation | relations involving representation, calculation type or provenance. |
| metric_relation | difference, distance, even/odd, prime/square/divisibility properties. |
| threshold_relation | relations involving number limits such as >N or ≤N. |
| sequence_relation | pair-to-pair change relations, such as how a side, anchor-distance or interval relation changed from pair 1 to pair 2. |
These tags are training metadata. Recent errors and slow correct answers can increase the sampling weight of categories carrying the weaker tags. v6.3.5.3 also derives executive-control tags from these frames: rule_switch, inhibition, raw_vs_transformed, side_role_conflict, quantifier_conflict, anchor_size_conflict, set_vs_magnitude, source_readout, temporal_reconfiguration, rule_identification and dual_binding. Structural-divisibility and ordinal-pattern tasks are treated as high-load set/magnitude or source-structure conflicts rather than as clinical diagnostics. The app stores accuracy and RT by executive tag, conflict type, readout type, selected distractor type, integration load, plan step and bridge between steps. These diagnostics are reported only in the Training Log.
| Layer | Active condition | Preview condition | Presence in Auto |
|---|---|---|---|
| L1 / META | Recent L0: ≥24 trials, ≥84% accuracy, RT ≤1900 ms, ≥2 families. | Recent L0: ≥18 trials, ≥76% accuracy, RT ≤1.28×L0 target, ≥2 families. | Preview ≈14%; Active ranges from reduced presence to full presence depending on L0 stability. |
| L2 / META² | L1: ≥10 trials, ≥80% accuracy, RT ≤4300 ms, ≥3 operation families. | L1: ≥6 trials, ≥70% accuracy, RT ≤1.32×L1 target. | Preview ≈9%; Active is dosed down if L1 is not strongly stable. |
| L3 / META³ | L2: ≥6 trials, ≥76% accuracy, RT ≤7200 ms, ≥2 families. | L2: ≥4 trials, ≥66% accuracy, RT ≤1.35×L2 target, ≥2 families. | Preview ≈6%; Active remains lower-density than L1/L2 because full Meta³ cycles are long. |
The precise numbers are training heuristics, not diagnostic thresholds. They exist to regulate progression and prevent both premature overload and indefinite L0 purgatory.
| Area | Stored / affected fields | Meaning |
|---|---|---|
| localStorage key | eucalculia_v6_2_27 | Current browser storage key, retained for compatibility. Current saved payload uses schemaVersion 19. |
| Saved configuration | mode, reps, metaLevel, metaAuto, autoMetaStable, blockSize, blockSizeAuto | Restores the active setup. In Relational Reasoning, metaAuto stores whether the integration ceiling is automatic or manually capped; autoMetaStable keeps the gradual-decay buffer for Auto levels; blockSizeAuto stores the mode-aware block-size setting. |
| Saved progression | levelByMode, etByMode, etByModeAndValue | Keeps adaptive levels and exposure times. |
| Saved performance | stats, statsByMode, posnerCatStats, frameStats, executiveStats, integrationStats, silent repair queue, meta stats | Preserves long-term adaptation and menu diagnostics. |
| Saved gamification layer | progressHistory, achievements | Stores compact block summaries for the menu chart and optional milestone unlocks. No trial-by-trial history is stored in this layer. |
| Capped dictionaries | confusion, problemValues | Pruned to prevent unbounded localStorage growth. |
| Reset behavior | disable persistence + removeItem + reload | Clears adaptive state, progress history and milestones, then restarts from defaults. Persistence is disabled before reload so beforeunload/visibilitychange cannot re-save the old in-memory state. |
Developed by Alberto Flaño Lombardo
linkedin.com/in/alberto-flaño-lombardo-762618259Based on research in numerical cognition, subitizing, Relational Frame Theory, the Posner paradigm, and Halford's relational complexity theory.