| --- |
| 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](#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 | |
|
|
| ```python |
| 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. |
|
|
| ```bibtex |
| @misc{zenyx_arithmetic_bench, |
| title = {Zenyx Arithmetic Bench (decontaminated)}, |
| author = {Sarkar, Anamitra}, |
| year = {2026}, |
| url = {https://huggingface.co/datasets/Arko007/arithmetic-bench} |
| } |
| ``` |
|
|
