Initial release: 150K verified arithmetic reasoning (v4) with tiered difficulty

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/train.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,194 @@
+---
+license: apache-2.0
+task_categories:
+- text-generation
+- question-answering
+language:
+- en
+pretty_name: Arithmetic-Reasoning
+size_categories:
+- 100K<n<1M
+tags:
+- math
+- reasoning
+- synthetic
+- arithmetic
+- chain-of-thought
+- small-lm
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train.parquet
+  - split: validation
+    path: data/val.parquet
+  - split: test
+    path: data/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 150K examples (135K train / 7.5K val / 7.5K test) 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.
+
+## 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")
+```
+
+Both `JSON` and `Parquet` are provided (`data/train.parquet` + `data/train.json`) — use either.
+
+# Dataset Summary
+
+- **Size:** 150,000 examples (135K train / 7.5K val / 7.5K test), 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)
+
+# 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 `150K`:
+`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)
+
+# 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 | 135,000 | `data/train.parquet` + `data/train.json` |
+| validation | 7,500 | `data/val.parquet` |
+| test | 7,500 | `data/test.parquet` |
+
+All splits are IID from same generator, `seed 42`, `balanced-sizes`, `max_digits 6`.
+
+# 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 `JSONL` + `Parquet`, 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.
+
+*Why Apache 2.0 vs MIT vs CC-BY-4.0?*
+- **MIT:** shortest, permissive, requires attribution, allows commercial, no explicit patent grant, no warranty.
+- **Apache 2.0:** like MIT but adds explicit patent grant from contributors and requires preserving `NOTICE` — safer for organisations, still permissive and commercial-friendly. Recommended for code+data where patent concerns matter.
+- **CC-BY-4.0:** designed for creative/data works, requires attribution, allows commercial/derivatives, no patent language, good for pure datasets. Also suitable, but Apache 2.0 is more standard on HF for synthetic code-like data and gives patent clarity.
+
+We chose **Apache 2.0** for this dataset as it is commercial-friendly, attribution-only, and includes patent protection — same as many HF synthetic datasets. If you prefer `CC-BY-4.0` or `MIT`, you can relicense your derived model/data accordingly with attribution.
+
+### 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.

data/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d65467c71b5403237c70801a498aaaf9339c80035a65c87f83516e61d764884
+size 746006

data/train.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc1f3b05a45f4f91444982d7ed6a822d0dae2717cbaa5130e663a15b2b1f44bc
+size 40159803

data/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c3d5e4a5f9de6b6cd5f1f37fc93e47e5c855c1692ccc5de61e234bfab930a78
+size 12574963

data/val.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e68483e98b570310d75d90c31066a0a891947562df5ed1fef28f46c065824159
+size 742818