Datasets:

Arko007
/

arithmetic-bench

pretty_name: Zenyx Arithmetic Bench (decontaminated)
license: apache-2.0
language:
  - en
size_categories:
  - 10K<n<100K
task_categories:
  - text-generation
  - question-answering
tags:
  - arithmetic
  - math
  - benchmark
  - evaluation
  - synthetic
  - decontaminated
configs:
  - config_name: default
    data_files:
      - split: test
        path: data/clean-16k.jsonl
  - config_name: legacy
    data_files:
      - split: test
        path: data/legacy-14k.jsonl
dataset_info:
  - config_name: default
    features:
      - name: id
        dtype: string
      - name: type
        dtype: string
      - name: operation
        dtype: string
      - name: a
        dtype: int64
      - name: operator
        dtype: string
      - name: b
        dtype: int64
      - name: question
        dtype: string
      - name: answer
        dtype: string
      - name: in_legacy_14k
        dtype: bool
    splits:
      - name: test
        num_examples: 16000
  - config_name: legacy
    features:
      - name: id
        dtype: string
      - name: type
        dtype: string
      - name: operation
        dtype: string
      - name: digits
        dtype: int32
      - name: a
        dtype: int64
      - name: operator
        dtype: string
      - name: b
        dtype: int64
      - name: question
        dtype: string
      - name: answer
        dtype: string
      - name: seen_in_training
        dtype: bool
    splits:
      - name: test
        num_examples: 14000

Zenyx Arithmetic Bench (decontaminated)

Integer arithmetic questions of the form What is 5895 / 15? with exact answers, built to measure whether a small language model can calculate, not whether it has memorised a training set. The default config has 16,000 questions in 8 types (2,000 each), and none of them occurs in the public arithmetic training corpus it was checked against.

It replaces an earlier suite of 14,000 questions that turned out to be mostly contaminated (see Why a new set). That earlier suite is kept as the legacy config, now with a per-item flag.

Contents (config `default`, split `test`)

Type	Operation	Operands	Items	Notes
`3ds`	subtraction	3-digit - 3-digit	2,000	89 items from the original suite, 1,911 new
`4da`	addition	4-digit + 4-digit	2,000	1,967 from the original suite, 33 new
`5da`	addition	5-digit + 5-digit	2,000	all 2,000 from the original suite
`5ds`	subtraction	5-digit - 5-digit	2,000	new
`4dm`	multiplication	4-digit x 4-digit	2,000	new
`5dm`	multiplication	5-digit x 5-digit	2,000	new
`34m`	multiplication	3-digit x 4-digit	2,000	new
`div`	division	(2-digit divisor x 3-digit quotient) / divisor	2,000	new; exact integer division, dividends 1,111 to 98,901

Every question is distinct. In subtraction the first operand is never smaller than the second, so no answer is negative.

Field	Meaning
`id`	`<type>-<index>`, for example `5dm-0412`
`type`, `operation`	the type code and the operation name
`a`, `operator`, `b`	the operands and `+`, `-`, `*` or `/`
`question`	the prompt text, `What is {a} {operator} {b}?`
`answer`	the exact integer result, as a string without separators
`in_legacy_14k`	true if the item was already in the original 14,000-question suite

from datasets import load_dataset
ds = load_dataset("Arko007/arithmetic-bench", split="test")                 # the clean 16,000
old = load_dataset("Arko007/arithmetic-bench", "legacy", split="test")      # the old 14,000, with seen_in_training

How the contamination check works

The training corpus checked is SagheerLab/Arithmetic-Reasoning (50,000,000 rows), which is part of the pre-training mixture of the Zenyx-100M model this bench was made for. All 50,000,000 rows were scanned, two columns each:

the question (instruction): every plain expression a op b in it, and
the written-out reasoning (reasoning): every step of the form a op b = c.

This gave 13,067,320 distinct single-operation expressions. A candidate question counts as seen if its expression a op b is among them, or b op a for the commutative operations + and *. Candidates that were seen were thrown away and replaced by new random ones from the same type, until each type had 2,000 unseen, distinct questions; scripts/build_clean_set.py does exactly this (it needs about 10 minutes and a machine with internet, no GPU). The scan reads the data in a streaming fashion; nothing needs to be kept.

Why a new set

The first release of this bench (now the legacy config) had 7 types x 2,000 questions drawn from fixed seeds. The full scan, which also reads the reasoning column (the first, partial scan read only the questions of 4 million rows), found that 9,944 of those 14,000 questions are in the training corpus:

Legacy type	In the training corpus
2da (2-digit +), 2ds (2-digit -), 2dm (2-digit x)	2,000 of 2,000 each
3da (3-digit +)	2,000 of 2,000
3ds (3-digit -)	1,911 of 2,000
4da (4-digit +)	33 of 2,000
5da (5-digit +)	0 of 2,000

The corpus effectively contains every 2-digit problem and almost every 3-digit addition and 3-digit multiplication. For that reason, no clean questions can be drawn for these types and they are not in the default config: 2da, 2ds, 2dm, 3da (only about 10 of its 810,000 possible questions are absent from the corpus) and 3dm (about 20 of 810,000). Larger operands, and 3-digit x 4-digit (34m) in place of 3dm, are clean. The legacy config keeps all 14,000 old questions with seen_in_training set per item, so old results can still be reproduced and split into the clean and the contaminated part.

How to score

Ask the question in whatever format suits the model (a chat template, a few worked examples for a base model, a bare 12 + 7 =), read the model's final answer and compare it to answer exactly. Report per type: the types differ enormously in difficulty (5-digit x 5-digit has 9 to 10 digit answers). The format matters a lot for small models, so state it with the score. The Zenyx-100M project scored its model in its own chat format with a short scratchpad and greedy decoding, strict exact match after </think>.

No model results are reported in this repository yet.

Limits (please read)

Clean means "not found in that one corpus", nothing more. A model trained on other data (word problems, textbooks, other synthetic arithmetic) may have met some of these questions; only the checked corpus is certified.
The check matches the written form a op b (and the swap for + and *). The same calculation phrased differently ("plus", "multiplied by", with spaces or separators) is not detected, and a model that memorised a different problem with the same answer is not detected either.
A question counts as seen if it is present in the corpus at all, whether or not a given model reached that row during training. The clean set is therefore conservative for such a model.
The questions are single operations on non-negative integers in one English template. Nothing here measures multi-step reasoning, word problems or other number formats.
All 16,000 questions are in one test split, and the generator is public: do not train on them.

License and citation

Apache-2.0. The questions are synthetic and contain no personal data.

@misc{zenyx_arithmetic_bench,
  title  = {Zenyx Arithmetic Bench (decontaminated)},
  author = {Sarkar, Anamitra},
  year   = {2026},
  url    = {https://huggingface.co/datasets/Arko007/arithmetic-bench}
}