Update dataset card with Quirke complexity labels

README.md

@@ -11,6 +11,7 @@ tags:
   - mechanistic-interpretability
   - addition
   - subtraction
+  - quirke
 size_categories:
   - 1M<n<10M
 ---
@@ -19,65 +20,77 @@ size_categories:
 
 Training and evaluation data for the **SoRL Arithmetic Interpretability Study**.
 
-We train small transformers on integer addition and subtraction, then use
-[Self-Organizing Reinforcement Learning (SoRL)](https://github.com/fangyuan-ksgk/mod_gpt)
-to externalize the model's carry/borrow circuits as explicit abstraction tokens.
+Small transformers trained on integer addition/subtraction, with
+[SoRL](https://github.com/fangyuan-ksgk/mod_gpt) to externalize carry/borrow circuits
+as explicit abstraction tokens.
 
 Reference: Quirke et al., "Understanding Addition and Subtraction in Transformers" (2024)
 
 ## Dataset Structure
 
-Each subfolder contains `train.parquet`, `val.parquet`, and `config.json`.
+| Subfolder | Operations | Train | Val | Eval (stratified) |
+|---|---|---|---|---|
+| `add_6digit` | addition only | 500K | 10K | ~550 (50 per S0-S6 + 200 random) |
+| `add_sub_6digit` | add + sub | 500K | 10K | ~1100 (50 per S0-S6 + M0-M6 + random) |
 
-| Subfolder | Digits | Operations | Train | Val | Sequence Length |
-|---|---|---|---|---|---|
-| `add_6digit` | 6 | addition | 500K | 10K | 21 tokens |
-| `add_sub_6digit` | 6 | add + sub | 500K | 10K | 21 tokens |
-| `add_4digit` | 4 | addition | 500K | 10K | 15 tokens |
-| `add_sub_4digit` | 4 | add + sub | 500K | 10K | 15 tokens |
+## Columns
 
-## Format
-
-Each row has:
-- **tokens**: list of ints — the full input sequence (operands + operator + answer)
-- **labels**: list of str — per-answer-digit sub-task label
-- **op**: `"add"` or `"sub"`
-- **x_digits**, **y_digits**, **z_digits**: the raw digit lists (MSB first)
-
-### Token format
-
-Addition: `XXXXXX+YYYYYY=ZZZZZZZ` (n_digits + operator + n_digits + equals + n_digits+1)
-
-Subtraction: `XXXXXX-YYYYYY=ZZZZZZZ` (x >= y guaranteed, answer zero-padded)
-
-Token IDs: 0-9 = digits, 10 = `+`, 11 = `=`, 12 = `-`
-
-### Sub-task labels
-
-Each answer digit is labeled with the arithmetic sub-task it requires:
-
-**Addition:**
-| Label | Name | Description |
-|---|---|---|
-| BA | Base Add | Simple addition, no carry |
-| MC1 | Make Carry | digit_sum >= 10, generates carry |
-| MS9 | Make Sum 9 | digit_sum == 9, propagates carry if present |
-| UC1 | Use Carry | carry_in=1, digit_sum != 9 |
-| US9 | Use Sum 9 | carry_in=1, digit_sum == 9 (cascade, hardest) |
-
-**Subtraction:**
-| Label | Name | Description |
+| Column | Type | Description |
 |---|---|---|
-| BS | Base Sub | Simple subtraction, no borrow |
-| MB1 | Make Borrow | x_i < y_i, needs borrow |
-| MD9 | Make Diff 9 | x_i == y_i, propagates borrow if present |
-| UB1 | Use Borrow | borrow_in=1, x_i != y_i |
-| UD9 | Use Diff 9 | borrow_in=1, x_i == y_i (cascade, hardest) |
+| `tokens` | list[int] | Full sequence (21 tokens for 6-digit) |
+| `labels` | list[str] | Per-answer-digit sub-task label |
+| `op` | str | `"add"` or `"sub"` |
+| `complexity` | str | Quirke complexity: `S0`-`S6` (add) or `M0`-`M6` (sub) |
+| `cascade_depth` | int | Max carry/borrow cascade length |
+| `x_digits` | list[int] | First operand (MSB first) |
+| `y_digits` | list[int] | Second operand (MSB first) |
+| `z_digits` | list[int] | Answer (MSB first, n_digits+1) |
+
+The `eval_stratified` split has an additional `eval_category` column.
+
+## Sub-task Labels (Quirke et al.)
+
+Each answer digit requires a specific arithmetic operation:
+
+### Addition
+| Label | Name | Condition | Role |
+|---|---|---|---|
+| SA | Base Add | `Dn + D'n < 9`, no carry | Simplest case |
+| SC | Make Carry | `Dn + D'n >= 10` | Generates carry |
+| SS | Sum is 9 | `Dn + D'n == 9` | Propagates carry if one arrives |
+| UC | Use Carry | carry_in=1, sum != 9 | Consumes incoming carry |
+| US | Use Sum-9 | carry_in=1, sum == 9 | Cascade: hardest case |
+
+### Subtraction (x >= y)
+| Label | Name | Condition | Role |
+|---|---|---|---|
+| MD | Base Diff | `Dn > D'n`, no borrow | Simplest case |
+| MB | Make Borrow | `Dn < D'n` | Generates borrow |
+| ME | Equal digits | `Dn == D'n` | Propagates borrow if one arrives |
+| UB | Use Borrow | borrow_in=1, `Dn != D'n` | Consumes incoming borrow |
+| UD | Use Equal | borrow_in=1, `Dn == D'n` | Cascade: hardest case |
+
+## Complexity Classification (Quirke Table 8)
+
+Complexity = length of longest carry/borrow cascade chain.
+
+Example: `555555+444448=1000003` is **S6** — the carry from D0 cascades through
+5 consecutive sum-9 positions.
+
+```
+S0: no carries            ~10%
+S1: isolated carries      ~50%
+S2: cascade of 2          ~26%
+S3: cascade of 3           ~9%
+S4: cascade of 4           ~3%
+S5: cascade of 5           ~1%
+S6: cascade of 6          <0.5%
+```
 
 ## Data Enrichment
 
-Following Quirke et al.: 60% of batches have 40% of digit positions forced to sum-to-9,
-increasing the frequency of US9 (carry cascade) examples from ~6% to ~8%.
+Following Quirke: 60% of batches have 40% of digit positions forced to sum-to-9,
+increasing cascade frequency so the model sees enough S4-S6 cases.
 
 ## Usage
 
@@ -86,12 +99,15 @@ from datasets import load_dataset
 
 ds = load_dataset("thoughtworks/arithmetic-sorl-data", data_dir="add_6digit")
 print(ds["train"][0])
-# {'tokens': [1, 2, 3, 4, 5, 6, 10, 6, 5, 4, 3, 2, 1, 11, 0, 7, 7, 7, 7, 7, 7],
-#  'labels': ['BA', 'UC1', 'MS9', ...], 'op': 'add', ...}
+# {'tokens': [...], 'labels': ['SA', 'UC', 'US', ...],
+#  'complexity': 'S3', 'cascade_depth': 3, ...}
+
+# Stratified eval
+eval_ds = load_dataset("thoughtworks/arithmetic-sorl-data",
+                       data_dir="add_6digit", data_files="eval_stratified.parquet")
 ```
 
 ## Related
 
 - Model checkpoints: [thoughtworks/arithmetic-sorl](https://huggingface.co/thoughtworks/arithmetic-sorl)
 - Code: [mod_gpt/arithmetic/](https://github.com/fangyuan-ksgk/mod_gpt/tree/amir/arithmetic/arithmetic)
-- SoRL paper: Yu & Abdullah, "Intention-Level Alignment with Weak Supervision" (2025)