"""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.1.0" DEFAULT_DATASET_ID = "stwistzz/Sudoku_DLM_Reasoning" DEFAULT_SEED = "0" SOURCE_REPO = "fhyfhy/diffusion-vs-ar-hard-sudoku" SOURCE_REVISION = "527859f62c745c16833aded130ad9f9ddddb76af" TDOKU_REFERENCE_REVISION = "af426180dc53aef89b82868e7b3fdfcf42165654" 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_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} \ --expected-seed {seed} ``` 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_difficulty_guide() -> str: return f"""# Difficulty definition and quantitative audit This document defines the difficulty fields used by Sudoku DLM Reasoning release `{DATASET_VERSION}`. Difficulty is an operational, solver-relative measurement; it is not a human Sudoku grade and is not defined by the number of clues. ## 1. Provenance of the rating For the Sudoku Extreme rows, the upstream `rating` column is copied into `official_rating` and labeled `rating_type = tdoku_backtracks`. The converter does not recompute the rating: - Sudoku Extreme card: https://huggingface.co/datasets/sapientinc/sudoku-extreme - Conversion code: https://github.com/hengyuf/diffusion-vs-ar/blob/ba0445f4d0808113bf08a9a9d8c7041086bfdf10/tools/prepare_sudoku_datasets.py The upstream card describes the value as the number of backtracks required by Tdoku. At public Tdoku commit `{TDOKU_REFERENCE_REVISION}`, the counter is named `num_guesses_` and is incremented whenever the DPLL solver expands a binary configuration decision: - Branch implementation: https://github.com/t-dillon/tdoku/blob/{TDOKU_REFERENCE_REVISION}/src/solver_dpll_triad_simd.cc#L539-L559 - Branch-variable selection: https://github.com/t-dillon/tdoku/blob/{TDOKU_REFERENCE_REVISION}/src/solver_dpll_triad_simd.cc#L473-L536 Operationally, `official_rating` is best interpreted as the number of search decision nodes visited before the first solution, rather than literal failed undo operations. ## 2. Constraint propagation and the DFS root Tdoku does not begin search from an empty board or from the first empty cell. For a standard 81-character puzzle it: 1. loads every given digit; 2. eliminates incompatible row, column, box, band, and stack configurations; 3. propagates those eliminations until the initialized state is consistent; and 4. calls depth-first search on that propagated partial state. The initialization and call path are visible in that pinned public source: - Initialization: https://github.com/t-dillon/tdoku/blob/{TDOKU_REFERENCE_REVISION}/src/solver_dpll_triad_simd.cc#L612-L634 - Solve entry point: https://github.com/t-dillon/tdoku/blob/{TDOKU_REFERENCE_REVISION}/src/solver_dpll_triad_simd.cc#L680-L693 Propagation applies only logical consequences of the current givens or branch assumption. It makes no new hypothesis and is not counted by the rating. It can end in a complete solution, a contradiction, or a fixed point that still has multiple configurations. This matters because two puzzles can both have rating zero while requiring very different amounts of propagation. ## 3. What one branch means For one digit in a three-row band (or a three-column stack), there are six possible global placements across the three boxes. Tdoku represents these as band configurations. When propagation leaves multiple configurations, the branching heuristic selects: 1. the unresolved band or stack with the fewest configurations; then 2. the digit in that band or stack with the fewest configurations. It then creates a binary decision: - left branch: force the first remaining configuration; - right branch: exclude that configuration and retain the others. The counter increases once for this binary split. If the left branch fails and the right branch immediately solves the puzzle, the count for that decision is still one. A later split of the remaining configurations increases it again. Therefore the rating is not the recursion depth, the number of filled cells, the number of contradictions, or a human solving-step count. ## 4. Bucket definitions The source converter applies these thresholds: | release label | operational rule | interpretation | |---|---:|---| | `original` | no Tdoku rating | separate easy collection; not numerically calibrated to Extreme | | `r0` | rating = 0 | propagation resolves the puzzle without a search decision | | `r1_4` | 1 <= rating < 5 | 1--4 visited decision nodes | | `r5_19` | 5 <= rating < 20 | 5--19 visited decision nodes | The upstream converter also defines `r20_49`, `r50_99`, and `r100_plus`, but those buckets are outside this v1 candidate pool. Thus `r5_19` is an adjacent held-out difficulty band, not the hardest part of the upstream corpus. ## 5. Quantitative audit of the raw candidate pool The following statistics were computed over all 1,415,420 rows included under `raw/`. Rating and clue statistics use the full pool. | bucket | rows | rating mean / median | clue mean / median | clue range | |---|---:|---:|---:|---:| | `original` | 101,000 | not rated | 33.813 / 34 | 29--37 | | `r0` | 614,136 | 0 / 0 | 26.282 / 26 | 17--37 | | `r1_4` | 588,453 | 1.976 / 2 | 25.604 / 26 | 17--31 | | `r5_19` | 111,831 | 11.776 / 12 | 24.932 / 25 | 17--30 | Clue count is not a substitute for this rating. Within `r1_4`, the Pearson correlation between rating and clues is -0.035; within `r5_19` it is 0.002. As an independent diagnostic, standard row/column/box naked-single propagation was run over all 101,000 original rows and deterministic 20,000-row reservoir samples of each Extreme bucket. The reservoir seeds were `20260816` for `r0`, `20260817` for `r1_4`, and `20260818` for `r5_19`: | bucket | rows checked | solved by naked singles | |---|---:|---:| | `original` | 101,000 | 100,959 (99.959%) | | `r0` | 20,000 | 3,691 (18.455%) | | `r1_4` | 20,000 | 0 | | `r5_19` | 20,000 | 0 | The 41 original rows that stalled under naked singles were all solved after adding hidden-single propagation. This independent audit describes basic Sudoku logic, not Tdoku's own internal propagation, which is configuration-based and stronger. ## 6. Released train and evaluation distributions The three training buckets are equal in size, but exact ratings inside `r1_4` retain the upstream proportions: | exact rating | train rows | |---:|---:| | 1 | 29,584 | | 2 | 16,809 | | 3 | 10,244 | | 4 | 8,899 | The main `r1_4` test allocation instead uses 250 rows at each exact rating 1, 2, 3, and 4. The `r5_19` test allocation uses 250 rows from each of `[5,8)`, `[8,12)`, `[12,16)`, and `[16,20)`; `test_ood_confirm` uses 1,000 per range. This supports per-rating or per-range reporting rather than only a bucket-wide average. ## 7. Source confounding Difficulty and source collection are not independent in the raw pool: - `r0`: 77.40% `puzzles1_unbiased`, 16.28% `puzzles0_kaggle`, and 6.30% `puzzles2_17_clue`; - `r1_4`: 85.02% `puzzles1_unbiased`, 9.70% `puzzles4_forum_hardest_1905`, and 3.40% `01_file1`; - `r5_19`: 68.19% `puzzles4_forum_hardest_1905`, 28.15% `01_file1`, and only 2.18% `puzzles1_unbiased`. Consequently, an `r5_19` result combines a Tdoku-rating shift, a held-out training-exposure shift, and a source-distribution shift. It must not be interpreted as a pure causal effect of search count. Recommended reporting includes exact rating or subrange, source collection, and clue count. A source- and clue-matched diagnostic set is appropriate when the goal is to isolate the rating axis. ## 8. Reproducibility limitation The public Sudoku Extreme card does not pin the Tdoku commit, build flags, command, permutation policy, or seed used to create its rating column. This release therefore preserves `official_rating` as an upstream measurement rather than claiming to reproduce it. For a fully controlled future rating, pin a Tdoku commit and configuration, record the branch count for the exact stored puzzle, and optionally measure its mean and variance over Sudoku-preserving isomorphic transformations. """ 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 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. Version {DATASET_VERSION} changes only the deterministic selection seed to `0` relative to v1.0.2. The raw CSV files, sources, bucket definitions, split quotas, schema, and validation rules are unchanged; the four Parquet splits are regenerated deterministically from the same candidate pool. ## 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 - `docs/DIFFICULTY.md`: operational difficulty definition and quantitative audit 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 | |---|---:|---:|---:|---:|---:| | 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 an upstream Tdoku search measurement. In public Tdoku commit `{TDOKU_REFERENCE_REVISION}`, the counter increments when the solver expands a binary band/stack-configuration decision after constraint propagation. It is therefore best interpreted as visited search decision nodes, not recursion depth, failed undo count, clue count, or human difficulty. `original` comes from a separate easy collection and has no official rating on this scale. See `docs/DIFFICULTY.md` for the DFS root, propagation and branch semantics, bucket formulas, full raw-pool statistics, source confounding, and the upstream rating-provenance limitation. 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 The pinned source CSV files are included under `raw/`. Run: ```bash python scripts/build_dataset.py \\ --source-dir raw \\ --output-dir /path/to/release \\ --dataset-id {dataset_id} \\ --seed {seed} ``` 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 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. See `RAW_DATA_LICENSES.md` for the raw-snapshot notice. """ 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" 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/9] Scanning and de-duplicating all protected upstream test pools...") test_scan = scan_pools(source_dir, test_specs, collect_all_ids=True) print("[2/9] 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/9] 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/9] 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/9] Strictly validating every selected puzzle and solution...") for rows in splits.values(): strict_validate_selected(rows) overlaps = overlap_audit(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" 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/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 / "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" ) (docs_dir / "DIFFICULTY.md").write_text( render_difficulty_guide(), 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) 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), } if relative in row_counts: entry["rows"] = row_counts[relative] release_files[relative] = entry 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", "raw_snapshot_file": "metadata/raw_manifest.json", } write_json(metadata_dir / "manifest.json", manifest) print("[9/9] 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()