README.md

---

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


![Banner](best_3440x1440.png)

# 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 | ... | 911468.1` | `911468.1` |
| 3 | **Multiplication** | `Calculate 3088 x 1685.` | `3088*5*10^0=15440 | running=15440 | ... | 5203280` | `5203280` |
| 4 | **Division** | `Divide 7763506128 by 8856.` | `77635/8856=8 | 8*8856=70848 | ... | 876638` | `876638` |
| 5 | **Percentages** | `What is 86 percent of 5.6.` | `5.6*86=481.6 | 481.6/100=4.816` | `4.816` |
| 6 | **Comparison** | `Which is smaller, 107473 or 709570?` | `107473 < 709570 | 107473 is smaller` | `107473 is smaller` |
| 7 | **Fractions** | `Find 3/4 of 8324.` | `8324/4=2081 | 2081*3=6243` | `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` | `57912 lemons` |
| 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. | | | |

Full per-operation counts in `50M`:
`word problems 13.6% | multi-step 10.7% | ratios 9.7% | hard arithmetic 5.7% | algebra 7.4% | fractions 4.6% | sequences 5.3% | geometry 5.1% | ...` (see `Per-operation` in generation log)


## Quickstart

```python

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

```

```python

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](#licensing-information)

# Dataset Structure

### Data Instances
```json

{

  "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
1. Generate 150K raw examples with `seed 42`
2. Verification pipeline (100%):
   ```python

   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)

   ```
3. Deduplicate `instruction` strings via `seen` set
4. 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.