Blame for README.md

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