Add Deep Arithmark 1: 1,000 long-horizon arithmetic items, generator, scorer, design notes

DEEPARITHMARK_DESIGN.md

@@ -0,0 +1,421 @@
+# Deep Arithmark — design
+
+> **Unofficial.** Deep Arithmark is an independent companion tier, not an
+> AxiomicLabs release. It is not affiliated with, endorsed by, or published by
+> AxiomicLabs, the authors of [ArithMark 3.0](https://huggingface.co/datasets/AxiomicLabs/Arithmark-3.0),
+> and the name is used descriptively. Any errors here are the author's. See
+> §10 for what is and is not reused from the upstream benchmark.
+
+Deep Arithmark is the long-horizon tier *of* ArithMark 3.0: the same task
+contract, the same scoring protocol, and a much harder item. This document
+records what changed, why, and what the measurements actually say.
+
+* Dataset: [`deeparithmark-dataset/data/deeparithmark-1.jsonl`](deeparithmark-dataset/data/deeparithmark-1.jsonl)
+  (1,000 items, sha256 `8a54eb90b66b142b7fea422b34d851746d1cabc476dcba906c7f3ad5ddc66ee0`)
+* Generator / auditor: [`deeparithmark.py`](deeparithmark.py)
+* Scorer: [`bench_deeparithmark.py`](bench_deeparithmark.py)
+* Baselines: [`benchmarks/deeparithmark_4models.json`](benchmarks/deeparithmark_4models.json),
+  [`benchmarks/deeparithmark_2models.json`](benchmarks/deeparithmark_2models.json),
+  [`benchmarks/deeparithmark_1models.json`](benchmarks/deeparithmark_1models.json)
+
+---
+
+## 1. Why a "Deep" ArithMark
+
+ArithMark 3.0 is a clean benchmark: 1,000 continuation-style word problems,
+four endings, chance 25 %, graded by length-normalised continuation
+log-likelihood with no chain-of-thought and no instruction following. It also
+saturates at both ends for the models it is meant to rank.
+
+Two properties do that.
+
+**The options are adjacent integers.** Every item looks like
+
+```
+Sam had 43 rubber bands. A friend gave Sam 19 more. Afterward, Sam had
+   0 ' 63 rubber bands.'
+   1 ' 62 rubber bands.'   <- correct
+   2 ' 61 rubber bands.'
+   3 ' 60 rubber bands.'
+```
+
+The four continuations differ by ±1, so a model never has to compute `43 + 19`.
+It only has to land in the right neighbourhood, and digit priors from
+pretraining are enough. That is why pythia-70m scores 27.0 % — barely above
+chance on 62 — while a 0.5B model scores 60.9 %.
+
+**Every item is one or two dependent operations.** Nothing requires holding an
+intermediate result across more than one step.
+
+Measured on the same weights and protocol as this repo (see §6), **Qwen2.5-0.5B
+scores 60.9 % on ArithMark 3.0**. There is no headroom left in the sub-1B band.
+
+Deep Arithmark is the same instrument aimed one tier up. Borrowing the DeepSWE
+framing — original tasks, longer horizon per item, short prompts, graded by
+outcome rather than process — it keeps the 4-way continuation contract but
+requires a chain of arithmetic to answer.
+
+---
+
+## 2. The three changes
+
+### 2.1 Depth
+
+Every item needs **2–5 dependent operations**, with 250 items per depth tier. A
+later operation consumes the result of an earlier one, so no single memorised
+pattern gets you the ending.
+
+Depth is defined as **the number of operations in the reference solution**, and
+that reference solution is shipped in the item (`metadata.solution_steps`), so
+the claim is checkable rather than asserted. `selftest` fails the build if
+`len(solution_steps) != depth` for any item. Examples:
+
+| depth | item |
+|---:|---|
+| 2 | a percentage off a price, then a handling fee added |
+| 3 | convert metres+centimetres to cm, add the remainder, subtract a cut |
+| 4 | receive, ship out, remove damaged units, then divide into crates |
+| 5 | two percentage days on a shrinking base, then palletise |
+
+### 2.2 Decoys with provenance
+
+No decoy is "answer ± 1", and no decoy is a random plausible number. Every
+decoy is the exact value a *specific* plausible wrong reasoning produces:
+
+* the state after step 2 instead of step 5 ("stopped before palletising"),
+* the percentage applied to the wrong base ("taxed the price before the discount"),
+* the divisor `n` instead of `n + 1` ("split among one more person"),
+* the unit conversion left out ("used 10 cm to the metre"),
+* the boundary handled the wrong way (ceil instead of floor),
+* the operation run the wrong direction ("added the cut instead of removing it").
+
+To reject a wrong option you must know *which step* was botched. Ranking the
+options by size is no longer enough, which is exactly the ±1 shortcut removed.
+
+Every record carries the provenance per ending:
+
+```json
+"metadata": {
+  "answer": "324",
+  "depth": 4,
+  "option_values": [180, 324, 252, 216],
+  "option_sources": ["forgot the discount", "correct", "taxed before discount", "split among one more person"],
+  "answer_rank": 3,
+  "solution_steps": ["...", "...", "...", "..."]
+}
+```
+
+`option_sources` is aligned to `endings`, so an error analysis can ask *which
+mistake the model made*, not just whether it was wrong.
+
+### 2.3 Balancing on three axes
+
+A multiple-choice benchmark is only measuring arithmetic if the option set
+carries no cheaper signal. Three axes are balanced, all enforced by `selftest`:
+
+| Axis | What it prevents | Achieved (of 1,000) |
+|---|---|---|
+| Correct slot (`label`) | position priors | 248–252 per slot |
+| Numeric rank of the answer | "pick the largest / smallest / median" | 248–252 per rank |
+| Roundness class of all four options | digit-prior smoothing toward round numbers | 100 % same class |
+
+`label` × `rank` × `depth` is a 64-cell grid filled at **15–16 items per cell**,
+so the axes cannot drift apart.
+
+The roundness axis was not in the first draft, and finding it is the most useful
+thing this build produced — see §4.
+
+---
+
+## 3. Composition
+
+| Property | Value |
+|---|---|
+| Items | 1,000 |
+| Answer choices | 4 (chance 25 %) |
+| Templates | 15 |
+| Topic labels | 14 |
+| Depth tiers | 2, 3, 4, 5 — 250 each |
+| Mean prompt length | 29.2 words (max 43) |
+| Mean ending length | 9.7 characters |
+| Splits | `test` (single split; never train on it) |
+
+| Template | Depth | Items | What it exercises |
+|---|---:|---:|---|
+| `money_discount_fee` | 2 | 122 | percent off, then a fixed fee |
+| `time_clock_end` | 2 | 128 | clock time + duration, hour carry |
+| `measure_cm_cut` | 3 | 33 | unit conversion, then subtraction |
+| `share_then_split` | 3 | 44 | fraction removed, remainder divided |
+| `two_rate_pay` | 3 | 45 | two rates, then a sum |
+| `stock_percent_pack` | 3 | 48 | percent sold, remainder packed |
+| `trip_minutes` | 3 | 33 | two legs at different speeds + a rest |
+| `schedule_sessions` | 3 | 47 | three durations across the hour |
+| `inventory_boxes` | 4 | 62 | receive, ship, damage, pack |
+| `mix_split` | 4 | 63 | two products, sum, then split |
+| `tank_fill` | 4 | 62 | two fill stages, then a drain |
+| `discount_tax_coupon_split` | 4 | 63 | discount, tax, coupon, split |
+| `salary_overtime_tax` | 5 | 84 | base + 1.5× overtime + bonus − tax |
+| `inventory_percent_chain` | 5 | 83 | two percentage days, then palletise |
+| `prize_ratio_charity` | 5 | 83 | fee, ratio split, charity cut, split |
+
+---
+
+## 4. Fairness audit (and the bug it caught)
+
+`python deeparithmark.py audit` measures what a model can score **without doing
+arithmetic**: fixed-slot priors, magnitude picks, text-length picks, roundness
+picks, and a trained character-3-gram classifier over the option text.
+
+Current build:
+
+| Shortcut | Score |
+|---|---:|
+| pick largest value | 25.20 % |
+| pick smallest value | 24.80 % |
+| pick second smallest | 25.20 % |
+| **pick roundest number** | **25.20 %** |
+| pick longest / shortest text | 25.50 % / 24.00 % |
+| fixed slot 0 / 1 / 2 / 3 | 25.20 / 25.20 / 24.80 / 24.80 % |
+| char-3-gram classifier (5 splits) | 25.47 % mean, 28.00 % max |
+
+All at chance (25 %). That was not true of the first build.
+
+**The bug.** The first build balanced slot and rank but not surface shape, and
+several decoy paths produced structurally rounder numbers than the answer (a
+"reported in whole metres" decoy, ×10 and ×100 unit-conversion artifacts). gpt2
+then behaved as a pure round-number picker — it chose a roundest option on 84 %
+of items — and scored **21.1 %**, *below* chance. Splitting by whether the
+correct answer happened to be the roundest option isolates the cause:
+
+| Where the answer sits by roundness | items | gpt2 acc |
+|---|---:|---:|
+| answer is the roundest option | 615 | 28.5 % |
+| a decoy is rounder | 385 | 9.4 % |
+
+So the option set was leaking a signal that was *anti-correlated* with
+correctness. A benchmark in which a stronger model scores lower than a coin flip
+is broken regardless of how hard its items are.
+
+**The fix.** All four options must share the answer's roundness class
+(trailing-zero count), so "which number looks most natural" carries exactly no
+information. That moved gpt2 from 21.1 % to 24.0 % and put every shortcut back
+at chance. Any future family added must satisfy the same constraint; `assemble`
+enforces it automatically.
+
+Two smaller items this audit forced:
+
+* `share_then_split` rendered "cookies" in the endings even when the prompt said
+  "muffins" — a unit mismatch that is both a grammar bug and a cue.
+* Time items originally mixed a.m. and p.m. among the options, which makes "the
+  odd one out" a free answer. All clock options are now inside the answer's half
+  of the day.
+
+---
+
+## 5. What is actually being measured
+
+With well-separated options, 4-way accuracy is all-or-nothing: a model either
+lands the exact number or not. There is no partial credit mechanism in a
+log-likelihood comparison — "roughly right" is not a thing the scorer can see.
+So the design reports two numbers:
+
+* **`acc_norm`** — hard accuracy, directly comparable to ArithMark 3.0.
+* **`soft`** — mean probability a proper scoring rule assigns to the correct
+  option after a softmax over the four continuation scores. This is the graded
+  signal; it is not comparable to ArithMark's accuracy, it is a different
+  statistic.
+
+§6 makes clear why both are needed: for sub-1B models, *both* sit at chance.
+
+---
+
+## 6. Measured baselines
+
+Protocol: zero-shot, `acc_norm` as the headline, bf16, batch 32,
+`--max-context 1024` — ArithMark 3.0's own protocol (`bencharithmark-3.py`).
+ArithMark 3.0 numbers below are produced by this repo on the same weights in the
+same run, not copied from the baseline table. gpt2 reproducing 34.7 % against
+the published 35.7 % validates the scorer.
+
+| Model | Params | Deep `acc_norm` | Deep `soft` | ArithMark-3 `acc_norm` | Δ |
+|---|---:|---:|---:|---:|---:|
+| Qwen2.5-1.5B-Instruct | 1.54 B | **38.00** | 27.23 | — | — |
+| Qwen2.5-0.5B | 494 M | 24.60 | 25.50 | 60.90 | −36.30 |
+| SmolLM2-360M-Instruct | 362 M | 23.80 | 25.19 | — | — |
+| GPT-X3-150M | 149 M | 25.20 | 25.07 | 49.60 | −24.40 |
+| SmolLM2-135M | 135 M | 24.80 | 25.21 | 38.60 | −13.80 |
+| gpt2 | 124 M | 24.00 | 24.98 | 34.70 | −10.70 |
+| EleutherAI/pythia-70m | 70 M | 22.70 | 24.34 | 28.80 | −6.10 |
+
+### The depth ladder works — above the sub-1B band
+
+Qwen2.5-1.5B-Instruct, per depth tier (n = 250 each):
+
+| Depth | `acc_norm` | `soft` |
+|---:|---:|---:|
+| 2 | 60.4 % | 30.5 % |
+| 3 | 40.8 % | 27.3 % |
+| 4 | 28.4 % | 26.1 % |
+| 5 | 22.4 % | 25.0 % |
+
+Monotone, and it collapses to chance exactly at depth 5. That is the intended
+behaviour: the items are solvable, the depth axis is real, and the benchmark has
+a definable ceiling. It also shows the benchmark is not degenerate — it is not
+"impossible", it is *out of reach for one forward pass of a small base model*.
+
+### The honest headline: sub-1B base models sit at chance
+
+Every sub-1B **base** model measures 22.7–25.2 % — chance, with pythia-70m
+slightly below. The `soft` score confirms this is not a metric artifact: if the
+models had any partial skill, the softmax probability of the correct option
+would drift above 25 %. It does not (24.3–25.5 %).
+
+That is the geometric consequence of the design, not a tuning failure: with
+well-separated options, scoring requires chaining the operations in a single
+forward pass, and 70M–500M base models cannot. ArithMark 3.0's ±1 options hid
+this by rewarding a magnitude prior instead of arithmetic.
+
+**Practical consequence:** use Deep Arithmark as a ceiling tier with the per-depth
+curve reported, not as a single number that gates a leaderboard. For a sub-1B
+model the useful reading is "still at chance, and here is how far into the depth
+tiers the first real signal appears". The benchmark becomes discriminative from
+roughly the 1.5B-instruct class upward; the 0.5B row shows the 36-point gap to
+ArithMark 3.0, which is the measured version of "harder".
+
+### Chance is not always guessing: GPT-X3-150M
+
+GPT-X3-150M is the sharpest case. It scores 49.6 % on ArithMark 3.0 — the best
+150M-class result in this table, 11 points above SmolLM2-135M — and lands on
+25.20 % here, a 24.4-point drop, the largest in the set.
+
+But it is *not* sampling uniformly. Its per-template accuracy spans 3.0 %
+(`trip_minutes`, n = 33) to 54.5 % (`share_then_split`, n = 44), and that spread
+is far beyond binomial noise: χ² = 63.2, df = 14, p < 1e-4 (20k-draw Monte Carlo,
+null of independent binomials at the observed rate). Two mechanisms produce it:
+
+1. **A small-number prior.** It selects the numerically smallest of the four
+   options 34.8 % of the time and the largest only 15.8 % (rank distribution
+   348 / 281 / 213 / 158 from smallest to largest).
+2. **A stable wrong path per family.** Where a single named mistake is the
+   attractive one, it picks it consistently and scores *below* chance —
+   `money_discount_fee` 16.4 %, `two_rate_pay` 11.1 %, `tank_fill` 14.5 %.
+
+The two cancel to exactly chance at the aggregate. `trip_minutes` is the clear
+illustration: the answer is never the smallest option there (rank distribution
+0 / 30 / 30 / 39), the model picks smallest 75.8 % of the time, so it scores
+3.0 %; `measure_cm_cut`, where the answer is never the largest (39 / 30 / 30 /
+0), scores 18.2 %.
+
+**What this implies.** The rank balance is enforced globally (248–252 per rank),
+not within each template — `measure_cm_cut` and `trip_minutes` are the extreme
+cases at 39/30/30/0 and 0/30/30/39. A per-template surface policy therefore has
+free signal that nets to zero across the dataset. That is harmless for the
+headline number, which no surface shortcut beats, but it means per-template
+accuracy rows should be read as "what does it prefer here", never as a partial
+skill estimate, and it is the one place where a per-template rank balance would
+buy a cleaner diagnostic.
+
+If a low-scoring tier is needed for a sub-1B leaderboard today, the depth-2
+families are where signal first appears, and `share_then_split` /
+`time_clock_end` are the two templates a 1.5B instruct model already solves
+(86.4 % and 85.9 %) — i.e. the ladder has a bottom rung, it is just above 1B.
+
+---
+
+## 7. Reproducing
+
+```bash
+# regenerate the dataset (deterministic for a fixed seed)
+python deeparithmark.py build
+
+# validate every structural claim + run the shortcut audit
+python deeparithmark.py selftest
+
+# score models (add --compare for ArithMark 3.0 on the same weights)
+python bench_deeparithmark.py --compare \
+    --model gpt2 --model HuggingFaceTB/SmolLM2-135M --model Qwen/Qwen2.5-0.5B \
+    --out benchmarks
+
+# per-item predictions, for the per-template / option-rank analysis in §6
+python bench_deeparithmark.py --model AxiomicLabs/GPT-X3-150M \
+    --dump-predictions preds.jsonl --no-save
+```
+
+The resulting JSONL is scored unchanged by ArithMark 3.0's own
+`bencharithmark-3.py --data-path deeparithmark-1.jsonl`; the loader is verified
+against that script, not just "schema-similar".
+
+---
+
+## 8. Known limitations
+
+* **1,000 items** → a 95 % confidence interval of about ±2.7 points at p = 25 %.
+  Treat differences smaller than ~4 points as noise.
+* **No partial credit** in the hard metric, by construction (see §5). The `soft`
+  score exists to recover a gradient but is a different statistic.
+* **A single split.** No train/dev split is provided on purpose: this is an
+  evaluation set, and the generator is the training-avoidance mechanism.
+* **Template-bound.** A model fine-tuned on these 15 templates would overfit
+  them. The seed makes the *item instances* contamination-free, not the template
+  shapes.
+* **Clock items are a.m.-only** across their four options (a fairness constraint
+  from §4), so time items never exercise a noon or midnight rollover.
+* **Grade bands are nominal.** "grades_7_8" describes the arithmetic, not a
+  curriculum claim.
+* **Cents vs dollars.** Money is integer cents internally, rendered as whole
+  dollars; options within an item always share a format.
+* **Rank balance is global, not per-template.** Overall each numeric rank is the
+  answer 248–252 times, so "pick the largest" gains nothing, but individual
+  templates can be lopsided (`measure_cm_cut` 39/30/30/0, `trip_minutes`
+  0/30/30/39). A per-template surface policy therefore shifts per-template
+  accuracy while netting to zero across the set — see the GPT-X3-150M note.
+* **A model that reports inside the noise band on the aggregate is not
+  necessarily guessing.** Check `--dump-predictions` before reading a chance score
+  as "no signal"; GPT-X3-150M is the worked example.
+
+---
+
+## 9. Adding a family
+
+A new family is a function `fam_x(rng) -> Draft | None` that returns the prompt,
+the answer, the reference `steps` (one per dependent operation), and a pool of
+`(kind, value)` wrong-path values. Requirements, enforced by `build`/`selftest`:
+
+1. `len(steps) == depth`, and `answer == steps[-1][1]`.
+2. At least three pool values on **each** side of the answer (so every rank is
+   reachable).
+3. No pool value that a reader would discard without arithmetic — `assemble`
+   rejects values whose roundness class differs from the answer's, or that are
+   more than 4× off.
+4. Every option must render with the same unit phrase, and no option may be
+   exactly `1` with a plural unit.
+5. Enough parameter variety for ~60+ distinct prompts (add names/nouns if the
+   arithmetic parameters are few).
+
+Then add it to `FAMILIES` under the tier matching its step count, rebuild, and
+run `selftest` — the audit and every balance table must still pass.
+
+---
+
+## 10. Attribution and licence
+
+**Upstream.** Deep Arithmark follows [ArithMark 3.0](https://huggingface.co/datasets/AxiomicLabs/Arithmark-3.0)
+by AxiomicLabs (Apache-2.0). Please cite ArithMark 3.0 as well as this work.
+
+**What is reused.** The *task contract* — one unfinished sentence, four
+continuations with a leading space, a single correct index, and scoring by
+length-normalised continuation log-likelihood — and the JSONL schema, which is
+why ArithMark 3.0's own `bencharithmark-3.py` scores this file unchanged.
+
+**What is not reused.** No upstream item appears here: all 1,000 prompts are
+generated by [`deeparithmark.py`](deeparithmark.py), and the released file shares
+zero identical contexts and zero eight-word n-grams with the upstream data.
+[`bench_deeparithmark.py`](bench_deeparithmark.py) is an independent
+implementation of the same protocol, not copied code — it shares only import and
+boilerplate lines with `bencharithmark-3.py`. `--compare` downloads the upstream
+dataset from `AxiomicLabs/Arithmark-3.0`, which is where it lives; Deep Arithmark
+is not published under that org.
+
+**Licence.** Apache License 2.0, matching upstream. "ArithMark" and
+"AxiomicLabs" remain the property of their owner; this use is descriptive and
+implies no affiliation or endorsement.

README.md

@@ -0,0 +1,309 @@
+---
+license: apache-2.0
+language:
+- en
+size_categories:
+- 1K<n<10K
+task_categories:
+- question-answering
+pretty_name: Deep Arithmark 1
+tags:
+- arithmetic
+- multiple-choice
+- synthetic
+- language-model-evaluation
+- long-horizon
+configs:
+- config_name: default
+  data_files:
+  - split: test
+    path: data/deeparithmark-1.jsonl
+---
+
+# Deep Arithmark 1
+
+**The long-horizon tier of [ArithMark 3.0](https://huggingface.co/datasets/AxiomicLabs/Arithmark-3.0).**
+
+> **Unofficial.** Deep Arithmark is an independent, community-built companion
+> tier. It is not affiliated with, endorsed by, or published by AxiomicLabs, the
+> authors of ArithMark 3.0, and it is not an official ArithMark release. It
+> follows their task contract and credits them throughout; any errors are the
+> author's. If you use this benchmark, cite ArithMark 3.0 as well.
+
+ArithMark 3.0 asks a base model to finish a one- or two-step word problem whose
+four continuations are **adjacent integers** (43 / 44 / 45 / 46). To reject a
+wrong option you only need to know the answer is "about 44", so a magnitude
+prior is enough and arithmetic is optional.
+
+Deep Arithmark keeps ArithMark's contract exactly — one unfinished sentence, four
+continuations with a leading space, one correct index, scored by
+length-normalised continuation log-likelihood, chance 25 % — and changes three
+things:
+
+1. **Depth.** Every item needs **2–5 dependent operations** (250 items per tier).
+   Later operations consume earlier results, so no single memorised template
+   yields the continuation.
+2. **Decoys with provenance.** No decoy is "answer ± 1". Every decoy is the exact
+   value some specific plausible wrong reasoning produces — the state after step
+   2 instead of step 5, the percentage on the wrong base, the divisor `n` instead
+   of `n + 1`, the unit conversion left out. `metadata.option_sources` records
+   which mistake each ending encodes, so error analysis can ask *which* step a
+   model botches.
+3. **Balanced on three axes.** The correct slot, the answer's *numeric rank* and
+   the *roundness class* of all four options are all balanced, so "pick the
+   largest" and "pick the roundest number" are worth exactly 25 %.
+
+Full design notes, the fairness audit and the measurement discussion are in
+`DEEPARITHMARK_DESIGN.md`, which ships in this repository next to the generator
+(`deeparithmark.py`) and the scorer (`bench_deeparithmark.py`).
+
+## At a glance
+
+| Property | Value |
+| --- | ---: |
+| Examples | 1,000 |
+| Answer choices per example | 4 |
+| Random-choice accuracy | 25 % |
+| Templates | 15 |
+| Topic labels | 14 |
+| Depth tiers | 2, 3, 4, 5 — 250 each |
+| Mean prompt length | 29.2 words (max 43) |
+| Mean ending length | 9.7 characters |
+| Language | English |
+| Data source | Synthetic (generated, deterministic seed) |
+| Dataset file | `data/deeparithmark-1.jsonl` |
+| SHA-256 | `8a54eb90b66b142b7fea422b34d851746d1cabc476dcba906c7f3ad5ddc66ee0` |
+
+## Repository contents
+
+| File | What it is |
+| --- | --- |
+| `data/deeparithmark-1.jsonl` | The dataset — 1,000 items, one JSON object per line |
+| `README.md` | This card |
+| `deeparithmark.py` | Deterministic generator, plus `selftest` and the shortcut `audit` |
+| `bench_deeparithmark.py` | Scorer with per-depth and per-template breakdowns and an ArithMark 3.0 comparison |
+| `DEEPARITHMARK_DESIGN.md` | Design rationale, fairness audit, measurement discussion |
+
+## Task format
+
+Identical to ArithMark 3.0, so `bencharithmark-3.py --data-path
+data/deeparithmark-1.jsonl` scores it unchanged (verified against that script's
+own loader).
+
+```json
+{
+  "ind": 3,
+  "activity_label": "deeparithmark::deeparithmark-1::multi_step_inventory::depth4::hard",
+  "ctx": "A warehouse held 420 units. A delivery added 260, then 210 units were shipped out, and 40 were found damaged. The rest were packed into crates of 16. The number of full crates packed was",
+  "endings": [" 26 crates.", " 29 crates.", " 27 crates.", " 31 crates."],
+  "label": "0",
+  "source_id": "deeparithmark_v1_multi_step_inventory_depth4_0003",
+  "split": "test",
+  "split_type": "synthetic",
+  "metadata": {
+    "answer": "26",
+    "unit": "crates",
+    "topic": "multi_step_inventory",
+    "depth": 4,
+    "option_values": [26, 29, 27, 31],
+    "option_sources": ["correct", "forgot the damaged units", "counted the loose units as a crate", "added the damaged units"],
+    "answer_rank": 0,
+    "solution_steps": [
+      "after delivery: 420 + 260 = 680",
+      "after shipping: 680 - 210 = 470",
+      "good units: 470 - 40 = 430",
+      "full crates: 430 / 16 = 26 (remainder 14)"
+    ]
+  }
+}
+```
+
+The correct continuation is ` 26 crates.` — `420 + 260 − 210 − 40 = 430`, and
+`430 // 16 = 26` full crates. Every wrong ending is the result of a named
+mistake, not a perturbation of 26.
+
+## Composition
+
+### Depth
+
+| Depth | Examples | Share | Typical item |
+| ---: | ---: | ---: | --- |
+| 2 | 250 | 25.0 % | percent off a price, then a fee |
+| 3 | 250 | 25.0 % | unit conversion, add, subtract |
+| 4 | 250 | 25.0 % | receive / ship / damage / pack |
+| 5 | 250 | 25.0 % | two percentage days, then palletise |
+
+`depth` equals the number of operations in `metadata.solution_steps` for every
+item; the build fails if that is not true.
+
+### Templates
+
+| Template | Depth | Examples | Topic |
+| --- | ---: | ---: | --- |
+| `money_discount_fee` | 2 | 122 | money_percent |
+| `time_clock_end` | 2 | 128 | time |
+| `measure_cm_cut` | 3 | 33 | measurement |
+| `share_then_split` | 3 | 44 | fractions |
+| `two_rate_pay` | 3 | 45 | rate_pay |
+| `stock_percent_pack` | 3 | 48 | percent |
+| `trip_minutes` | 3 | 33 | rate_time |
+| `schedule_sessions` | 3 | 47 | time |
+| `inventory_boxes` | 4 | 62 | multi_step_inventory |
+| `mix_split` | 4 | 63 | money |
+| `tank_fill` | 4 | 62 | rate |
+| `discount_tax_coupon_split` | 4 | 63 | percent_money |
+| `salary_overtime_tax` | 5 | 84 | money_rate |
+| `inventory_percent_chain` | 5 | 83 | percent_multi_step |
+| `prize_ratio_charity` | 5 | 83 | ratio |
+
+### Correct-answer positions and numeric rank
+
+Both balanced, so neither slot priors nor magnitude priors are worth anything:
+
+| Axis | Distribution |
+| --- | --- |
+| Correct slot | 252 / 252 / 248 / 248 |
+| Answer numeric rank (smallest → largest) | 248 / 252 / 248 / 252 |
+
+The `slot × rank × depth` grid is filled at 15–16 items per cell.
+
+## Shortcut audit
+
+Measured on this file (`python deeparithmark.py audit`); chance is 25.00 %:
+
+| Strategy that needs no arithmetic | Score |
+| --- | ---: |
+| pick largest value | 25.20 % |
+| pick smallest value | 24.80 % |
+| pick second smallest | 25.20 % |
+| pick the roundest number | 25.20 % |
+| pick longest / shortest text | 25.50 % / 24.00 % |
+| fixed slot 0 / 1 / 2 / 3 | 25.20 / 25.20 / 24.80 / 24.80 % |
+| char-3-gram classifier over option text | 25.47 % (max 28.00 % over 5 splits) |
+
+Nothing clears chance. This matters: an early build of this dataset scored gpt2
+**below** chance (21.1 %) because several decoys were structurally rounder than
+the answer, so a round-number prior was anti-correlated with correctness. The
+fix — all four options in the same roundness class — is documented in the design
+notes, and it is now a build constraint.
+
+## Baselines
+
+Zero-shot, `acc_norm`, bf16, batch 32, `--max-context 1024` (ArithMark 3.0's
+protocol). ArithMark 3.0 numbers were produced on the same weights in the same
+run, not copied from a table.
+
+| Model | Params | Deep | soft | d2 | d3 | d4 | d5 | ArithMark-3 | Δ |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| Qwen2.5-1.5B-Instruct | 1.54 B | **38.00 %** | 27.23 % | 60.4 | 40.8 | 28.4 | 22.4 | — | — |
+| Qwen2.5-0.5B | 494 M | 24.60 % | 25.50 % | 24.8 | 26.4 | 23.6 | 23.6 | 60.90 % | −36.30 |
+| SmolLM2-360M-Instruct | 362 M | 23.80 % | 25.19 % | 24.8 | 26.8 | 26.4 | 17.2 | — | — |
+| GPT-X3-150M | 149 M | 25.20 % | 25.07 % | 23.6 | 24.0 | 25.6 | 27.6 | 49.60 % | −24.40 |
+| SmolLM2-135M | 135 M | 24.80 % | 25.21 % | 18.0 | 29.2 | 26.4 | 25.6 | 38.60 % | −13.80 |
+| gpt2 | 124 M | 24.00 % | 24.98 % | 22.0 | 23.2 | 25.2 | 25.6 | 34.70 % | −10.70 |
+| EleutherAI/pythia-70m | 70 M | 22.70 % | 24.34 % | 21.6 | 26.0 | 21.6 | 21.6 | 28.80 % | −6.10 |
+
+`d2`–`d5` are `acc_norm` per depth tier (250 items each, chance 25 %). `soft` is
+the mean probability a proper scoring rule gives the correct option after a
+softmax over the four continuation scores — the graded companion to hard
+accuracy. Δ is Deep Arithmark minus ArithMark 3.0 on the same weights.
+
+**Read the baselines carefully.** Every sub-1B *base* model sits at chance
+(22.7–25.2 %), and the soft score agrees (24.3–25.5 %), so it is not a metric
+artifact: a single forward pass of a sub-1B base model cannot chain 2+ operations.
+
+GPT-X3-150M (149 M) makes that concrete. It is the strongest 150M-class model
+here on ArithMark 3.0 — **49.60 %**, 11 points above SmolLM2-135M — and drops
+**24.4 points** to 25.20 % on this dataset. But it is not guessing uniformly:
+per-template accuracy runs from 3.0 % to 54.5 % (χ² = 63.2, df = 14, p < 1e-4),
+driven by a small-number prior (it picks the smallest option 34.8 % of the time,
+the largest 15.8 %) plus one stable wrong path per family in others. Those
+cancel to chance in aggregate, so the 25.20 % is a real reading of "cannot solve
+these", not noise — but treat per-template rows as preference, not skill.
+Full breakdown in the design notes, §6.
+
+What proves the dataset is nonetheless real and graded is the depth curve of a
+model that can: Qwen2.5-1.5B-Instruct runs **60.4 → 40.8 → 28.4 → 22.4 %** across
+d2–d5. Monotone, reaching chance exactly at depth 5. The items are solvable, the
+depth axis is genuine, and the ceiling is well defined — it is just above the
+sub-1B base class. Against ArithMark 3.0, Qwen2.5-0.5B loses **36.3 points**,
+which is the measured form of "harder".
+
+No sub-1B model shows a monotone curve in the other direction, and where one
+drifts above 25 % on a tier it does not survive the set as a whole — see the
+GPT-X3-150M discussion above.
+
+For a sub-1B leaderboard, report the per-depth curve rather than only the single
+number: the first real signal appears at the depth-2 rung, and at 1.5B-instruct
+the two solvable templates are `share_then_split` (86.4 %) and `time_clock_end`
+(85.9 %).
+
+## Usage
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("OPENGCM/DeepArithmark-1", split="test")
+item = ds[0]
+# score the four continuations of item["ctx"] by length-normalised
+# log-likelihood and take the argmax; compare it with int(item["label"])
+```
+
+Or score Hugging Face models directly, including a side-by-side ArithMark 3.0
+comparison on the same weights:
+
+```bash
+python bench_deeparithmark.py --compare --model HuggingFaceTB/SmolLM2-135M
+python bench_deeparithmark.py --model Qwen/Qwen2.5-0.5B --out benchmarks
+```
+
+ArithMark 3.0's own script works unchanged:
+
+```bash
+python bencharithmark-3.py --data-path data/deeparithmark-1.jsonl --model gpt2
+```
+
+## How it was generated
+
+`deeparithmark.py build` renders the file deterministically from seed
+`20261027`: 15 parameterised families, exact integer arithmetic, and a decoy
+pool per family of plausible wrong paths. `python deeparithmark.py selftest`
+re-checks every claim on this page — schema, unit consistency, option
+distinctness, step count vs depth, all three balance axes, and the shortcut
+audit.
+
+The seed makes the *instances* reproducible and unseen; it does not make the
+template shapes novel. Do not train on this file.
+
+## Limitations
+
+- 1,000 items → roughly ±2.7 points (95 % CI) at chance. Differences under ~4
+  points are noise.
+- Hard 4-way accuracy gives no partial credit by design; use the soft score for
+  a gradient.
+- Single `test` split, no train split (evaluation set).
+- 15 templates only: fine-tuning on them would overfit.
+- Clock items keep all four options inside one half of the day, so no noon
+  rollover is exercised.
+- Grade bands (`grades_4_5` … `grades_7_8`) describe the arithmetic, not a
+  curriculum.
+
+## Licence and attribution
+
+This dataset is released under the **Apache License 2.0**.
+
+**Upstream work.** Deep Arithmark follows [ArithMark 3.0](https://huggingface.co/datasets/AxiomicLabs/Arithmark-3.0)
+by AxiomicLabs, also Apache-2.0. What is reused is the *task contract*: one
+unfinished sentence, four continuations with a leading space, a single correct
+index, and scoring by length-normalised continuation log-likelihood — plus the
+JSONL schema, so ArithMark 3.0's own scorer runs on this file unchanged.
+
+**What is not reused.** No ArithMark 3.0 item appears here. Every prompt is
+generated from the parameterised families in `deeparithmark.py`,
+and the released file shares **0 identical contexts and 0 eight-word n-grams**
+with the 1,000 upstream items. The accompanying scorer is an independent
+implementation of the same protocol, not copied code.
+
+**Trademarks.** "ArithMark" and "AxiomicLabs" remain the property of their
+owner. Their use here is descriptive, to state which benchmark this one extends.
+It does not imply affiliation or endorsement — see the notice at the top.

bench_deeparithmark.py

@@ -0,0 +1,389 @@
+#!/usr/bin/env python3
+"""
+Score Hugging Face causal LMs on Deep Arithmark (and, side by side, ArithMark 3.0).
+
+The scoring protocol follows ArithMark 3.0's (AxiomicLabs) so the two numbers
+are directly comparable. This file is an independent implementation, not copied
+code; it shares only imports and boilerplate with `bencharithmark-3.py`:
+
+  * zero-shot continuation log-likelihood -- the model never generates text;
+  * context and continuation tokenized separately, so the continuation cannot
+    be scored through the context's tokenization;
+  * `acc` sums the token log-probabilities, `acc_norm` averages them;
+  * bf16, batch 32, `--max-context 1024`, by default.
+
+On top of that it reports the profile the depth tiers are for:
+
+  * a per-depth curve (2, 3, 4, 5 dependent operations), so a sub-1B model has
+    something to climb instead of a single number pinned at chance;
+  * per-template and per-topic accuracy, so a regression is attributable;
+  * the share of items where `acc` and `acc_norm` disagree (a near-tie signal).
+
+Usage
+-----
+    python bench_deeparithmark.py --model HuggingFaceTB/SmolLM2-135M
+    python bench_deeparithmark.py --model gpt2 --compare   # ArithMark 3.0 too
+    python bench_deeparithmark.py --models-file models.txt --out benchmarks/
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import hashlib
+import json
+import math
+import time
+from collections import defaultdict
+from pathlib import Path
+
+import torch
+import torch.nn.functional as F
+from huggingface_hub import hf_hub_download
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# Our own data is read from disk; this repo is not published under AxiomicLabs.
+DATA_DEFAULT = "deeparithmark-dataset/data/deeparithmark-1.jsonl"
+# The one AxiomicLabs reference that must stay: `--compare` downloads the upstream
+# benchmark from its authors' org, which is where it actually lives. Changing this
+# to another namespace would break the head-to-head.
+ARITHMARK3_REPO = "AxiomicLabs/Arithmark-3.0"
+ARITHMARK3_FILE = "arithmark-3.jsonl"
+BATCH_SIZE = 32
+MAX_CONTEXT = 1024
+DEPTHS = (2, 3, 4, 5)
+
+# every model here is under 1B parameters, which is the target of this benchmark
+DEFAULT_MODELS = [
+    "gpt2",
+    "EleutherAI/pythia-70m",
+    "HuggingFaceTB/SmolLM2-135M",
+    "Qwen/Qwen2.5-0.5B",
+]
+
+
+def load_items(path: Path) -> list[dict]:
+    items = []
+    with path.open(encoding="utf-8-sig") as fh:
+        for line_no, line in enumerate(fh, 1):
+            if not line.strip():
+                continue
+            item = json.loads(line)
+            label = item["label"]
+            items.append(
+                {
+                    "id": str(item.get("ind", line_no)),
+                    "ctx": item["ctx"],
+                    "endings": item["endings"],
+                    "label": int(label),
+                    "depth": item.get("metadata", {}).get("depth"),
+                    "topic": item.get("metadata", {}).get("topic"),
+                    "template": item.get("metadata", {}).get("template_id"),
+                }
+            )
+    if not items:
+        raise SystemExit(f"no items in {path}")
+    return items
+
+
+def resolve_device(requested: str) -> str:
+    if requested != "auto":
+        return requested
+    return "cuda" if torch.cuda.is_available() else "cpu"
+
+
+def load_model(model_name: str, device: str, dtype_name: str):
+    dtype = {"float32": torch.float32, "float16": torch.float16, "bfloat16": torch.bfloat16}[
+        dtype_name
+    ]
+    if device == "cpu":
+        dtype = torch.float32
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name, dtype=dtype, trust_remote_code=True
+    ).to(device)
+    model.eval()
+    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True, use_fast=False)
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token = tokenizer.eos_token or 0
+    return model, tokenizer, dtype
+
+
+@torch.inference_mode()
+def score_items(model, tokenizer, device, dtype, items, batch_size: int, max_context: int):
+    """Return (items, labels, raw_scores, norm_scores) -- 4 scores per item.
+
+    Results follow the length-sorted order used for batching, so the returned
+    item list is what the labels and scores line up with.
+    """
+    prepared = []
+    for item in items:
+        requests = []
+        for ending in item["endings"]:
+            ctx_ids = tokenizer(item["ctx"], add_special_tokens=False).input_ids
+            end_ids = tokenizer(ending, add_special_tokens=False).input_ids
+            if not ctx_ids or not end_ids:
+                raise SystemExit(f"empty tokenization in item {item['id']}")
+            ctx_ids = ctx_ids[-(max_context - len(end_ids)) :]
+            requests.append((ctx_ids + end_ids, len(end_ids)))
+        prepared.append((item, requests))
+    # similar lengths together: less padding, fewer wasted logits
+    prepared.sort(key=lambda pair: max(len(t) for t, _ in pair[1]))
+
+    labels, raw, norm = [], [], []
+    for start in range(0, len(prepared), batch_size):
+        batch = prepared[start : start + batch_size]
+        flats, lengths, cont_lens = [], [], []
+        for _, requests in batch:
+            for tokens, cont_len in requests:
+                flats.append(tokens)
+                lengths.append(len(tokens))
+                cont_lens.append(cont_len)
+        width = max(lengths)
+        ids = torch.tensor(
+            [t + [tokenizer.pad_token_id] * (width - len(t)) for t in flats],
+            dtype=torch.long,
+            device=device,
+        )
+        mask = torch.arange(width, device=device)[None, :] < torch.tensor(
+            lengths, device=device
+        )[:, None]
+        starts = torch.tensor(
+            [len(t) - c for t, c in zip(flats, cont_lens)], dtype=torch.long, device=device
+        )
+        with (
+            torch.autocast("cuda", dtype=dtype) if device == "cuda" and dtype != torch.float32 else torch.no_grad()
+        ):
+            logits = model(ids, attention_mask=mask, use_cache=False).logits
+        positions = torch.arange(1, width, device=device)[None, :]
+        score_mask = (positions >= starts[:, None]) & (
+            positions < torch.tensor(lengths, device=device)[:, None]
+        )
+        row_idx, rel = score_mask.nonzero(as_tuple=True)
+        tok_pos = rel + 1
+        picked = logits[row_idx, tok_pos - 1, :]
+        targets = ids[row_idx, tok_pos]
+        tok_ll = -F.cross_entropy(picked.float(), targets, reduction="none")
+        raw_t = torch.zeros(len(flats), device=device).scatter_add_(0, row_idx, tok_ll)
+        cnt_t = torch.zeros(len(flats), device=device).scatter_add_(
+            0, row_idx, torch.ones_like(tok_ll)
+        )
+        raw_f = raw_t.cpu().tolist()
+        norm_f = (raw_t / cnt_t.clamp_min(1)).cpu().tolist()
+        for i, (item, _) in enumerate(batch):
+            base = 4 * i
+            labels.append(item["label"])
+            raw.append(raw_f[base : base + 4])
+            norm.append(norm_f[base : base + 4])
+        del logits, ids, mask
+    return [item for item, _ in prepared], labels, raw, norm
+
+
+def summarize(items, labels, raw, norm) -> dict:
+    def pick(scores, i):
+        return max(range(4), key=lambda k: scores[i][k])
+
+    hit_raw = [int(pick(raw, i) == labels[i]) for i in range(len(items))]
+    hit_norm = [int(pick(norm, i) == labels[i]) for i in range(len(items))]
+
+    # Soft score: the probability a proper scoring rule assigns to the correct
+    # option after a softmax over the four continuations. Hard accuracy is
+    # all-or-nothing (a model either lands the exact number or not), so it sits
+    # at 25 % for sub-1B models; this keeps the graded signal visible.
+    def soft(row, label):
+        top = max(row)
+        exps = [math.exp(s - top) for s in row]
+        return exps[label] / sum(exps)
+
+    soft_norm = [soft(norm[i], labels[i]) for i in range(len(items))]
+    soft_by_depth = defaultdict(lambda: [0.0, 0])
+    for i, item in enumerate(items):
+        if item.get("depth"):
+            soft_by_depth[item["depth"]][0] += soft_norm[i]
+            soft_by_depth[item["depth"]][1] += 1
+
+    def pct(correct: int, n: int) -> float:
+        return 100.0 * correct / n if n else 0.0
+
+    by_depth = defaultdict(lambda: [0, 0])
+    by_topic = defaultdict(lambda: [0, 0])
+    by_template = defaultdict(lambda: [0, 0])
+    for i, item in enumerate(items):
+        if item.get("depth"):
+            by_depth[item["depth"]][0] += hit_norm[i]
+            by_depth[item["depth"]][1] += 1
+        by_topic[item.get("topic") or "n/a"][0] += hit_norm[i]
+        by_topic[item.get("topic") or "n/a"][1] += 1
+        by_template[item.get("template") or "n/a"][0] += hit_norm[i]
+        by_template[item.get("template") or "n/a"][1] += 1
+
+    n = len(items)
+    return {
+        "n": n,
+        "acc": pct(sum(hit_raw), n),
+        "acc_norm": pct(sum(hit_norm), n),
+        "soft": 100.0 * sum(soft_norm) / n,
+        "disagreements": sum(1 for a, b in zip(hit_raw, hit_norm) if a != b),
+        "by_depth": {
+            d: {
+                "acc_norm": pct(v[0], v[1]),
+                "soft": 100.0 * soft_by_depth[d][0] / soft_by_depth[d][1],
+                "n": v[1],
+            }
+            for d, v in sorted(by_depth.items())
+        },
+        "by_topic": {
+            t: {"acc_norm": pct(v[0], v[1]), "n": v[1]} for t, v in sorted(by_topic.items())
+        },
+        "by_template": {
+            t: {"acc_norm": pct(v[0], v[1]), "n": v[1]} for t, v in sorted(by_template.items())
+        },
+    }
+
+
+def print_report(name, params, res) -> None:
+    print(f"\n{name}  ({params:,} parameters)")
+    print(f"  Deep Arithmark score (acc_norm)  {res['acc_norm']:6.2f}%")
+    print(f"  soft score (P[correct])          {res['soft']:6.2f}%")
+    print(f"  raw token-sum accuracy (acc)     {res['acc']:6.2f}%")
+    if res["by_depth"]:
+        print("  depth curve (acc_norm / soft):")
+        for depth, vals in res["by_depth"].items():
+            print(
+                f"    depth {depth}: {vals['acc_norm']:6.2f}% / {vals['soft']:6.2f}%"
+                f"  (n={vals['n']})"
+            )
+    print("  by template:")
+    for template, vals in sorted(res["by_template"].items(), key=lambda kv: -kv[1]["acc_norm"]):
+        print(f"    {template:34s} {vals['acc_norm']:6.2f}%  (n={vals['n']})")
+
+
+def arithmark3_path() -> Path:
+    return Path(hf_hub_download(ARITHMARK3_REPO, ARITHMARK3_FILE, repo_type="dataset"))
+
+
+def run_model(model_name, args, device, deep_items, am3_items):
+    model, tokenizer, dtype = load_model(model_name, device, args.dtype)
+    params = sum(p.numel() for p in model.parameters())
+    out = {"model": model_name, "params": params, "protocol": {
+        "dtype": str(dtype), "batch_size": args.batch_size,
+        "max_context": args.max_context, "shots": 0,
+    }}
+    t0 = time.perf_counter()
+    ordered, labels, raw, norm = score_items(
+        model, tokenizer, device, dtype, deep_items, args.batch_size, args.max_context
+    )
+    res = summarize(ordered, labels, raw, norm)
+    out["deeparithmark"] = res
+    print_report(model_name, params, res)
+    if args.dump_predictions:
+        target = Path(args.dump_predictions)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        with target.open("a", encoding="utf-8") as fh:
+            for i, item in enumerate(ordered):
+                fh.write(
+                    json.dumps(
+                        {
+                            "model": model_name,
+                            "id": item["id"],
+                            "depth": item.get("depth"),
+                            "template": item.get("template"),
+                            "label": labels[i],
+                            "raw_pick": max(range(4), key=lambda k: raw[i][k]),
+                            "norm_pick": max(range(4), key=lambda k: norm[i][k]),
+                            "raw": raw[i],
+                            "norm": norm[i],
+                        }
+                    )
+                    + "\n"
+                )
+    if am3_items is not None:
+        ordered, labels, raw, norm = score_items(
+            model, tokenizer, device, dtype, am3_items, args.batch_size, args.max_context
+        )
+        am3 = summarize(ordered, labels, raw, norm)
+        out["arithmark3"] = am3
+        print(f"  ArithMark 3.0 (acc_norm)         {am3['acc_norm']:6.2f}%   [same weights, same protocol]")
+        print(f"  drop                             {am3['acc_norm'] - res['acc_norm']:+6.2f} points")
+    out["seconds"] = round(time.perf_counter() - t0, 2)
+    del model, tokenizer
+    gc.collect()
+    if device == "cuda":
+        torch.cuda.empty_cache()
+    return out
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--model", action="append", help="HF model id; repeatable")
+    ap.add_argument("--data", default=DATA_DEFAULT)
+    ap.add_argument("--compare", action="store_true", help="also score ArithMark 3.0")
+    ap.add_argument("--arithmark3", help="local path to arithmark-3.jsonl")
+    ap.add_argument("--batch-size", type=int, default=BATCH_SIZE)
+    ap.add_argument("--max-context", type=int, default=MAX_CONTEXT)
+    ap.add_argument("--dtype", choices=("float32", "float16", "bfloat16"), default="bfloat16")
+    ap.add_argument("--device", choices=("auto", "cpu", "cuda"), default="auto")
+    ap.add_argument("--out", default="benchmarks")
+    ap.add_argument("--no-save", action="store_true")
+    ap.add_argument(
+        "--dump-predictions",
+        help="write per-item scores to this JSONL path for error analysis",
+    )
+    args = ap.parse_args()
+
+    torch.set_float32_matmul_precision("high")
+    if torch.cuda.is_available():
+        torch.backends.cuda.matmul.allow_tf32 = True
+
+    data_path = Path(args.data)
+    if not data_path.exists():
+        raise SystemExit(f"missing {data_path}; run `python deeparithmark.py build`")
+    deep_items = load_items(data_path)
+    sha = hashlib.sha256(data_path.read_bytes()).hexdigest()
+    device = resolve_device(args.device)
+    print(f"device: {device} | items: {len(deep_items)} | sha256: {sha[:16]}...")
+
+    am3_items = None
+    if args.compare or args.arithmark3:
+        am3_file = Path(args.arithmark3) if args.arithmark3 else arithmark3_path()
+        am3_items = load_items(am3_file)
+        print(f"comparing against ArithMark 3.0 ({len(am3_items)} items): {am3_file}")
+
+    models = args.model or DEFAULT_MODELS
+    results = []
+    for name in models:
+        try:
+            results.append(run_model(name, args, device, deep_items, am3_items))
+        except Exception as exc:  # a broken hub repo should not kill the sweep
+            print(f"\n{name}: FAILED -- {str(exc).splitlines()[0]}")
+
+    if results:
+        print("\n" + "=" * 84)
+        print(f"{'model':40s} {'deep':>8s} {'soft':>8s} {'arith3':>8s}")
+        for r in results:
+            am3 = r.get("arithmark3", {}).get("acc_norm")
+            print(
+                f"{r['model']:40s} {r['deeparithmark']['acc_norm']:7.2f}%"
+                f" {r['deeparithmark']['soft']:7.2f}%"
+                + (f" {am3:7.2f}%" if am3 is not None else "       -")
+            )
+        print("=" * 84)
+
+    if not args.no_save and results:
+        out_dir = Path(args.out)
+        out_dir.mkdir(parents=True, exist_ok=True)
+        payload = {
+            "dataset": {"name": "deeparithmark-1", "path": str(data_path), "sha256": sha,
+                        "items": len(deep_items)},
+            "protocol": {
+                "shots": 0, "dtype": args.dtype, "batch_size": args.batch_size,
+                "max_context": args.max_context, "metric": "acc_norm",
+            },
+            "results": results,
+        }
+        target = out_dir / f"deeparithmark_{len(results)}models.json"
+        target.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+        print(f"\nresults -> {target}")
+
+
+if __name__ == "__main__":
+    main()

deeparithmark.py

@@ -0,0 +1,1545 @@
+#!/usr/bin/env python3
+"""
+Deep Arithmark — the long-horizon tier of ArithMark.
+
+ArithMark 3.0 asks a base model to finish a two-clause word problem whose four
+continuations are **adjacent integers** (43 / 44 / 45 / 46). That design has a
+measurable shortcut: to reject a wrong option you only need to know that the
+answer is "about 44", so magnitude smoothing wins points without arithmetic.
+Every item is also one or two dependent operations, which is why the best
+sub-1B model (MobileLLM-R1-140M) sits at 65.7 %.
+
+Deep Arithmark keeps ArithMark's contract exactly -- one unfinished sentence,
+four continuations with a leading space, one correct index, scored by
+length-normalised continuation log-likelihood, chance 25 % -- and changes three
+things:
+
+  * **Depth.** Every item needs 2-5 *dependent* operations. Later steps consume
+    the result of earlier steps, so you cannot get the ending by matching a
+    phrase to a memorised one-step template.
+  * **Decoys with provenance.** No decoy is "answer ± 1". Every decoy is the
+    exact value some specific plausible wrong reasoning produces: the state
+    after step 2 instead of step 4, the percentage applied to the wrong base,
+    the divisor n instead of n+1, the unit conversion left out, ceil instead of
+    floor, the a.m./p.m. carry dropped. Each ending therefore has to be judged,
+    not merely ranked by size. `metadata.option_sources` records, per ending,
+    which wrong path produced it -- the dataset is auditable, not a black box.
+  * **Balanced rank, not just balanced position.** ArithMark balances which
+    slot holds the answer, but leaves the answer's *numeric* rank free, so
+    "pick the largest" is worth points on the easy tiers. Here the answer's
+    rank among the four values is balanced too: 25 % of items have it as the
+    smallest, 25 % as the second, and so on. Picking a magnitude is worth 25 %.
+
+Why this is still fair to a sub-1B model: scoring is pure continuation
+log-likelihood (no chain-of-thought, no tools, no generation), items stay under
+~45 words, the whole set is 1,000 items, and it is graded in four depth tiers so
+a 100M model still has a readable curve to climb instead of a single number
+pinned at chance.
+
+Usage
+-----
+    python deeparithmark.py selftest
+    python deeparithmark.py build --out deeparithmark-dataset/data/deeparithmark-1.jsonl
+    python deeparithmark.py audit  --data deeparithmark-dataset/data/deeparithmark-1.jsonl
+
+Grading a model on it is `bench_deeparithmark.py`; the file below is also scored
+unchanged by ArithMark 3.0's own `bencharithmark-3.py --data-path`, because the
+record schema is identical.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import random
+import statistics
+from collections import Counter
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable
+
+VERSION = "1.0"
+DATASET_NAME = "deeparithmark-1"
+DEPTHS = (2, 3, 4, 5)
+PER_DEPTH = 250
+# ranks are split 62/63/62/63 so each depth still totals exactly PER_DEPTH
+RANK_QUOTAS = (62, 63, 62, 63)
+
+
+# ---------------------------------------------------------------------------
+# drafts: what a problem family produces before options are laid out
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class Draft:
+    """One generated problem, before decoy selection and slot assignment."""
+
+    ctx: str
+    answer: int
+    # (kind, value) for every plausible wrong reasoning path we can compute.
+    # `kind` is a short human-readable description of the mistake.
+    pool: list[tuple[str, int]]
+    fmt: Callable[[int], str]
+    unit: str
+    topic: str
+    grade_band: str
+    difficulty: str
+    depth: int
+    steps: list[tuple[str, int]]
+    # number-valued options need the "no 1" rule (all endings share one plural
+    # unit, so " 1 boxes." would be ungrammatical *and* a giveaway).
+    render_is_number: bool = True
+
+
+NAMES = [
+    "Amara", "Ben", "Chen", "Dara", "Eli", "Farid", "Greta", "Hana",
+    "Ivo", "Jae", "Kofi", "Lena", "Milo", "Nia", "Omar", "Priya",
+    "Quinn", "Rosa", "Samir", "Tara", "Umar", "Vera", "Wes", "Yara",
+]
+
+
+def num(v: int, unit: str) -> str:
+    return f" {v} {unit}."
+
+
+def dollars(v: int) -> str:
+    """Render an integer number of cents as a dollar amount."""
+    return f"${v // 100}.{v % 100:02d}"
+
+
+def money(v: int) -> str:
+    return f" {dollars(v)}."
+
+
+def _same_period(
+    pool: list[tuple[str, int]], window: int
+) -> list[tuple[str, int]]:
+    """Keep only options inside one half of the day (all a.m., or all p.m.).
+
+    Every option in a time item has to carry the same a.m./p.m. marker, or the
+    marker itself becomes an "odd one out" cue that needs no arithmetic.
+    """
+    low = window * 720
+    return [(k, v) for k, v in pool if low <= v < low + 720]
+
+
+def _clock(total_minutes: int) -> str:
+    """Render minutes past midnight as a 12-hour clock time."""
+    minutes = total_minutes % (24 * 60)
+    hour, minute = divmod(minutes, 60)
+    suffix = "a.m." if hour < 12 else "p.m."
+    display = hour % 12 or 12
+    return f" {display}:{minute:02d} {suffix}"
+
+
+def _ok_value(v: int) -> bool:
+    return v >= 0 and v != 1
+
+
+
+
+# ---------------------------------------------------------------------------
+# problem families
+#
+# Each family returns a Draft or None when the random parameters landed on a
+# degenerate case (colliding values, non-integer division, an ungrammatical
+# option). The caller retries. `steps` is the real computation, so
+# `answer == steps[-1][1]` by construction and selftest can assert it.
+# ---------------------------------------------------------------------------
+
+
+def fam_money_discount_fee(rng: random.Random) -> Draft | None:
+    """depth 2 - percent off, then a fixed fee (money)."""
+    price = rng.choice([240, 320, 380, 460, 540, 680, 720, 840, 960])
+    pct = rng.choice([10, 20, 25, 50])
+    fee = rng.choice([15, 25, 35, 45, 60])
+    discount = price * pct // 100
+    reduced = price - discount
+    answer = reduced + fee
+    ctx = (
+        f"At the fair, a ride pass cost {dollars(price)}. The booth took {pct}% off the pass "
+        f"and then charged a handling fee of {dollars(fee)}. In total, the pass cost"
+    )
+    steps = [
+        (f"take {pct}% of {price} off: {price} - {discount} = {reduced}", reduced),
+        (f"add the {fee}-cent fee: {reduced} + {fee} = {answer}", answer),
+    ]
+    flat = price - pct + fee  # read "20%" as "20 cents"
+    pool = [
+        ("forgot the fee", price - discount),
+        ("forgot the discount", price + fee),
+        ("added the discount instead of removing it", price + discount + fee),
+        ("took the percentage off twice", price - 2 * discount + fee),
+        ("read the percentage as a flat number of cents", flat),
+        ("charged the handling fee twice", reduced + 2 * fee),
+        (
+            "took the discount off the fee as well",
+            (price + fee) - (price + fee) * pct // 100,
+        ),
+    ]
+    return Draft(
+        ctx=ctx,
+        answer=answer,
+        pool=pool,
+        fmt=money,
+        unit="dollars",
+        topic="money_percent",
+        grade_band="grades_4_5",
+        difficulty="medium",
+        depth=2,
+        steps=steps,
+    )
+
+
+def fam_measure_cm_cut(rng: random.Random) -> Draft | None:
+    """depth 2 - metres+centimetres converted, then cut (measurement)."""
+    meters = rng.randint(2, 6)
+    extra = rng.choice([12, 25, 38, 47, 55, 68, 74])
+    cut = rng.choice([45, 60, 75, 90, 115, 130])
+    total = meters * 100 + extra
+    answer = total - cut
+    if answer < 20:
+        return None
+    ctx = (
+        f"A board was {meters} metres and {extra} centimetres long. A worker cut off "
+        f"{cut} centimetres. The board left was"
+    )
+    steps = [
+        (f"convert metres: {meters} x 100 = {meters * 100} cm", meters * 100),
+        (f"add the extra centimetres: {meters * 100} + {extra} = {total} cm", total),
+        (f"subtract the cut: {total} - {cut} = {answer} cm", answer),
+    ]
+    pool = [
+        ("forgot the extra centimetres", meters * 100 - cut),
+        ("used 10 cm to the metre", meters * 10 + extra - cut),
+        ("used 1000 cm to the metre", meters * 1000 + extra - cut),
+        ("added the cut instead of removing it", total + cut),
+        ("cut a whole metre off as well", total - cut - 100),
+        ("reported the length in whole metres", (answer // 100) * 100),
+        ("subtracted the cut from the centimetres only", meters * 100 + (extra - cut)),
+        ("added the cut and a whole metre", total + cut + 100),
+        ("counted the extra centimetres twice", total + extra - cut),
+        ("stopped ten centimetres short of the cut", total - cut + 10),
+    ]
+    return Draft(
+        ctx=ctx,
+        answer=answer,
+        pool=pool,
+        fmt=lambda v: num(v, "centimetres"),
+        unit="centimetres",
+        topic="measurement",
+        grade_band="grades_4_5",
+        difficulty="medium",
+        depth=3,  # convert, add the extra centimetres, subtract the cut
+        steps=steps,
+    )
+
+
+def fam_time_clock_end(rng: random.Random) -> Draft | None:
+    """depth 2 - clock time plus a duration (time)."""
+    start = rng.randrange(6 * 60, 8 * 60 + 45)  # 06:00 .. 08:44
+    duration = rng.choice([50, 65, 80, 95, 110, 125])
+    end = start + duration
+    # keep the whole item inside the morning: every option has to share the
+    # a.m. marker, or the marker itself becomes an "odd one out" cue
+    if not 6 * 60 <= end <= 10 * 60 + 50:
+        return None
+    ctx = (
+        f"The hall was booked from {_clock(start).strip()} for {duration} minutes. "
+        f"The booking ended at"
+    )
+    steps = [
+        (f"convert the start: {start} minutes after midnight", start),
+        (f"add the duration: {start} + {duration} = {end} minutes", end),
+    ]
+
+    def fmt(v: int) -> str:
+        return _clock(v)
+
+    pool = [
+        ("dropped the hour carry", start - (start % 60) + ((start + duration) % 60)),
+        ("added an extra hour", end + 60),
+        ("subtracted the duration instead of adding it", start - duration),
+        ("counted the duration as hours, not minutes", start + duration * 60),
+        ("added the minutes without the hours", start + duration % 60),
+        ("counted the duration as ten minutes an hour", start + duration * 10),
+        ("forgot the last full hour", end - 60),
+        ("ran half an hour long", end + 30),
+        ("stopped a quarter of an hour early", end - 15),
+        ("ran an hour and a half long", end + 90),
+    ]
+    pool = _same_period(pool, 0)
+    return Draft(
+        ctx=ctx,
+        answer=end,
+        pool=pool,
+        fmt=fmt,
+        unit="clock time",
+        topic="time",
+        grade_band="grades_4_5",
+        difficulty="medium",
+        depth=2,
+        steps=steps,
+        render_is_number=False,
+    )
+
+
+def fam_share_then_split(rng: random.Random) -> Draft | None:
+    """depth 3 - give away a third, then split the rest (fractions)."""
+    k = rng.choice([4, 5, 6])
+    # a larger per-child share keeps the four candidate values far enough apart
+    # that "about this big" smoothing cannot separate them
+    share = rng.choice([12, 15, 18, 20, 24])
+    rest = k * share
+    # rest must be two thirds of the total
+    total = rest * 3 // 2
+    if rest * 3 % 2 or total % 3:
+        return None
+    given = total // 3
+    if given != total - rest:
+        return None
+    if total > 400 or given < 6:
+        return None
+    baker = rng.choice(NAMES)
+    noun = rng.choice(["cookies", "muffins", "biscuits", "buns"])
+    ctx = (
+        f"{baker} baked {total} {noun}. One third went to a neighbour, and the rest were "
+        f"split equally among {k} grandchildren. Each grandchild got"
+    )
+    describe = noun
+    steps = [
+        (f"one third given away: {total} / 3 = {given}", given),
+        (f"rest kept: {total} - {given} = {rest}", rest),
+        (f"split among {k}: {rest} / {k} = {share}", share),
+    ]
+    pool = [
+        ("split all the cookies, not the rest", total // k),
+        ("gave away a half instead of a third", (total - total // 2) // k),
+        ("stopped after giving the third away", rest),
+        ("split the rest among one more child", rest // (k + 1)),
+        ("gave away a third twice", (rest - rest // 3) // k),
+        ("multiplied instead of dividing", rest * k),
+        ("split the given-away cookies too", given // k),
+        ("gave away a half and split among one more child", (total - total // 2) // (k + 1)),
+        ("gave away two thirds", (total - 2 * given) // k),
+        ("split all the cookies among one more child", total // (k + 1)),
+        ("split the rest among twice as many children", rest // (2 * k)),
+        ("gave away two thirds and split among one more child", (total - 2 * given) // (k + 1)),
+        ("gave away a third twice and split among one more child", (rest - rest // 3) // (k + 1)),
+        ("split all the cookies among two more children", total // (k + 2)),
+    ]
+    return Draft(
+        ctx=ctx,
+        answer=share,
+        pool=pool,
+        fmt=lambda v: num(v, describe),
+        unit=describe,
+        topic="fractions",
+        grade_band="grades_5_6",
+        difficulty="hard",
+        depth=3,
+        steps=steps,
+    )
+
+
+def fam_two_rate_pay(rng: random.Random) -> Draft | None:
+    """depth 3 - two different hourly rates (rate/money)."""
+    h1 = rng.choice([3, 4, 5, 6])
+    h2 = rng.choice([2, 3, 4])
+    r1 = rng.choice([900, 1100, 1250, 1400, 1500])
+    r2 = r1 + rng.choice([200, 300, 400, 500])
+    part1 = h1 * r1
+    part2 = h2 * r2
+    answer = part1 + part2
+    ctx = (
+        f"Ravi worked {h1} hours at {dollars(r1)} an hour, and then {h2} hours at "
+        f"{dollars(r2)} an hour. He earned"
+    )
+    steps = [
+        (f"first stretch: {h1} x {r1} = {part1}", part1),
+        (f"second stretch: {h2} x {r2} = {part2}", part2),
+        (f"total pay: {part1} + {part2} = {answer}", answer),
+    ]
+    pool = [
+        ("paid every hour at the first rate", (h1 + h2) * r1),
+        ("paid every hour at the second rate", (h1 + h2) * r2),
+        ("forgot the second stretch", part1),
+        ("forgot the first stretch", part2),
+        ("swapped the two rates", h1 * r2 + h2 * r1),
+        ("added the rates together", (h1 + h2) * (r1 + r2)),
+        ("worked one hour less in the first stretch", (h1 - 1) * r1 + part2),
+        ("worked one hour less in each stretch", (h1 - 1) * r1 + (h2 - 1) * r2),
+        ("paid the slower rate for the whole day", (h1 + h2) * r1 // 2),
+    ]
+    return Draft(
+        ctx=ctx,
+        answer=answer,
+        pool=pool,
+        fmt=money,
+        unit="dollars",
+        topic="rate_pay",
+        grade_band="grades_5_6",
+        difficulty="hard",
+        depth=3,
+        steps=steps,
+    )
+
+
+def fam_mix_split(rng: random.Random) -> Draft | None:
+    """depth 3 - mixed basket, then split (money)."""
+    a = rng.choice([4, 5, 6, 7, 8])
+    b = rng.choice([3, 4, 5, 6])
+    x = rng.choice([45, 60, 75, 80, 95, 120])
+    y = rng.choice([30, 35, 50, 65, 70])
+    friends = rng.choice([2, 3, 4, 5])
+    total = a * x + b * y
+    people = friends + 1
+    if total % people:
+        return None
+    answer = total // people
+    if answer < 4:
+        return None
+    ctx = (
+        f"Priya bought {a} markers at {dollars(x)} each and {b} erasers at {dollars(y)} "
+        f"each. She split the total cost equally between herself and {friends} friends. "
+        f"Each person paid"
+    )
+    steps = [
+        (f"markers: {a} x {x} = {a * x}", a * x),
+        (f"erasers: {b} x {y} = {b * y}", b * y),
+        (f"total cost: {a * x} + {b * y} = {total}", total),
+        (f"split between {people} people: {total} / {people} = {answer}", answer),
+    ]
+    pool = [
+        ("split only between the friends", total // friends),
+        ("divided by one person too few", total // (people - 1)),
+        ("forgot the erasers", (a * x) // people),
+        ("charged the marker price for everything", ((a + b) * x) // people),
+        ("swapped the two unit prices", (a * y + b * x) // people),
+        ("did not split the total at all", total),
+        ("added the unit prices instead of multiplying", (a * (x + 1) + b * (y + 1)) // people),
+        ("split among one more person", total // (people + 1)),
+        ("bought one extra of each item", ((a + 1) * x + (b + 1) * y) // people),
+        ("split among two more people", total // (people + 2)),
+    ]
+    return Draft(
+        ctx=ctx,
+        answer=answer,
+        pool=pool,
+        fmt=money,
+        unit="dollars",
+        topic="money",
+        grade_band="grades_5_6",
+        difficulty="hard",
+        depth=4,  # two products, a sum, then the split
+        steps=steps,
+    )
+
+
+def fam_stock_percent_pack(rng: random.Random) -> Draft | None:
+    """depth 3 - sell a percentage, pack the rest (percent / packing)."""
+    stock = rng.choice([240, 280, 320, 360, 400, 440, 480])
+    pct = rng.choice([15, 25, 30, 40, 55])
+    crate = rng.choice([6, 7, 8, 9, 12])
+    sold = stock * pct // 100
+    rest = stock - sold
+    answer = rest // crate
+    if answer < 3:
+        return None
+    ctx = (
+        f"A shop had {stock} shirts. It sold {pct}% of them, then packed the rest into "
+        f"boxes of {crate}. The number of full boxes filled was"
+    )
+    steps = [
+        (f"sold: {pct}% of {stock} = {sold}", sold),
+        (f"left over: {stock} - {sold} = {rest}", rest),
+        (f"full boxes: {rest} / {crate} = {answer} (remainder {rest % crate})", answer),
+    ]
+    pool = [
+        ("packed the whole stock, not the rest", stock // crate),
+        ("packed the sold shirts", sold // crate),
+        ("rounded the box count up", -(-rest // crate)),
+        ("sold twice as many", (stock - 2 * sold) // crate),
+        ("took the percentage off the remainder again", (rest * (100 - pct) // 100) // crate),
+        ("divided by the number of boxes left over", rest // max(1, rest % crate)),
+        ("counted the loose shirts as a box", rest // crate + 1),
+        ("sold half the stock regardless of the percentage", (stock - stock // 2) // crate),
+        ("sold only a tenth of the stock", (stock - stock // 10) // crate),
+    ]
+    return Draft(
+        ctx=ctx,
+        answer=answer,
+        pool=pool,
+        fmt=lambda v: num(v, "boxes"),
+        unit="boxes",
+        topic="percent",
+        grade_band="grades_6",
+        difficulty="hard",
+        depth=3,
+        steps=steps,
+    )
+
+
+def fam_inventory_boxes(rng: random.Random) -> Draft | None:
+    """depth 4 - receive, ship, damage, then pack (multi-step)."""
+    start = rng.choice([420, 480, 560, 620, 700, 760, 840])
+    add = rng.choice([130, 180, 240, 260, 310])
+    ship = rng.choice([90, 140, 170, 210, 250])
+    damaged = rng.choice([12, 18, 24, 32, 40])
+    crate = rng.choice([8, 9, 12, 14, 16])
+    after_add = start + add
+    after_ship = after_add - ship
+    good = after_ship - damaged
+    answer = good // crate
+    if answer < 3 or good < 30:
+        return None
+    ctx = (
+        f"A warehouse held {start} units. A delivery added {add}, then {ship} units were "
+        f"shipped out, and {damaged} were found damaged. The rest were packed into crates "
+        f"of {crate}. The number of full crates packed was"
+    )
+    steps = [
+        (f"after delivery: {start} + {add} = {after_add}", after_add),
+        (f"after shipping: {after_add} - {ship} = {after_ship}", after_ship),
+        (f"good units: {after_ship} - {damaged} = {good}", good),
+        (f"full crates: {good} / {crate} = {answer} (remainder {good % crate})", answer),
+    ]
+    pool = [
+        ("forgot the damaged units", after_ship // crate),
+        ("forgot the shipping", (after_add - damaged) // crate),
+        ("added the damaged units", (after_ship + damaged) // crate),
+        ("shipped out twice", (after_add - 2 * ship - damaged) // crate),
+        ("counted the loose units as a crate", good // crate + 1),
+        ("stopped before packing", good),
+        ("packed the arriving units only", (add - damaged) // crate),
+        ("packed into larger crates", good // (crate + 1)),
+        ("shipped twice and damaged twice", (after_add - 2 * ship - 2 * damaged) // crate),
+        ("forgot the delivery", (start - ship - damaged) // crate),
+    ]
+    return Draft(
+        ctx=ctx,
+        answer=answer,
+        pool=pool,
+        fmt=lambda v: num(v, "crates"),
+        unit="crates",
+        topic="multi_step_inventory",
+        grade_band="grades_6_7",
+        difficulty="hard",
+        depth=4,
+        steps=steps,
+    )
+
+
+def fam_trip_minutes(rng: random.Random) -> Draft | None:
+    """depth 4 - two legs at different speeds plus a rest (rate/time)."""
+    v1 = rng.choice([12, 15, 18, 20])
+    v2 = rng.choice([4, 5, 6])
+    d1 = v1 * rng.choice([1, 2, 3])
+    d2 = v2 * rng.choice([1, 2, 3])
+    rest = rng.choice([12, 15, 20, 25, 30])
+    t1 = 60 * d1 // v1
+    t2 = 60 * d2 // v2
+    answer = t1 + rest + t2
+    if answer < 20 or (d1 + d2) < 6:
+        return None
+    ctx = (
+        f"Nadia cycled {d1} km at {v1} km/h, rested {rest} minutes, then walked {d2} km "
+        f"at {v2} km/h. Her total time, in minutes, was"
+    )
+    steps = [
+        (f"cycling time: 60 x {d1} / {v1} = {t1} minutes", t1),
+        (f"walking time: 60 x {d2} / {v2} = {t2} minutes", t2),
+        (f"add the rest: {t1} + {rest} + {t2} = {answer} minutes", answer),
+    ]
+    pool = [
+        ("forgot the rest", t1 + t2),
+        ("counted the rest twice", t1 + 2 * rest + t2),
+        ("counted the rest as hours", t1 + t2 + 60 * rest),
+        ("used the cycling speed for both legs", 60 * (d1 + d2) // v1 + rest),
+        ("used the walking speed for both legs", 60 * (d1 + d2) // v2 + rest),
+        ("forgot the walking leg", t1 + rest),
+        ("divided by the speed twice", (t1 + t2) // max(1, v2) + rest),
+    ]
+    return Draft(
+        ctx=ctx,
+        answer=answer,
+        pool=pool,
+        fmt=lambda v: num(v, "minutes"),
+        unit="minutes",
+        topic="rate_time",
+        grade_band="grades_6_7",
+        difficulty="hard",
+        depth=3,  # cycling time, walking time, then add the rest
+        steps=steps,
+    )
+
+
+def fam_discount_tax_coupon_split(rng: random.Random) -> Draft | None:
+    """depth 4 - discount, tax, coupon, then split (percent/money)."""
+    price = rng.choice([1200, 1600, 2000, 2400, 2800, 3600])
+    pct = rng.choice([10, 20, 25, 30])
+    tax = rng.choice([5, 8, 10, 15])
+    coupon = rng.choice([40, 60, 80, 120])
+    group = rng.choice([2, 3, 4, 5])
+    discount = price * pct // 100
+    reduced = price - discount
+    taxed = reduced * (100 + tax)
+    if taxed % 100:
+        return None
+    taxed //= 100
+    total = taxed - coupon
+    if total <= 0 or total % group:
+        return None
+    answer = total // group
+    if answer < 4:
+        return None
+    ctx = (
+        f"An order cost {dollars(price)}. A {pct}% discount came off it, then {tax}% tax "
+        f"was added to the discounted price, and a {dollars(coupon)} coupon was applied "
+        f"last. {group} people split the final cost equally. Each paid"
+    )
+    steps = [
+        (f"discount: {price} - {discount} = {reduced}", reduced),
+        (f"tax on the discounted price: {reduced} + {taxed - reduced} = {taxed}", taxed),
+        (f"coupon: {taxed} - {coupon} = {total}", total),
+        (f"split {group} ways: {total} / {group} = {answer}", answer),
+    ]
+    pool = [
+        ("forgot the coupon", taxed // group),
+        ("forgot the discount", ((price * (100 + tax) // 100) - coupon) // group),
+        (
+            "taxed the price before the discount",
+            (((price * (100 + tax) // 100) * (100 - pct) // 100) - coupon) // group,
+        ),
+        ("forgot the discount and the coupon", (price * (100 + tax) // 100) // group),
+        ("split the total among one fewer person", total // (group - 1) if group > 1 else total),
+        ("did not split the cost at all", total),
+        ("added the coupon instead of subtracting it", (taxed + coupon) // group),
+        ("split the price before the discount", price // group),
+        ("used the coupon twice", (taxed - 2 * coupon) // group),
+        ("split the total among one more person", total // (group + 1)),
+        (
+            "applied the discount twice",
+            (((price - 2 * discount) * (100 + tax) // 100) - coupon) // group,
+        ),
+    ]
+    return Draft(
+        ctx=ctx,
+        answer=answer,
+        pool=pool,
+        fmt=money,
+        unit="dollars",
+        topic="percent_money",
+        grade_band="grades_7_8",
+        difficulty="hard",
+        depth=4,
+        steps=steps,
+    )
+
+
+def fam_tank_fill(rng: random.Random) -> Draft | None:
+    """depth 4 - two fill stages, then a drain (rate)."""
+    start = rng.choice([120, 180, 240, 300])
+    r1 = rng.choice([6, 9, 12, 15])
+    t1 = rng.choice([4, 6, 8, 10])
+    r2 = rng.choice([3, 5, 7])
+    t2 = rng.choice([5, 7, 9])
+    drain = rng.choice([25, 40, 55, 70])
+    stage1 = r1 * t1
+    stage2 = r2 * t2
+    filled = start + stage1 + stage2
+    answer = filled - drain
+    if answer < 30:
+        return None
+    ctx = (
+        f"A tank held {start} litres. A pipe added {r1} litres per minute for {t1} minutes, "
+        f"then {r2} litres per minute for {t2} minutes. A drain then removed {drain} litres. "
+        f"The tank then held"
+    )
+    steps = [
+        (f"first fill: {r1} x {t1} = {stage1} litres", stage1),
+        (f"second fill: {r2} x {t2} = {stage2} litres", stage2),
+        (f"before draining: {start} + {stage1} + {stage2} = {filled}", filled),
+        (f"after draining: {filled} - {drain} = {answer}", answer),
+    ]
+    pool = [
+        ("forgot the drain", filled),
+        ("added the drain instead of removing it", filled + drain),
+        ("forgot the second fill", start + stage1 - drain),
+        ("forgot the first fill", start + stage2 - drain),
+        ("used the first rate for both stages", start + r1 * (t1 + t2) - drain),
+        ("added the rates and multiplied once", start + (r1 + r2) * (t1 + t2) - drain),
+        ("drained twice", filled - 2 * drain),
+    ]
+    return Draft(
+        ctx=ctx,
+        answer=answer,
+        pool=pool,
+        fmt=lambda v: num(v, "litres"),
+        unit="litres",
+        topic="rate",
+        grade_band="grades_6_7",
+        difficulty="hard",
+        depth=4,
+        steps=steps,
+    )
+
+
+def fam_schedule_sessions(rng: random.Random) -> Draft | None:
+    """depth 4 - two sessions and a break across the hour (time)."""
+    start = rng.randrange(6 * 60, 8 * 60 + 30)
+    m1 = rng.choice([45, 50, 55, 60, 70])
+    brk = rng.choice([10, 15, 20, 25])
+    m2 = rng.choice([35, 40, 45, 50])
+    end = start + m1 + brk + m2
+    if not 6 * 60 <= end <= 10 * 60 + 45:
+        return None
+    ctx = (
+        f"Rehearsal began at {_clock(start).strip()}. The first session lasted {m1} minutes, "
+        f"the break lasted {brk} minutes, and the second session lasted {m2} minutes. "
+        f"Rehearsal ended at"
+    )
+    steps = [
+        (f"after the first session: {start} + {m1} = {start + m1} minutes after midnight", start + m1),
+        (f"after the break: {start + m1} + {brk} = {start + m1 + brk}", start + m1 + brk),
+        (f"after the second session: {start + m1 + brk} + {m2} = {end}", end),
+    ]
+
+    def fmt(v: int) -> str:
+        return _clock(v)
+
+    pool = [
+        ("forgot the break", start + m1 + m2),
+        ("counted the break twice", end + brk),
+        ("forgot the second session", start + m1 + brk),
+        ("counted the first session twice", start + 2 * m1 + brk + m2),
+        ("counted the break as hours, not minutes", end + brk * 60),
+        ("dropped the hour carry", start - (start % 60) + (end % 60)),
+        ("added the minutes but not the hours", start + (m1 + brk + m2) % 60),
+        ("counted the first session as hours, not minutes", start + m1 * 60 + brk + m2),
+        ("finished half an hour late on top of the break", end + brk + 30),
+        ("forgot the last session and the break", start + m1),
+    ]
+    pool = _same_period(pool, 0)
+    return Draft(
+        ctx=ctx,
+        answer=end,
+        pool=pool,
+        fmt=fmt,
+        unit="clock time",
+        topic="time",
+        grade_band="grades_6_7",
+        difficulty="hard",
+        depth=3,  # three dependent additions across the hour
+        steps=steps,
+        render_is_number=False,
+    )
+
+
+def fam_salary_overtime_tax(rng: random.Random) -> Draft | None:
+    """depth 5 - base pay, overtime at 1.5x, bonus, then tax (money)."""
+    hours = rng.choice([32, 36, 38, 40])
+    ot_hours = rng.choice([4, 6, 8, 10])
+    rate = rng.choice([1200, 1400, 1600, 1800, 2000])
+    bonus = rng.choice([2000, 3000, 4000, 5000])
+    tax = rng.choice([10, 15, 20, 25])
+    base = hours * rate
+    ot_rate = rate * 3 // 2
+    overtime = ot_hours * ot_rate
+    gross = base + overtime + bonus
+    if gross * tax % 100:
+        return None
+    withheld = gross * tax // 100
+    answer = gross - withheld
+    ctx = (
+        f"Jo worked {hours} regular hours at {dollars(rate)} an hour and {ot_hours} "
+        f"overtime hours at one and a half times that rate. A {dollars(bonus)} bonus was "
+        f"added, and then {tax}% of the total was withheld for tax. Jo took home"
+    )
+    steps = [
+        (f"regular pay: {hours} x {rate} = {base}", base),
+        (f"overtime rate: {rate} x 1.5 = {ot_rate}", ot_rate),
+        (f"overtime pay: {ot_hours} x {ot_rate} = {overtime}", overtime),
+        (f"gross with bonus: {base} + {overtime} + {bonus} = {gross}", gross),
+        (f"take-home: {gross} - {withheld} = {answer}", answer),
+    ]
+    gross_no_bonus = base + overtime
+    pool = [
+        ("forgot the tax", gross),
+        ("added the tax instead of withholding it", gross + withheld),
+        ("forgot the bonus", gross_no_bonus - gross_no_bonus * tax // 100),
+        ("paid overtime at the normal rate", (base + ot_hours * rate + bonus) - (base + ot_hours * rate + bonus) * tax // 100),
+        ("taxed only the regular pay", gross - base * tax // 100),
+        ("paid overtime at double rate", (base + 2 * ot_hours * rate + bonus) - (base + 2 * ot_hours * rate + bonus) * tax // 100),
+        ("forgot the overtime", (base + bonus) - (base + bonus) * tax // 100),
+        ("taxed twice", gross - 2 * withheld),
+    ]
+    return Draft(
+        ctx=ctx,
+        answer=answer,
+        pool=pool,
+        fmt=money,
+        unit="dollars",
+        topic="money_rate",
+        grade_band="grades_7_8",
+        difficulty="hard",
+        depth=5,
+        steps=steps,
+    )
+
+
+def fam_inventory_percent_chain(rng: random.Random) -> Draft | None:
+    """depth 5 - two percentage days, then palletising."""
+    stock = rng.choice([600, 800, 1000, 1200, 1400, 1600])
+    p1 = rng.choice([10, 20, 25, 30])
+    p2 = rng.choice([10, 20, 25, 40])
+    pallet = rng.choice([8, 10, 12, 15])
+    monday = stock * p1 // 100
+    rem1 = stock - monday
+    tuesday = rem1 * p2 // 100
+    rem2 = rem1 - tuesday
+    answer = rem2 // pallet
+    if answer < 3 or rem2 < 40:
+        return None
+    ctx = (
+        f"A depot held {stock} sacks. It sent out {p1}% of them on Monday and {p2}% of the "
+        f"remainder on Tuesday. The rest were stacked on pallets of {pallet}. "
+        f"The number of full pallets was"
+    )
+    steps = [
+        (f"Monday: {p1}% of {stock} = {monday}", monday),
+        (f"left after Monday: {stock} - {monday} = {rem1}", rem1),
+        (f"Tuesday: {p2}% of {rem1} = {tuesday}", tuesday),
+        (f"left after Tuesday: {rem1} - {tuesday} = {rem2}", rem2),
+        (f"full pallets: {rem2} / {pallet} = {answer}", answer),
+    ]
+    pool = [
+        (
+            "took both percentages off the original stock",
+            (stock - stock * p1 // 100 - stock * p2 // 100) // pallet,
+        ),
+        ("forgot Tuesday", rem1 // pallet),
+        ("forgot Monday", (stock - tuesday) // pallet),
+        (
+            "took the second percentage off the original stock",
+            (rem1 - stock * p2 // 100) // pallet,
+        ),
+        ("counted the loose sacks as a pallet", rem2 // pallet + 1),
+        ("stopped before palletising", rem2),
+        ("stacked on larger pallets", rem2 // (pallet + 1)),
+        ("added the two percentages", (stock - stock * (p1 + p2) // 100) // pallet),
+        ("took both percentages twice", (stock - 2 * monday - 2 * tuesday) // pallet),
+    ]
+    return Draft(
+        ctx=ctx,
+        answer=answer,
+        pool=pool,
+        fmt=lambda v: num(v, "pallets"),
+        unit="pallets",
+        topic="percent_multi_step",
+        grade_band="grades_7_8",
+        difficulty="hard",
+        depth=5,  # two percentage days, then palletising
+        steps=steps,
+    )
+
+
+def fam_prize_ratio_charity(rng: random.Random) -> Draft | None:
+    """depth 5 - fee, ratio split, charity cut, then split among players."""
+    parts_a = rng.choice([2, 3, 4, 5])
+    parts_b = rng.choice([1, 2, 3])
+    if parts_a <= parts_b:
+        return None
+    unit = rng.choice([30, 40, 50, 60, 70])
+    fee = rng.choice([200, 300, 400, 500])
+    charity = rng.choice([10, 20, 25, 50])
+    players = rng.choice([4, 5, 8])
+    prize = (parts_a + parts_b) * unit + fee
+    share = parts_a * unit
+    charity_cut = share * charity // 100
+    kept = share - charity_cut
+    if kept % players or kept == 0:
+        return None
+    answer = kept // players
+    if answer < 4:
+        return None
+    ctx = (
+        f"A prize of {dollars(prize)} was split between two teams in the ratio "
+        f"{parts_a}:{parts_b} after a {dollars(fee)} fee was deducted. The larger team gave "
+        f"{charity}% of its share to charity and split the rest equally among its {players} "
+        f"players. Each player got"
+    )
+    steps = [
+        (f"after the fee: {prize} - {fee} = {prize - fee}", prize - fee),
+        (f"one ratio part: {prize - fee} / {parts_a + parts_b} = {unit}", unit),
+        (f"larger share: {parts_a} x {unit} = {share}", share),
+        (f"after charity: {share} - {charity_cut} = {kept}", kept),
+        (f"per player: {kept} / {players} = {answer}", answer),
+    ]
+    pre_fee = prize // (parts_a + parts_b)
+    pool = [
+        ("forgot to deduct the fee", (pre_fee * parts_a) // players),
+        ("gave the larger share to the smaller ratio", (parts_b * unit) // players),
+        ("forgot the charity cut", share // players),
+        ("split the whole prize among one team", (prize - fee) // players),
+        ("divided between the teams instead of the players", kept // 2),
+        (
+            "took the charity cut off the whole prize",
+            ((prize - fee) - (prize - fee) * charity // 100) // players,
+        ),
+        (
+            "swapped the ratio parts",
+            ((parts_b * unit) - (parts_b * unit) * charity // 100) // players,
+        ),
+        ("split among one more player", kept // (players + 1)),
+        ("gave twice the share away to charity", (share - 2 * charity_cut) // players),
+        ("forgot the fee and the charity cut", ((prize - fee) // 2) // players),
+    ]
+    return Draft(
+        ctx=ctx,
+        answer=answer,
+        pool=pool,
+        fmt=money,
+        unit="dollars",
+        topic="ratio",
+        grade_band="grades_7_8",
+        difficulty="hard",
+        depth=5,
+        steps=steps,
+    )
+
+
+FAMILIES: dict[int, list[Callable[[random.Random], Draft | None]]] = {
+    2: [fam_money_discount_fee, fam_time_clock_end],
+    3: [
+        fam_measure_cm_cut,
+        fam_share_then_split,
+        fam_two_rate_pay,
+        fam_stock_percent_pack,
+        fam_trip_minutes,
+        fam_schedule_sessions,
+    ],
+    4: [
+        fam_inventory_boxes,
+        fam_discount_tax_coupon_split,
+        fam_tank_fill,
+        fam_mix_split,
+    ],
+    5: [fam_salary_overtime_tax, fam_inventory_percent_chain, fam_prize_ratio_charity],
+}
+
+
+# ---------------------------------------------------------------------------
+# assembling four options from a draft
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class Assembled:
+    draft: Draft
+    decoys: list[tuple[str, int]]  # exactly 3 wrong-path (kind, value) pairs
+
+    @property
+    def rank(self) -> int:
+        """0 = answer is the smallest of the four, 3 = the largest."""
+        answer = self.draft.answer
+        return sum(1 for _, v in self.decoys if v < answer)
+
+    def slots(self, label: int) -> tuple[list[int], list[str]]:
+        """Lay the answer at `label` and the decoys in the remaining slots."""
+        values: list[int] = []
+        sources: list[str] = []
+        remaining = list(self.decoys)
+        for slot in range(4):
+            if slot == label:
+                values.append(self.draft.answer)
+                sources.append("correct")
+            else:
+                kind, value = remaining.pop(0)
+                values.append(value)
+                sources.append(kind)
+        return values, sources
+
+
+def roundness(v: int) -> int:
+    """How "prototypical" a number looks: trailing zeros, capped at 3."""
+    if v == 0:
+        return 3
+    score = 0
+    while v % 10 == 0 and score < 3:
+        v //= 10
+        score += 1
+    return score
+
+
+def _implausible(value: int, answer: int) -> bool:
+    """Reject decoys a reader would eliminate without doing any arithmetic.
+
+    A decoy that is an order of magnitude off, or several powers of ten rounder
+    than the answer, is not a reasoning trap -- it is a surface cue, and a base
+    model will simply pick whichever option looks most prototypical. Both cases
+    showed up in error analysis (gpt2 picked a "roundest option" on 84 % of
+    items and scored far below chance as a result).
+    """
+    if answer > 0 and (value > 4 * answer or value * 4 < answer):
+        return True
+    # Same roundness class as the answer. A number's "naturalness" (trailing
+    # zeros) is the one surface feature a base model reliably smooths toward, so
+    # if the correct option is systematically the least round one, a model that
+    # cannot compute scores *below* chance. Keeping all four in one class makes
+    # the options exchangeable under the model's no-skill prior.
+    return roundness(value) != roundness(answer)
+
+
+def _too_clustered(values: list[int]) -> bool:
+    """Reject option sets where three or more values are consecutive integers.
+
+    One near-miss is a legitimate boundary error (floor vs ceil). A whole run of
+    adjacent integers is ArithMark 3.0's shortcut and is what we are removing.
+    """
+    ordered = sorted(values)
+    gaps_of_one = sum(1 for a, b in zip(ordered, ordered[1:]) if b - a == 1)
+    return gaps_of_one >= 2
+
+
+def assemble(
+    draft: Draft, rng: random.Random, target_rank: int, max_tries: int = 40
+) -> Assembled | None:
+    """Pick three wrong-path values so the answer lands at `target_rank`."""
+    answer = draft.answer
+    seen: set[int] = set()
+    pool: list[tuple[str, int]] = []
+    for kind, value in draft.pool:
+        if not isinstance(value, int) or value == answer or value in seen:
+            continue
+        if draft.render_is_number and not _ok_value(value):
+            continue
+        if _implausible(value, answer):
+            continue
+        seen.add(value)
+        pool.append((kind, value))
+    below = [(k, v) for k, v in pool if v < answer]
+    above = [(k, v) for k, v in pool if v > answer]
+    want_below = target_rank
+    want_above = 3 - target_rank
+    if len(below) < want_below or len(above) < want_above:
+        return None
+    for _ in range(max_tries):
+        chosen = rng.sample(below, want_below) + rng.sample(above, want_above)
+        values = [answer] + [v for _, v in chosen]
+        if len(set(values)) != 4:
+            continue
+        if draft.render_is_number and any(not _ok_value(v) for v in values):
+            continue
+        if _too_clustered(values):
+            continue
+        return Assembled(draft=draft, decoys=chosen)
+    return None
+
+
+# ---------------------------------------------------------------------------
+# dataset build
+# ---------------------------------------------------------------------------
+
+
+def _activity_label(draft: Draft) -> str:
+    return (
+        f"deeparithmark::{DATASET_NAME}::{draft.topic}::"
+        f"depth{draft.depth}::{draft.difficulty}"
+    )
+
+
+def _record(a: Assembled, index: int, label: int, template_id: str) -> dict:
+    d = a.draft
+    values, sources = a.slots(label)
+    endings = [d.fmt(v) for v in values]
+    assert sources[label] == "correct"
+    assert values[label] == d.answer
+    return {
+        "ind": index,
+        "activity_label": _activity_label(d),
+        "ctx_a": d.ctx,
+        "ctx_b": "",
+        "ctx": d.ctx,
+        "endings": endings,
+        "source_id": f"deeparithmark_v1_{d.topic}_depth{d.depth}_{index:04d}",
+        "split": "test",
+        "split_type": "synthetic",
+        "label": str(label),
+        "metadata": {
+            "answer": str(d.answer),
+            "unit": d.unit,
+            "topic": d.topic,
+            "difficulty": d.difficulty,
+            "grade_band": d.grade_band,
+            "template_id": template_id,
+            "depth": d.depth,
+            "option_sources": sources,
+            "solution_steps": [text for text, _ in d.steps],
+            "option_values": values,
+            "answer_rank": a.rank,
+            "format_note": (
+                "Continuation-style prompt for base-model log-likelihood scoring; "
+                "endings include leading spaces and share one unit phrase."
+            ),
+        },
+    }
+
+
+def template_id_for(fn: Callable) -> str:
+    return fn.__name__.removeprefix("fam_")
+
+
+def build(seed: int = 20261027, total_depths: int = PER_DEPTH) -> list[dict]:
+    """Generate the balanced dataset, deterministically for a given seed."""
+    rng = random.Random(seed)
+    records: list[dict] = []
+    used_ctx: set[str] = set()
+    shortfall: Counter = Counter()
+    index = 0
+    for depth in DEPTHS:
+        families = FAMILIES[depth]
+        slot_rotation = 0
+        for rank, quota in enumerate(RANK_QUOTAS):
+            need = round(quota * total_depths / PER_DEPTH)
+            produced = 0
+            # stagger which family leads each rank bucket, so no topic is
+            # confined to one rank, then split the cell evenly across families
+            rotation = rank % len(families)
+            order = families[rotation:] + families[:rotation]
+            shares = [need // len(order)] * len(order)
+            for i in range(need - sum(shares)):
+                shares[i] += 1
+            for family, want in zip(order, shares):
+                got = 0
+                attempts = 0
+                while got < want and attempts < 8000:
+                    attempts += 1
+                    draft = family(rng)
+                    if draft is None:
+                        continue
+                    a = assemble(draft, rng, rank)
+                    if a is None:
+                        continue
+                    if draft.ctx in used_ctx:
+                        continue
+                    if not draft.steps or draft.steps[-1][1] != draft.answer:
+                        raise AssertionError(
+                            f"{family.__name__} produced an inconsistent chain"
+                        )
+                    used_ctx.add(draft.ctx)
+                    # the answer slot rotates so label counts stay flat per depth
+                    label = slot_rotation % 4
+                    slot_rotation += 1
+                    records.append(_record(a, index, label, template_id_for(family)))
+                    index += 1
+                    got += 1
+                    produced += 1
+            # a family that cannot reach this rank hands its share to the others
+            attempts = 0
+            while produced < need and attempts < 60000:
+                attempts += 1
+                family = order[attempts % len(order)]
+                draft = family(rng)
+                if draft is None:
+                    continue
+                a = assemble(draft, rng, rank)
+                if a is None or draft.ctx in used_ctx:
+                    continue
+                if not draft.steps or draft.steps[-1][1] != draft.answer:
+                    raise AssertionError(
+                        f"{family.__name__} produced an inconsistent chain"
+                    )
+                used_ctx.add(draft.ctx)
+                label = slot_rotation % 4
+                slot_rotation += 1
+                records.append(_record(a, index, label, template_id_for(family)))
+                index += 1
+                produced += 1
+            if produced < need:
+                shortfall[(depth, rank)] = need - produced
+    if shortfall:
+        raise RuntimeError(
+            "could not fill every (depth, rank) cell; widen the parameter ranges: "
+            f"{dict(shortfall)}"
+        )
+    rng.shuffle(records)
+    for i, rec in enumerate(records):
+        rec["ind"] = i
+        rec["source_id"] = (
+            f"deeparithmark_v1_{rec['metadata']['topic']}_"
+            f"depth{rec['metadata']['depth']}_{i:04d}"
+        )
+    return records
+
+
+# ---------------------------------------------------------------------------
+# validation
+# ---------------------------------------------------------------------------
+
+
+def load_jsonl(path: Path) -> list[dict]:
+    out = []
+    with path.open(encoding="utf-8-sig") as fh:
+        for line_no, line in enumerate(fh, 1):
+            if not line.strip():
+                continue
+            try:
+                out.append(json.loads(line))
+            except json.JSONDecodeError as exc:
+                raise ValueError(f"{path}:{line_no}: invalid JSON") from exc
+    return out
+
+
+def validate(records: list[dict], verbose: bool = True) -> dict:
+    """Assert every structural invariant the benchmark claims to have."""
+    problems: list[str] = []
+    ctx_seen: Counter = Counter()
+    depth_c: Counter = Counter()
+    rank_c: Counter = Counter()
+    label_c: Counter = Counter()
+    topic_c: Counter = Counter()
+    template_c: Counter = Counter()
+    grid: Counter = Counter()
+    adjacent_items = 0
+
+    for rec in records:
+        rid = rec.get("ind")
+        ctx = rec.get("ctx")
+        endings = rec.get("endings")
+        try:
+            label = int(rec.get("label"))
+        except (TypeError, ValueError):
+            problems.append(f"{rid}: label is not an int")
+            continue
+        if not isinstance(ctx, str) or not ctx.strip():
+            problems.append(f"{rid}: empty ctx")
+            continue
+        if not isinstance(endings, list) or len(endings) != 4:
+            problems.append(f"{rid}: expected exactly 4 endings")
+            continue
+        if not 0 <= label < 4:
+            problems.append(f"{rid}: label out of range")
+            continue
+        if not all(isinstance(e, str) and e.startswith(" ") for e in endings):
+            problems.append(f"{rid}: an ending lost its leading space")
+        if len(set(endings)) != 4:
+            problems.append(f"{rid}: duplicate endings")
+        # every option must share the unit phrase: strip the leading number/time
+        tails = {_unit_of(e) for e in endings}
+        if len(tails) != 1:
+            problems.append(f"{rid}: options have different unit phrases {tails}")
+        if re_has_value_one(endings):
+            problems.append(f"{rid}: option value 1 with a plural unit")
+        meta = rec["metadata"]
+        values = meta.get("option_values")
+        if not isinstance(values, list) or len(values) != 4:
+            problems.append(f"{rid}: option_values missing")
+            values = None
+        elif int(meta["answer"]) != values[label]:
+            problems.append(f"{rid}: label does not point at the answer value")
+        if values:
+            rank = sum(1 for v in values if v < values[label])
+            if rank != meta.get("answer_rank"):
+                problems.append(f"{rid}: answer_rank does not match values")
+            ordered = sorted(values)
+            if sum(1 for a, b in zip(ordered, ordered[1:]) if b - a == 1) >= 2:
+                adjacent_items += 1
+                problems.append(f"{rid}: options cluster on consecutive integers")
+            if len(set(values)) != 4:
+                problems.append(f"{rid}: duplicate option values")
+        sources = meta.get("option_sources")
+        if not isinstance(sources, list) or len(sources) != 4:
+            problems.append(f"{rid}: option_sources missing")
+        elif sources[label] != "correct":
+            problems.append(f"{rid}: option_sources is not aligned with the label")
+        if not meta.get("depth") in DEPTHS:
+            problems.append(f"{rid}: bad depth")
+        steps = meta.get("solution_steps")
+        if not steps:
+            problems.append(f"{rid}: missing solution_steps")
+        elif len(steps) != meta.get("depth"):
+            problems.append(
+                f"{rid}: {len(steps)} solution steps but declared depth {meta.get('depth')}"
+            )
+        ctx_seen[ctx] += 1
+        depth_c[meta.get("depth")] += 1
+        rank_c[meta.get("answer_rank")] += 1
+        label_c[label] += 1
+        topic_c[meta.get("topic")] += 1
+        template_c[meta.get("template_id")] += 1
+        grid[(meta.get("depth"), meta.get("answer_rank"), label)] += 1
+
+    dupes = [c for c, n in ctx_seen.items() if n > 1]
+    if dupes:
+        problems.append(f"{len(dupes)} duplicated prompts")
+
+    n = len(records)
+    balance = {
+        "n": n,
+        "depth": dict(sorted(depth_c.items())),
+        "rank": dict(sorted(rank_c.items())),
+        "label": dict(sorted(label_c.items())),
+        "topic": dict(sorted(topic_c.items())),
+        "templates": len(template_c),
+        "worst_grid_cell": min(grid.values()) if grid else 0,
+        "best_grid_cell": max(grid.values()) if grid else 0,
+        "adjacent_option_items": adjacent_items,
+    }
+    if verbose:
+        print(f"items: {n}")
+        print(f"depth: {balance['depth']}")
+        print(f"answer rank: {balance['rank']}")
+        print(f"label slot: {balance['label']}")
+        print(f"topics: {balance['topic']}")
+        print(f"templates: {balance['templates']}")
+        print(
+            f"(depth, rank, slot) grid: {balance['worst_grid_cell']}"
+            f"..{balance['best_grid_cell']} items per cell"
+        )
+        print(f"options clustering on consecutive ints: {adjacent_items} items")
+        if problems:
+            print(f"\nPROBLEMS ({len(problems)}):")
+            for p in problems[:20]:
+                print("  -", p)
+    return {"problems": problems, "balance": balance}
+
+
+def _unit_of(ending: str) -> str:
+    """The part of an ending after its leading numeric/time token."""
+    text = ending.strip()
+    parts = text.split(" ")
+    return " ".join(parts[1:]) if len(parts) > 1 else ""
+
+
+def re_has_value_one(endings: list[str]) -> bool:
+    for e in endings:
+        head = e.strip().split(" ")[0]
+        if head == "1":
+            return True
+    return False
+
+
+# ---------------------------------------------------------------------------
+# shortcut audit: prove the options cannot be gamed without arithmetic
+# ---------------------------------------------------------------------------
+
+
+def audit(records: list[dict], seeds: int = 5) -> dict:
+    """Measure what a model can score without doing any arithmetic.
+
+    Baselines that need no reasoning at all (pick largest / pick a fixed slot /
+    pick the longest string) plus a trained character-n-gram classifier over the
+    option text. If the last one clears ~25 % the option strings leak the answer
+    and the benchmark is broken, whatever the model scores say.
+    """
+    import numpy as np
+
+    n = len(records)
+    report: dict = {}
+
+    def acc(picker) -> float:
+        hits = 0
+        for rec in records:
+            if picker(rec) == int(rec["label"]):
+                hits += 1
+        return 100.0 * hits / n
+
+    def numeric(rec):
+        return rec["metadata"].get("option_values")
+
+    def pick_largest(rec):
+        v = numeric(rec)
+        return max(range(4), key=lambda i: v[i]) if v else 0
+
+    def pick_smallest(rec):
+        v = numeric(rec)
+        return min(range(4), key=lambda i: v[i]) if v else 0
+
+    def pick_median(rec):
+        v = numeric(rec)
+        if not v:
+            return 0
+        order = sorted(range(4), key=lambda i: v[i])
+        return order[1]
+
+    def pick_roundest(rec):
+        values = numeric(rec)
+        if not values:
+            return 0
+        return max(range(4), key=lambda i: roundness(values[i]))
+
+    def pick_longest(rec):
+        return max(range(4), key=lambda i: len(rec["endings"][i]))
+
+    def pick_shortest(rec):
+        return min(range(4), key=lambda i: len(rec["endings"][i]))
+
+    report["pick_largest"] = acc(pick_largest)
+    report["pick_smallest"] = acc(pick_smallest)
+    report["pick_second_smallest"] = acc(pick_median)
+    report["pick_roundest"] = acc(pick_roundest)
+    report["pick_longest"] = acc(pick_longest)
+    report["pick_shortest"] = acc(pick_shortest)
+    report["fixed_slot"] = [
+        acc(lambda rec, s=s: s) for s in range(4)
+    ]
+
+    # character n-gram logistic regression over the option text only
+    def features(text: str) -> np.ndarray:
+        text = text.strip().lower()
+        grams = [text[i : i + 3] for i in range(max(1, len(text) - 2))]
+        grams += [f"#{g}" for g in text.split(" ")[0][:4]]
+        return grams
+
+    def run_probe(seed: int) -> float:
+        rng = random.Random(seed)
+        idx = list(range(n))
+        rng.shuffle(idx)
+        cut = int(0.7 * n)
+        train, test = idx[:cut], idx[cut:]
+        vocab: dict[str, int] = {}
+        X, y = [], []
+        for i in train:
+            rec = records[i]
+            for slot in range(4):
+                y.append(1 if slot == int(rec["label"]) else 0)
+                X.append(features(rec["endings"][slot]))
+        for gs in X:
+            for g in gs:
+                if g not in vocab:
+                    vocab[g] = len(vocab)
+        dim = len(vocab) + 1
+        Xm = np.zeros((len(X), dim), dtype=np.float32)
+        for r, gs in enumerate(X):
+            for g in gs:
+                Xm[r, vocab[g]] += 1.0
+        Xm[:, -1] = 1.0  # bias
+        Xm /= np.maximum(1.0, Xm.sum(axis=1, keepdims=True))
+        ym = np.array(y, dtype=np.float32)
+        w = np.zeros(dim, dtype=np.float32)
+        lr, l2 = 0.5, 1e-4
+        for _ in range(300):
+            p = 1.0 / (1.0 + np.exp(-(Xm @ w)))
+            grad = Xm.T @ (p - ym) / len(ym) + l2 * w
+            w -= lr * grad
+        hits = 0
+        for i in test:
+            rec = records[i]
+            scores = []
+            for slot in range(4):
+                gs = features(rec["endings"][slot])
+                vec = np.zeros(dim, dtype=np.float32)
+                for g in gs:
+                    if g in vocab:
+                        vec[vocab[g]] += 1.0
+                vec[-1] = 1.0
+                vec /= max(1.0, vec.sum())
+                scores.append(float(vec @ w))
+            if max(range(4), key=lambda s: scores[s]) == int(rec["label"]):
+                hits += 1
+        return 100.0 * hits / len(test)
+
+    probe = [run_probe(1000 + s) for s in range(seeds)]
+    report["ngram_probe"] = probe
+    report["ngram_probe_mean"] = statistics.mean(probe)
+    report["ngram_probe_max"] = max(probe)
+    report["chance"] = 25.0
+
+    print("\nshortcut audit (chance = 25.00%)")
+    print(f"  pick largest value        {report['pick_largest']:6.2f}%")
+    print(f"  pick smallest value       {report['pick_smallest']:6.2f}%")
+    print(f"  pick second smallest      {report['pick_second_smallest']:6.2f}%")
+    print(f"  pick roundest number      {report['pick_roundest']:6.2f}%")
+    print(f"  pick longest option text  {report['pick_longest']:6.2f}%")
+    print(f"  pick shortest option text {report['pick_shortest']:6.2f}%")
+    print("  fixed slot               " + " ".join(f"{v:6.2f}%" for v in report["fixed_slot"]))
+    print(
+        f"  char-3gram probe (mean)   {report['ngram_probe_mean']:6.2f}%"
+        f"   (max {report['ngram_probe_max']:.2f}% over {seeds} splits)"
+    )
+    worst = max(
+        [
+            report["pick_largest"],
+            report["pick_smallest"],
+            report["pick_roundest"],
+            report["ngram_probe_mean"],
+        ]
+    )
+    report["worst_shortcut"] = worst
+    if worst > 30.0:
+        print(f"  WARNING: a shortcut reaches {worst:.2f}% -- options leak the answer")
+    else:
+        print("  OK: no shortcut materially beats chance")
+    return report
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+def cmd_build(args) -> None:
+    records = build(seed=args.seed, total_depths=args.per_depth)
+    out = Path(args.out)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    with out.open("w", encoding="utf-8") as fh:
+        for rec in records:
+            fh.write(json.dumps(rec, ensure_ascii=False) + "\n")
+    digest = hashlib.sha256(out.read_bytes()).hexdigest()
+    print(f"wrote {len(records)} items to {out}")
+    print(f"sha256: {digest}")
+
+
+def cmd_selftest(args) -> None:
+    path = Path(args.data)
+    if not path.exists():
+        raise SystemExit(f"missing {path}; run `build` first")
+    records = load_jsonl(path)
+    result = validate(records)
+    if result["problems"]:
+        raise SystemExit(f"{len(result['problems'])} validation problems")
+    # ArithMark 3.0's own loader rules, repeated here so compatibility is checked
+    for rec in records:
+        assert rec["ctx"] and rec["endings"] and len(rec["endings"]) >= 2
+        assert all(e.startswith(" ") for e in rec["endings"])
+        assert all(isinstance(e, str) and e for e in rec["endings"])
+        int(rec["label"])
+    print("\nselftest: OK (schema matches ArithMark 3.0; all invariants hold)")
+    if not args.no_audit:
+        audit(records)
+
+
+def cmd_audit(args) -> None:
+    records = load_jsonl(Path(args.data))
+    validate(records, verbose=False)
+    audit(records)
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    b = sub.add_parser("build", help="generate the dataset")
+    b.add_argument("--out", default=f"deeparithmark-dataset/data/{DATASET_NAME}.jsonl")
+    b.add_argument("--seed", type=int, default=20261027)
+    b.add_argument("--per-depth", type=int, default=PER_DEPTH)
+    b.set_defaults(func=cmd_build)
+
+    s = sub.add_parser("selftest", help="validate the dataset and audit shortcuts")
+    s.add_argument("--data", default=f"deeparithmark-dataset/data/{DATASET_NAME}.jsonl")
+    s.add_argument("--no-audit", action="store_true")
+    s.set_defaults(func=cmd_selftest)
+
+    a = sub.add_parser("audit", help="shortcut audit only")
+    a.add_argument("--data", default=f"deeparithmark-dataset/data/{DATASET_NAME}.jsonl")
+    a.set_defaults(func=cmd_audit)
+
+    args = ap.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()