Datasets:

SagheerLab
/

Arithmetic-Reasoning

license: apache-2.0
task_categories:
  - text-generation
  - question-answering
language:
  - en
pretty_name: Arithmetic-Reasoning
size_categories:
  - 10M<n<100M
tags:
  - math
  - reasoning
  - synthetic
  - arithmetic
  - chain-of-thought
  - small-lm
configs:
  - config_name: default
    data_files:
      - split: train
        path: parquet/train-*.parquet
      - split: validation
        path: parquet/validation-*.parquet
      - split: test
        path: parquet/test-*.parquet

SagheerLab/Arithmetic-Reasoning

A high-quality synthetic arithmetic and elementary mathematics reasoning dataset for training and evaluating small language models - not an "ultimate math" claim, but a clean, verified, tiered reasoning dataset where every answer is programmatically checked.

This dataset was built to train 100M-ish models that benefit disproportionately from clean, unambiguous examples. At ~~50M examples (~~45M train / 2.5M val / 2.5M test, ~5GB parquet) it is designed as a reasoning dataset: every sample has an instruction, a step-by-step reasoning trace, and a final answer, all verified to be mathematically correct.

Why this dataset?

Small models (25M-100M) trained on our earlier 5-minute budget went from 0.5% → 89.8% with scratchpad formats and to 98.3% with reverse-answers + scratchpad - format and verification matter more than scale. This release distills those findings into a publishable, 100% verified dataset.

Problem Types - Top 10 + 8 more

We cover 18+ operation families. Each instruction is sampled from 20+ phrasings with varied names/objects so at 1M tokens <1% duplicates.

#	Operation	Example Instruction	Reasoning	Answer
1	Addition	`Calculate 313921 + 108618.`	`313921 + 108618 = 422539`	`422539`
2	Subtraction	`Please compute 964047 - 52578.9.`	`964047-50000=914047	...
3	Multiplication	`Calculate 3088 x 1685.`	`3088510^0=15440	running=15440
4	Division	`Divide 7763506128 by 8856.`	`77635/8856=8	8*8856=70848
5	Percentages	`What is 86 percent of 5.6.`	`5.6*86=481.6	481.6/100=4.816`
6	Comparison	`Which is smaller, 107473 or 709570?`	`107473 < 709570	107473 is smaller`
7	Fractions	`Find 3/4 of 8324.`	`8324/4=2081	2081*3=6243`
8	Word Problems	`Layla has 95 bags with 608 lemons each and found 152 more lemons. How many lemons total?`	`95*608=57760	57760+152=57912`
9	Algebra	`Solve for x: x + 39 = 150`	`x = 150 - 39 = 111`	`111`
10	Geometry	`What is the area of a rectangle 884 by 752?`	`884*752=664768`	`664768`
	+ 8 more: `ratios, powers/roots, decimals, halving/doubling, sequences, multi-step, hard arithmetic, quantitative reasoning` - see `operation` field for full list.

Quickstart

from datasets import load_dataset
ds = load_dataset("SagheerLab/Arithmetic-Reasoning")
print(ds["train"][0])
# {'instruction': 'What is 86 percent of 5.6.', 'reasoning': '5.6*86=481.6 | 481.6/100=4.816', 'answer': '4.816', ...}

# pretraining text format
print(ds["train"][0]["text"])
# Calculate 86 percent of 5.6.
# 5.6*86=481.6 | 481.6/100=4.816
# Answer: 4.816

from huggingface_hub import snapshot_download
snapshot_download("SagheerLab/Arithmetic-Reasoning", repo_type="dataset", local_dir="./arithmetic-reasoning")

Dataset Summary

Size: ~~50M examples (~~45M train / 2.5M val / 2.5M test, ~5GB parquet), 100% programmatically verified
Generation: deterministic src/generate_data_v4.py with NAMES 120 + OBJECTS 150 + VERBS 100 for lexical variation, de-duplicated (<1% dupes)
Tiers: easy 30% (1-2 digits, 1 step) | intermediate 35% (3-4 digits, 2-3 steps) | hard 25% (5-6 digits, 3-8 steps) | very hard 10% (competition/GSM8K-style)
License: Apache 2.0 - see Licensing

Dataset Structure

Data Instances

{
  "instruction": "What is 86 percent of 5.6.",
  "reasoning": "5.6*86=481.6 | 481.6/100=4.816",
  "answer": "4.816",
  "text": "What is 86 percent of 5.6.\n5.6*86=481.6 | 481.6/100=4.816\nAnswer: 4.816",
  "operation": "percentage",
  "difficulty": "easy",
  "num_steps": 1,
  "max_digits": 2
}

Data Fields

instruction (string): the question, varied phrasing with names/objects
reasoning (string): step-by-step trace (| separates steps, \n for long division), last step is answer
answer (string): final answer only (with unit for word problems, e.g. 57912 lemons)
text (string): instruction + "\n" + reasoning + "\nAnswer: " + answer for pretraining
operation (string): addition | subtraction | multiplication | division | percentage | comparison | fractions | ... | word problems
difficulty (string): easy | intermediate | hard | very hard
num_steps (int): reasoning steps (1 for easy, 2-3 for intermediate, 3-8 for hard)
max_digits (int): largest operand digits (1-6)

Data Splits

Split	Size	Path
train	~45M	`parquet/train-*.parquet` (sharded, ~4.5GB)
validation	~2.5M	`parquet/validation-*.parquet`
test	~2.5M	`parquet/test-*.parquet`

All splits are IID from same generator, seed 42, balanced-sizes, max_digits 6, sharded for Viewer (row_group_size=10000, write_page_index=True).

Dataset Creation

Curation Rationale

Small LMs benefit from clean, unambiguous, verified reasoning traces. We built this to provide a tiered, diverse arithmetic reasoning dataset where easy teaches columns, intermediate teaches decomposition, hard teaches 3-8 step planning, and very hard teaches GSM8K-style 4-5 op word problems.

Source Data

Synthetic - generated by src/generate_data_v4.py (deterministic, efficient, <30s for 150K). No web crawl.

Generation uses:

PROMPT_TEMPLATES 20+ per op (so at 100K <1% duplicate instructions)
NAMES 120 + OBJECTS 150 + VERBS 100 for word problems (e.g., Jaxson had 133 rainbows... not just Sarah had...)
balanced-sizes uniform 1-6 digits, DIVISOR_MAX_DIGITS 4, scratchpad-mul v2, scratchpad-div v3, scratchpad-sub

Data processing steps

Generate 150K raw examples with seed 42

Verification pipeline (100%):

true = calc(instruction)  # independent python calc
assert answer == true
assert reasoning.split("|")[-1].strip().endswith(answer) or reasoning.split("\n")[-1].strip() == answer
assert reasoning lines are arithmetically valid
# else drop & regenerate (seen set ensures <1% dupes)

Deduplicate instruction strings via seen set
Shuffle and split 90/5/5, write Parquet shards (row_group_size=10000, write_page_index=True), copy best_3440x1440.png banner

Personal and Sensitive Information

None - all synthetic. Names are sampled from common first names, no real PII.

Considerations for Using the Data

Social Impact

Helps make reasoning training accessible for small models without web-scale data. No harmful content.

Discussion of Biases

Word problems sample NAMES uniformly from a US-centric list - not representative of global names. Objects are everyday items. No systematic bias in math, but phrasing reflects English templates.

Other Known Limitations

English only, 1-6 digit arithmetic (no logs, no negative numbers yet - planned for v2)
Fractions are a/b where a divisible by b (exact)
Division is exact or integer quotient (no decimal remainder except very hard GSM8K remainder)
Sequences are +step, *2, Fibonacci, +3/*2 alternating - not full competition variety

Additional Information

Licensing Information

Apache 2.0 - permissive, allows commercial use, modification, distribution, and private use with attribution and a patent grant. You must include copyright/license notices. See LICENSE file.

Citation

No citation required, but if you use this dataset please cite:

@dataset{sagheerlab_arithmetic_reasoning_2026,
  title={Arithmetic-Reasoning: A High-Quality Synthetic Arithmetic Reasoning Dataset for Small LMs},
  author={SagheerLab},
  year={2026},
  url={https://huggingface.co/datasets/SagheerLab/Arithmetic-Reasoning}
}

Contributions

Thanks to the synthetic data verification pipeline and tiered difficulty design. Banner image best_3440x1440.png included at repo root.