#!/usr/bin/env python3 """Validate a downloaded copy of the Cost-Aware Protocol Routing dataset. Usage ----- python validate.py # validate the directory this file is in python validate.py --dir PATH # validate another directory python validate.py --skip-checksums Exits 0 if every check passes, 1 on a validation failure, 2 on a usage error. Requires ONLY the Python standard library -- no pandas, no numpy, nothing to install. It is meant to be the first thing you run after `hf download`. """ from __future__ import annotations import argparse import csv import hashlib import json import os import sys EXPECTED_RELEASE_VERSION = "1.0.0" EXPECTED_SCHEMA_VERSION = "emnlp-protocol-routing-dataset-v1.0.0" PROTOCOLS = ["baseline_llm", "single_agent", "per", "broadcast"] ORACLE_LABELS = PROTOCOLS + ["none"] REQUIRED_FILES = [ "README.md", "LICENSE", "NOTICE", "CITATION.cff", "registry/experiments.csv", "registry/benchmarks.csv", "registry/models.csv", "registry/protocols.csv", "registry/schema.json", "registry/release_manifest.json", "registry/checksums.sha256", "data/matched_labels.csv", "data/problems.csv", "data/labels_for_scoring.csv", "data/probe_inputs.jsonl", "data/splits/six_setting_splits.csv", "data/splits/primary_omnimath_splits.csv", "data/router/six_setting_test_predictions.csv", "data/router/six_setting_metrics.csv", "data/confidence/six_setting_confidence_metrics.csv", "data/confidence/primary_omnimath_confidence_predictions.csv", "data/confidence/postanswer_confidence_predictions.csv", "data/confidence/failure_and_protocol_value_targets.csv", "data/costs/omnimath_per_protocol_costs.csv", "registry/example_id_crosswalk.csv", "docs/confidence_probe_prompt.txt", "docs/primary_confidence_probe_prompt.txt", "TODO.md", "validate.py", "data/aggregate/matched_protocol_coverage.csv", "data/aggregate/oracle_label_distribution.csv", "data/aggregate/main_routing_heldout.csv", "docs/schema.md", "docs/provenance.md", "docs/license_audit.md", "docs/reconstruction.md", "docs/anonymization_report.md", ] # Optional artifacts: absent by design, listed so their absence is explicit. OPTIONAL_ARTIFACTS = { "data/problem_text.csv": "upstream problem text (withheld for licensing; see docs/reconstruction.md)", "data/baseline_final_answers.csv": "Baseline final-answer text (NOT released; probe is not re-runnable without it)", "data/traces/": "raw protocol traces / model generations (out of scope for this table-first release)", "data/costs/other_settings_per_protocol_costs.csv": "per-problem costs for the other 9 settings (UNRESOLVED -- must not be " "back-filled from an incompatible token convention; see TODO.md)", } EXPECTED_ROWS = { "data/matched_labels.csv": 15088, "data/problems.csv": 6803, "data/labels_for_scoring.csv": 12928, "data/probe_inputs.jsonl": 12928, "data/splits/six_setting_splits.csv": 12928, "data/splits/primary_omnimath_splits.csv": 4181, "data/router/six_setting_test_predictions.csv": 5832, "data/confidence/primary_omnimath_confidence_predictions.csv": 839, "data/confidence/postanswer_confidence_predictions.csv": 12928, "registry/example_id_crosswalk.csv": 12928, "data/costs/omnimath_per_protocol_costs.csv": 4155, } EXPECTED_SETTINGS = { "omnimath2__competition_math_4181__gpt_oss_120b": 4181, "omnimath2__competition_math_4181__gemma_4_31b": 4181, "labbench__text_no_tool__gpt_oss_120b_text_no_tool": 1542, "labbench__text_no_tool__gemma_4_31b_text_no_tool": 1542, "labbench__llm_strict__gpt_oss_120b": 741, "labbench__llm_strict__gemma_4_31b": 741, "scibench__text_only__gpt_oss_120b": 565, "scibench__text_only__gemma_4_31b": 565, "jeebench__text_only__gpt_oss_120b": 515, "jeebench__text_only__gemma_4_31b": 515, } EXPECTED_BENCHMARKS = {"omnimath2": 4181, "labbench": 1542, "scibench": 565, "jeebench": 515} EXPECTED_MODELS = {"gpt_oss_120b": 5, "gemma_4_31b": 5} # Files that must never contain outcome/label columns. FEATURE_FILES = [ "data/problems.csv", "data/probe_inputs.jsonl", "data/splits/six_setting_splits.csv", "data/splits/primary_omnimath_splits.csv", "data/confidence/primary_omnimath_confidence_predictions.csv", "data/confidence/postanswer_confidence_predictions.csv", "data/costs/omnimath_per_protocol_costs.csv", ] FORBIDDEN_IN_FEATURES = { "oracle_label", "baseline_correct", "single_correct", "per_correct", "broadcast_correct", "any_protocol_solved", "answer", "gold", "gold_answer", "problem_text", "question", "reference_solution", "options", "baseline_final_answer", "baseline_final_passed", "cheapest_successful_protocol", } # Infrastructure that download tools and version control create alongside the # release. Not release content, so never expected in checksums.sha256. Matched by # PATH COMPONENT, so any depth is covered (e.g. .cache/huggingface/download/*.lock). IGNORED_DIR_COMPONENTS = {".cache", ".git", "__pycache__", ".ipynb_checkpoints"} IGNORED_BASENAMES = {".gitattributes", ".gitignore", ".DS_Store", ".gitmodules", "Thumbs.db"} MAX_LISTED_OFFENDERS = 10 FAILS: list[str] = [] WARNS: list[str] = [] def is_infrastructure(rel_path: str) -> bool: """True for tool-created files that are not part of the release payload.""" parts = rel_path.replace(os.sep, "/").split("/") if any(part in IGNORED_DIR_COMPONENTS for part in parts[:-1]): return True return parts[-1] in IGNORED_BASENAMES def abbreviate(items: "list[str]", limit: int = MAX_LISTED_OFFENDERS) -> str: """Render a list without letting it swamp the output.""" shown = ", ".join(items[:limit]) if len(items) > limit: shown += f", ... and {len(items) - limit} more" return shown def ok(label: str, passed: bool, detail: str = "", fail_detail: str = "") -> bool: """Report one check. `detail` is a factual measurement and prints either way. `fail_detail` explains what went wrong and prints ONLY on failure -- a check must never print a reason that contradicts its own verdict. """ shown = detail if passed else (fail_detail or detail) print(f" [{'PASS' if passed else 'FAIL'}] {label}" + (f" -- {shown}" if shown else "")) if not passed: FAILS.append(f"{label}: {shown}" if shown else label) return passed def head(title: str) -> None: print(f"\n{title}\n{'-' * len(title)}") def sha256(path: str) -> str: h = hashlib.sha256() with open(path, "rb") as fh: for chunk in iter(lambda: fh.read(1 << 20), b""): h.update(chunk) return h.hexdigest() def read_csv(path: str) -> "list[dict[str, str]]": """Read a CSV into a list of dicts using only the stdlib. Empty cells come back as the empty string, never as a float NaN. Callers that care about missing values must test for "" explicitly -- absence must not be allowed to read as a value. """ with open(path, newline="", encoding="utf-8") as fh: return list(csv.DictReader(fh)) def header(path: str) -> "list[str]": with open(path, newline="", encoding="utf-8") as fh: return next(csv.reader(fh), []) def count_distinct(rows, key_col, group_col): """{group value: number of distinct key_col values}.""" acc = {} for r in rows: acc.setdefault(r[group_col], set()).add(r[key_col]) return {k: len(v) for k, v in acc.items()} def count_rows(rows, group_col): acc = {} for r in rows: acc[r[group_col]] = acc.get(r[group_col], 0) + 1 return acc def main() -> int: ap = argparse.ArgumentParser() ap.add_argument("--dir", default=os.path.dirname(os.path.abspath(__file__))) ap.add_argument("--skip-checksums", action="store_true") args = ap.parse_args() root = os.path.abspath(args.dir) print("=" * 72) print("Cost-Aware Protocol Routing -- dataset validation") print("=" * 72) print(f"Directory: {root}") # ---- versions ------------------------------------------------------- head("Versions") mpath = os.path.join(root, "registry/release_manifest.json") if not os.path.exists(mpath): ok("registry/release_manifest.json present", False, "missing") print("\nCannot continue without the manifest.") return 1 man = json.load(open(mpath)) rv, sv = man.get("dataset_version"), man.get("schema_version") print(f" release version : {rv}") print(f" schema version : {sv}") print(f" generated (UTC) : {man.get('generated_utc')}") ok("release version matches", rv == EXPECTED_RELEASE_VERSION, f"got {rv}") ok("schema version matches", sv == EXPECTED_SCHEMA_VERSION, f"got {sv}") # ---- expected files ------------------------------------------------- head("Expected files") missing = [f for f in REQUIRED_FILES if not os.path.exists(os.path.join(root, f))] ok(f"all {len(REQUIRED_FILES)} required files present", not missing, f"missing: {missing}" if missing else "") if missing: print("\nCannot continue with required files missing.") return 1 # ---- row counts ----------------------------------------------------- head("Row counts") for rel, exp in EXPECTED_ROWS.items(): p = os.path.join(root, rel) n = sum(1 for _ in open(p)) if rel.endswith(".jsonl") else sum(1 for _ in open(p)) - 1 ok(f"{rel} == {exp} rows", n == exp, f"got {n}") m = read_csv(os.path.join(root, "data/matched_labels.csv")) # ---- coverage ------------------------------------------------------- head("Benchmark coverage") got_b = count_distinct(m, "problem_id", "benchmark_id") for b, exp in EXPECTED_BENCHMARKS.items(): ok(f"{b}: {exp} distinct problems", got_b.get(b) == exp, f"got {got_b.get(b)}") ok("no unexpected benchmark", set(got_b) == set(EXPECTED_BENCHMARKS), f"unexpected: {sorted(set(got_b) - set(EXPECTED_BENCHMARKS))}") ok("MaScQA absent (excluded: NonCommercial, not in paper)", "mascqa" not in got_b) head("Model coverage") got_m = count_distinct(m, "setting_id", "model") for mod, exp in EXPECTED_MODELS.items(): ok(f"{mod}: {exp} settings", got_m.get(mod) == exp, f"got {got_m.get(mod)}") ok("no unexpected solver", set(got_m) == set(EXPECTED_MODELS), f"unexpected: {sorted(set(got_m) - set(EXPECTED_MODELS))}") all_settings = {r["setting_id"] for r in m} ok("Gemma-3-27B scope check absent", not any("gemma3_27b" in s_ for s_ in all_settings)) head("Setting coverage") got_s = count_rows(m, "setting_id") ok("exactly 10 settings", len(got_s) == 10, f"got {len(got_s)}") for s_, exp in EXPECTED_SETTINGS.items(): ok(f"{s_} == {exp}", got_s.get(s_) == exp, f"got {got_s.get(s_)}") head("Protocol coverage") cols = [f"{x}_correct" for x in ["baseline", "single", "per", "broadcast"]] mcols = header(os.path.join(root, "data/matched_labels.csv")) ok("all four protocol columns present", all(c in mcols for c in cols), f"missing: {[c for c in cols if c not in mcols]}") # Empty string means a missing cell. Absence must not read as a value. blanks = sum(1 for r in m for c in cols if r[c].strip() == "") ok("no null protocol outcomes", blanks == 0, f"{blanks} blank cells") bad = sum(1 for r in m for c in cols if r[c].strip() not in ("0", "1")) ok("protocol outcomes are strictly 0/1", bad == 0, f"{bad} out of range") got_lab = {r["oracle_label"] for r in m} ok("oracle_label uses the documented vocabulary", got_lab <= set(ORACLE_LABELS), f"unexpected: {sorted(got_lab - set(ORACLE_LABELS))}") head("Oracle recomputation (Baseline -> Single -> PER -> Broadcast -> None)") mism = inv = 0 seen = set() dupes = 0 for r in m: flags = [r["baseline_correct"], r["single_correct"], r["per_correct"], r["broadcast_correct"]] rec = "none" for proto, flag in zip(PROTOCOLS, flags): if flag == "1": rec = proto break if rec != r["oracle_label"]: mism += 1 if (r["oracle_label"] == "none") != (r["any_protocol_solved"] == "0"): inv += 1 k = (r["setting_id"], r["problem_id"]) if k in seen: dupes += 1 seen.add(k) ok("oracle recomputation agrees on every row", mism == 0, f"{mism} mismatches") ok("oracle_label=='none' iff any_protocol_solved==0", inv == 0, f"{inv} violations") ok("(setting_id, problem_id) unique", dupes == 0, f"{dupes} duplicates") head("Split integrity") for rel in ["data/splits/primary_omnimath_splits.csv", "data/splits/six_setting_splits.csv"]: rows = read_csv(os.path.join(root, rel)) groups = {} for r in rows: g = r.get("setting_id", "(all)") groups.setdefault(g, {}).setdefault(r["split"], set()).add(r["problem_id"]) bad_n = 0 for _, st in groups.items(): tr, dv, te = st.get("train", set()), st.get("dev", set()), st.get("test", set()) if (tr & dv) or (tr & te) or (dv & te): bad_n += 1 ok(f"{rel}: train/dev/test pairwise disjoint", bad_n == 0, f"{bad_n} groups overlap") head("Leakage guard (feature files must carry no outcomes)") for rel in FEATURE_FILES: p_ = os.path.join(root, rel) if rel.endswith(".jsonl"): with open(p_, encoding="utf-8") as fh: cs = set(json.loads(fh.readline()).keys()) else: cs = set(header(p_)) hits = sorted(cs & FORBIDDEN_IN_FEATURES) ok(f"{rel} carries no outcome/answer column", not hits, f"found {hits}") head("Confidence probes (two distinct instruments)") post = read_csv(os.path.join(root, "data/confidence/postanswer_confidence_predictions.csv")) pre = read_csv(os.path.join(root, "data/confidence/primary_omnimath_confidence_predictions.csv")) post_types = {r["probe_type"] for r in post} pre_types = {r["probe_type"] for r in pre} ok("post-answer file is uniformly probe_type=post_answer_pre_collaboration", post_types == {"post_answer_pre_collaboration"}, f"got {sorted(post_types)}") ok("pre-answer file is uniformly probe_type=pre_answer_q1", pre_types == {"pre_answer_q1"}, f"got {sorted(pre_types)}") post_eids = [r["example_id"] for r in post] ok("post-answer example_id is unique", len(set(post_eids)) == len(post_eids), f"{len(post_eids) - len(set(post_eids))} duplicates") # Scale and null semantics: a "probability"-named column on a 0-100 scale is # the kind of thing a reader gets silently wrong, so assert it rather than # only document it. post_conf = [float(r["confidence"]) for r in post if r["confidence"].strip() != ""] post_hi = max(post_conf) if post_conf else 0.0 ok("post-answer `confidence` is on the documented 0-100 scale", post_hi > 1.0, detail=f"range {min(post_conf)}-{post_hi} over {len(post_conf)} parsed rows", fail_detail=f"max is {post_hi}: the column looks like a 0-1 probability, " f"not the documented 0-100 scale") ok("post-answer `confidence` is blank exactly where parse_ok is false", sum(1 for r in post if r["confidence"].strip() == "") == sum(1 for r in post if r["parse_ok"].strip().lower() == "false")) pre_vals = [float(r["confidence_probability"]) for r in pre if r["confidence_probability"].strip() != ""] pre_hi = max(pre_vals) if pre_vals else 0.0 ok("pre-answer `confidence_probability` is on the documented 0-100 scale", pre_hi > 1.0, detail=f"range {min(pre_vals)}-{pre_hi} over {len(pre_vals)} parsed rows", fail_detail=f"max is {pre_hi}: the column looks like a 0-1 probability, " f"not the documented 0-100 scale") fb = [r for r in pre if r["used_fallback"].strip().lower() == "true"] fb_with_value = sum(1 for r in fb if r["confidence_probability"].strip() != "") ok("pre-answer fallback rows carry NO confidence value (documented as null)", fb_with_value == 0, f"{fb_with_value} of {len(fb)} fallback rows have a value") print(f" {len(fb)} fallback rows are null; treat a null as ESCALATE " f"(see docs/schema.md -- other readings give 73.76% or 60.76% " f"against the published 78.0%)") xw = read_csv(os.path.join(root, "registry/example_id_crosswalk.csv")) xw_keys = {(r["setting_id"], r["example_id"], r["problem_id"]) for r in xw} resolved = sum(1 for r in post if (r["setting_id"], r["example_id"], r["problem_id"]) in xw_keys) ok("crosswalk resolves every post-answer example_id", resolved == len(post), f"{resolved}/{len(post)}") matched_keys = {(r["setting_id"], r["problem_id"]) for r in m} joined = sum(1 for r in post if (r["setting_id"], r["example_id"], r["problem_id"]) in xw_keys and (r["setting_id"], r["problem_id"]) in matched_keys) ok("post-answer predictions join to matched outcomes via the crosswalk", joined == len(post), f"{joined}/{len(post)}") head("Cost layer (one setting only)") costs = read_csv(os.path.join(root, "data/costs/omnimath_per_protocol_costs.csv")) cset = {r["setting_id"] for r in costs} ok("costs cover exactly one setting", cset == {"omnimath2__competition_math_4181__gpt_oss_120b"}, f"got {sorted(cset)}") cids = [r["problem_id"] for r in costs] ok("cost problem_id is unique", len(set(cids)) == len(cids), f"{len(cids) - len(set(cids))} duplicates") om = {r["problem_id"] for r in m if r["setting_id"] == "omnimath2__competition_math_4181__gpt_oss_120b"} ok("every cost row resolves to a released problem", set(cids) <= om, f"{len(set(cids) - om)} unresolved") ok("26 of 4181 problems omitted (duplicate-text groups; see TODO.md)", len(om - set(cids)) == 26, f"{len(om - set(cids))} omitted") tokcols = [f"{x}_total_tokens" for x in ["baseline", "single", "per", "broadcast"]] blank = sum(1 for r in costs for c in tokcols if r[c].strip() == "") ok("no blank token totals", blank == 0, f"{blank} blanks") mean_base = sum(int(r["baseline_total_tokens"]) for r in costs) / len(costs) print(f" mean Baseline tokens over the {len(costs)} emitted rows: {mean_base:,.1f}") print(" (the paper's figure over all 4,181 problems is 18,385.4 -- the gap is the") print(" 26 omitted rows, not a disagreement. See docs/schema.md.)") ok("mean Baseline tokens is the documented 18,432.0", abs(mean_base - 18432.0) < 0.05, f"got {mean_base:.1f}") # ---- checksums ------------------------------------------------------ head("Checksums") cpath = os.path.join(root, "registry/checksums.sha256") expected = {} for line in open(cpath): line = line.strip() if not line or line.startswith("#"): continue digest, rel = line.split(None, 1) expected[rel.strip()] = digest print(f" {len(expected)} entries in registry/checksums.sha256") if args.skip_checksums: print(" (skipped by --skip-checksums)") else: bad, absent = [], [] for rel, digest in sorted(expected.items()): p = os.path.join(root, rel) if not os.path.exists(p): absent.append(rel) elif sha256(p) != digest: bad.append(rel) ok("every checksummed file is present", not absent, f"missing: {absent}") ok("every checksum matches", not bad, f"mismatched: {bad}") on_disk = set() skipped_infra = 0 for dp, _, fs in os.walk(root): for fn in fs: r = os.path.relpath(os.path.join(dp, fn), root) if r == "registry/checksums.sha256": continue if is_infrastructure(r): skipped_infra += 1 continue on_disk.add(r) if skipped_infra: print(f" ({skipped_infra} tool-created file(s) ignored: download cache, " f"version-control and OS metadata)") extra = sorted(on_disk - set(expected)) if extra: # An unexpected extra file is not corruption, so this stays a warning. WARNS.append(f"{len(extra)} file(s) present but not checksummed: " f"{abbreviate(extra)}") print(f" [WARN] {len(extra)} file(s) not in checksums.sha256: " f"{abbreviate(extra)}") # ---- optional artifacts -------------------------------------------- head("Optional artifacts (absent by design)") for rel, why in OPTIONAL_ARTIFACTS.items(): present = os.path.exists(os.path.join(root, rel.rstrip("/"))) print(f" [{'present' if present else 'ABSENT '}] {rel} -- {why}") print("\n NOTE: Baseline final-answer text is NOT in this release. The post-answer") print(" confidence probe consumed it, so the probe CANNOT be re-run from this") print(" release alone. data/probe_inputs.jsonl is an identifier manifest, not a") print(" runnable prompt set. See docs/reconstruction.md and TODO.md.") # ---- result --------------------------------------------------------- print("\n" + "=" * 72) if FAILS: print(f"RESULT: FAILED -- {len(FAILS)} check(s) did not pass") for f in FAILS: print(f" - {f}") print("=" * 72) return 1 print("RESULT: PASSED -- all checks succeeded") if WARNS: print(f"({len(WARNS)} warning(s))") for w in WARNS: print(f" ! {w}") print("=" * 72) return 0 if __name__ == "__main__": sys.exit(main())