#!/usr/bin/env python3 """Export the screening-ceiling dataset from committed source artifacts. Two very different kinds of row come out of this, and keeping them straight is the whole point of the dataset: certified_regions.jsonl -- a UNIVERSAL claim. 256 sub-boxes of a 4-parameter family, each certified by outward-rounded interval branch-and-bound to contain NO layout whose screening factor exceeds k_bar. Exported from a committed proof witness; provenance recorded by digest. counterexamples.jsonl -- an EXISTENTIAL refutation. Concrete layouts where a second-order Born extractor predicts k > 1, which no passive arrangement of conductors can do. Generated here by running the open-source `maxwell-lint` reference models, so every row is reproducible from published code alone. Run: python3 export.py # writes data/ python3 export.py --check # verify existing data, write nothing """ from __future__ import annotations import argparse import hashlib import json import pathlib import sys HERE = pathlib.Path(__file__).resolve().parent DATA = HERE / "data" REPO = HERE.parents[2] WITNESS = REPO / "benchmarks" / "impossibility" / \ "family_two_tight_pairs_k10pct_parallel_2026_07.json" DIM_NAMES = ["d0_um", "pt_mult", "sep_mult", "jog_mult"] # Reproduced verbatim from the source witness so the published scope statement # cannot drift from the one the proof was run under. HONEST_SCOPE = ( "A complete interval theorem about the frozen MONOPOLE-CLOSURE model only. " "The closure-vs-BEM/PDE model gap remains additive and unresolved. This " "witness does not establish Maxwell, BEM, driven-S, fabrication, or " "measured-silicon truth." ) def sha256(path: pathlib.Path) -> str: return hashlib.sha256(path.read_bytes()).hexdigest() # --------------------------------------------------------------- certified regions def export_certified_regions(w: dict) -> list[dict]: """One row per certified root region of the branch-and-bound partition. The witness stores the 256-region partition with per-region certification rather than all 237,490 leaves. That is what gets published, and the distinction is stated rather than glossed: each row is a region the prover certified, together with how many leaves it took and the largest screening factor the interval enclosure admitted anywhere inside it. """ rows = [] for r in w["root_results"]: rows.append({ "region_id": r["root_id"], "bounds": {n: {"lo": lo, "hi": hi} for n, (lo, hi) in zip(DIM_NAMES, r["box"])}, "status": r["status"], "certified_leaves": r["certified_boxes"], "processed_leaves": r["processed_boxes"], "sup_certified_k_hi": r["sup_certified_k_hi"], "volume_fraction_of_region": r["certified_volume_frac_of_root"], "unresolved_leaves": r["unresolved_count"], }) return rows # ----------------------------------------------------------------- counterexamples def export_counterexamples() -> list[dict]: """Concrete layouts where a plausible cheap extractor predicts k > 1. Generated by running the published `maxwell-lint` reference models, so a reader can regenerate every row without this repository. Full coordinates are emitted -- a counterexample you cannot rebuild is an anecdote. """ try: import numpy as np from maxwell_lint.models import ( born_second_order, isolated_pair_matrix, random_layout, ) except ImportError as exc: # pragma: no cover - exercised by the CLI path raise SystemExit( f"counterexample export needs maxwell-lint installed: {exc}\n" " pip install ../../maxwell-lint") from exc rows = [] for n in (6, 8, 12): for pitch in (60.0, 80.0, 100.0): for seed in range(4): lay = random_layout(n, seed=seed, pitch_um=pitch) full = born_second_order(lay) iso = isolated_pair_matrix(lay) with np.errstate(divide="ignore", invalid="ignore"): k = np.where(iso > 0, full / iso, 0.0) np.fill_diagonal(k, 0.0) i, j = np.unravel_index(int(np.argmax(k)), k.shape) kmax = float(k[i, j]) if kmax <= 1.0: continue rows.append({ "case_id": f"born2_n{n}_p{int(pitch)}_s{seed}", "model": "born_second_order", "n_conductors": int(n), "nominal_pitch_um": pitch, "seed": int(seed), "worst_pair": [int(i), int(j)], "k_predicted": kmax, "violates_ceiling": True, "n_pairs_violating": int((k > 1.0).sum()), "n_pairs_total": int(n * (n - 1)), "xy_um": [[float(x * 1e6), float(y * 1e6)] for x, y in lay.xy], "radius_um": [float(r * 1e6) for r in lay.radius], "eps_r": float(lay.eps_r), }) return rows # ------------------------------------------------------------------------ theorem def export_theorem(w: dict) -> dict: return { "family": w["family"], "parameters": DIM_NAMES, # the top-level box is keyed by name; the per-region boxes are positional "family_box": {n: {"lo": w["box"][n][0], "hi": w["box"][n][1]} for n in DIM_NAMES}, "k_bar": w["k_bar"], "statement": ( "For every layout in the family box, the monopole-closure many-body " f"screening factor satisfies k <= {w['k_bar']:.12f}. A pairwise-" "superposition extractor assumes k == 1, so it over-predicts the worst " f"coupling by at least {100.0 / w['k_bar'] - 100.0:.4f}% on every " "member of the family." ), # Derived from the supremum the proof actually certified, not from the # target bound -- so it is very slightly STRONGER than 100/k_bar - 100 # (10.000002% vs 10.000000%). Recorded explicitly because a reader who # divides by k_bar and gets a different last digit deserves an answer. "forced_pairwise_overprediction_pct": w["forced_pairwise_overprediction_pct"], "forced_pairwise_overprediction_basis": "sup_certified_k_hi", "certified_leaves_total": w["certified_boxes"], "processed_leaves_total": w["processed_boxes"], "certified_volume_fraction": w["certified_volume_frac"], "failure_regions": w["n_failure_regions"], "open_boxes": w["open_boxes"], "sup_certified_k_hi": w["sup_certified_k_hi"], "enclosure_mode": w["enclosure_mode"], "status": w["status"], "honest_scope": HONEST_SCOPE, "geometry": { "description": ( "Four parallel circular conductors forming two tight pairs. " "pitch = 1.6 * d0 * pt_mult; separation = pitch * sep_mult; " "jog = jog_mult * separation. Conductor centres at (0,0), " "(pitch,0), (separation,jog), (separation+pitch,jog); every " "conductor has diameter d0." ), "units": "d0_um in micrometres; the multipliers are dimensionless", "self_term_radius_scale": 1.0, }, "provenance": { "source_witness": WITNESS.name, "source_sha256": sha256(WITNESS), "witness_content_sha256": w["content_sha256"], "schema": w["schema"], "prover_wall_seconds": w["wall_s"], "partition_regions": w["root_count"], }, } def write_jsonl(path: pathlib.Path, rows: list[dict]) -> None: with path.open("w", encoding="utf-8", newline="\n") as fh: for r in rows: fh.write(json.dumps(r, sort_keys=True) + "\n") def main() -> int: ap = argparse.ArgumentParser(description=__doc__) ap.add_argument("--check", action="store_true", help="verify the committed data instead of rewriting it") args = ap.parse_args() if not WITNESS.exists(): print(f"source witness not found: {WITNESS}", file=sys.stderr) print("(export requires the source repository; the published data files " "stand alone)", file=sys.stderr) return 2 w = json.loads(WITNESS.read_text(encoding="utf-8")) regions = export_certified_regions(w) theorem = export_theorem(w) counters = export_counterexamples() if args.check: old_r = [json.loads(x) for x in (DATA / "certified_regions.jsonl").read_text(encoding="utf-8").splitlines()] old_c = [json.loads(x) for x in (DATA / "counterexamples.jsonl").read_text(encoding="utf-8").splitlines()] old_t = json.loads((DATA / "theorem.json").read_text(encoding="utf-8")) ok = (old_r == regions and old_c == counters and old_t == theorem) print("data matches a fresh export" if ok else "DATA DRIFT") return 0 if ok else 1 DATA.mkdir(parents=True, exist_ok=True) write_jsonl(DATA / "certified_regions.jsonl", regions) write_jsonl(DATA / "counterexamples.jsonl", counters) (DATA / "theorem.json").write_text( json.dumps(theorem, indent=2, sort_keys=True) + "\n", encoding="utf-8", newline="\n") n_viol = sum(r["n_pairs_violating"] for r in counters) print(f"certified_regions.jsonl {len(regions)} regions " f"({theorem['certified_leaves_total']} leaves)") print(f"counterexamples.jsonl {len(counters)} layouts " f"({n_viol} violating pairs)") print(f"theorem.json k_bar = {theorem['k_bar']:.12f}") return 0 if __name__ == "__main__": raise SystemExit(main())