Publish v1.0.1 raw snapshot and reproducible build process

Add the complete 1,415,420-row raw candidate pool used by the v1 protocol, raw provenance and license notices, exact build and verification scripts, and metadata manifests. Processed Parquet split contents remain byte-identical to v1.0.0.

.gitattributes

@@ -58,3 +58,9 @@ 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
+raw/processed/sudoku_extreme_test_r0.csv filter=lfs diff=lfs merge=lfs -text
+raw/processed/sudoku_extreme_test_r1_4.csv filter=lfs diff=lfs merge=lfs -text
+raw/processed/sudoku_extreme_test_r5_19.csv filter=lfs diff=lfs merge=lfs -text
+raw/processed/sudoku_extreme_train_r0.csv filter=lfs diff=lfs merge=lfs -text
+raw/processed/sudoku_extreme_train_r1_4.csv filter=lfs diff=lfs merge=lfs -text
+raw/sudoku_train.csv filter=lfs diff=lfs merge=lfs -text

RAW_DATA_LICENSES.md

@@ -0,0 +1,25 @@
+# Raw data licensing and provenance notice
+
+This dataset repository uses `license: other` because the included raw data does
+not have one uniform declared license.
+
+- Construction code in `hengyuf/diffusion-vs-ar` is distributed under the
+  Apache License 2.0. That software license does not automatically relicense all
+  third-party puzzle data.
+- The original easy Sudoku CSV files are mirrored from the pinned
+  `fhyfhy/diffusion-vs-ar-hard-sudoku` dataset snapshot.
+- The `sudoku_extreme_*` files derive from `sapientinc/sudoku-extreme`, which
+  combines several community benchmark sources and does not declare one uniform
+  dataset license.
+
+Files under `raw/` are unmodified research mirrors with byte-level provenance in
+`metadata/raw_manifest.json`. Their inclusion here does not grant rights beyond
+those provided by their respective upstream sources. Users are responsible for
+reviewing and complying with the upstream terms before redistribution or use,
+especially outside research contexts.
+
+Upstream references:
+
+- https://huggingface.co/datasets/fhyfhy/diffusion-vs-ar-hard-sudoku
+- https://huggingface.co/datasets/sapientinc/sudoku-extreme
+- https://github.com/hengyuf/diffusion-vs-ar/tree/hard-sudoku-datasets

README.md

@@ -25,10 +25,22 @@ configs:
 # 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
+diffusion language models, depth, and iterative decoding. Version 1.0.1
 trains only on `original`, `r0`, and `r1_4`; `r5_19` is held out for adjacent
 difficulty extrapolation.
 
+## Repository layout
+
+- `raw/`: complete 1,415,420-row candidate snapshot used by this protocol
+- `data/`: selected, leakage-audited Parquet splits used for experiments
+- `metadata/`: source/release hashes, split specification, and audits
+- `scripts/`: deterministic builder and independent verifier
+- `docs/BUILDING.md`: end-to-end reconstruction instructions
+
+Files under `raw/` are explicitly source data and are not loaded as extra splits.
+Only the four `data/*.parquet` paths declared in the card metadata form the
+`default` dataset config.
+
 ## Splits
 
 | split | original | r0 | r1_4 | r5_19 | total |
@@ -99,17 +111,18 @@ cell in `puzzle`.
 
 ## Rebuild
 
-Download the pinned source CSV files listed in `metadata/manifest.json`, then run:
+The pinned source CSV files are included under `raw/`. Run:
 
 ```bash
 python scripts/build_dataset.py \
-  --source-dir /path/to/source \
+  --source-dir raw \
   --output-dir /path/to/release \
   --dataset-id stwistzz/Sudoku_DLM_Reasoning \
   --seed 20260815
 ```
 
-The builder requires Python 3.10+ and PyArrow.
+The builder requires Python 3.10+ and PyArrow. See `docs/BUILDING.md`, then run
+`scripts/verify_dataset.py` against the rebuilt release.
 
 ## Attribution and license
 
@@ -120,3 +133,4 @@ which packages the original Sudoku data from
 [`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.
+See `RAW_DATA_LICENSES.md` for the raw-snapshot notice.

docs/BUILDING.md

@@ -0,0 +1,36 @@
+# Building the processed dataset from `raw/`
+
+The repository is self-contained for reconstructing the processed release.
+
+## Inputs
+
+- Raw snapshot: `raw/`
+- Dataset ID: `stwistzz/Sudoku_DLM_Reasoning`
+- Release seed: `20260815`
+- Upstream revision: `527859f62c745c16833aded130ad9f9ddddb76af`
+
+First verify that the raw files match `metadata/raw_manifest.json`. Then run the
+builder from the repository root:
+
+```bash
+python scripts/build_dataset.py \
+  --source-dir raw \
+  --output-dir rebuilt-release \
+  --dataset-id stwistzz/Sudoku_DLM_Reasoning \
+  --seed 20260815
+```
+
+The builder performs two full source scans. It validates formats and clues,
+protects all upstream test IDs, removes exact and digit-renaming-equivalent
+cross-split overlap, allocates metadata-stratified quotas, selects by seeded
+SHA-256 rank, validates every selected Sudoku solution, and writes Parquet plus
+machine-readable audits.
+
+Verify the result independently:
+
+```bash
+python scripts/verify_dataset.py rebuilt-release --expected-version 1.0.1
+```
+
+The expected processed split hashes are recorded in `metadata/manifest.json`.
+Timestamp fields may differ across rebuilds; the Parquet content hashes must not.

metadata/audit.json

@@ -1,5 +1,5 @@
 {
-  "dataset_version": "1.0.0",
+  "dataset_version": "1.0.1",
   "pairwise_overlap": {
     "test__vs__test_ood_confirm": {
       "digit_normalized_id": 0,

metadata/manifest.json

@@ -1,8 +1,16 @@
 {
   "audit_file": "metadata/audit.json",
   "dataset_id": "stwistzz/Sudoku_DLM_Reasoning",
-  "dataset_version": "1.0.0",
+  "dataset_version": "1.0.1",
   "files": {
+    "RAW_DATA_LICENSES.md": {
+      "bytes": 1252,
+      "sha256": "4749d8f59f442d90f1241e37ee2a6de27e0de0bc9b2712ec8a44a5a64e4a0c95"
+    },
+    "README.md": {
+      "bytes": 5349,
+      "sha256": "812dc60c7543bd923a04eac5ef12391996063137966b1d717c9344cf0f309e6f"
+    },
     "data/test.parquet": {
       "bytes": 742254,
       "rows": 4000,
@@ -23,20 +31,80 @@
       "rows": 6144,
       "sha256": "2d63592476956148d5ae836d21ff19b5a7962bcb3caf3e4147e77faa2e09b688"
     },
+    "docs/BUILDING.md": {
+      "bytes": 1228,
+      "sha256": "5c4d605f33bfc700afba5a37ce8049ea48a24e64e0e6eb9b3cce2c18d103fa87"
+    },
     "metadata/audit.json": {
       "bytes": 5465,
-      "sha256": "81a54e426eccad84ee3ce42f4f5609ad73aa8addf65cf9799d99875b4b75bb26"
+      "sha256": "970bd16c1120344e1eb04a5325b0ba45d592b79b4360317b35da9a099b0b030d"
+    },
+    "metadata/raw_manifest.json": {
+      "bytes": 2592,
+      "sha256": "d061c6a3e1b29e796cd8e5a2daae1180efbdde67a78f351ec3f6d254bfb91971"
     },
     "metadata/split_spec.json": {
       "bytes": 849,
-      "sha256": "be57f555641388613768d8eb4fa0b041345154b556e36e388a35509d25164280"
+      "sha256": "18e4e6ffe8dbd843a9882ad78164da7152532a214ef7d9dcd4460a59c6f775e1"
+    },
+    "raw/README.md": {
+      "bytes": 1187,
+      "sha256": "101942ebbc7a1550e9a304d89e29dcd771e036d377eb73cfe94f5decd92c1be5"
+    },
+    "raw/processed/sudoku_extreme_test_r0.csv": {
+      "bytes": 13913402,
+      "rows": 61127,
+      "sha256": "37c7b2dae5a09341bfc8dbd3c674d7671d7bf5df8a2dedcc69992e7202796bd6"
+    },
+    "raw/processed/sudoku_extreme_test_r1_4.csv": {
+      "bytes": 13545003,
+      "rows": 58717,
+      "sha256": "398d806a65818104b2696e1363aded5d1b4d328789547bd2b68a263735282cf8"
+    },
+    "raw/processed/sudoku_extreme_test_r5_19.csv": {
+      "bytes": 26407097,
+      "rows": 111831,
+      "sha256": "93852c0de8b7c6731a247ad6b28d4f64bfd33aa752a121b989180a7a767d7b5b"
+    },
+    "raw/processed/sudoku_extreme_train_r0.csv": {
+      "bytes": 126425169,
+      "rows": 553009,
+      "sha256": "c2d1930e4ca1d857943042e7ea0396bb7de29d4f793ac9e9cc304ed3de80f035"
+    },
+    "raw/processed/sudoku_extreme_train_r1_4.csv": {
+      "bytes": 122726060,
+      "rows": 529736,
+      "sha256": "b7f8701f34aba3003298d03580a53d1ac73c1f5930704d621b11781977f891b8"
+    },
+    "raw/sudoku_test.csv": {
+      "bytes": 165019,
+      "rows": 1000,
+      "sha256": "36779035c7278bef48f1f4edba67def0d463195ca333ce1857c0bf79e48153c4"
+    },
+    "raw/sudoku_train.csv": {
+      "bytes": 16500019,
+      "rows": 100000,
+      "sha256": "b9c13489f2a68af96074c12feccaf90bb9e87e0589df41bef4922b0ebe219a4e"
+    },
+    "raw/upstream_processed_manifest.json": {
+      "bytes": 806,
+      "sha256": "4fe25596a1845e6033e1ffbf787fe640529cf4b4ffead313e38ddfbeccd01cd4"
+    },
+    "requirements.txt": {
+      "bytes": 13,
+      "sha256": "1842dad6fc80950a344e79b6831aeacf39f51f9949742de90114bccb350a26a9"
     },
     "scripts/build_dataset.py": {
-      "bytes": 37701,
-      "sha256": "2ebef7a4e6d268bfecbbacdd38f3f6e585d3a9b4169c522497efeb146829deac"
+      "bytes": 44856,
+      "sha256": "1133254160b1496d6bc017753247c98acf8dc06d5ab494db15a98f19bfd75090"
+    },
+    "scripts/verify_dataset.py": {
+      "bytes": 10838,
+      "sha256": "1cc3a341225c6aa700ec6d675e675d75982ee6325682d643112000010e6571bd"
     }
   },
-  "generated_at_utc": "2026-08-15T16:35:33.206067+00:00",
+  "generated_at_utc": "2026-08-15T17:06:43.211264+00:00",
+  "raw_snapshot_file": "metadata/raw_manifest.json",
   "schema": [
     {
       "name": "example_id",

metadata/raw_manifest.json

@@ -0,0 +1,67 @@
+{
+  "candidate_rows": 1415420,
+  "files": {
+    "raw/processed/sudoku_extreme_test_r0.csv": {
+      "bytes": 13913402,
+      "difficulty_bucket": "r0",
+      "rows": 61127,
+      "sha256": "37c7b2dae5a09341bfc8dbd3c674d7671d7bf5df8a2dedcc69992e7202796bd6",
+      "upstream_path": "processed/sudoku_extreme_test_r0.csv",
+      "upstream_split": "test"
+    },
+    "raw/processed/sudoku_extreme_test_r1_4.csv": {
+      "bytes": 13545003,
+      "difficulty_bucket": "r1_4",
+      "rows": 58717,
+      "sha256": "398d806a65818104b2696e1363aded5d1b4d328789547bd2b68a263735282cf8",
+      "upstream_path": "processed/sudoku_extreme_test_r1_4.csv",
+      "upstream_split": "test"
+    },
+    "raw/processed/sudoku_extreme_test_r5_19.csv": {
+      "bytes": 26407097,
+      "difficulty_bucket": "r5_19",
+      "rows": 111831,
+      "sha256": "93852c0de8b7c6731a247ad6b28d4f64bfd33aa752a121b989180a7a767d7b5b",
+      "upstream_path": "processed/sudoku_extreme_test_r5_19.csv",
+      "upstream_split": "test"
+    },
+    "raw/processed/sudoku_extreme_train_r0.csv": {
+      "bytes": 126425169,
+      "difficulty_bucket": "r0",
+      "rows": 553009,
+      "sha256": "c2d1930e4ca1d857943042e7ea0396bb7de29d4f793ac9e9cc304ed3de80f035",
+      "upstream_path": "processed/sudoku_extreme_train_r0.csv",
+      "upstream_split": "train"
+    },
+    "raw/processed/sudoku_extreme_train_r1_4.csv": {
+      "bytes": 122726060,
+      "difficulty_bucket": "r1_4",
+      "rows": 529736,
+      "sha256": "b7f8701f34aba3003298d03580a53d1ac73c1f5930704d621b11781977f891b8",
+      "upstream_path": "processed/sudoku_extreme_train_r1_4.csv",
+      "upstream_split": "train"
+    },
+    "raw/sudoku_test.csv": {
+      "bytes": 165019,
+      "difficulty_bucket": "original",
+      "rows": 1000,
+      "sha256": "36779035c7278bef48f1f4edba67def0d463195ca333ce1857c0bf79e48153c4",
+      "upstream_path": "sudoku_test.csv",
+      "upstream_split": "test"
+    },
+    "raw/sudoku_train.csv": {
+      "bytes": 16500019,
+      "difficulty_bucket": "original",
+      "rows": 100000,
+      "sha256": "b9c13489f2a68af96074c12feccaf90bb9e87e0589df41bef4922b0ebe219a4e",
+      "upstream_path": "sudoku_train.csv",
+      "upstream_split": "train"
+    }
+  },
+  "label": "raw",
+  "license_notice": "RAW_DATA_LICENSES.md",
+  "scope": "complete candidate pool used by the v1 protocol",
+  "source_repo": "fhyfhy/diffusion-vs-ar-hard-sudoku",
+  "source_revision": "527859f62c745c16833aded130ad9f9ddddb76af",
+  "upstream_processed_manifest": "raw/upstream_processed_manifest.json"
+}

metadata/split_spec.json

@@ -14,7 +14,7 @@
     "train_per_bucket": 65536,
     "validation_per_bucket": 2048
   },
-  "dataset_version": "1.0.0",
+  "dataset_version": "1.0.1",
   "ood_bucket": "r5_19",
   "seed": "20260815",
   "selection": "metadata-stratified bottom-k SHA-256 rank",

raw/README.md

@@ -0,0 +1,23 @@
+# Raw source snapshot
+
+This directory is explicitly labeled **raw**. It contains unmodified copies of
+the seven upstream CSV files scanned by the `1.0.1` builder:
+
+| raw path | upstream split | difficulty | rows |
+|---|---|---|---:|
+| `sudoku_train.csv` | train | original | 100,000 |
+| `sudoku_test.csv` | test | original | 1,000 |
+| `processed/sudoku_extreme_train_r0.csv` | train | r0 | 553,009 |
+| `processed/sudoku_extreme_test_r0.csv` | test | r0 | 61,127 |
+| `processed/sudoku_extreme_train_r1_4.csv` | train | r1_4 | 529,736 |
+| `processed/sudoku_extreme_test_r1_4.csv` | test | r1_4 | 58,717 |
+| `processed/sudoku_extreme_test_r5_19.csv` | test | r5_19 | 111,831 |
+
+Total: **1,415,420 rows**. This is the complete candidate pool for the v1
+protocol, not the complete 8.1M-row upstream repository. Unused difficulty
+buckets and unrelated dataset families are intentionally excluded.
+
+These files are not additional Hugging Face splits. The dataset card explicitly
+maps only `data/*.parquet` into the `default` config. See
+`metadata/raw_manifest.json` for SHA-256 hashes and exact provenance, and
+`RAW_DATA_LICENSES.md` before redistributing the raw files.

raw/processed/sudoku_extreme_test_r0.csv

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

raw/processed/sudoku_extreme_test_r1_4.csv

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

raw/processed/sudoku_extreme_test_r5_19.csv

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

raw/processed/sudoku_extreme_train_r0.csv

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

raw/processed/sudoku_extreme_train_r1_4.csv

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

raw/sudoku_train.csv

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

raw/upstream_processed_manifest.json

@@ -0,0 +1,22 @@
+{
+  "sudoku_exchange_train_diabolical": 119681,
+  "sudoku_exchange_train_easy": 100000,
+  "sudoku_exchange_train_hard": 321592,
+  "sudoku_exchange_train_medium": 352643,
+  "sudoku_extreme_test_r0": 61127,
+  "sudoku_extreme_test_r100_plus": 4364,
+  "sudoku_extreme_test_r1_4": 58717,
+  "sudoku_extreme_test_r20_49": 143851,
+  "sudoku_extreme_test_r50_99": 42896,
+  "sudoku_extreme_test_r5_19": 111831,
+  "sudoku_extreme_train_r0": 553009,
+  "sudoku_extreme_train_r100_plus": 40656,
+  "sudoku_extreme_train_r1_4": 529736,
+  "sudoku_extreme_train_r20_49": 1306567,
+  "sudoku_extreme_train_r50_99": 382534,
+  "sudoku_extreme_train_r5_19": 1019492,
+  "sudoku_kaggle3m_train_r0": 1294081,
+  "sudoku_kaggle3m_train_r1_2": 812419,
+  "sudoku_kaggle3m_train_r2_4": 816076,
+  "sudoku_kaggle3m_train_r4_plus": 77424
+}

scripts/build_dataset.py

@@ -32,7 +32,7 @@ import pyarrow as pa
 import pyarrow.parquet as pq
 
 
-DATASET_VERSION = "1.0.0"
+DATASET_VERSION = "1.0.1"
 DEFAULT_DATASET_ID = "stwistzz/Sudoku_DLM_Reasoning"
 DEFAULT_SEED = "20260815"
 SOURCE_REPO = "fhyfhy/diffusion-vs-ar-hard-sudoku"
@@ -596,6 +596,134 @@ def source_metadata(source_dir: Path, specs: Iterable[PoolSpec]) -> dict[str, ob
     return result
 
 
+def render_raw_readme() -> str:
+    return f"""# Raw source snapshot
+
+This directory is explicitly labeled **raw**. It contains unmodified copies of
+the seven upstream CSV files scanned by the `{DATASET_VERSION}` builder:
+
+| raw path | upstream split | difficulty | rows |
+|---|---|---|---:|
+| `sudoku_train.csv` | train | original | 100,000 |
+| `sudoku_test.csv` | test | original | 1,000 |
+| `processed/sudoku_extreme_train_r0.csv` | train | r0 | 553,009 |
+| `processed/sudoku_extreme_test_r0.csv` | test | r0 | 61,127 |
+| `processed/sudoku_extreme_train_r1_4.csv` | train | r1_4 | 529,736 |
+| `processed/sudoku_extreme_test_r1_4.csv` | test | r1_4 | 58,717 |
+| `processed/sudoku_extreme_test_r5_19.csv` | test | r5_19 | 111,831 |
+
+Total: **1,415,420 rows**. This is the complete candidate pool for the v1
+protocol, not the complete 8.1M-row upstream repository. Unused difficulty
+buckets and unrelated dataset families are intentionally excluded.
+
+These files are not additional Hugging Face splits. The dataset card explicitly
+maps only `data/*.parquet` into the `default` config. See
+`metadata/raw_manifest.json` for SHA-256 hashes and exact provenance, and
+`RAW_DATA_LICENSES.md` before redistributing the raw files.
+"""
+
+
+def render_building_guide(dataset_id: str, seed: str) -> str:
+    return f"""# Building the processed dataset from `raw/`
+
+The repository is self-contained for reconstructing the processed release.
+
+## Inputs
+
+- Raw snapshot: `raw/`
+- Dataset ID: `{dataset_id}`
+- Release seed: `{seed}`
+- Upstream revision: `{SOURCE_REVISION}`
+
+First verify that the raw files match `metadata/raw_manifest.json`. Then run the
+builder from the repository root:
+
+```bash
+python scripts/build_dataset.py \\
+  --source-dir raw \\
+  --output-dir rebuilt-release \\
+  --dataset-id {dataset_id} \\
+  --seed {seed}
+```
+
+The builder performs two full source scans. It validates formats and clues,
+protects all upstream test IDs, removes exact and digit-renaming-equivalent
+cross-split overlap, allocates metadata-stratified quotas, selects by seeded
+SHA-256 rank, validates every selected Sudoku solution, and writes Parquet plus
+machine-readable audits.
+
+Verify the result independently:
+
+```bash
+python scripts/verify_dataset.py rebuilt-release --expected-version {DATASET_VERSION}
+```
+
+The expected processed split hashes are recorded in `metadata/manifest.json`.
+Timestamp fields may differ across rebuilds; the Parquet content hashes must not.
+"""
+
+
+def render_raw_license_notice() -> str:
+    return """# Raw data licensing and provenance notice
+
+This dataset repository uses `license: other` because the included raw data does
+not have one uniform declared license.
+
+- Construction code in `hengyuf/diffusion-vs-ar` is distributed under the
+  Apache License 2.0. That software license does not automatically relicense all
+  third-party puzzle data.
+- The original easy Sudoku CSV files are mirrored from the pinned
+  `fhyfhy/diffusion-vs-ar-hard-sudoku` dataset snapshot.
+- The `sudoku_extreme_*` files derive from `sapientinc/sudoku-extreme`, which
+  combines several community benchmark sources and does not declare one uniform
+  dataset license.
+
+Files under `raw/` are unmodified research mirrors with byte-level provenance in
+`metadata/raw_manifest.json`. Their inclusion here does not grant rights beyond
+those provided by their respective upstream sources. Users are responsible for
+reviewing and complying with the upstream terms before redistribution or use,
+especially outside research contexts.
+
+Upstream references:
+
+- https://huggingface.co/datasets/fhyfhy/diffusion-vs-ar-hard-sudoku
+- https://huggingface.co/datasets/sapientinc/sudoku-extreme
+- https://github.com/hengyuf/diffusion-vs-ar/tree/hard-sudoku-datasets
+"""
+
+
+def copy_raw_snapshot(
+    source_dir: Path, output_dir: Path, specs: Iterable[PoolSpec]
+) -> dict[str, object]:
+    raw_dir = output_dir / "raw"
+    raw_dir.mkdir()
+    files: dict[str, object] = {}
+    for spec in sorted(set(specs), key=lambda item: item.relative_path):
+        source = source_dir / spec.relative_path
+        destination = raw_dir / spec.relative_path
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, destination)
+        relative = destination.relative_to(output_dir).as_posix()
+        source_hash = sha256_file(source)
+        destination_hash = sha256_file(destination)
+        if source_hash != destination_hash:
+            raise IOError(f"raw copy hash mismatch: {spec.relative_path}")
+        files[relative] = {
+            "bytes": destination.stat().st_size,
+            "sha256": destination_hash,
+            "rows": spec.expected_rows,
+            "upstream_path": spec.relative_path,
+            "upstream_split": spec.upstream_split,
+            "difficulty_bucket": spec.bucket,
+        }
+
+    upstream_manifest = source_dir / "processed/manifest.json"
+    if upstream_manifest.is_file():
+        shutil.copy2(upstream_manifest, raw_dir / "upstream_processed_manifest.json")
+    (raw_dir / "README.md").write_text(render_raw_readme(), encoding="utf-8")
+    return files
+
+
 def render_readme(dataset_id: str, seed: str) -> str:
     return f"""---
 license: other
@@ -628,6 +756,18 @@ diffusion language models, depth, and iterative decoding. Version {DATASET_VERSI
 trains only on `original`, `r0`, and `r1_4`; `r5_19` is held out for adjacent
 difficulty extrapolation.
 
+## Repository layout
+
+- `raw/`: complete 1,415,420-row candidate snapshot used by this protocol
+- `data/`: selected, leakage-audited Parquet splits used for experiments
+- `metadata/`: source/release hashes, split specification, and audits
+- `scripts/`: deterministic builder and independent verifier
+- `docs/BUILDING.md`: end-to-end reconstruction instructions
+
+Files under `raw/` are explicitly source data and are not loaded as extra splits.
+Only the four `data/*.parquet` paths declared in the card metadata form the
+`default` dataset config.
+
 ## Splits
 
 | split | original | r0 | r1_4 | r5_19 | total |
@@ -698,17 +838,18 @@ cell in `puzzle`.
 
 ## Rebuild
 
-Download the pinned source CSV files listed in `metadata/manifest.json`, then run:
+The pinned source CSV files are included under `raw/`. Run:
 
 ```bash
 python scripts/build_dataset.py \\
-  --source-dir /path/to/source \\
+  --source-dir raw \\
   --output-dir /path/to/release \\
   --dataset-id {dataset_id} \\
   --seed {seed}
 ```
 
-The builder requires Python 3.10+ and PyArrow.
+The builder requires Python 3.10+ and PyArrow. See `docs/BUILDING.md`, then run
+`scripts/verify_dataset.py` against the rebuilt release.
 
 ## Attribution and license
 
@@ -719,6 +860,7 @@ which packages the original Sudoku data from
 [`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.
+See `RAW_DATA_LICENSES.md` for the raw-snapshot notice.
 """
 
 
@@ -737,17 +879,19 @@ def build_dataset(
     data_dir = output_dir / "data"
     metadata_dir = output_dir / "metadata"
     scripts_dir = output_dir / "scripts"
+    docs_dir = output_dir / "docs"
     data_dir.mkdir()
     metadata_dir.mkdir()
     scripts_dir.mkdir()
+    docs_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...")
+    print("[1/9] 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...")
+    print("[2/9] Scanning train pools and excluding all test-equivalent rows...")
     train_scan = scan_pools(
         source_dir,
         train_specs,
@@ -805,7 +949,7 @@ def build_dataset(
     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...")
+    print("[3/9] Selecting deterministic train and validation rows...")
     selected_train = collect_ranked_candidates(
         source_dir,
         train_specs,
@@ -823,7 +967,7 @@ def build_dataset(
         second_split="validation",
     )
 
-    print("[4/8] Selecting deterministic ID/OOD test and OOD confirmation rows...")
+    print("[4/9] Selecting deterministic ID/OOD test and OOD confirmation rows...")
     selected_test = collect_ranked_candidates(
         source_dir,
         test_specs,
@@ -856,12 +1000,12 @@ def build_dataset(
             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...")
+    print("[5/9] 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...")
+    print("[6/9] Writing Parquet splits and processed-split audits...")
     parquet_paths: dict[str, Path] = {}
     for split, rows in splits.items():
         path = data_dir / f"{split}.parquet"
@@ -919,35 +1063,65 @@ def build_dataset(
     }
     write_json(metadata_dir / "split_spec.json", split_spec)
 
-    print("[7/8] Writing dataset card, provenance, and reproducibility files...")
+    print("[7/9] Writing dataset card, documentation, and reproducibility scripts...")
     (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"
+    (output_dir / "requirements.txt").write_text("pyarrow>=17\n", encoding="utf-8")
+    (output_dir / "RAW_DATA_LICENSES.md").write_text(
+        render_raw_license_notice(), encoding="utf-8"
+    )
+    (docs_dir / "BUILDING.md").write_text(
+        render_building_guide(dataset_id, seed), encoding="utf-8"
     )
     shutil.copy2(Path(__file__), scripts_dir / "build_dataset.py")
 
+    verifier_candidates = (
+        Path(__file__).with_name("verify_sudoku_dlm_reasoning_dataset.py"),
+        Path(__file__).with_name("verify_dataset.py"),
+    )
+    verifier_source = next((path for path in verifier_candidates if path.is_file()), None)
+    if verifier_source is None:
+        raise FileNotFoundError("independent dataset verifier is missing")
+    shutil.copy2(verifier_source, scripts_dir / "verify_dataset.py")
+
     all_specs = list(POOLS.values())
     source_files = source_metadata(source_dir, all_specs)
-    release_files = {
-        path.relative_to(output_dir).as_posix(): {
+
+    print("[8/9] Copying the complete v1 candidate pool under raw/...")
+    raw_files = copy_raw_snapshot(source_dir, output_dir, all_specs)
+    raw_manifest = {
+        "label": "raw",
+        "scope": "complete candidate pool used by the v1 protocol",
+        "candidate_rows": sum(spec.expected_rows for spec in all_specs),
+        "source_repo": SOURCE_REPO,
+        "source_revision": SOURCE_REVISION,
+        "files": raw_files,
+        "upstream_processed_manifest": "raw/upstream_processed_manifest.json",
+        "license_notice": "RAW_DATA_LICENSES.md",
+    }
+    write_json(metadata_dir / "raw_manifest.json", raw_manifest)
+
+    row_counts = {
+        path.relative_to(output_dir).as_posix(): len(splits[split])
+        for split, path in parquet_paths.items()
+    }
+    row_counts.update(
+        {relative: int(details["rows"]) for relative, details in raw_files.items()}
+    )
+    release_files: dict[str, object] = {}
+    for path in sorted(output_dir.rglob("*")):
+        if not path.is_file():
+            continue
+        relative = path.relative_to(output_dir).as_posix()
+        if relative == "metadata/manifest.json":
+            continue
+        entry: dict[str, object] = {
             "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"),
-    }
+        if relative in row_counts:
+            entry["rows"] = row_counts[relative]
+        release_files[relative] = entry
+
     manifest = {
         "dataset_id": dataset_id,
         "dataset_version": DATASET_VERSION,
@@ -963,10 +1137,11 @@ def build_dataset(
         "files": release_files,
         "audit_file": "metadata/audit.json",
         "split_spec_file": "metadata/split_spec.json",
+        "raw_snapshot_file": "metadata/raw_manifest.json",
     }
     write_json(metadata_dir / "manifest.json", manifest)
 
-    print("[8/8] Build complete.")
+    print("[9/9] Build complete.")
     print(json.dumps({"output_dir": str(output_dir), "splits": expected_sizes}, indent=2))
 
 

scripts/verify_dataset.py

@@ -0,0 +1,275 @@
+"""Independently verify a built Sudoku_DLM_Reasoning release."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+from collections import Counter
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+EXPECTED_BUCKETS = {
+    "train": {"original": 65_536, "r0": 65_536, "r1_4": 65_536},
+    "validation": {"original": 2_048, "r0": 2_048, "r1_4": 2_048},
+    "test": {"original": 1_000, "r0": 1_000, "r1_4": 1_000, "r5_19": 1_000},
+    "test_ood_confirm": {"r5_19": 4_000},
+}
+
+EXPECTED_SUBBUCKETS = {
+    "test": {
+        "original": 1_000,
+        "r0": 1_000,
+        "r1_2": 250,
+        "r2_3": 250,
+        "r3_4": 250,
+        "r4_5": 250,
+        "r5_7": 250,
+        "r8_11": 250,
+        "r12_15": 250,
+        "r16_19": 250,
+    },
+    "test_ood_confirm": {
+        "r5_7": 1_000,
+        "r8_11": 1_000,
+        "r12_15": 1_000,
+        "r16_19": 1_000,
+    },
+}
+
+EXPECTED_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),
+    ]
+)
+
+VERIFY_COLUMNS = [
+    "example_id",
+    "puzzle_id",
+    "digit_normalized_id",
+    "puzzle",
+    "solution",
+    "difficulty_bucket",
+    "difficulty_subbucket",
+    "clues",
+    "upstream_split",
+    "release_split",
+    "evaluation_role",
+    "is_ood",
+    "source_row_index",
+]
+
+
+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_id(puzzle: str, solution: str) -> str:
+    mapping: dict[str, str] = {}
+    for digit in solution:
+        mapping.setdefault(digit, str(len(mapping) + 1))
+    if len(mapping) != 9:
+        raise AssertionError("solution does not contain all digits")
+    normalized_puzzle = "".join("0" if digit == "0" else mapping[digit] for digit in puzzle)
+    normalized_solution = "".join(mapping[digit] for digit in solution)
+    return sha256_text(f"{normalized_puzzle}|{normalized_solution}")
+
+
+def validate_sudoku(puzzle: str, solution: str) -> None:
+    assert len(puzzle) == 81 and set(puzzle) <= set("0123456789")
+    assert len(solution) == 81 and set(solution) <= set("123456789")
+    assert all(clue == "0" or clue == solution[index] for index, clue in enumerate(puzzle))
+    expected = set("123456789")
+    units = [solution[index : index + 9] for index in range(0, 81, 9)]
+    units.extend(solution[index::9] for index in range(9))
+    for box_row in range(3):
+        for box_col in range(3):
+            units.append(
+                "".join(
+                    solution[row * 9 + box_col * 3 : row * 9 + box_col * 3 + 3]
+                    for row in range(box_row * 3, box_row * 3 + 3)
+                )
+            )
+    assert all(set(unit) == expected for unit in units)
+
+
+def expected_role(split: str, bucket: str) -> tuple[str, bool]:
+    if split == "train":
+        return "train_id", False
+    if split == "validation":
+        return "validation_id", False
+    if split == "test":
+        return ("test_ood", True) if bucket == "r5_19" else ("test_id", False)
+    return "confirm_ood", True
+
+
+def verify_split(path: Path, split: str) -> tuple[dict[str, set[str]], dict[str, object]]:
+    file_schema = pq.read_schema(path)
+    if not file_schema.equals(EXPECTED_SCHEMA, check_metadata=False):
+        raise AssertionError(f"{split}: schema mismatch\n{file_schema}\n!=\n{EXPECTED_SCHEMA}")
+    table = pq.read_table(path, columns=VERIFY_COLUMNS)
+    expected_rows = sum(EXPECTED_BUCKETS[split].values())
+    assert table.num_rows == expected_rows, (split, table.num_rows, expected_rows)
+    columns = table.to_pydict()
+    ids = {name: set() for name in ("example_id", "puzzle_id", "digit_normalized_id")}
+    buckets: Counter[str] = Counter()
+    subbuckets: Counter[str] = Counter()
+    expected_upstream = "train" if split in {"train", "validation"} else "test"
+
+    for index in range(table.num_rows):
+        puzzle = columns["puzzle"][index]
+        solution = columns["solution"][index]
+        bucket = columns["difficulty_bucket"][index]
+        validate_sudoku(puzzle, solution)
+        assert columns["example_id"][index] == sha256_text(f"{puzzle}|{solution}")
+        assert columns["puzzle_id"][index] == sha256_text(puzzle)
+        assert columns["digit_normalized_id"][index] == digit_normalized_id(puzzle, solution)
+        assert columns["clues"][index] == sum(value != "0" for value in puzzle)
+        assert columns["upstream_split"][index] == expected_upstream
+        assert columns["release_split"][index] == split
+        role, is_ood = expected_role(split, bucket)
+        assert columns["evaluation_role"][index] == role
+        assert columns["is_ood"][index] is is_ood
+        assert columns["source_row_index"][index] >= 0
+        buckets[bucket] += 1
+        subbuckets[columns["difficulty_subbucket"][index]] += 1
+        for name in ids:
+            value = columns[name][index]
+            if value in ids[name]:
+                raise AssertionError(f"{split}: duplicate {name} {value}")
+            ids[name].add(value)
+
+    assert dict(buckets) == EXPECTED_BUCKETS[split], (split, buckets)
+    if split in EXPECTED_SUBBUCKETS:
+        assert dict(subbuckets) == EXPECTED_SUBBUCKETS[split], (split, subbuckets)
+    return ids, {
+        "rows": table.num_rows,
+        "difficulty_buckets": dict(sorted(buckets.items())),
+        "difficulty_subbuckets": dict(sorted(subbuckets.items())),
+        "sha256": sha256_file(path),
+    }
+
+
+def count_csv_rows(path: Path) -> int:
+    with path.open("r", encoding="utf-8", newline="") as handle:
+        reader = csv.reader(handle)
+        next(reader)
+        return sum(1 for _ in reader)
+
+
+def verify_raw_snapshot(root: Path, manifest: dict[str, object]) -> dict[str, object] | None:
+    raw_manifest_name = manifest.get("raw_snapshot_file")
+    if raw_manifest_name is None:
+        return None
+    raw_manifest = json.loads((root / str(raw_manifest_name)).read_text(encoding="utf-8"))
+    assert raw_manifest["label"] == "raw"
+    rows = 0
+    for relative_path, declared in raw_manifest["files"].items():
+        path = root / relative_path
+        assert relative_path.startswith("raw/"), relative_path
+        assert path.is_file(), relative_path
+        assert path.stat().st_size == declared["bytes"], relative_path
+        assert sha256_file(path) == declared["sha256"], relative_path
+        observed_rows = count_csv_rows(path)
+        assert observed_rows == declared["rows"], relative_path
+        release_declared = manifest["files"][relative_path]
+        assert release_declared["sha256"] == declared["sha256"], relative_path
+        assert release_declared["rows"] == observed_rows, relative_path
+        rows += observed_rows
+    assert rows == raw_manifest["candidate_rows"]
+    return {"label": "raw", "files": len(raw_manifest["files"]), "rows": rows}
+
+
+def verify_release(root: Path, expected_version: str | None = None) -> dict[str, object]:
+    manifest = json.loads((root / "metadata/manifest.json").read_text(encoding="utf-8"))
+    audit = json.loads((root / "metadata/audit.json").read_text(encoding="utf-8"))
+    assert manifest["dataset_id"] == "stwistzz/Sudoku_DLM_Reasoning"
+    dataset_version = str(manifest["dataset_version"])
+    if expected_version is not None:
+        assert dataset_version == expected_version, (dataset_version, expected_version)
+    assert manifest["seed"] == "20260815"
+    assert audit["dataset_version"] == dataset_version
+
+    split_ids: dict[str, dict[str, set[str]]] = {}
+    summaries: dict[str, object] = {}
+    for split in EXPECTED_BUCKETS:
+        relative_path = f"data/{split}.parquet"
+        ids, summary = verify_split(root / relative_path, split)
+        split_ids[split] = ids
+        summaries[split] = summary
+        declared = manifest["files"][relative_path]
+        assert declared["rows"] == summary["rows"]
+        assert declared["sha256"] == summary["sha256"]
+
+    split_names = list(EXPECTED_BUCKETS)
+    overlaps: dict[str, dict[str, int]] = {}
+    for left_index, left in enumerate(split_names):
+        for right in split_names[left_index + 1 :]:
+            key = f"{left}__vs__{right}"
+            overlaps[key] = {
+                name: len(split_ids[left][name] & split_ids[right][name])
+                for name in split_ids[left]
+            }
+    assert not any(value for result in overlaps.values() for value in result.values())
+    assert audit["pairwise_overlap"] == overlaps
+    assert audit["strict_selected_rows_verified"] == sum(
+        sum(counts.values()) for counts in EXPECTED_BUCKETS.values()
+    )
+
+    for relative_path, declared in manifest["files"].items():
+        path = root / relative_path
+        assert path.is_file(), relative_path
+        assert path.stat().st_size == declared["bytes"], relative_path
+        assert sha256_file(path) == declared["sha256"], relative_path
+
+    raw_summary = verify_raw_snapshot(root, manifest)
+    return {
+        "dataset_version": dataset_version,
+        "splits": summaries,
+        "pairwise_overlap": overlaps,
+        "raw_snapshot": raw_summary,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("release_dir", type=Path)
+    parser.add_argument("--expected-version")
+    args = parser.parse_args()
+    result = verify_release(args.release_dir.resolve(), args.expected_version)
+    print(json.dumps(result, indent=2, sort_keys=True))
+    print("VERIFICATION_OK")
+
+
+if __name__ == "__main__":
+    main()