scripts/verify_dataset.py

"""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,
    expected_seed: 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"))
    split_spec = json.loads(
        (root / "metadata/split_spec.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)
    selection_seed = str(manifest["seed"])
    if expected_seed is not None:
        assert selection_seed == expected_seed, (selection_seed, expected_seed)
    assert audit["dataset_version"] == dataset_version
    assert split_spec["dataset_version"] == dataset_version
    assert str(audit["seed"]) == selection_seed
    assert str(split_spec["seed"]) == selection_seed

    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,
        "selection_seed": selection_seed,
        "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")
    parser.add_argument("--expected-seed")
    args = parser.parse_args()
    result = verify_release(
        args.release_dir.resolve(), args.expected_version, args.expected_seed
    )
    print(json.dumps(result, indent=2, sort_keys=True))
    print("VERIFICATION_OK")


if __name__ == "__main__":
    main()