Datasets:

OPENGCM
/

DeepArithmark-1

---
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
---

![image](https://cdn-uploads.huggingface.co/production/uploads/69c842686cf758859915159c/EU5Wf-2PNhf6VzK1KKkmP.png)

**1,000 arithmetic word problems that need 2–5 dependent operations.** Same
format as [ArithMark 3.0](https://huggingface.co/datasets/AxiomicLabs/Arithmark-3.0)
— finish the sentence, pick one of four continuations, chance 25 % — but the
wrong answers are no longer ±1 of the right one, so a magnitude guess does not
work.

> **Unofficial.** Deep Arithmark is an independent 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.

| | |
| --- | ---: |
| Examples | 1,000 |
| Choices per example | 4 |
| Chance | 25 % |
| Depth tiers | 2, 3, 4, 5 — 250 each |
| Templates / topic labels | 15 / 14 |
| Mean prompt length | 29.2 words (max 43) |
| Language, source | English, synthetic (deterministic seed) |

## Quick start

```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, take the argmax, compare with int(item["label"])
```

Score models directly, including an ArithMark 3.0 comparison on the same weights:

```bash
python bench_deeparithmark.py --compare --model HuggingFaceTB/SmolLM2-135M
```

ArithMark 3.0's own scorer runs on this file unchanged (verified against that
script's loader):

```bash
python bencharithmark-3.py --data-path data/deeparithmark-1.jsonl --model gpt2
```

## Why it is harder

ArithMark 3.0's four continuations are **adjacent integers** (43 / 44 / 45 / 46).
Rejecting a wrong option only needs "the answer is about 44", so a magnitude
prior is sufficient and the arithmetic is optional. Deep Arithmark keeps the
contract and changes three things:

1. **Depth.** Every item needs 2–5 dependent operations; later steps consume
   earlier results. `depth` equals the length of `metadata.solution_steps`, and
   the build fails otherwise.
2. **Decoys with provenance.** No decoy is "answer ± 1". Each one is the exact
   value of a specific plausible mistake — the state after step 2 instead of
   step 5, the percentage on the wrong base, the divisor `n` instead of `n + 1`,
   the dropped unit conversion. `metadata.option_sources` names the mistake per
   ending, so error analysis can ask *which step* a model botches.
3. **Balanced on three axes.** Correct slot, the answer's *numeric rank*, and the
   *roundness class* of all four options are each balanced. "Pick the largest"
   and "pick the roundest number" are both worth 25 %.

## One item

```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 answer is ` 26 crates.` — `420 + 260 − 210 − 40 = 430`, and `430 // 16 = 26`
full crates. `29` is what you get by forgetting the damaged units, `27` by
counting the loose units as a crate, `31` by adding them.

## Scores

Zero-shot, `acc_norm`, bf16, batch 32, `--max-context 1024`. ArithMark 3.0
numbers were produced on the same weights in the same run, not copied from a
table. `soft` is the mean probability of the correct option after a softmax over
the four scores; `d2`–`d5` are `acc_norm` per depth tier (250 items each, chance
25 %). Δ is Deep Arithmark minus ArithMark 3.0. Every row is in one file,
`benchmarks/deeparithmark_17models.json`.

`LiquidAI/LFM3-1.7B-Base` ships remote modelling code written against
transformers 4.x — it decorates its convolution with a hub-kernel helper that
5.x removed — so the scorer stubs two deleted helpers and runs the checkpoint's
own pure-torch path. Re-scoring it at batch 8 instead of 32 moved two items
(31.90 % against 31.70 %), which is bf16 kernel noise, not a padding leak.

| Model | Params | Deep | soft | d2 | d3 | d4 | d5 | ArithMark-3 | Δ |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| SmolLM3-3B-Base (2025-06) | 3.08 B | 36.50 % | 27.09 % | 57.6 | 35.6 | 26.0 | 26.8 | 75.70 % | −39.20 |
| Qwen3.5-2B-Base (2026-02) | 1.88 B | 36.00 % | 27.01 % | 59.2 | 26.4 | 28.8 | 29.6 | 86.70 % | −50.70 |
| LFM3-1.7B-Base (2026-10) | 1.73 B | 31.70 % | 26.42 % | 41.2 | 38.4 | 23.6 | 23.6 | **93.10 %** | **−61.40** |
| granite-4.0-1b-base (2025-10) | 1.63 B | 29.90 % | 26.13 % | 39.2 | 29.2 | 28.4 | 22.8 | 84.20 % | −54.30 |
| Qwen2.5-1.5B-Instruct | 1.54 B | 38.00 % | 27.23 % | 60.4 | 40.8 | 28.4 | 22.4 | — | — |
| Qwen3.5-0.8B-Base | 752 M | 26.70 % | 25.48 % | 28.8 | 24.4 | 28.8 | 24.8 | 75.40 % | −48.70 |
| Tev1-0.8B-experimental | 752 M | 23.10 % | 25.30 % | 20.8 | 24.4 | 23.6 | 23.6 | 71.40 % | −48.30 |
| Qwen3-0.6B-Base | 596 M | **29.20 %** | 25.73 % | 37.6 | 32.0 | 28.8 | 18.4 | 68.40 % | −39.20 |
| 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 | — | — |
| LFM2.5-350M-Base | 354 M | 20.00 % | 24.01 % | 17.2 | 23.6 | 21.2 | 18.0 | 36.00 % | −16.00 |
| granite-4.0-350m-base | 352 M | 24.10 % | 25.34 % | 24.4 | 22.0 | 23.6 | 26.4 | 75.70 % | −51.60 |
| 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 |
| nanowhale-100m-base | 110 M | 21.30 % | 24.46 % | 15.6 | 22.8 | 23.6 | 23.2 | 26.50 % | −5.20 |
| EleutherAI/pythia-70m | 70 M | 22.70 % | 24.34 % | 21.6 | 26.0 | 21.6 | 21.6 | 28.80 % | −6.10 |

`Tev1-0.8B-experimental` is a post-trained derivative of `Qwen/Qwen3.5-0.8B`
(identical parameter count), so that pair is base vs. post-trained on one
architecture rather than two models. `gemma-3-270m` and `MobileLLM-R1-950M` are
gated and have not been scored.

**Four bands.** Below ~350 M nothing clears chance, and two models sit
significantly *below* it — nanowhale-100M (21.3 %, p = 0.007) and LFM2.5-350M
(20.0 %, p = 0.0002) — meaning a stable losing strategy rather than absent
arithmetic encoding. **Qwen3-0.6B-Base is the first sub-1B model to clear chance
significantly: 29.20 %, p = 0.0027.** The 1.6–3.1 B band clears it comfortably
and then stalls at 29.9–36.5 % (p = 4.5e−4 to 8e−16). Only the post-trained
Qwen2.5-1.5B-Instruct declines smoothly all the way down (60.4 → 40.8 → 28.4 →
22.4); every *base* model from 1.6 B to 3.1 B is back at chance by depth 4.

**The one to watch is Qwen3-0.6B's depth curve:** 37.6 → 32.0 → 28.8 → **18.4 %**,
significant at both ends (depth 2 p = 1e-5, depth 5 p = 0.016). Being *below*
chance at depth 5 means it commits to a stable wrong path — it starts computing
and drops the last step — rather than guessing. Option rank is balanced uniformly
across depth, so no rank preference can produce that shape.

**Hardness scales with how well a model exploits ±1 options.** granite-4.0-350M
Base scores **75.70 %** on ArithMark 3.0, the highest sub-1B result here, and
24.10 % on this dataset — a **51.6-point** drop, against GPT-X3-150M's 24.4.

**The extreme case is now LFM3-1.7B-Base.** It scores **93.10 %** on ArithMark
3.0 — the highest figure in this table — and 31.70 % here: a **61.4-point** drop,
larger than granite-4.0-350M's 51.6. It is also the only model whose depth-3
bucket stays within three points of its depth-2 bucket with both above chance
(41.2 → 38.4, p = 3e−6) before falling off a cliff at depth 4 (23.6). That
skill is concentrated in two templates: `share_then_split` 93.2 % and
`time_clock_end` 77.3 %, with `money_discount_fee` at 3.3 %. A 1.7 B model that
nearly aces another benchmark is still a single-template specialist here.

**Scaling 0.6 B → 3.1 B buys about seven points.** Qwen3-0.6B 29.2,
granite-1B 29.9, LFM3-1.7B 31.7, Qwen3.5-2B 36.0, SmolLM3-3B 36.5: a 5× parameter
increase for +7.3 points, while ArithMark 3.0 on the same runs spans 68.4 → 93.1.
The aggregate also hides opposite failure shapes at the same level. Qwen3.5-2B
has the best depth-2 bucket in the table (59.2 %, p = 2e−30) and collapses at
depth 3 (26.4 %); SmolLM3-3B is weaker at depth 2 (57.6) yet still holds depth 3
(35.6 %, p = 2e−4). Same ~36 %, different structure — which is why the curve is
the reportable unit, not the single number.

**A chance score is not always guessing.** GPT-X3-150M scores 49.60 % on
ArithMark 3.0 and 25.20 % here, but its per-template accuracy spans 3.0 % to
54.5 % (χ² = 63.2, df = 14, p < 1e-4): a small-number prior (picks the smallest
option 34.8 % of the time, the largest 15.8 %) plus one stable wrong path per
family. These cancel to chance in aggregate, so treat per-template rows as
preference, not partial skill. Worked through in the design notes, §6.

For a sub-1B leaderboard, report the per-depth curve rather than only the single
number. The two solvable templates are stable across families: at 1.5B-instruct
`share_then_split` (86.4 %) and `time_clock_end` (85.9 %), at 1.7 B `share_then_split`
93.2 %, and at 2 B `time_clock_end` 90.6 %.

## Composition

| Depth | Examples | Typical item |
| ---: | ---: | --- |
| 2 | 250 | percent off a price, then a fee |
| 3 | 250 | unit conversion, add, subtract |
| 4 | 250 | receive / ship / damage / pack |
| 5 | 250 | two percentage days, then palletise |

| Template | Depth | Examples | Template | Depth | Examples |
| --- | ---: | ---: | --- | ---: | ---: |
| `money_discount_fee` | 2 | 122 | `schedule_sessions` | 3 | 47 |
| `time_clock_end` | 2 | 128 | `inventory_boxes` | 4 | 62 |
| `measure_cm_cut` | 3 | 33 | `mix_split` | 4 | 63 |
| `share_then_split` | 3 | 44 | `tank_fill` | 4 | 62 |
| `two_rate_pay` | 3 | 45 | `discount_tax_coupon_split` | 4 | 63 |
| `stock_percent_pack` | 3 | 48 | `salary_overtime_tax` | 5 | 84 |
| `trip_minutes` | 3 | 33 | `inventory_percent_chain` | 5 | 83 |
| | | | `prize_ratio_charity` | 5 | 83 |

Correct slot is 252 / 252 / 248 / 248, answer numeric rank (smallest → largest)
is 248 / 252 / 248 / 252, and the `slot × rank × depth` grid holds 15–16 items
per cell.

### Shortcut audit

No strategy that skips the arithmetic beats chance (`python deeparithmark.py
audit`, chance 25.00 %):

| Strategy | Score |
| --- | ---: |
| pick largest / smallest value | 25.20 % / 24.80 % |
| pick the roundest number | 25.20 % |
| fixed slot 0 / 1 / 2 / 3 | 25.20 / 25.20 / 24.80 / 24.80 % |
| longest / shortest text | 25.50 % / 24.00 % |
| char-3-gram classifier over option text | 25.47 % |

This is a build constraint, not a happy accident. An early build scored gpt2
**below** chance (21.1 %) because several decoys were structurally rounder than
the answer, making a roundness prior anti-correlated with correctness. All four
options are now forced into the same roundness class.

## 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.
- Rank balance is global, not per-template, so per-template rows read as
  preference rather than skill.
- Clock items keep all four options inside one half of the day, so no noon
  rollover is exercised.

## How it was generated

`deeparithmark.py build` renders the file deterministically from seed `20261027`:
15 parameterised families, exact integer arithmetic, one decoy pool per family.
`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 audit above.

The seed makes the *instances* reproducible and unseen; it does not make the
template shapes novel. Do not train on this file.

## Licence and attribution

Released under the **Apache License 2.0**. Dataset SHA-256:
`8a54eb90b66b142b7fea422b34d851746d1cabc476dcba906c7f3ad5ddc66ee0`.

**Upstream work.** Deep Arithmark follows [ArithMark 3.0](https://huggingface.co/datasets/AxiomicLabs/Arithmark-3.0)
by AxiomicLabs, also Apache-2.0. 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 — plus the JSONL
schema, so their scorer runs on this file unchanged.

**What is not reused.** No ArithMark 3.0 item appears here. Every prompt comes
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 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.

## Files

| File | What it is |
| --- | --- |
| `data/deeparithmark-1.jsonl` | The dataset — 1,000 items, one JSON object per line |
| `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 |
| `benchmarks/deeparithmark_6models.json` | Raw results for the 2026 sub-1B sweep |

	---
	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
	---


	![image](https://cdn-uploads.huggingface.co/production/uploads/69c842686cf758859915159c/EU5Wf-2PNhf6VzK1KKkmP.png)

	1,000 arithmetic word problems that need 2–5 dependent operations. Same
	format as [ArithMark 3.0](https://huggingface.co/datasets/AxiomicLabs/Arithmark-3.0)
	— finish the sentence, pick one of four continuations, chance 25 % — but the
	wrong answers are no longer ±1 of the right one, so a magnitude guess does not
	work.

	> Unofficial. Deep Arithmark is an independent 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.

	\| \| \|
	\| --- \| ---: \|
	\| Examples \| 1,000 \|
	\| Choices per example \| 4 \|
	\| Chance \| 25 % \|
	\| Depth tiers \| 2, 3, 4, 5 — 250 each \|
	\| Templates / topic labels \| 15 / 14 \|
	\| Mean prompt length \| 29.2 words (max 43) \|
	\| Language, source \| English, synthetic (deterministic seed) \|

	## Quick start

	```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, take the argmax, compare with int(item["label"])
	```

	Score models directly, including an ArithMark 3.0 comparison on the same weights:

	```bash
	python bench_deeparithmark.py --compare --model HuggingFaceTB/SmolLM2-135M
	```

	ArithMark 3.0's own scorer runs on this file unchanged (verified against that
	script's loader):

	```bash
	python bencharithmark-3.py --data-path data/deeparithmark-1.jsonl --model gpt2
	```

	## Why it is harder

	ArithMark 3.0's four continuations are adjacent integers (43 / 44 / 45 / 46).
	Rejecting a wrong option only needs "the answer is about 44", so a magnitude
	prior is sufficient and the arithmetic is optional. Deep Arithmark keeps the
	contract and changes three things:

	1. Depth. Every item needs 2–5 dependent operations; later steps consume
	earlier results. `depth` equals the length of `metadata.solution_steps`, and
	the build fails otherwise.
	2. Decoys with provenance. No decoy is "answer ± 1". Each one is the exact
	value of a specific plausible mistake — the state after step 2 instead of
	step 5, the percentage on the wrong base, the divisor `n` instead of `n + 1`,
	the dropped unit conversion. `metadata.option_sources` names the mistake per
	ending, so error analysis can ask which step a model botches.
	3. Balanced on three axes. Correct slot, the answer's numeric rank, and the
	roundness class of all four options are each balanced. "Pick the largest"
	and "pick the roundest number" are both worth 25 %.

	## One item

	```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 answer is ` 26 crates.` — `420 + 260 − 210 − 40 = 430`, and `430 // 16 = 26`
	full crates. `29` is what you get by forgetting the damaged units, `27` by
	counting the loose units as a crate, `31` by adding them.

	## Scores

	Zero-shot, `acc_norm`, bf16, batch 32, `--max-context 1024`. ArithMark 3.0
	numbers were produced on the same weights in the same run, not copied from a
	table. `soft` is the mean probability of the correct option after a softmax over
	the four scores; `d2`–`d5` are `acc_norm` per depth tier (250 items each, chance
	25 %). Δ is Deep Arithmark minus ArithMark 3.0. Every row is in one file,
	`benchmarks/deeparithmark_17models.json`.

	`LiquidAI/LFM3-1.7B-Base` ships remote modelling code written against
	transformers 4.x — it decorates its convolution with a hub-kernel helper that
	5.x removed — so the scorer stubs two deleted helpers and runs the checkpoint's
	own pure-torch path. Re-scoring it at batch 8 instead of 32 moved two items
	(31.90 % against 31.70 %), which is bf16 kernel noise, not a padding leak.

	\| Model \| Params \| Deep \| soft \| d2 \| d3 \| d4 \| d5 \| ArithMark-3 \| Δ \|
	\| --- \| ---: \| ---: \| ---: \| ---: \| ---: \| ---: \| ---: \| ---: \| ---: \|
	\| SmolLM3-3B-Base (2025-06) \| 3.08 B \| 36.50 % \| 27.09 % \| 57.6 \| 35.6 \| 26.0 \| 26.8 \| 75.70 % \| −39.20 \|
	\| Qwen3.5-2B-Base (2026-02) \| 1.88 B \| 36.00 % \| 27.01 % \| 59.2 \| 26.4 \| 28.8 \| 29.6 \| 86.70 % \| −50.70 \|
	\| LFM3-1.7B-Base (2026-10) \| 1.73 B \| 31.70 % \| 26.42 % \| 41.2 \| 38.4 \| 23.6 \| 23.6 \| 93.10 % \| −61.40 \|
	\| granite-4.0-1b-base (2025-10) \| 1.63 B \| 29.90 % \| 26.13 % \| 39.2 \| 29.2 \| 28.4 \| 22.8 \| 84.20 % \| −54.30 \|
	\| Qwen2.5-1.5B-Instruct \| 1.54 B \| 38.00 % \| 27.23 % \| 60.4 \| 40.8 \| 28.4 \| 22.4 \| — \| — \|
	\| Qwen3.5-0.8B-Base \| 752 M \| 26.70 % \| 25.48 % \| 28.8 \| 24.4 \| 28.8 \| 24.8 \| 75.40 % \| −48.70 \|
	\| Tev1-0.8B-experimental \| 752 M \| 23.10 % \| 25.30 % \| 20.8 \| 24.4 \| 23.6 \| 23.6 \| 71.40 % \| −48.30 \|
	\| Qwen3-0.6B-Base \| 596 M \| 29.20 % \| 25.73 % \| 37.6 \| 32.0 \| 28.8 \| 18.4 \| 68.40 % \| −39.20 \|
	\| 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 \| — \| — \|
	\| LFM2.5-350M-Base \| 354 M \| 20.00 % \| 24.01 % \| 17.2 \| 23.6 \| 21.2 \| 18.0 \| 36.00 % \| −16.00 \|
	\| granite-4.0-350m-base \| 352 M \| 24.10 % \| 25.34 % \| 24.4 \| 22.0 \| 23.6 \| 26.4 \| 75.70 % \| −51.60 \|
	\| 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 \|
	\| nanowhale-100m-base \| 110 M \| 21.30 % \| 24.46 % \| 15.6 \| 22.8 \| 23.6 \| 23.2 \| 26.50 % \| −5.20 \|
	\| EleutherAI/pythia-70m \| 70 M \| 22.70 % \| 24.34 % \| 21.6 \| 26.0 \| 21.6 \| 21.6 \| 28.80 % \| −6.10 \|

	`Tev1-0.8B-experimental` is a post-trained derivative of `Qwen/Qwen3.5-0.8B`
	(identical parameter count), so that pair is base vs. post-trained on one
	architecture rather than two models. `gemma-3-270m` and `MobileLLM-R1-950M` are
	gated and have not been scored.

	Four bands. Below ~350 M nothing clears chance, and two models sit
	significantly below it — nanowhale-100M (21.3 %, p = 0.007) and LFM2.5-350M
	(20.0 %, p = 0.0002) — meaning a stable losing strategy rather than absent
	arithmetic encoding. **Qwen3-0.6B-Base is the first sub-1B model to clear chance
	significantly: 29.20 %, p = 0.0027.** The 1.6–3.1 B band clears it comfortably
	and then stalls at 29.9–36.5 % (p = 4.5e−4 to 8e−16). Only the post-trained
	Qwen2.5-1.5B-Instruct declines smoothly all the way down (60.4 → 40.8 → 28.4 →
	22.4); every base model from 1.6 B to 3.1 B is back at chance by depth 4.

	The one to watch is Qwen3-0.6B's depth curve: 37.6 → 32.0 → 28.8 → 18.4 %,
	significant at both ends (depth 2 p = 1e-5, depth 5 p = 0.016). Being below
	chance at depth 5 means it commits to a stable wrong path — it starts computing
	and drops the last step — rather than guessing. Option rank is balanced uniformly
	across depth, so no rank preference can produce that shape.

	Hardness scales with how well a model exploits ±1 options. granite-4.0-350M
	Base scores 75.70 % on ArithMark 3.0, the highest sub-1B result here, and
	24.10 % on this dataset — a 51.6-point drop, against GPT-X3-150M's 24.4.

	The extreme case is now LFM3-1.7B-Base. It scores 93.10 % on ArithMark
	3.0 — the highest figure in this table — and 31.70 % here: a 61.4-point drop,
	larger than granite-4.0-350M's 51.6. It is also the only model whose depth-3
	bucket stays within three points of its depth-2 bucket with both above chance
	(41.2 → 38.4, p = 3e−6) before falling off a cliff at depth 4 (23.6). That
	skill is concentrated in two templates: `share_then_split` 93.2 % and
	`time_clock_end` 77.3 %, with `money_discount_fee` at 3.3 %. A 1.7 B model that
	nearly aces another benchmark is still a single-template specialist here.

	Scaling 0.6 B → 3.1 B buys about seven points. Qwen3-0.6B 29.2,
	granite-1B 29.9, LFM3-1.7B 31.7, Qwen3.5-2B 36.0, SmolLM3-3B 36.5: a 5× parameter
	increase for +7.3 points, while ArithMark 3.0 on the same runs spans 68.4 → 93.1.
	The aggregate also hides opposite failure shapes at the same level. Qwen3.5-2B
	has the best depth-2 bucket in the table (59.2 %, p = 2e−30) and collapses at
	depth 3 (26.4 %); SmolLM3-3B is weaker at depth 2 (57.6) yet still holds depth 3
	(35.6 %, p = 2e−4). Same ~36 %, different structure — which is why the curve is
	the reportable unit, not the single number.

	A chance score is not always guessing. GPT-X3-150M scores 49.60 % on
	ArithMark 3.0 and 25.20 % here, but its per-template accuracy spans 3.0 % to
	54.5 % (χ² = 63.2, df = 14, p < 1e-4): a small-number prior (picks the smallest
	option 34.8 % of the time, the largest 15.8 %) plus one stable wrong path per
	family. These cancel to chance in aggregate, so treat per-template rows as
	preference, not partial skill. Worked through in the design notes, §6.

	For a sub-1B leaderboard, report the per-depth curve rather than only the single
	number. The two solvable templates are stable across families: at 1.5B-instruct
	`share_then_split` (86.4 %) and `time_clock_end` (85.9 %), at 1.7 B `share_then_split`
	93.2 %, and at 2 B `time_clock_end` 90.6 %.

	## Composition

	\| Depth \| Examples \| Typical item \|
	\| ---: \| ---: \| --- \|
	\| 2 \| 250 \| percent off a price, then a fee \|
	\| 3 \| 250 \| unit conversion, add, subtract \|
	\| 4 \| 250 \| receive / ship / damage / pack \|
	\| 5 \| 250 \| two percentage days, then palletise \|

	\| Template \| Depth \| Examples \| Template \| Depth \| Examples \|
	\| --- \| ---: \| ---: \| --- \| ---: \| ---: \|
	\| `money_discount_fee` \| 2 \| 122 \| `schedule_sessions` \| 3 \| 47 \|
	\| `time_clock_end` \| 2 \| 128 \| `inventory_boxes` \| 4 \| 62 \|
	\| `measure_cm_cut` \| 3 \| 33 \| `mix_split` \| 4 \| 63 \|
	\| `share_then_split` \| 3 \| 44 \| `tank_fill` \| 4 \| 62 \|
	\| `two_rate_pay` \| 3 \| 45 \| `discount_tax_coupon_split` \| 4 \| 63 \|
	\| `stock_percent_pack` \| 3 \| 48 \| `salary_overtime_tax` \| 5 \| 84 \|
	\| `trip_minutes` \| 3 \| 33 \| `inventory_percent_chain` \| 5 \| 83 \|
	\| \| \| \| `prize_ratio_charity` \| 5 \| 83 \|

	Correct slot is 252 / 252 / 248 / 248, answer numeric rank (smallest → largest)
	is 248 / 252 / 248 / 252, and the `slot × rank × depth` grid holds 15–16 items
	per cell.

	### Shortcut audit

	No strategy that skips the arithmetic beats chance (`python deeparithmark.py
	audit`, chance 25.00 %):

	\| Strategy \| Score \|
	\| --- \| ---: \|
	\| pick largest / smallest value \| 25.20 % / 24.80 % \|
	\| pick the roundest number \| 25.20 % \|
	\| fixed slot 0 / 1 / 2 / 3 \| 25.20 / 25.20 / 24.80 / 24.80 % \|
	\| longest / shortest text \| 25.50 % / 24.00 % \|
	\| char-3-gram classifier over option text \| 25.47 % \|

	This is a build constraint, not a happy accident. An early build scored gpt2
	below chance (21.1 %) because several decoys were structurally rounder than
	the answer, making a roundness prior anti-correlated with correctness. All four
	options are now forced into the same roundness class.

	## 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.
	- Rank balance is global, not per-template, so per-template rows read as
	preference rather than skill.
	- Clock items keep all four options inside one half of the day, so no noon
	rollover is exercised.

	## How it was generated

	`deeparithmark.py build` renders the file deterministically from seed `20261027`:
	15 parameterised families, exact integer arithmetic, one decoy pool per family.
	`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 audit above.

	The seed makes the instances reproducible and unseen; it does not make the
	template shapes novel. Do not train on this file.

	## Licence and attribution

	Released under the Apache License 2.0. Dataset SHA-256:
	`8a54eb90b66b142b7fea422b34d851746d1cabc476dcba906c7f3ad5ddc66ee0`.

	Upstream work. Deep Arithmark follows [ArithMark 3.0](https://huggingface.co/datasets/AxiomicLabs/Arithmark-3.0)
	by AxiomicLabs, also Apache-2.0. 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 — plus the JSONL
	schema, so their scorer runs on this file unchanged.

	What is not reused. No ArithMark 3.0 item appears here. Every prompt comes
	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 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.

	## Files

	\| File \| What it is \|
	\| --- \| --- \|
	\| `data/deeparithmark-1.jsonl` \| The dataset — 1,000 items, one JSON object per line \|
	\| `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 \|
	\| `benchmarks/deeparithmark_6models.json` \| Raw results for the 2026 sub-1B sweep \|