Arko007/zenyx-arithmetic-100m

Zenyx Arithmetic Reasoning 100M

100,000,000 exact integer-arithmetic questions with step-by-step scratchpads: addition, subtraction, long multiplication and long division (with and without remainder). Built to teach a small language model to compute with a procedure instead of guessing a result in one jump.

Every row was produced by a deterministic algorithm and then re-read from disk after it was written (just before upload) and verified by independent code: each step recomputed, the answer recomputed, the metadata recomputed, no question from the evaluation benchmark Arko007/arithmetic-bench, no repeated question. Result for all 100,000,000 rows: 0 validation errors, 0 duplicate questions.

Dataset summary

Rows	100,000,000 (21 Parquet shards, 6.4 GB, zstd)
Language	English (a single fixed question template)
Task	text generation; the reasoning field is a chain of verified a op b = c steps ending in answer
Origin	synthetic, machine-generated, no personal data
License	Apache-2.0
Intended training format	Zenyx-100M ChatML with a <think> scratchpad (see Usage)

Contents

All rows are in one configuration, default, split train: 21 shards of about 4.8M rows (data/train-XXXXX-of-00021.parquet, roughly 307 MB each). The rows are shuffled: every shard contains every operation and every digit-size bucket in proportion, so reading the first shard already gives a representative sample and a streaming reader never meets long single-operation runs. Select an operation with the operation column (ds.filter(lambda r: r["operation"] == "multiplication")).

Operation	Rows	Share	What the scratchpad contains
addition	20,000,000	20%	one step a + b = c; operands 1 to 5 digits each
subtraction	25,000,000	25%	one step a - b = c (never negative); the larger operand has 5 or 6 digits
multiplication	35,000,000	35%	long multiplication by place value, operands 2 to 5 digits each
division	20,000,000	20%	place-value long division: 12,000,000 with remainder (dividends 4 to 7 digits, divisors 2 or 3 digits) and 8,000,000 exact (2 or 3 digit divisor times a 2 to 4 digit quotient)

There is one split, train: this is a training corpus. For evaluation use Arko007/arithmetic-bench, whose questions are guaranteed absent from this corpus.

Dataset structure

Data fields

Field	Type	Description
instruction	string	The question, always What is {a} {op} {b}? with op one of + - * /.
reasoning	string	The scratchpad: one line, steps joined by |. Each step is a op b = c (non-negative integers, single spaces, no separators or units). Division steps may carry remainder r.
answer	string	The final result, equal to the result of the last step: an integer, or q remainder r.
operation	string	addition, subtraction, multiplication or division.
difficulty	string	By the longest operand: easy (1-2 digits), intermediate (3), hard (4-5), very hard (6 or more).
num_steps	int32	Number of steps in reasoning.
max_digits	int32	Digits of the longer operand.

Examples

{"instruction": "What is 48213 + 9071?", "reasoning": "48213 + 9071 = 57284", "answer": "57284", "operation": "addition", "difficulty": "hard", "num_steps": 1, "max_digits": 5}

{"instruction": "What is 7203 * 4081?", "reasoning": "7203 * 1 = 7203 | 7203 * 8 = 57624 | 57624 * 10 = 576240 | 7203 * 4 = 28812 | 28812 * 1000 = 28812000 | 7203 + 576240 = 583443 | 583443 + 28812000 = 29395443", "answer": "29395443", "operation": "multiplication", "difficulty": "hard", "num_steps": 7, "max_digits": 4}

{"instruction": "What is 22231 / 43?", "reasoning": "43 * 500 = 21500 | 22231 - 21500 = 731 | 43 * 10 = 430 | 731 - 430 = 301 | 43 * 7 = 301 | 301 - 301 = 0 | 500 + 10 = 510 | 510 + 7 = 517 | 22231 / 43 = 517", "answer": "517", "operation": "division", "difficulty": "hard", "num_steps": 9, "max_digits": 5}

{"instruction": "What is 1234567 / 89?", "reasoning": "89 * 10000 = 890000 | 1234567 - 890000 = 344567 | 89 * 3000 = 267000 | 344567 - 267000 = 77567 | 89 * 800 = 71200 | 77567 - 71200 = 6367 | 89 * 70 = 6230 | 6367 - 6230 = 137 | 89 * 1 = 89 | 137 - 89 = 48 | 10000 + 3000 = 13000 | 13000 + 800 = 13800 | 13800 + 70 = 13870 | 13870 + 1 = 13871 | 1234567 / 89 = 13871 remainder 48", "answer": "13871 remainder 48", "operation": "division", "difficulty": "very hard", "num_steps": 15, "max_digits": 7}

The scratchpad algorithms

• Multiplication a * b. For every non-zero digit d of b at place 10^k, from the lowest place up: a * d = p, then p * 10^k = P when k > 0. The partial products are then added from left to right. Every step is a (up to 5-digit) x (one digit) product, a shift by a power of ten, or one addition.
• Division a / b. From the highest place down, take the largest digit d with b * d * 10^k <= rest: b * (d * 10^k) = prod, then rest - prod = rest'. The quotient parts are added left to right, and the last step states the whole result, a / b = q or a / b = q remainder r.
• Addition and subtraction are a single step.

Distribution

Operand pairs are drawn per digit-length bucket (AxB = A-digit first operand, B-digit second operand; for exact division dXqY = X-digit divisor, Y-digit quotient). Bucket quotas grow with the square root of the number of available pairs, so large operands dominate without drowning the small ones; a bucket is capped by how many distinct pairs exist (there are only 81 one-digit additions).

Rows per bucket (click to expand)

Addition

Operand digits	Rows	Share
1x1	81	0.0%
1x2	810	0.0%
1x3	8,100	0.0%
1x4	34,631	0.2%
1x5	98,698	0.5%
2x1	810	0.0%
2x2	8,100	0.0%
2x3	34,631	0.2%
2x4	98,698	0.5%
2x5	301,301	1.5%
3x1	8,100	0.0%
3x2	34,631	0.2%
3x3	98,698	0.5%
3x4	301,300	1.5%
3x5	941,984	4.7%
4x1	34,630	0.2%
4x2	98,697	0.5%
4x3	301,300	1.5%
4x4	941,961	4.7%
4x5	2,968,006	14.8%
5x1	98,697	0.5%
5x2	301,300	1.5%
5x3	941,984	4.7%
5x4	2,968,006	14.8%
5x5	9,374,846	46.9%

Subtraction

Operand digits	Rows	Share
5x1	48,203	0.2%
5x2	141,620	0.6%
5x3	437,029	1.7%
5x4	1,371,195	5.5%
5x5	3,059,885	12.2%
6x1	141,619	0.6%
6x2	437,028	1.7%
6x3	1,371,194	5.5%
6x4	4,325,285	17.3%
6x5	13,666,942	54.7%

Multiplication

Operand digits	Rows	Share
2x2	8,100	0.0%
2x3	57,698	0.2%
2x4	171,647	0.5%
2x5	531,984	1.5%
3x2	57,698	0.2%
3x3	171,647	0.5%
3x4	531,919	1.5%
3x5	1,671,471	4.8%
4x2	171,647	0.5%
4x3	531,918	1.5%
4x4	1,671,429	4.8%
4x5	5,274,843	15.1%
5x2	531,983	1.5%
5x3	1,671,470	4.8%
5x4	5,274,843	15.1%
5x5	16,669,703	47.6%

Division with remainder (dividend digits by divisor digits)

Dividend by divisor	Rows	Share
4by2	67,760	0.6%
4by3	203,462	1.7%
5by2	203,462	1.7%
5by3	632,591	5.3%
6by2	632,590	5.3%
6by3	1,989,615	16.6%
7by2	1,989,615	16.6%
7by3	6,280,905	52.3%

Exact division

Divisor / quotient digits	Rows	Share
d2q2	8,100	0.1%
d2q3	79,000	1.0%
d2q4	810,000	10.1%
d3q2	81,000	1.0%
d3q3	810,000	10.1%
d3q4	6,211,900	77.6%

Dataset creation

Generation

Three generator runs each produce one third of every bucket (every bucket is cut into three interleaved slices of its operand-pair walk, so the three runs never produce the same pair and each run sees all operations and digit sizes). A deterministic generator walks each bucket's operand-pair space in a pseudo-random order (an affine permutation, so no pair appears twice), seed 20261026, and builds the scratchpad with the algorithms above. Each run then shuffles its rows into 7 shards (two passes: random split into bins, then a permutation of each bin) and uploads them. The generator is scripts/gen_arith_100m.py, the shuffle is scripts/shuffle_arith_100m.py. The generator started from one written by an AI assistant; that code was reviewed and changed: the benchmark exclusion was made mandatory, an exact-division stream was added (the original produced about 1% exact divisions), the validation was made independent of the generator, quotas take the benchmark pairs into account, and the work was parallelised.

Validation

1. During generation (every row, after writing). Each shard is written, read back from disk and every row is checked before it is used: the question matches the template; every step is a op b = c and arithmetically true (floor quotient and remainder for /); the last step equals answer; answer is the true result of the question; operation, difficulty, num_steps and max_digits are recomputed; no <think>, special-token strings, code fences or newlines; the operand pair (and its swap for + and *) is not in the benchmark Arko007/arithmetic-bench (clean-16k); a 64-bit hash of every question is checked for duplicates. Result: 0 errors, 0 duplicates.

2. Shuffle fingerprint. Before a shuffled shard is uploaded, the row count and the order-independent sum and xor of the 64-bit hashes of all questions are compared before and after the shuffle: identical for all three runs (100,000,000 rows).

3. Independent audit of the uploaded files (scripts/verify_arith_100m.py, a separate implementation that does not import the generator). All 100,000,000 rows were downloaded back from this repository and, for every row, the complete expected row (instruction, reasoning, answer, operation, difficulty, num_steps, max_digits) was re-derived from the two operands with a fresh implementation of the documented algorithm and compared character for character; in addition the Parquet schema (names, int32 numbers, no nulls), the format of every question (no leading zeros), the documented operand-size range of the operation, and the benchmark exclusion were checked. Result: 0 errors. A second pass over the question column of all 100,000,000 rows found 0 duplicate questions (100,000,000 distinct), and its hash fingerprint equals that of the audited rows. The verifier itself was tested on deliberately corrupted files (wrong step, reordered steps, wrong metadata, wrong type, null, out-of-range operand, benchmark overlap, ...) and catches each of them.

Reports: reports/validation_report-fin*.json, shuffle_report-*.json, verification_report-*.json.

Usage

from datasets import load_dataset

ds = load_dataset("Arko007/zenyx-arithmetic-100m", split="train", streaming=True)
for row in ds.take(3):
    print(row["instruction"], "->", row["answer"])

mult = ds.filter(lambda r: r["operation"] == "multiplication")      # one operation

Turning a row into a chat training document, as Zenyx-100M does:

def to_chat(r):
    return (f"<|im_start|>user\n{r['instruction']}<|im_end|>\n"
            f"<|im_start|>assistant\n<think>\n{r['reasoning']}\n</think>\n\n{r['answer']}<|im_end|>\n")

Considerations and limitations

• Narrow by design. Single operations on non-negative integers in one English template. No word problems, fractions, decimals, negative numbers, exponents or multi-operation expressions.
• Style is a choice. Other valid scratchpad styles (column layout, digit-by-digit carries, base-10 expansions) are not included. A model trained on this learns this style.
• Not an evaluation set. Do not report results on it. It was built to train; the held-out benchmark is Arko007/arithmetic-bench, which this corpus excludes by construction.
• Other contamination. Exclusion covers that benchmark only. Questions in this corpus can coincide with questions in other public arithmetic datasets (small operands especially, since the space of small problems is small).
• Not stratified by answer. Digit-length buckets are balanced; individual numbers are not.

Additional information

• Maintainer: Anamitra Sarkar (Arko007), part of the Zenyx-100M project.
• License: Apache-2.0.
• Related: Arko007/arithmetic-bench (decontaminated benchmark), Arko007/Zenyx-100M-Base (the model).

@misc{zenyx_arithmetic_reasoning_100m,
  title  = {Zenyx Arithmetic Reasoning 100M},
  author = {Sarkar, Anamitra},
  year   = {2026},
  url    = {https://huggingface.co/datasets/Arko007/zenyx-arithmetic-100m}
}