Datasets:

arpjw
/

microreason-math

language:
  - en
pretty_name: MicroReason Math
size_categories:
  - 100K<n<1M
task_categories:
  - text-generation
  - question-answering
tags:
  - math
  - arithmetic
  - algebra
  - synthetic
  - reasoning
  - chain-of-thought
  - compositional-generalization
configs:
  - config_name: benchmark
    data_files:
      - split: val
        path: data/benchmark/val.jsonl
      - split: val_heldout_shape
        path: data/benchmark/val_heldout_shape.jsonl
      - split: test_id
        path: data/benchmark/test_id.jsonl
      - split: test_heldout_shape
        path: data/benchmark/test_heldout_shape.jsonl
      - split: test_extrapolation
        path: data/benchmark/test_extrapolation.jsonl
      - split: test_extrapolation_fresh
        path: data/benchmark/test_extrapolation_fresh.jsonl
  - config_name: sft
    data_files:
      - split: train
        path: data/sft/train.jsonl

MicroReason Math

Synthetic arithmetic and linear-algebra problems with exact answers and canonical step-by-step solutions. They were generated to train and evaluate MicroReason-43M, a small language model trained from scratch.

Generation and checking:

Source: every problem comes from a seeded grammar over random expression trees and linear equations.
Answers: each answer is verified by an independent exact solver.
Steps: every solution step is checked to be correct.

The benchmark splits test generalization to unseen problem structures and to larger numbers than those seen in training.

from datasets import load_dataset

bench = load_dataset("arpjw/microreason-math", "benchmark")   # 6 evaluation splits, 40,000 problems
sft = load_dataset("arpjw/microreason-math", "sft", split="train")   # 100,000 training problems

Examples

Compute: 93 - (-90) * (-73)
  1. Multiply: -90 * (-73) = 6570
  2. Subtract: 93 - 6570 = -6477
  answer: -6477

Find x: 23x + 7462 = 15(x - 2721)
  1. Expand: 23x + 7462 = 15x - 40815
  2. Subtract 15x from both sides: 8x + 7462 = -40815
  3. Subtract 7462 from both sides: 8x = -48277
  4. Divide both sides by 8: x = -48277/8
  answer: -48277/8

Splits

Config / split	Problems	Shapes	What it measures
`benchmark` / `val`	7,000	1,555	In-distribution validation
`benchmark` / `val_heldout_shape`	6,000	1,039	Validation on problem structures never seen in training
`benchmark` / `test_id`	7,000	1,574	In-distribution test
`benchmark` / `test_heldout_shape`	6,000	1,053	Test on unseen structures (3–5 operators and equations)
`benchmark` / `test_extrapolation`	7,000	1,214	Test with 4–5 digit numbers (training uses 0–999)
`benchmark` / `test_extrapolation_fresh`	7,000	1,209	An independent second extrapolation suite (own seed, frozen separately)
`sft` / `train`	100,000	9,407	Supervised fine-tuning problems

Family mix:

Expressions: 1–5 operators over + − × ÷. In-distribution splits are about 11% 1-op, 20% 2-op, 16% 3-op, 10% 4-op and 8% 5-op.
Equations: linear equations make up about 35% of in-distribution splits.
Held-out-shape splits: only 3+ operator structures and equations.

How shapes are held out: a shape is the operator structure of an expression tree, such as (- n (* n n)), or an equation template.

Assignment: each shape is hashed into exactly one of train-visible (80%), held-out-val (10%) or held-out-test (10%).
Coverage guarantee: every operator and pairing in a held-out shape also appears in a training shape. Held-out problems are new combinations, not new primitives.

Contamination checks:

No problem appears in more than one split.
Every evaluation problem was checked against the 435 k-document general-text corpus (Cosmopedia) used in pretraining.

Fields

Field	Description
`id`	Stable record id
`prompt`	The problem as posed to the model, e.g. `Compute: …` or `Find x: …`
`solution_steps`	Canonical worked solution: post-order reductions or fixed equation moves
`final_answer`	Exact answer: an integer, or a reduced fraction like `-48277/8`
`answer_type`	`integer` or `rational`
`kind`	`expression` or `linear_equation`
`math_text`	The bare expression or equation
`variable`	`x` for equations, else null
`family`	`expression_1op` … `expression_5op`, `linear_equation`
`shape`	Structural template (used for held-out splits and cluster bootstrap)
`difficulty`	Integer difficulty level
`number_range`	`in_distribution` (0–999) or `extrapolation` (4–5 digits)
`params`	JSON string of the sampled numbers
`seed`	Generator seed (string; a 64-bit unsigned integer)
`semantic_fingerprint`	Hash of the canonical problem, used for de-duplication
`generator_version`	`3.0`

Exact original files

data/ holds loader-friendly copies, with seed and params stored as strings. raw/ holds the byte-exact files produced by the generator. Their sha256 hashes match the frozen manifests in the MicroReason repository:

File	sha256
`raw/benchmark_val.jsonl`	`4d9b10b32896…`
`raw/benchmark_val_heldout_shape.jsonl`	`fabbcecef5dd…`
`raw/benchmark_test_id.jsonl`	`2085da0f3c2e…`
`raw/benchmark_test_heldout_shape.jsonl`	`a370443a077d…`
`raw/benchmark_test_extrapolation.jsonl`	`28db77f8794d…`
`raw/benchmark_test_extrapolation_fresh.jsonl`	`35d481707bd9…`
`raw/sft_train.jsonl`	`0020a0e550aa…`

How MicroReason-43M scores

Greedy decoding, show-work prompt, exact final answer:

Model	`test_id`	`test_heldout_shape`	`test_extrapolation`	`test_extrapolation_fresh`
`sft-long`	87.1%	81.4%	10.2%	9.5%
`grpo`	87.8%	82.0%	10.1%	9.3%
`extra-sft`	88.8%	83.1%	7.8%	7.4%

Not included

The larger training pools used for pretraining, mid-training, long SFT and RL are not included: 6 M + 5 M + 4 M records. They come from the same generator and are rebuilt deterministically from their seeds.

Notes

Prompt conventions: in MicroReason the show-work prompt appends Show your work. to prompt. Solutions are rendered as numbered lines inside [steps] … [/steps], followed by [answer]…[/answer].
Purpose: these are synthetic problems for studying small-model reasoning and generalization. They are not representative of natural-language math word problems.