Publish v1.0.0 formal hard-Sudoku splits

Train on balanced original, r0, and r1_4; reserve r5_19 for OOD evaluation. Includes deterministic builder, provenance hashes, and overlap audit.

README.md

@@ -0,0 +1,122 @@
+---
+license: other
+task_categories:
+- text-generation
+tags:
+- sudoku
+- reasoning
+- planning
+- discrete-diffusion
+- out-of-distribution
+pretty_name: Sudoku DLM Reasoning
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train.parquet
+  - split: validation
+    path: data/validation.parquet
+  - split: test
+    path: data/test.parquet
+  - split: test_ood_confirm
+    path: data/test_ood_confirm.parquet
+---
+
+# Sudoku DLM Reasoning
+
+`stwistzz/Sudoku_DLM_Reasoning` is a deterministic 9x9 Sudoku benchmark for studying masked
+diffusion language models, depth, and iterative decoding. Version 1.0.0
+trains only on `original`, `r0`, and `r1_4`; `r5_19` is held out for adjacent
+difficulty extrapolation.
+
+## Splits
+
+| split | original | r0 | r1_4 | r5_19 | total |
+|---|---:|---:|---:|---:|---:|
+| train | 65,536 | 65,536 | 65,536 | 0 | 196,608 |
+| validation | 2,048 | 2,048 | 2,048 | 0 | 6,144 |
+| test | 1,000 | 1,000 | 1,000 | 1,000 | 4,000 |
+| test_ood_confirm | 0 | 0 | 0 | 4,000 | 4,000 |
+
+The primary zero-shot protocol selects the checkpoint, decoding strategy, and
+number of decoding steps using only `validation`. It must not use `r5_19` before
+the final `test` evaluation. `test_ood_confirm` is reserved for confirming a
+small number of already-selected configurations; it is not a tuning split.
+
+## Difficulty
+
+`r0`, `r1_4`, and `r5_19` use the number of tdoku backtracks. Higher values are
+harder. `original` comes from a separate easy Sudoku collection and is not on the
+same numeric scale.
+
+The evaluation sample deliberately covers subranges:
+
+- `r1_4`: `[1,2)`, `[2,3)`, `[3,4)`, `[4,5)`
+- `r5_19`: `[5,8)`, `[8,12)`, `[12,16)`, `[16,20)`
+
+The 1,000-row test allocation uses 250 rows from each subrange. The 4,000-row
+confirmation allocation uses 1,000 rows from each `r5_19` subrange. Within a
+subrange, source collection and clue count retain their upstream proportions.
+
+## Deterministic construction
+
+- Upstream repository: [`fhyfhy/diffusion-vs-ar-hard-sudoku`](https://huggingface.co/datasets/fhyfhy/diffusion-vs-ar-hard-sudoku)
+- Pinned upstream revision: `527859f62c745c16833aded130ad9f9ddddb76af`
+- Release seed: `20260815`
+- Sampling: proportional metadata-stratified bottom-k by SHA-256 rank
+- Leakage checks: exact puzzle plus digit-renaming-normalized puzzle/solution pair
+- Validation: 81-character format, clue consistency, and Sudoku row/column/box validity
+
+The source train/test boundary is preserved. Validation rows come only from
+unused upstream training rows. Test and confirmation rows come only from upstream
+test files. Full file hashes, row provenance, exclusions, and pairwise overlap
+checks are in `metadata/manifest.json` and `metadata/audit.json`.
+
+The upstream Sudoku Extreme corpus states that its official train and test sets
+are mathematically inequivalent. This release additionally audits exact and digit
+renaming overlap across the mixed original/Extreme sources. It does not implement
+full canonicalization over every Sudoku row, column, band, stack, and transpose
+symmetry; that remains a documented limitation.
+
+## Schema
+
+The main columns are `puzzle`, `solution`, `difficulty_bucket`,
+`difficulty_subbucket`, `official_rating`, `clues`, `source_collection`, and
+`release_split`. `example_id`, `puzzle_id`, and `digit_normalized_id` are stable
+SHA-256 identifiers. `source_file` and `source_row_index` provide exact provenance.
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("stwistzz/Sudoku_DLM_Reasoning")
+train = dataset["train"]
+validation = dataset["validation"]
+test = dataset["test"]
+```
+
+Puzzles and solutions are 81-character row-major strings. `0` denotes an empty
+cell in `puzzle`.
+
+## Rebuild
+
+Download the pinned source CSV files listed in `metadata/manifest.json`, then run:
+
+```bash
+python scripts/build_dataset.py \
+  --source-dir /path/to/source \
+  --output-dir /path/to/release \
+  --dataset-id stwistzz/Sudoku_DLM_Reasoning \
+  --seed 20260815
+```
+
+The builder requires Python 3.10+ and PyArrow.
+
+## Attribution and license
+
+The data is derived from
+[`fhyfhy/diffusion-vs-ar-hard-sudoku`](https://huggingface.co/datasets/fhyfhy/diffusion-vs-ar-hard-sudoku),
+which packages the original Sudoku data from
+[`HKUNLP/diffusion-vs-ar`](https://github.com/HKUNLP/diffusion-vs-ar) and the
+[`sapientinc/sudoku-extreme`](https://huggingface.co/datasets/sapientinc/sudoku-extreme)
+corpus. Please consult and comply with the licenses and attribution requirements
+of all upstream sources. This derived release does not grant rights beyond them.

data/test.parquet

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

data/test_ood_confirm.parquet

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

data/train.parquet

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

data/validation.parquet

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

metadata/audit.json

@@ -0,0 +1,224 @@
+{
+  "dataset_version": "1.0.0",
+  "pairwise_overlap": {
+    "test__vs__test_ood_confirm": {
+      "digit_normalized_id": 0,
+      "example_id": 0,
+      "puzzle_id": 0
+    },
+    "train__vs__test": {
+      "digit_normalized_id": 0,
+      "example_id": 0,
+      "puzzle_id": 0
+    },
+    "train__vs__test_ood_confirm": {
+      "digit_normalized_id": 0,
+      "example_id": 0,
+      "puzzle_id": 0
+    },
+    "train__vs__validation": {
+      "digit_normalized_id": 0,
+      "example_id": 0,
+      "puzzle_id": 0
+    },
+    "validation__vs__test": {
+      "digit_normalized_id": 0,
+      "example_id": 0,
+      "puzzle_id": 0
+    },
+    "validation__vs__test_ood_confirm": {
+      "digit_normalized_id": 0,
+      "example_id": 0,
+      "puzzle_id": 0
+    }
+  },
+  "seed": "20260815",
+  "selected_splits": {
+    "test": {
+      "clues": {
+        "max": 36,
+        "mean": 27.65425,
+        "min": 17
+      },
+      "difficulty_buckets": {
+        "original": 1000,
+        "r0": 1000,
+        "r1_4": 1000,
+        "r5_19": 1000
+      },
+      "difficulty_subbuckets": {
+        "original": 1000,
+        "r0": 1000,
+        "r12_15": 250,
+        "r16_19": 250,
+        "r1_2": 250,
+        "r2_3": 250,
+        "r3_4": 250,
+        "r4_5": 250,
+        "r5_7": 250,
+        "r8_11": 250
+      },
+      "official_rating": {
+        "max": 19.0,
+        "mean": 4.712,
+        "min": 0.0
+      },
+      "rows": 4000,
+      "source_collections": {
+        "01_file1": 337,
+        "diffusion_vs_ar_original": 1000,
+        "puzzles0_kaggle": 163,
+        "puzzles1_unbiased": 1559,
+        "puzzles2_17_clue": 78,
+        "puzzles4_forum_hardest_1905": 850,
+        "puzzles5_forum_hardest_1905_11+": 13
+      },
+      "unique_digit_normalized_ids": 4000,
+      "unique_example_ids": 4000,
+      "unique_puzzle_ids": 4000
+    },
+    "test_ood_confirm": {
+      "clues": {
+        "max": 29,
+        "mean": 24.933,
+        "min": 17
+      },
+      "difficulty_buckets": {
+        "r5_19": 4000
+      },
+      "difficulty_subbuckets": {
+        "r12_15": 1000,
+        "r16_19": 1000,
+        "r5_7": 1000,
+        "r8_11": 1000
+      },
+      "official_rating": {
+        "max": 19.0,
+        "mean": 11.61,
+        "min": 5.0
+      },
+      "rows": 4000,
+      "source_collections": {
+        "01_file1": 1120,
+        "puzzles1_unbiased": 96,
+        "puzzles2_17_clue": 2,
+        "puzzles4_forum_hardest_1905": 2728,
+        "puzzles5_forum_hardest_1905_11+": 54
+      },
+      "unique_digit_normalized_ids": 4000,
+      "unique_example_ids": 4000,
+      "unique_puzzle_ids": 4000
+    },
+    "train": {
+      "clues": {
+        "max": 37,
+        "mean": 28.56609598795573,
+        "min": 17
+      },
+      "difficulty_buckets": {
+        "original": 65536,
+        "r0": 65536,
+        "r1_4": 65536
+      },
+      "difficulty_subbuckets": {
+        "original": 65536,
+        "r0": 65536,
+        "r1_2": 29584,
+        "r2_3": 16809,
+        "r3_4": 10244,
+        "r4_5": 8899
+      },
+      "official_rating": {
+        "max": 4.0,
+        "mean": 0.9882354736328125,
+        "min": 0.0
+      },
+      "rows": 196608,
+      "source_collections": {
+        "01_file1": 2235,
+        "diffusion_vs_ar_original": 65536,
+        "puzzles0_kaggle": 10672,
+        "puzzles1_unbiased": 106434,
+        "puzzles2_17_clue": 5208,
+        "puzzles3_magictour_top1465": 82,
+        "puzzles4_forum_hardest_1905": 6354,
+        "puzzles5_forum_hardest_1905_11+": 87
+      },
+      "unique_digit_normalized_ids": 196608,
+      "unique_example_ids": 196608,
+      "unique_puzzle_ids": 196608
+    },
+    "validation": {
+      "clues": {
+        "max": 36,
+        "mean": 28.565592447916668,
+        "min": 17
+      },
+      "difficulty_buckets": {
+        "original": 2048,
+        "r0": 2048,
+        "r1_4": 2048
+      },
+      "difficulty_subbuckets": {
+        "original": 2048,
+        "r0": 2048,
+        "r1_2": 924,
+        "r2_3": 525,
+        "r3_4": 319,
+        "r4_5": 280
+      },
+      "official_rating": {
+        "max": 4.0,
+        "mean": 0.989013671875,
+        "min": 0.0
+      },
+      "rows": 6144,
+      "source_collections": {
+        "01_file1": 72,
+        "diffusion_vs_ar_original": 2048,
+        "puzzles0_kaggle": 333,
+        "puzzles1_unbiased": 3327,
+        "puzzles2_17_clue": 163,
+        "puzzles4_forum_hardest_1905": 199,
+        "puzzles5_forum_hardest_1905_11+": 2
+      },
+      "unique_digit_normalized_ids": 6144,
+      "unique_example_ids": 6144,
+      "unique_puzzle_ids": 6144
+    }
+  },
+  "source_test_scan": {
+    "accepted_counts": {
+      "original": 1000,
+      "r0": 61127,
+      "r1_4": 58717,
+      "r5_19": 111831
+    },
+    "exclusions": {},
+    "raw_counts": {
+      "original": 1000,
+      "r0": 61127,
+      "r1_4": 58717,
+      "r5_19": 111831
+    }
+  },
+  "source_train_scan": {
+    "accepted_counts": {
+      "original": 100000,
+      "r0": 553009,
+      "r1_4": 529736
+    },
+    "exclusions": {},
+    "raw_counts": {
+      "original": 100000,
+      "r0": 553009,
+      "r1_4": 529736
+    }
+  },
+  "strict_selected_rows_verified": 210752,
+  "symmetry_audit_scope": {
+    "digit_renaming": true,
+    "exact_puzzle": true,
+    "full_row_column_band_stack_transpose_group": false
+  }
+}

metadata/manifest.json

@@ -0,0 +1,329 @@
+{
+  "audit_file": "metadata/audit.json",
+  "dataset_id": "stwistzz/Sudoku_DLM_Reasoning",
+  "dataset_version": "1.0.0",
+  "files": {
+    "data/test.parquet": {
+      "bytes": 742254,
+      "rows": 4000,
+      "sha256": "b5d26f815582561672ead76547bc0c5618e5fbff1b8d031b3c9aa14d0e3d180e"
+    },
+    "data/test_ood_confirm.parquet": {
+      "bytes": 731113,
+      "rows": 4000,
+      "sha256": "e9312e11fb4034585f4640ac663cc43d99f968b63e419aacc0314efae5d20157"
+    },
+    "data/train.parquet": {
+      "bytes": 36554476,
+      "rows": 196608,
+      "sha256": "265e248af10ec7d7c0fb70f99ad91bd21fc2a66b835c0d0805bedb9764950c13"
+    },
+    "data/validation.parquet": {
+      "bytes": 1144080,
+      "rows": 6144,
+      "sha256": "2d63592476956148d5ae836d21ff19b5a7962bcb3caf3e4147e77faa2e09b688"
+    },
+    "metadata/audit.json": {
+      "bytes": 5465,
+      "sha256": "81a54e426eccad84ee3ce42f4f5609ad73aa8addf65cf9799d99875b4b75bb26"
+    },
+    "metadata/split_spec.json": {
+      "bytes": 849,
+      "sha256": "be57f555641388613768d8eb4fa0b041345154b556e36e388a35509d25164280"
+    },
+    "scripts/build_dataset.py": {
+      "bytes": 37701,
+      "sha256": "2ebef7a4e6d268bfecbbacdd38f3f6e585d3a9b4169c522497efeb146829deac"
+    }
+  },
+  "generated_at_utc": "2026-08-15T16:35:33.206067+00:00",
+  "schema": [
+    {
+      "name": "example_id",
+      "type": "string"
+    },
+    {
+      "name": "puzzle_id",
+      "type": "string"
+    },
+    {
+      "name": "digit_normalized_id",
+      "type": "string"
+    },
+    {
+      "name": "puzzle",
+      "type": "string"
+    },
+    {
+      "name": "solution",
+      "type": "string"
+    },
+    {
+      "name": "difficulty_bucket",
+      "type": "string"
+    },
+    {
+      "name": "difficulty_subbucket",
+      "type": "string"
+    },
+    {
+      "name": "source_family",
+      "type": "string"
+    },
+    {
+      "name": "source_collection",
+      "type": "string"
+    },
+    {
+      "name": "official_rating",
+      "type": "double"
+    },
+    {
+      "name": "rating_type",
+      "type": "string"
+    },
+    {
+      "name": "clues",
+      "type": "int16"
+    },
+    {
+      "name": "upstream_split",
+      "type": "string"
+    },
+    {
+      "name": "release_split",
+      "type": "string"
+    },
+    {
+      "name": "evaluation_role",
+      "type": "string"
+    },
+    {
+      "name": "is_ood",
+      "type": "bool"
+    },
+    {
+      "name": "source_file",
+      "type": "string"
+    },
+    {
+      "name": "source_row_index",
+      "type": "int64"
+    },
+    {
+      "name": "stratum",
+      "type": "string"
+    }
+  ],
+  "seed": "20260815",
+  "source": {
+    "files": {
+      "processed/sudoku_extreme_test_r0.csv": {
+        "bytes": 13913402,
+        "difficulty_bucket": "r0",
+        "expected_rows": 61127,
+        "sha256": "37c7b2dae5a09341bfc8dbd3c674d7671d7bf5df8a2dedcc69992e7202796bd6",
+        "upstream_split": "test"
+      },
+      "processed/sudoku_extreme_test_r1_4.csv": {
+        "bytes": 13545003,
+        "difficulty_bucket": "r1_4",
+        "expected_rows": 58717,
+        "sha256": "398d806a65818104b2696e1363aded5d1b4d328789547bd2b68a263735282cf8",
+        "upstream_split": "test"
+      },
+      "processed/sudoku_extreme_test_r5_19.csv": {
+        "bytes": 26407097,
+        "difficulty_bucket": "r5_19",
+        "expected_rows": 111831,
+        "sha256": "93852c0de8b7c6731a247ad6b28d4f64bfd33aa752a121b989180a7a767d7b5b",
+        "upstream_split": "test"
+      },
+      "processed/sudoku_extreme_train_r0.csv": {
+        "bytes": 126425169,
+        "difficulty_bucket": "r0",
+        "expected_rows": 553009,
+        "sha256": "c2d1930e4ca1d857943042e7ea0396bb7de29d4f793ac9e9cc304ed3de80f035",
+        "upstream_split": "train"
+      },
+      "processed/sudoku_extreme_train_r1_4.csv": {
+        "bytes": 122726060,
+        "difficulty_bucket": "r1_4",
+        "expected_rows": 529736,
+        "sha256": "b7f8701f34aba3003298d03580a53d1ac73c1f5930704d621b11781977f891b8",
+        "upstream_split": "train"
+      },
+      "sudoku_test.csv": {
+        "bytes": 165019,
+        "difficulty_bucket": "original",
+        "expected_rows": 1000,
+        "sha256": "36779035c7278bef48f1f4edba67def0d463195ca333ce1857c0bf79e48153c4",
+        "upstream_split": "test"
+      },
+      "sudoku_train.csv": {
+        "bytes": 16500019,
+        "difficulty_bucket": "original",
+        "expected_rows": 100000,
+        "sha256": "b9c13489f2a68af96074c12feccaf90bb9e87e0589df41bef4922b0ebe219a4e",
+        "upstream_split": "train"
+      }
+    },
+    "repo_id": "fhyfhy/diffusion-vs-ar-hard-sudoku",
+    "revision": "527859f62c745c16833aded130ad9f9ddddb76af"
+  },
+  "split_spec_file": "metadata/split_spec.json",
+  "splits": {
+    "test": {
+      "clues": {
+        "max": 36,
+        "mean": 27.65425,
+        "min": 17
+      },
+      "difficulty_buckets": {
+        "original": 1000,
+        "r0": 1000,
+        "r1_4": 1000,
+        "r5_19": 1000
+      },
+      "difficulty_subbuckets": {
+        "original": 1000,
+        "r0": 1000,
+        "r12_15": 250,
+        "r16_19": 250,
+        "r1_2": 250,
+        "r2_3": 250,
+        "r3_4": 250,
+        "r4_5": 250,
+        "r5_7": 250,
+        "r8_11": 250
+      },
+      "official_rating": {
+        "max": 19.0,
+        "mean": 4.712,
+        "min": 0.0
+      },
+      "rows": 4000,
+      "source_collections": {
+        "01_file1": 337,
+        "diffusion_vs_ar_original": 1000,
+        "puzzles0_kaggle": 163,
+        "puzzles1_unbiased": 1559,
+        "puzzles2_17_clue": 78,
+        "puzzles4_forum_hardest_1905": 850,
+        "puzzles5_forum_hardest_1905_11+": 13
+      },
+      "unique_digit_normalized_ids": 4000,
+      "unique_example_ids": 4000,
+      "unique_puzzle_ids": 4000
+    },
+    "test_ood_confirm": {
+      "clues": {
+        "max": 29,
+        "mean": 24.933,
+        "min": 17
+      },
+      "difficulty_buckets": {
+        "r5_19": 4000
+      },
+      "difficulty_subbuckets": {
+        "r12_15": 1000,
+        "r16_19": 1000,
+        "r5_7": 1000,
+        "r8_11": 1000
+      },
+      "official_rating": {
+        "max": 19.0,
+        "mean": 11.61,
+        "min": 5.0
+      },
+      "rows": 4000,
+      "source_collections": {
+        "01_file1": 1120,
+        "puzzles1_unbiased": 96,
+        "puzzles2_17_clue": 2,
+        "puzzles4_forum_hardest_1905": 2728,
+        "puzzles5_forum_hardest_1905_11+": 54
+      },
+      "unique_digit_normalized_ids": 4000,
+      "unique_example_ids": 4000,
+      "unique_puzzle_ids": 4000
+    },
+    "train": {
+      "clues": {
+        "max": 37,
+        "mean": 28.56609598795573,
+        "min": 17
+      },
+      "difficulty_buckets": {
+        "original": 65536,
+        "r0": 65536,
+        "r1_4": 65536
+      },
+      "difficulty_subbuckets": {
+        "original": 65536,
+        "r0": 65536,
+        "r1_2": 29584,
+        "r2_3": 16809,
+        "r3_4": 10244,
+        "r4_5": 8899
+      },
+      "official_rating": {
+        "max": 4.0,
+        "mean": 0.9882354736328125,
+        "min": 0.0
+      },
+      "rows": 196608,
+      "source_collections": {
+        "01_file1": 2235,
+        "diffusion_vs_ar_original": 65536,
+        "puzzles0_kaggle": 10672,
+        "puzzles1_unbiased": 106434,
+        "puzzles2_17_clue": 5208,
+        "puzzles3_magictour_top1465": 82,
+        "puzzles4_forum_hardest_1905": 6354,
+        "puzzles5_forum_hardest_1905_11+": 87
+      },
+      "unique_digit_normalized_ids": 196608,
+      "unique_example_ids": 196608,
+      "unique_puzzle_ids": 196608
+    },
+    "validation": {
+      "clues": {
+        "max": 36,
+        "mean": 28.565592447916668,
+        "min": 17
+      },
+      "difficulty_buckets": {
+        "original": 2048,
+        "r0": 2048,
+        "r1_4": 2048
+      },
+      "difficulty_subbuckets": {
+        "original": 2048,
+        "r0": 2048,
+        "r1_2": 924,
+        "r2_3": 525,
+        "r3_4": 319,
+        "r4_5": 280
+      },
+      "official_rating": {
+        "max": 4.0,
+        "mean": 0.989013671875,
+        "min": 0.0
+      },
+      "rows": 6144,
+      "source_collections": {
+        "01_file1": 72,
+        "diffusion_vs_ar_original": 2048,
+        "puzzles0_kaggle": 333,
+        "puzzles1_unbiased": 3327,
+        "puzzles2_17_clue": 163,
+        "puzzles4_forum_hardest_1905": 199,
+        "puzzles5_forum_hardest_1905_11+": 2
+      },
+      "unique_digit_normalized_ids": 6144,
+      "unique_example_ids": 6144,
+      "unique_puzzle_ids": 6144
+    }
+  }
+}

metadata/split_spec.json

@@ -0,0 +1,40 @@
+{
+  "bucket_mix": "equal across training buckets; natural proportions within buckets",
+  "confirm_subbucket_targets": {
+    "r5_19": {
+      "r12_15": 1000,
+      "r16_19": 1000,
+      "r5_7": 1000,
+      "r8_11": 1000
+    }
+  },
+  "counts": {
+    "test_ood_confirm": 4000,
+    "test_per_bucket": 1000,
+    "train_per_bucket": 65536,
+    "validation_per_bucket": 2048
+  },
+  "dataset_version": "1.0.0",
+  "ood_bucket": "r5_19",
+  "seed": "20260815",
+  "selection": "metadata-stratified bottom-k SHA-256 rank",
+  "test_subbucket_targets": {
+    "r1_4": {
+      "r1_2": 250,
+      "r2_3": 250,
+      "r3_4": 250,
+      "r4_5": 250
+    },
+    "r5_19": {
+      "r12_15": 250,
+      "r16_19": 250,
+      "r5_7": 250,
+      "r8_11": 250
+    }
+  },
+  "training_buckets": [
+    "original",
+    "r0",
+    "r1_4"
+  ]
+}

requirements.txt

@@ -0,0 +1 @@
+pyarrow>=17

scripts/build_dataset.py

@@ -0,0 +1,984 @@
+"""Build the versioned Sudoku_DLM_Reasoning dataset release.
+
+The release is deliberately small enough for controlled model and decoding
+experiments while preserving the upstream train/test boundary:
+
+* train:      65,536 examples from each of original, r0, and r1_4
+* validation:  2,048 examples from each of original, r0, and r1_4
+* test:         1,000 examples from each of original, r0, r1_4, and r5_19
+* confirm:      4,000 additional r5_19 examples, reserved for final confirmation
+
+Selection is deterministic. Rows are ranked by SHA-256 within metadata strata,
+not by their position in the source CSV. Exact-puzzle and digit-renaming overlap
+is excluded across all released splits.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import heapq
+import json
+import math
+import shutil
+from collections import Counter, defaultdict
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterable, Iterator, Mapping, MutableMapping, Sequence
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+DATASET_VERSION = "1.0.0"
+DEFAULT_DATASET_ID = "stwistzz/Sudoku_DLM_Reasoning"
+DEFAULT_SEED = "20260815"
+SOURCE_REPO = "fhyfhy/diffusion-vs-ar-hard-sudoku"
+SOURCE_REVISION = "527859f62c745c16833aded130ad9f9ddddb76af"
+
+TRAIN_PER_BUCKET = 65_536
+VALIDATION_PER_BUCKET = 2_048
+TEST_PER_BUCKET = 1_000
+OOD_CONFIRM_SIZE = 4_000
+
+BUCKET_ORDER = {"original": 0, "r0": 1, "r1_4": 2, "r5_19": 3}
+TEST_PRIORITY = ("r5_19", "r1_4", "r0", "original")
+TRAIN_PRIORITY = ("r1_4", "r0", "original")
+
+SCHEMA = pa.schema(
+    [
+        pa.field("example_id", pa.string(), nullable=False),
+        pa.field("puzzle_id", pa.string(), nullable=False),
+        pa.field("digit_normalized_id", pa.string(), nullable=False),
+        pa.field("puzzle", pa.string(), nullable=False),
+        pa.field("solution", pa.string(), nullable=False),
+        pa.field("difficulty_bucket", pa.string(), nullable=False),
+        pa.field("difficulty_subbucket", pa.string(), nullable=False),
+        pa.field("source_family", pa.string(), nullable=False),
+        pa.field("source_collection", pa.string(), nullable=False),
+        pa.field("official_rating", pa.float64(), nullable=True),
+        pa.field("rating_type", pa.string(), nullable=False),
+        pa.field("clues", pa.int16(), nullable=False),
+        pa.field("upstream_split", pa.string(), nullable=False),
+        pa.field("release_split", pa.string(), nullable=False),
+        pa.field("evaluation_role", pa.string(), nullable=False),
+        pa.field("is_ood", pa.bool_(), nullable=False),
+        pa.field("source_file", pa.string(), nullable=False),
+        pa.field("source_row_index", pa.int64(), nullable=False),
+        pa.field("stratum", pa.string(), nullable=False),
+    ]
+)
+
+
+@dataclass(frozen=True)
+class PoolSpec:
+    bucket: str
+    upstream_split: str
+    relative_path: str
+    expected_rows: int
+    is_original: bool = False
+
+
+POOLS = {
+    ("original", "train"): PoolSpec(
+        "original", "train", "sudoku_train.csv", 100_000, True
+    ),
+    ("original", "test"): PoolSpec(
+        "original", "test", "sudoku_test.csv", 1_000, True
+    ),
+    ("r0", "train"): PoolSpec(
+        "r0", "train", "processed/sudoku_extreme_train_r0.csv", 553_009
+    ),
+    ("r0", "test"): PoolSpec(
+        "r0", "test", "processed/sudoku_extreme_test_r0.csv", 61_127
+    ),
+    ("r1_4", "train"): PoolSpec(
+        "r1_4", "train", "processed/sudoku_extreme_train_r1_4.csv", 529_736
+    ),
+    ("r1_4", "test"): PoolSpec(
+        "r1_4", "test", "processed/sudoku_extreme_test_r1_4.csv", 58_717
+    ),
+    ("r5_19", "test"): PoolSpec(
+        "r5_19", "test", "processed/sudoku_extreme_test_r5_19.csv", 111_831
+    ),
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source-dir", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument("--dataset-id", default=DEFAULT_DATASET_ID)
+    parser.add_argument("--seed", default=DEFAULT_SEED)
+    return parser.parse_args()
+
+
+def sha256_text(value: str) -> str:
+    return hashlib.sha256(value.encode("utf-8")).hexdigest()
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def digit_normalized_pair(puzzle: str, solution: str) -> tuple[str, str]:
+    """Canonicalize digit names using their first occurrence in the solution."""
+    mapping: dict[str, str] = {}
+    for digit in solution:
+        if digit not in mapping:
+            mapping[digit] = str(len(mapping) + 1)
+    if len(mapping) != 9:
+        raise ValueError("solution does not contain all nine digits")
+    normalized_solution = "".join(mapping[digit] for digit in solution)
+    normalized_puzzle = "".join("0" if digit == "0" else mapping[digit] for digit in puzzle)
+    return normalized_puzzle, normalized_solution
+
+
+def subbucket(bucket: str, rating: float | None) -> str:
+    if bucket in {"original", "r0"}:
+        return bucket
+    if rating is None:
+        raise ValueError(f"missing official rating for {bucket}")
+    if bucket == "r1_4":
+        if not 1 <= rating < 5:
+            raise ValueError(f"rating {rating} is outside r1_4")
+        lower = math.floor(rating)
+        return f"r{lower}_{lower + 1}"
+    if bucket == "r5_19":
+        if not 5 <= rating < 20:
+            raise ValueError(f"rating {rating} is outside r5_19")
+        if rating < 8:
+            return "r5_7"
+        if rating < 12:
+            return "r8_11"
+        if rating < 16:
+            return "r12_15"
+        return "r16_19"
+    raise ValueError(f"unknown difficulty bucket: {bucket}")
+
+
+def make_stratum(record: Mapping[str, object]) -> str:
+    bucket = str(record["difficulty_bucket"])
+    clues = int(record["clues"])
+    if bucket == "original":
+        return f"bucket=original|clues={clues}"
+    source = str(record["source_collection"])
+    if bucket == "r0":
+        return f"bucket=r0|source={source}|clues={clues}"
+    return (
+        f"bucket={bucket}|sub={record['difficulty_subbucket']}|"
+        f"source={source}|clues={clues}"
+    )
+
+
+def validate_strings(puzzle: str, solution: str, context: str) -> None:
+    if len(puzzle) != 81 or any(char not in "0123456789" for char in puzzle):
+        raise ValueError(f"{context}: puzzle must contain 81 digits")
+    if len(solution) != 81 or any(char not in "123456789" for char in solution):
+        raise ValueError(f"{context}: solution must contain 81 digits 1-9")
+    for index, clue in enumerate(puzzle):
+        if clue != "0" and clue != solution[index]:
+            raise ValueError(f"{context}: clue disagrees with solution at cell {index}")
+
+
+def validate_solution(solution: str, context: str) -> None:
+    expected = set("123456789")
+    rows = [solution[index : index + 9] for index in range(0, 81, 9)]
+    columns = [solution[index::9] for index in range(9)]
+    boxes = []
+    for box_row in range(3):
+        for box_col in range(3):
+            cells = []
+            for row in range(box_row * 3, box_row * 3 + 3):
+                start = row * 9 + box_col * 3
+                cells.extend(solution[start : start + 3])
+            boxes.append("".join(cells))
+    if any(set(unit) != expected for unit in rows + columns + boxes):
+        raise ValueError(f"{context}: invalid completed Sudoku solution")
+
+
+def iter_pool(source_dir: Path, spec: PoolSpec) -> Iterator[dict[str, object]]:
+    path = source_dir / Path(spec.relative_path)
+    with path.open("r", encoding="utf-8", newline="") as handle:
+        reader = csv.DictReader(handle)
+        required = {"quizzes", "solutions"}
+        if not required.issubset(reader.fieldnames or []):
+            raise ValueError(f"{path}: missing required columns {sorted(required)}")
+        for row_index, row in enumerate(reader):
+            puzzle = row["quizzes"].strip()
+            solution = row["solutions"].strip()
+            context = f"{spec.relative_path}:{row_index + 2}"
+            validate_strings(puzzle, solution, context)
+            clues = sum(char != "0" for char in puzzle)
+
+            if spec.is_original:
+                source_family = "original"
+                source_collection = "diffusion_vs_ar_original"
+                official_rating = None
+                rating_type = "not_rated"
+            else:
+                if row.get("dataset") != "sudoku_extreme":
+                    raise ValueError(f"{context}: unexpected dataset family {row.get('dataset')!r}")
+                if row.get("difficulty_bucket") != spec.bucket:
+                    raise ValueError(f"{context}: unexpected difficulty bucket")
+                if row.get("split") != spec.upstream_split:
+                    raise ValueError(f"{context}: unexpected upstream split")
+                source_family = "sudoku_extreme"
+                source_collection = row["source"].strip()
+                official_rating = float(row["official_rating"])
+                rating_type = row["rating_type"].strip()
+                declared_clues = int(row["clues"])
+                if declared_clues != clues:
+                    raise ValueError(
+                        f"{context}: declared clues {declared_clues} != computed clues {clues}"
+                    )
+
+            normalized_puzzle, normalized_solution = digit_normalized_pair(puzzle, solution)
+            record: dict[str, object] = {
+                "example_id": sha256_text(f"{puzzle}|{solution}"),
+                "puzzle_id": sha256_text(puzzle),
+                "digit_normalized_id": sha256_text(
+                    f"{normalized_puzzle}|{normalized_solution}"
+                ),
+                "puzzle": puzzle,
+                "solution": solution,
+                "difficulty_bucket": spec.bucket,
+                "difficulty_subbucket": subbucket(spec.bucket, official_rating),
+                "source_family": source_family,
+                "source_collection": source_collection,
+                "official_rating": official_rating,
+                "rating_type": rating_type,
+                "clues": clues,
+                "upstream_split": spec.upstream_split,
+                "source_file": spec.relative_path.replace("\\", "/"),
+                "source_row_index": row_index,
+            }
+            record["stratum"] = make_stratum(record)
+            yield record
+
+
+def ordered_specs(split: str, priority: Sequence[str]) -> list[PoolSpec]:
+    return [POOLS[(bucket, split)] for bucket in priority]
+
+
+def scan_pools(
+    source_dir: Path,
+    specs: Sequence[PoolSpec],
+    *,
+    protected_puzzles: set[str] | None = None,
+    protected_digit_normalized: set[str] | None = None,
+    collect_all_ids: bool = False,
+) -> dict[str, object]:
+    protected_puzzles = protected_puzzles or set()
+    protected_digit_normalized = protected_digit_normalized or set()
+    seen_puzzles: set[str] = set()
+    seen_digit_normalized: set[str] = set()
+    all_puzzles: set[str] = set()
+    all_digit_normalized: set[str] = set()
+    counts: dict[str, Counter[str]] = defaultdict(Counter)
+    stratum_groups: dict[str, str] = {}
+    raw_counts: Counter[str] = Counter()
+    accepted_counts: Counter[str] = Counter()
+    exclusions: Counter[str] = Counter()
+
+    for spec in specs:
+        for record in iter_pool(source_dir, spec):
+            raw_counts[spec.bucket] += 1
+            puzzle_id = str(record["puzzle_id"])
+            normalized_id = str(record["digit_normalized_id"])
+            if collect_all_ids:
+                all_puzzles.add(puzzle_id)
+                all_digit_normalized.add(normalized_id)
+            if puzzle_id in protected_puzzles:
+                exclusions["protected_exact_puzzle"] += 1
+                continue
+            if normalized_id in protected_digit_normalized:
+                exclusions["protected_digit_normalized"] += 1
+                continue
+            if puzzle_id in seen_puzzles:
+                exclusions["duplicate_exact_puzzle"] += 1
+                continue
+            if normalized_id in seen_digit_normalized:
+                exclusions["duplicate_digit_normalized"] += 1
+                continue
+            seen_puzzles.add(puzzle_id)
+            seen_digit_normalized.add(normalized_id)
+            stratum = str(record["stratum"])
+            group = str(record["difficulty_subbucket"])
+            if stratum in stratum_groups and stratum_groups[stratum] != group:
+                raise AssertionError(f"stratum {stratum} mapped to two groups")
+            stratum_groups[stratum] = group
+            counts[spec.bucket][stratum] += 1
+            accepted_counts[spec.bucket] += 1
+
+        if raw_counts[spec.bucket] != spec.expected_rows:
+            raise ValueError(
+                f"{spec.relative_path}: expected {spec.expected_rows} rows, "
+                f"found {raw_counts[spec.bucket]}"
+            )
+
+    return {
+        "counts": dict(counts),
+        "stratum_groups": stratum_groups,
+        "raw_counts": dict(raw_counts),
+        "accepted_counts": dict(accepted_counts),
+        "exclusions": dict(exclusions),
+        "seen_puzzles": seen_puzzles,
+        "seen_digit_normalized": seen_digit_normalized,
+        "all_puzzles": all_puzzles,
+        "all_digit_normalized": all_digit_normalized,
+    }
+
+
+def allocate_proportional(counts: Mapping[str, int], total: int) -> dict[str, int]:
+    available = sum(counts.values())
+    if total < 0 or total > available:
+        raise ValueError(f"cannot allocate {total} rows from {available}")
+    if total == 0:
+        return {key: 0 for key in counts}
+    exact = {key: value * total / available for key, value in counts.items()}
+    allocation = {key: min(value, math.floor(exact[key])) for key, value in counts.items()}
+    remaining = total - sum(allocation.values())
+    order = sorted(
+        counts,
+        key=lambda key: (-(exact[key] - math.floor(exact[key])), key),
+    )
+    while remaining:
+        changed = False
+        for key in order:
+            if allocation[key] < counts[key]:
+                allocation[key] += 1
+                remaining -= 1
+                changed = True
+                if remaining == 0:
+                    break
+        if not changed:
+            raise AssertionError("capacity-aware quota allocation stalled")
+    return allocation
+
+
+def subtract_counts(
+    counts: Mapping[str, int], allocation: Mapping[str, int]
+) -> dict[str, int]:
+    return {key: counts[key] - allocation.get(key, 0) for key in counts}
+
+
+def add_allocations(*allocations: Mapping[str, int]) -> dict[str, int]:
+    result: Counter[str] = Counter()
+    for allocation in allocations:
+        result.update(allocation)
+    return dict(result)
+
+
+def allocate_balanced_groups(
+    counts: Mapping[str, int],
+    stratum_groups: Mapping[str, str],
+    targets: Mapping[str, int],
+) -> dict[str, int]:
+    allocation: dict[str, int] = {key: 0 for key in counts}
+    for group, target in targets.items():
+        group_counts = {
+            key: value for key, value in counts.items() if stratum_groups[key] == group
+        }
+        if not group_counts:
+            raise ValueError(f"no rows available for required group {group}")
+        allocation.update(allocate_proportional(group_counts, target))
+    if sum(allocation.values()) != sum(targets.values()):
+        raise AssertionError("balanced group allocation returned the wrong total")
+    return allocation
+
+
+def allocation_rank(seed: str, scope: str, bucket: str, example_id: str) -> int:
+    digest = hashlib.sha256(f"{seed}|{scope}|{bucket}|{example_id}".encode()).digest()
+    return int.from_bytes(digest, byteorder="big", signed=False)
+
+
+def collect_ranked_candidates(
+    source_dir: Path,
+    specs: Sequence[PoolSpec],
+    capacities: Mapping[str, int],
+    *,
+    seed: str,
+    scope: str,
+    protected_puzzles: set[str] | None = None,
+    protected_digit_normalized: set[str] | None = None,
+) -> dict[str, list[dict[str, object]]]:
+    protected_puzzles = protected_puzzles or set()
+    protected_digit_normalized = protected_digit_normalized or set()
+    seen_puzzles: set[str] = set()
+    seen_digit_normalized: set[str] = set()
+    heaps: dict[str, list[tuple[int, str, dict[str, object]]]] = defaultdict(list)
+
+    for spec in specs:
+        for record in iter_pool(source_dir, spec):
+            puzzle_id = str(record["puzzle_id"])
+            normalized_id = str(record["digit_normalized_id"])
+            if puzzle_id in protected_puzzles or normalized_id in protected_digit_normalized:
+                continue
+            if puzzle_id in seen_puzzles or normalized_id in seen_digit_normalized:
+                continue
+            seen_puzzles.add(puzzle_id)
+            seen_digit_normalized.add(normalized_id)
+
+            stratum = str(record["stratum"])
+            capacity = capacities.get(stratum, 0)
+            if capacity == 0:
+                continue
+            rank = allocation_rank(seed, scope, spec.bucket, str(record["example_id"]))
+            record["_allocation_rank"] = rank
+            heap = heaps[stratum]
+            entry = (-rank, str(record["example_id"]), record)
+            if len(heap) < capacity:
+                heapq.heappush(heap, entry)
+            elif rank < -heap[0][0]:
+                heapq.heapreplace(heap, entry)
+
+    selected: dict[str, list[dict[str, object]]] = {}
+    for stratum, capacity in capacities.items():
+        records = [entry[2] for entry in heaps.get(stratum, [])]
+        records.sort(key=lambda record: (int(record["_allocation_rank"]), record["example_id"]))
+        if len(records) != capacity:
+            raise ValueError(
+                f"stratum {stratum}: selected {len(records)} rows, expected {capacity}"
+            )
+        selected[stratum] = records
+    return selected
+
+
+def assign_release_rows(
+    selected: Mapping[str, Sequence[dict[str, object]]],
+    first_allocation: Mapping[str, int],
+    second_allocation: Mapping[str, int] | None,
+    *,
+    first_split: str,
+    second_split: str | None,
+) -> tuple[list[dict[str, object]], list[dict[str, object]]]:
+    first_rows: list[dict[str, object]] = []
+    second_rows: list[dict[str, object]] = []
+    second_allocation = second_allocation or {}
+    for stratum, records in selected.items():
+        first_n = first_allocation.get(stratum, 0)
+        second_n = second_allocation.get(stratum, 0)
+        if len(records) != first_n + second_n:
+            raise AssertionError(f"allocation mismatch for {stratum}")
+        for record in records[:first_n]:
+            first_rows.append(finalize_record(record, first_split))
+        for record in records[first_n : first_n + second_n]:
+            if second_split is None:
+                raise AssertionError("second allocation supplied without a split name")
+            second_rows.append(finalize_record(record, second_split))
+    return first_rows, second_rows
+
+
+def finalize_record(record: Mapping[str, object], release_split: str) -> dict[str, object]:
+    result = {key: value for key, value in record.items() if not key.startswith("_")}
+    bucket = str(result["difficulty_bucket"])
+    is_ood = bucket == "r5_19"
+    if release_split == "train":
+        role = "train_id"
+    elif release_split == "validation":
+        role = "validation_id"
+    elif release_split == "test":
+        role = "test_ood" if is_ood else "test_id"
+    elif release_split == "test_ood_confirm":
+        role = "confirm_ood"
+    else:
+        raise ValueError(f"unknown release split {release_split}")
+    result["release_split"] = release_split
+    result["evaluation_role"] = role
+    result["is_ood"] = is_ood
+    return result
+
+
+def stable_output_order(rows: list[dict[str, object]], seed: str, split: str) -> None:
+    rows.sort(
+        key=lambda row: sha256_text(f"{seed}|output|{split}|{row['example_id']}")
+    )
+
+
+def strict_validate_selected(rows: Sequence[Mapping[str, object]]) -> None:
+    for row in rows:
+        context = f"selected:{row['release_split']}:{row['example_id']}"
+        validate_strings(str(row["puzzle"]), str(row["solution"]), context)
+        validate_solution(str(row["solution"]), context)
+
+
+def summarize_rows(rows: Sequence[Mapping[str, object]]) -> dict[str, object]:
+    bucket_counts = Counter(str(row["difficulty_bucket"]) for row in rows)
+    subbucket_counts = Counter(str(row["difficulty_subbucket"]) for row in rows)
+    source_counts = Counter(str(row["source_collection"]) for row in rows)
+    clue_counts = [int(row["clues"]) for row in rows]
+    ratings = [float(row["official_rating"]) for row in rows if row["official_rating"] is not None]
+    return {
+        "rows": len(rows),
+        "difficulty_buckets": dict(sorted(bucket_counts.items())),
+        "difficulty_subbuckets": dict(sorted(subbucket_counts.items())),
+        "source_collections": dict(sorted(source_counts.items())),
+        "clues": {
+            "min": min(clue_counts),
+            "max": max(clue_counts),
+            "mean": sum(clue_counts) / len(clue_counts),
+        },
+        "official_rating": (
+            {
+                "min": min(ratings),
+                "max": max(ratings),
+                "mean": sum(ratings) / len(ratings),
+            }
+            if ratings
+            else None
+        ),
+        "unique_example_ids": len({str(row["example_id"]) for row in rows}),
+        "unique_puzzle_ids": len({str(row["puzzle_id"]) for row in rows}),
+        "unique_digit_normalized_ids": len(
+            {str(row["digit_normalized_id"]) for row in rows}
+        ),
+    }
+
+
+def overlap_audit(splits: Mapping[str, Sequence[Mapping[str, object]]]) -> dict[str, object]:
+    identifiers = ("example_id", "puzzle_id", "digit_normalized_id")
+    sets = {
+        split: {identifier: {str(row[identifier]) for row in rows} for identifier in identifiers}
+        for split, rows in splits.items()
+    }
+    pairwise: dict[str, dict[str, int]] = {}
+    split_names = list(splits)
+    for left_index, left in enumerate(split_names):
+        for right in split_names[left_index + 1 :]:
+            key = f"{left}__vs__{right}"
+            pairwise[key] = {
+                identifier: len(sets[left][identifier] & sets[right][identifier])
+                for identifier in identifiers
+            }
+    if any(value for result in pairwise.values() for value in result.values()):
+        raise ValueError(f"cross-split overlap detected: {pairwise}")
+    return pairwise
+
+
+def write_parquet(path: Path, rows: list[dict[str, object]]) -> None:
+    table = pa.Table.from_pylist(rows, schema=SCHEMA)
+    pq.write_table(
+        table,
+        path,
+        compression="zstd",
+        compression_level=9,
+        use_dictionary=True,
+        write_statistics=True,
+        row_group_size=8_192,
+    )
+
+
+def write_json(path: Path, value: object) -> None:
+    path.write_text(
+        json.dumps(value, indent=2, sort_keys=True, ensure_ascii=False, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+
+
+def source_metadata(source_dir: Path, specs: Iterable[PoolSpec]) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for spec in sorted(set(specs), key=lambda item: item.relative_path):
+        path = source_dir / spec.relative_path
+        result[spec.relative_path] = {
+            "bytes": path.stat().st_size,
+            "sha256": sha256_file(path),
+            "expected_rows": spec.expected_rows,
+            "upstream_split": spec.upstream_split,
+            "difficulty_bucket": spec.bucket,
+        }
+    return result
+
+
+def render_readme(dataset_id: str, seed: str) -> str:
+    return f"""---
+license: other
+task_categories:
+- text-generation
+tags:
+- sudoku
+- reasoning
+- planning
+- discrete-diffusion
+- out-of-distribution
+pretty_name: Sudoku DLM Reasoning
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train.parquet
+  - split: validation
+    path: data/validation.parquet
+  - split: test
+    path: data/test.parquet
+  - split: test_ood_confirm
+    path: data/test_ood_confirm.parquet
+---
+
+# Sudoku DLM Reasoning
+
+`{dataset_id}` is a deterministic 9x9 Sudoku benchmark for studying masked
+diffusion language models, depth, and iterative decoding. Version {DATASET_VERSION}
+trains only on `original`, `r0`, and `r1_4`; `r5_19` is held out for adjacent
+difficulty extrapolation.
+
+## Splits
+
+| split | original | r0 | r1_4 | r5_19 | total |
+|---|---:|---:|---:|---:|---:|
+| train | 65,536 | 65,536 | 65,536 | 0 | 196,608 |
+| validation | 2,048 | 2,048 | 2,048 | 0 | 6,144 |
+| test | 1,000 | 1,000 | 1,000 | 1,000 | 4,000 |
+| test_ood_confirm | 0 | 0 | 0 | 4,000 | 4,000 |
+
+The primary zero-shot protocol selects the checkpoint, decoding strategy, and
+number of decoding steps using only `validation`. It must not use `r5_19` before
+the final `test` evaluation. `test_ood_confirm` is reserved for confirming a
+small number of already-selected configurations; it is not a tuning split.
+
+## Difficulty
+
+`r0`, `r1_4`, and `r5_19` use the number of tdoku backtracks. Higher values are
+harder. `original` comes from a separate easy Sudoku collection and is not on the
+same numeric scale.
+
+The evaluation sample deliberately covers subranges:
+
+- `r1_4`: `[1,2)`, `[2,3)`, `[3,4)`, `[4,5)`
+- `r5_19`: `[5,8)`, `[8,12)`, `[12,16)`, `[16,20)`
+
+The 1,000-row test allocation uses 250 rows from each subrange. The 4,000-row
+confirmation allocation uses 1,000 rows from each `r5_19` subrange. Within a
+subrange, source collection and clue count retain their upstream proportions.
+
+## Deterministic construction
+
+- Upstream repository: [`{SOURCE_REPO}`](https://huggingface.co/datasets/{SOURCE_REPO})
+- Pinned upstream revision: `{SOURCE_REVISION}`
+- Release seed: `{seed}`
+- Sampling: proportional metadata-stratified bottom-k by SHA-256 rank
+- Leakage checks: exact puzzle plus digit-renaming-normalized puzzle/solution pair
+- Validation: 81-character format, clue consistency, and Sudoku row/column/box validity
+
+The source train/test boundary is preserved. Validation rows come only from
+unused upstream training rows. Test and confirmation rows come only from upstream
+test files. Full file hashes, row provenance, exclusions, and pairwise overlap
+checks are in `metadata/manifest.json` and `metadata/audit.json`.
+
+The upstream Sudoku Extreme corpus states that its official train and test sets
+are mathematically inequivalent. This release additionally audits exact and digit
+renaming overlap across the mixed original/Extreme sources. It does not implement
+full canonicalization over every Sudoku row, column, band, stack, and transpose
+symmetry; that remains a documented limitation.
+
+## Schema
+
+The main columns are `puzzle`, `solution`, `difficulty_bucket`,
+`difficulty_subbucket`, `official_rating`, `clues`, `source_collection`, and
+`release_split`. `example_id`, `puzzle_id`, and `digit_normalized_id` are stable
+SHA-256 identifiers. `source_file` and `source_row_index` provide exact provenance.
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("{dataset_id}")
+train = dataset["train"]
+validation = dataset["validation"]
+test = dataset["test"]
+```
+
+Puzzles and solutions are 81-character row-major strings. `0` denotes an empty
+cell in `puzzle`.
+
+## Rebuild
+
+Download the pinned source CSV files listed in `metadata/manifest.json`, then run:
+
+```bash
+python scripts/build_dataset.py \\
+  --source-dir /path/to/source \\
+  --output-dir /path/to/release \\
+  --dataset-id {dataset_id} \\
+  --seed {seed}
+```
+
+The builder requires Python 3.10+ and PyArrow.
+
+## Attribution and license
+
+The data is derived from
+[`fhyfhy/diffusion-vs-ar-hard-sudoku`](https://huggingface.co/datasets/{SOURCE_REPO}),
+which packages the original Sudoku data from
+[`HKUNLP/diffusion-vs-ar`](https://github.com/HKUNLP/diffusion-vs-ar) and the
+[`sapientinc/sudoku-extreme`](https://huggingface.co/datasets/sapientinc/sudoku-extreme)
+corpus. Please consult and comply with the licenses and attribution requirements
+of all upstream sources. This derived release does not grant rights beyond them.
+"""
+
+
+def build_dataset(
+    source_dir: Path,
+    output_dir: Path,
+    *,
+    dataset_id: str,
+    seed: str,
+) -> None:
+    if not source_dir.is_dir():
+        raise FileNotFoundError(f"source directory does not exist: {source_dir}")
+    if output_dir.exists() and any(output_dir.iterdir()):
+        raise FileExistsError(f"output directory must be absent or empty: {output_dir}")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    data_dir = output_dir / "data"
+    metadata_dir = output_dir / "metadata"
+    scripts_dir = output_dir / "scripts"
+    data_dir.mkdir()
+    metadata_dir.mkdir()
+    scripts_dir.mkdir()
+
+    test_specs = ordered_specs("test", TEST_PRIORITY)
+    train_specs = ordered_specs("train", TRAIN_PRIORITY)
+
+    print("[1/8] Scanning and de-duplicating all protected upstream test pools...")
+    test_scan = scan_pools(source_dir, test_specs, collect_all_ids=True)
+
+    print("[2/8] Scanning train pools and excluding all test-equivalent rows...")
+    train_scan = scan_pools(
+        source_dir,
+        train_specs,
+        protected_puzzles=test_scan["all_puzzles"],
+        protected_digit_normalized=test_scan["all_digit_normalized"],
+    )
+
+    train_allocations: dict[str, dict[str, int]] = {}
+    validation_allocations: dict[str, dict[str, int]] = {}
+    for bucket in TRAIN_PRIORITY:
+        counts = train_scan["counts"][bucket]
+        train_quota = allocate_proportional(counts, TRAIN_PER_BUCKET)
+        validation_quota = allocate_proportional(
+            subtract_counts(counts, train_quota), VALIDATION_PER_BUCKET
+        )
+        train_allocations[bucket] = train_quota
+        validation_allocations[bucket] = validation_quota
+
+    test_allocations: dict[str, dict[str, int]] = {}
+    confirm_allocations: dict[str, dict[str, int]] = {}
+    for bucket in TEST_PRIORITY:
+        counts = test_scan["counts"][bucket]
+        if bucket in {"original", "r0"}:
+            test_quota = allocate_proportional(counts, TEST_PER_BUCKET)
+        elif bucket == "r1_4":
+            test_quota = allocate_balanced_groups(
+                counts,
+                test_scan["stratum_groups"],
+                {"r1_2": 250, "r2_3": 250, "r3_4": 250, "r4_5": 250},
+            )
+        else:
+            test_quota = allocate_balanced_groups(
+                counts,
+                test_scan["stratum_groups"],
+                {"r5_7": 250, "r8_11": 250, "r12_15": 250, "r16_19": 250},
+            )
+        test_allocations[bucket] = test_quota
+        remaining = subtract_counts(counts, test_quota)
+        if bucket == "r5_19":
+            confirm_allocations[bucket] = allocate_balanced_groups(
+                remaining,
+                test_scan["stratum_groups"],
+                {
+                    "r5_7": 1_000,
+                    "r8_11": 1_000,
+                    "r12_15": 1_000,
+                    "r16_19": 1_000,
+                },
+            )
+        else:
+            confirm_allocations[bucket] = {key: 0 for key in counts}
+
+    train_quota_all = add_allocations(*train_allocations.values())
+    validation_quota_all = add_allocations(*validation_allocations.values())
+    test_quota_all = add_allocations(*test_allocations.values())
+    confirm_quota_all = add_allocations(*confirm_allocations.values())
+
+    print("[3/8] Selecting deterministic train and validation rows...")
+    selected_train = collect_ranked_candidates(
+        source_dir,
+        train_specs,
+        add_allocations(train_quota_all, validation_quota_all),
+        seed=seed,
+        scope="train_validation",
+        protected_puzzles=test_scan["all_puzzles"],
+        protected_digit_normalized=test_scan["all_digit_normalized"],
+    )
+    train_rows, validation_rows = assign_release_rows(
+        selected_train,
+        train_quota_all,
+        validation_quota_all,
+        first_split="train",
+        second_split="validation",
+    )
+
+    print("[4/8] Selecting deterministic ID/OOD test and OOD confirmation rows...")
+    selected_test = collect_ranked_candidates(
+        source_dir,
+        test_specs,
+        add_allocations(test_quota_all, confirm_quota_all),
+        seed=seed,
+        scope="test_confirm",
+    )
+    test_rows, confirm_rows = assign_release_rows(
+        selected_test,
+        test_quota_all,
+        confirm_quota_all,
+        first_split="test",
+        second_split="test_ood_confirm",
+    )
+
+    splits = {
+        "train": train_rows,
+        "validation": validation_rows,
+        "test": test_rows,
+        "test_ood_confirm": confirm_rows,
+    }
+    expected_sizes = {
+        "train": 3 * TRAIN_PER_BUCKET,
+        "validation": 3 * VALIDATION_PER_BUCKET,
+        "test": 4 * TEST_PER_BUCKET,
+        "test_ood_confirm": OOD_CONFIRM_SIZE,
+    }
+    for split, rows in splits.items():
+        if len(rows) != expected_sizes[split]:
+            raise AssertionError(f"{split}: got {len(rows)}, expected {expected_sizes[split]}")
+        stable_output_order(rows, seed, split)
+
+    print("[5/8] Strictly validating every selected puzzle and solution...")
+    for rows in splits.values():
+        strict_validate_selected(rows)
+    overlaps = overlap_audit(splits)
+
+    print("[6/8] Writing Parquet splits...")
+    parquet_paths: dict[str, Path] = {}
+    for split, rows in splits.items():
+        path = data_dir / f"{split}.parquet"
+        write_parquet(path, rows)
+        parquet_paths[split] = path
+
+    split_summaries = {split: summarize_rows(rows) for split, rows in splits.items()}
+    audit = {
+        "dataset_version": DATASET_VERSION,
+        "seed": seed,
+        "selected_splits": split_summaries,
+        "pairwise_overlap": overlaps,
+        "source_test_scan": {
+            key: test_scan[key]
+            for key in ("raw_counts", "accepted_counts", "exclusions")
+        },
+        "source_train_scan": {
+            key: train_scan[key]
+            for key in ("raw_counts", "accepted_counts", "exclusions")
+        },
+        "symmetry_audit_scope": {
+            "exact_puzzle": True,
+            "digit_renaming": True,
+            "full_row_column_band_stack_transpose_group": False,
+        },
+        "strict_selected_rows_verified": sum(len(rows) for rows in splits.values()),
+    }
+    write_json(metadata_dir / "audit.json", audit)
+
+    split_spec = {
+        "dataset_version": DATASET_VERSION,
+        "seed": seed,
+        "training_buckets": ["original", "r0", "r1_4"],
+        "ood_bucket": "r5_19",
+        "counts": {
+            "train_per_bucket": TRAIN_PER_BUCKET,
+            "validation_per_bucket": VALIDATION_PER_BUCKET,
+            "test_per_bucket": TEST_PER_BUCKET,
+            "test_ood_confirm": OOD_CONFIRM_SIZE,
+        },
+        "test_subbucket_targets": {
+            "r1_4": {"r1_2": 250, "r2_3": 250, "r3_4": 250, "r4_5": 250},
+            "r5_19": {"r5_7": 250, "r8_11": 250, "r12_15": 250, "r16_19": 250},
+        },
+        "confirm_subbucket_targets": {
+            "r5_19": {
+                "r5_7": 1_000,
+                "r8_11": 1_000,
+                "r12_15": 1_000,
+                "r16_19": 1_000,
+            }
+        },
+        "selection": "metadata-stratified bottom-k SHA-256 rank",
+        "bucket_mix": "equal across training buckets; natural proportions within buckets",
+    }
+    write_json(metadata_dir / "split_spec.json", split_spec)
+
+    print("[7/8] Writing dataset card, provenance, and reproducibility files...")
+    (output_dir / "README.md").write_text(render_readme(dataset_id, seed), encoding="utf-8")
+    (output_dir / "requirements.txt").write_text(
+        "pyarrow>=17\n", encoding="utf-8"
+    )
+    shutil.copy2(Path(__file__), scripts_dir / "build_dataset.py")
+
+    all_specs = list(POOLS.values())
+    source_files = source_metadata(source_dir, all_specs)
+    release_files = {
+        path.relative_to(output_dir).as_posix(): {
+            "bytes": path.stat().st_size,
+            "sha256": sha256_file(path),
+            "rows": len(splits[split]),
+        }
+        for split, path in parquet_paths.items()
+    }
+    release_files["metadata/audit.json"] = {
+        "bytes": (metadata_dir / "audit.json").stat().st_size,
+        "sha256": sha256_file(metadata_dir / "audit.json"),
+    }
+    release_files["metadata/split_spec.json"] = {
+        "bytes": (metadata_dir / "split_spec.json").stat().st_size,
+        "sha256": sha256_file(metadata_dir / "split_spec.json"),
+    }
+    release_files["scripts/build_dataset.py"] = {
+        "bytes": (scripts_dir / "build_dataset.py").stat().st_size,
+        "sha256": sha256_file(scripts_dir / "build_dataset.py"),
+    }
+    manifest = {
+        "dataset_id": dataset_id,
+        "dataset_version": DATASET_VERSION,
+        "generated_at_utc": datetime.now(timezone.utc).isoformat(),
+        "seed": seed,
+        "source": {
+            "repo_id": SOURCE_REPO,
+            "revision": SOURCE_REVISION,
+            "files": source_files,
+        },
+        "schema": [{"name": field.name, "type": str(field.type)} for field in SCHEMA],
+        "splits": split_summaries,
+        "files": release_files,
+        "audit_file": "metadata/audit.json",
+        "split_spec_file": "metadata/split_spec.json",
+    }
+    write_json(metadata_dir / "manifest.json", manifest)
+
+    print("[8/8] Build complete.")
+    print(json.dumps({"output_dir": str(output_dir), "splits": expected_sizes}, indent=2))
+
+
+def main() -> None:
+    args = parse_args()
+    build_dataset(
+        args.source_dir.resolve(),
+        args.output_dir.resolve(),
+        dataset_id=args.dataset_id,
+        seed=str(args.seed),
+    )
+
+
+if __name__ == "__main__":
+    main()