README.md

---
license: mit
language:
- en
tags:
- arithmetic
- process-supervision
- scratchpad
- chain-of-thought
- synthetic
task_categories:
- text-generation
size_categories:
- 100K<n<1M
---

# Contents

| Split | Rows |
|-------|-----:|
| train | 100,000 |
| validation | 4,000 |
| test | 4,000 |
| **total** | **108,000** |

Splits are **prompt-disjoint** — no expression appears in more than one split,
and commutative swaps and trace keys are de-duplicated across splits to prevent
split leakage.

| Operation | Rows |
|-----------|-----:|
| `×` | 32,000 |
| `÷` | 32,000 |
| `+` | 22,000 |
| `−` | 22,000 |

Operands lie in **[−999, 999]**. Division answers use a fixed `DDD.ddd` form
(round-half-up to three decimals); division by zero is an atomic `<nan>`.

## Schema

One JSON object per line. Key fields:

| Field | Description |
|-------|-------------|
| `prompt` | the question, e.g. `842/37=` |
| `text` | the full serialized string: prompt + scratchpad + answer |
| `operation` | `+`, `-`, `*`, `/` |
| `effective_operation` | canonical magnitude op after sign planning (`add`/`sub`/`mul`/`div`) |
| `result_sign` | `positive` / `negative` |
| `state` | the normalized operands the scratchpad works over |
| `steps` | list of structured step records (each with a `serialized` string) |
| `internal_answer` | canonical internal answer (e.g. `022.757`, or `<nan>`) |
| `natural_answer` | human-readable answer (e.g. `22.757`) |
| `scenario` | difficulty/skill bucket (e.g. `rounded_ge_one_up`, `high_column_sum`) |
| `split` | `train` / `val` / `test` |
| `encoded_tokens` | actual row length including `<bos>` and `<eos>` (max 162) |

### The scratchpad grammar

Every row begins with the original expression and then a normalized arithmetic
plan:

```
<prompt><effective-op><result-sign><state><six-digit-state>...<ans><answer>
```

`<effective-op>` is one of `<add>`, `<sub>`, `<mul>`, or `<div>`, and
`<result-sign>` is `<pos>` or `<neg>`. For signed `+` and `-` expressions, the
effective magnitude operation can differ from the prompt operator. For example,
adding operands with opposite signs uses the subtraction grammar after their
magnitudes are ordered.

#### Addition (`<add>`)

The six-digit state contains two zero-padded, three-digit magnitudes in reversed
(units-first) order:

```
<state><left-reversed:3><right-reversed:3>
```

Exactly three `<step>` records follow, one each for the units, tens, and
hundreds columns. Every record has five digits:

```
<step><left-digit><right-digit><carry-in><output-digit><carry-out>
```

The answer is a four-digit, units-first magnitude; the fourth position holds
the final carry:

```
457+386=<add><pos><state>754683<step>76031<step>58141<step>43180<ans>3480
```

Here, `<ans>3480` decodes to `843`.

#### Subtraction (`<sub>`)

The state contains the larger magnitude followed by the smaller magnitude, both
zero-padded to three digits and reversed:

```
<state><larger-reversed:3><smaller-reversed:3>
```

Exactly three five-digit `<step>` records describe the units, tens, and
hundreds columns:

```
<step><minuend-digit><subtrahend-digit><borrow-in><output-digit><borrow-out>
```

The answer is a four-digit, units-first magnitude. Its sign comes from
`<result-sign>`:

```
312-748=<sub><neg><state>847213<step>82060<step>41030<step>73040<ans>6340
```

Here, `<neg>` and `<ans>6340` decode to `-436`.

#### Multiplication (`<mul>`)

The state contains the two zero-padded magnitudes in reversed, units-first
order. Five output columns are processed from least significant to most
significant. Across those columns the grammar contains nine term records,
distributed `1, 2, 3, 2, 1`, and five column-finalization records:

```
<step><left-digit><right-digit><product:2><running-total:3>
<col><output-digit><carry-out:2>
```

Each `<step>` therefore has seven digits and each `<col>` has three. The answer
is a six-digit, units-first product:

```
213*145=<mul><pos><state>312541<step>3515015<col>501 … <col>300<ans>588030
```

Here, `<ans>588030` decodes to `30885`.

#### Division (`<div>`)

Division retains ordinary most-significant-digit-first order. The state is the
zero-padded numerator followed by the zero-padded divisor:

```
<state><numerator:3><divisor:3>
```

For a nonzero divisor, long division has seven positions: three integer
positions, three retained decimal positions, and one guard position used for
round-half-up. Each position is decomposed into three records:

```
<step><remainder-in:3><incoming-digit><partial-dividend:4>
<qmul><quotient-digit><quotient-product:4>
<rem><remainder-out:3>
```

The fixed answer format is `DDD.ddd`:

```
842/37=<div><pos><state>842037<step>00080008<qmul>00000<rem>008<step>00840084<qmul>20074<rem>010 … <ans>022.757
```

Division by zero contains no arithmetic records and ends with the atomic
`<nan>` answer:

```
12/0=<div><pos><state>012000<ans><nan>
```

## How it was generated (and verified)

The complete dataset was generated deterministically with seed `20260722`.
Operands and sign patterns were sampled according to per-operation scenario
quotas so that each split contains its requested mix of identity cases,
carry/borrow patterns, multiplication column-sum bands, and exact or rounded
quotients.

Every accepted row passed the same structured validation pipeline:

1. Parse and validate both signed operands and the requested operation.
2. Construct the canonical magnitude operation, result sign, and normalized
   six-digit state.
3. Generate every structured arithmetic record and the serialized scratchpad.
4. Reconstruct the internal answer from the step records and compare it with the
   exact arithmetic result.
5. Verify the serialized form, fixed field widths, token count, scenario label,
   and row metadata.

The test split was generated first, followed by validation and training.
Prompts, canonical trace keys, sign-equivalent traces, and commutative swaps were
reserved before sampling later splits. The final integrity audit confirmed:

- 108,000 rows and 108,000 unique prompts;
- zero prompt overlap across train, validation, and test;
- zero canonical-trace overlap across splits;
- zero swapped-commutative leakage into held-out splits;
- every row successfully verified and within the declared token limit.

## License

MIT.