#!/usr/bin/env python3 """Build the public [[210,10,16]] release from sealed Stage 3 artifacts. This release-specific builder intentionally fails closed. It accepts only the audited candidate, source commit, aggregate, and terminal checkpoints named below. Operational paths, process metadata, commands, and raw logs are not copied into the public records. """ from __future__ import annotations import argparse import gzip import hashlib import io import json import subprocess import sys from pathlib import Path from typing import Any CANDIDATE_ID = "5f773fbfbce9775bc30b" CANONICAL_DIGEST = ( "4ba2bcc894b883eb930bf727148c2f57bcf4963c903a940528613b2f542a607c" ) STATE_KEY = ( "2975b8ebd74a3842501a042746bf7877ca11d0326841d3ee4238a6724d0da26e" ) QCODE_COMMIT = "ade9dc706a455427384e4ba82c0981d9cc9f6671" HF_BASE_COMMIT = "3a24375d3494479c76ecd7c377c9b5d038f2561b" EXPECTED_SOURCE_SHA256 = { "stage3-summary.json": ( "4579c4472879e78da8a77b66e240b6e2ea66a1d47ca782f889247b3186b0a5ab" ), "stage3-ranked.jsonl": ( "b8a0f2a7dd4191dd6d578addaec67cee60786104a748dd78203a822e196e3129" ), "stage3-thresholds.jsonl": ( "1c3a4bcf0a4598fc7c91236c01513f375746ba0d8c635d88630800be9f5bfcd6" ), "aggregate": ( "ee2965586cff334caf22d1c0b360127c22cca34c5136f58c88cdd150a5ffeefd" ), "lower-terminal": ( "9def4c1d0134165bbf3166382d8b07b361b816504e00e2473615fe9c45a26218" ), "upper-terminal": ( "f1fe9686eaac799ecf4583d48fe39858381b29e7a47844af5c447e6e21ebc86e" ), } DISTQLDPC_BINARY_SHA256 = ( "9e09c544d5151d872dc1037dcb1440509e27b8b485a7f9ea5a15d6e55b36d3fa" ) DISTQLDPC_SOURCE_COMMIT = ( "c01fa93eb5e1e62948e4861e2c164a6b64fe88eb" ) EXPECTED_TYPED_CLAIM_SHA256 = ( "1a2a076a891a790a92359d903f7874f989d12a2f684518fd227923bbe7f0c2c9" ) EXPECTED_TYPED_REQUEST_SHA256 = ( "ce20b44a85b000cf59b24fa4fa69196ccd596ba3d42c78ab325bad1fac99caad" ) EXPECTED_TYPED_ARTIFACT_SHA256 = ( "ed3f639b3b7254566b248e3314dcca9aed82a8a91f0465a61d920571b2c9c6d3" ) RAW_LOWER_EVIDENCE_SHA256 = ( "75ac260531dba3618c14fb459e86e2e8bfe39d205a1705da61d516528d0db581" ) RESUMED_LOWER_EVIDENCE_SHA256 = ( "fb0bb3fc7b3dc6312952ad7ba9d324346ebd16db35e59e3b894ae3c0f70d489e" ) RAW_UPPER_EVIDENCE_SHA256 = ( "8da3a1ee2523a0e7e4c4e21a627c8a780d8160cd09d9beb5130044cd8936fdbe" ) RESUMED_UPPER_EVIDENCE_SHA256 = ( "d637b58008f17e1380fb1a3ed6f262b4183b7e19f4c420555d89df0c33340d5b" ) KNOWN_ANSWER_GATE_SHA256 = ( "7adf6f4a93cb321fa0501cbb62723370cdbc3a85db7d9e2565cc086ea6a00687" ) KNOWN_ANSWER_TRUST_SHA256 = ( "1e67120095a358bbcb2166a6804479655dc3bdd8b36c4d12bc56f73d5e741140" ) REGISTRY_FILE_SHA256 = ( "265f1a3fefef884adeaa980a5dce2441dee4f6f6d71c253ba7a6491360733689" ) REGISTRY_INTERNAL_SHA256 = ( "536c733d68d344ed9fef9992bbeb1000900174ad0c500ddb7004126ae5c98408" ) EXPECTED_MATRIX_RECORDS = { "hx": { "content_sha256": "3e84de485357b46239174805f8fc3378eeb0e4207a06fc3a95568e5630c58c8e", "file_sha256": "a8d53c3e14419e0b0c30e2960621394475e06d0cff30a6c1f0c9635c8f5bf9ea", }, "hz": { "content_sha256": "21b89580009d0ce19cab3c537ddc53c0211a962d88e4aaa1cf3b9a6752d502ab", "file_sha256": "fae00c16429f8312a9a5f1c8e7f025431f986ac8dcc13a433887111f5503baa4", }, } MUTABLE_BASE_FILES = frozenset( { "README.md", "THIRD_PARTY_NOTICES.md", "docs/REPRODUCE.md", "docs/SCHEMA.md", "docs/STAGE3_TYPED_EXACT_FOM_GT_12.md", "data/stage3_typed_exact_fom_gt_12.jsonl", "evidence/stage3_typed_exact_matrix_index.jsonl", "evidence/stage3_typed_exact_proofs.jsonl", "manifests/stage3_typed_exact_fom_gt_12.json", "scripts/build_exact_fom_gt_12_release.py", "scripts/verify_stage3_typed_exact_fom_gt_12.py", "scripts/verify_dataset.py", } ) LFS_POINTER_PREFIX = b"version https://git-lfs.github.com/spec/v1\n" def sha256_bytes(value: bytes) -> str: return hashlib.sha256(value).hexdigest() def sha256_file(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for block in iter(lambda: handle.read(1 << 20), b""): digest.update(block) return digest.hexdigest() def canonical_sha256(value: dict[str, Any], omitted: str) -> str: payload = {key: item for key, item in value.items() if key != omitted} encoded = json.dumps( payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False, allow_nan=False, ).encode() return sha256_bytes(encoded) def canonical_value_sha256(value: Any) -> str: encoded = json.dumps( value, sort_keys=True, separators=(",", ":"), ensure_ascii=False, allow_nan=False, ).encode() return sha256_bytes(encoded) def load_json(path: Path) -> dict[str, Any]: value = json.loads(path.read_text(encoding="utf-8")) if not isinstance(value, dict): raise ValueError(f"expected one JSON object: {path}") return value def verify_materialized_base(root: Path) -> None: sums_path = root / "manifests" / "SHA256SUMS" for line in sums_path.read_text(encoding="utf-8").splitlines(): if not line: continue expected, relative = line.split(" ", 1) path = root / relative if not path.is_file(): raise ValueError(f"missing base release file: {relative}") if path.read_bytes()[: len(LFS_POINTER_PREFIX)] == LFS_POINTER_PREFIX: raise ValueError( f"Git LFS object is not materialized: {relative}; run git lfs pull" ) if relative not in MUTABLE_BASE_FILES: observed = sha256_file(path) if observed != expected: raise ValueError(f"sealed base file changed: {relative}") def git_head(root: Path) -> str: return subprocess.check_output( ["git", "-C", str(root), "rev-parse", "HEAD"], text=True, ).strip() def gf2_rank(matrix: Any) -> int: rows = [ sum((int(bit) & 1) << col for col, bit in enumerate(row)) for row in matrix.tolist() ] rank = 0 while rows: pivot = max(rows) if not pivot: break bit = 1 << (pivot.bit_length() - 1) rank += 1 rows = [ value ^ pivot if value & bit else value for value in rows if value != pivot ] return rank def content_sha256(matrix: Any) -> str: shape = [int(matrix.shape[0]), int(matrix.shape[1])] header = json.dumps( {"dtype": "uint8-gf2", "shape": shape}, sort_keys=True, separators=(",", ":"), ) return sha256_bytes(header.encode() + b"\n" + matrix.tobytes(order="C")) def dist_array_sha256(name: str, matrix: Any) -> str: digest = hashlib.sha256() digest.update(name.encode()) digest.update(b"\0") digest.update(json.dumps(list(matrix.shape), separators=(",", ":")).encode()) digest.update(b"\0") digest.update(matrix.tobytes(order="C")) return digest.hexdigest() def matrix_market_gzip(name: str, matrix: Any) -> bytes: rows, cols = map(int, matrix.shape) entries = [ f"{row + 1} {col + 1} 1\n" for row in range(rows) for col in range(cols) if int(matrix[row, col]) & 1 ] body = ( "%%MatrixMarket matrix coordinate integer general\n" f"% qcode candidate {CANDIDATE_ID} {name}; entries are GF(2)\n" f"{rows} {cols} {len(entries)}\n" + "".join(entries) ).encode("ascii") output = io.BytesIO() with gzip.GzipFile( filename="", mode="wb", fileobj=output, compresslevel=9, mtime=0, ) as handle: handle.write(body) return output.getvalue() def matrix_record(root: Path, name: str, matrix: Any) -> dict[str, Any]: relative = Path("matrices") / CANDIDATE_ID / f"{name}.mtx.gz" path = root / relative path.parent.mkdir(parents=True, exist_ok=True) payload = matrix_market_gzip(name, matrix) path.write_bytes(payload) return { "path": relative.as_posix(), "shape": [int(matrix.shape[0]), int(matrix.shape[1])], "file_sha256": sha256_bytes(payload), "content_sha256": content_sha256(matrix), } def write_jsonl_one(path: Path, value: dict[str, Any]) -> None: payload = json.dumps( value, sort_keys=True, separators=(",", ":"), ensure_ascii=False, allow_nan=False, ) + "\n" path.parent.mkdir(parents=True, exist_ok=True) path.write_text(payload, encoding="utf-8") def source_paths(run: Path) -> dict[str, Path]: unit_dir = ( run / "solver-state" / "sat-sectors" / "sat-units" / STATE_KEY ) return { "stage3-summary.json": run / "stage3-summary.json", "stage3-ranked.jsonl": run / "stage3-ranked.jsonl", "stage3-thresholds.jsonl": run / "stage3-thresholds.jsonl", "aggregate": run / "solver-state" / "sat-sectors" / f"{STATE_KEY}.json", "lower-terminal": unit_dir / "lower-distqldpc-mto-XZ-global.json", "upper-terminal": unit_dir / "upper-X-global.json", } def build(root: Path, source_run: Path, qcode_root: Path) -> None: root = root.resolve(strict=True) source_run = source_run.resolve(strict=True) qcode_root = qcode_root.resolve(strict=True) verify_materialized_base(root) if git_head(root) != HF_BASE_COMMIT: raise ValueError("Hugging Face release base commit changed") if git_head(qcode_root) != QCODE_COMMIT: raise ValueError("qcode source commit changed") if subprocess.check_output( [ "git", "-C", str(qcode_root), "status", "--porcelain", "--untracked-files=no", ], text=True, ).strip(): raise ValueError("qcode source tree has tracked modifications") if sha256_file(root / "reference/known_answer_gate.json") != KNOWN_ANSWER_GATE_SHA256: raise ValueError("known-answer gate changed") if sha256_file(root / "reference/known_answer_trust.json") != KNOWN_ANSWER_TRUST_SHA256: raise ValueError("known-answer trust record changed") registry_path = qcode_root / "results" / "known_code_registry.json" if sha256_file(registry_path) != REGISTRY_FILE_SHA256: raise ValueError("known-code registry file changed") registry = load_json(registry_path) if registry.get("registry_sha256") != REGISTRY_INTERNAL_SHA256: raise ValueError("known-code registry internal seal changed") paths = source_paths(source_run) for label, path in paths.items(): observed = sha256_file(path) if observed != EXPECTED_SOURCE_SHA256[label]: raise ValueError(f"unexpected {label} SHA256: {observed}") sys.path.insert(0, str(qcode_root)) import numpy as np from evaluation.bb_code import build_bb_code from evaluation.distance_distqldpc import ( verify_distqldpc_exact_evidence, verify_distqldpc_lower_evidence, ) from evaluation.distance_milp import get_code_matrices from evaluation.sector_certificate import ( REQUEST_FIELD, claim_from_sector_sat_artifact, ) from humanize.state import code_key aggregate = load_json(paths["aggregate"]) lower = load_json(paths["lower-terminal"]) upper = load_json(paths["upper-terminal"]) summary = load_json(paths["stage3-summary.json"]) candidate = aggregate["candidate"] if aggregate.get("status") != "EXACT_PROVEN": raise ValueError("source aggregate is not EXACT_PROVEN") if aggregate.get("artifact_sha256") != ( "fa03b3a2a8f43d77131c8a5491efbb56d98800d9e215b45e9e5b3e7f86509159" ): raise ValueError("source aggregate canonical seal changed") if candidate.get("canonical_digest") != CANONICAL_DIGEST: raise ValueError("source candidate digest changed") if code_key(candidate) != CANDIDATE_ID: raise ValueError("candidate_id no longer matches humanize.state.code_key") if summary.get("status_counts") != {"EXACT_PROVEN": 1}: raise ValueError("Stage 3 summary is not the accepted one-result handoff") summary_expected = { "schema_version": 1, "gate": "qldpc-direction-candidate-pool", "target_mode": "scalar-fom-inclusive-v1", "backend": "sat-sectors", "input_rows": 4096, "selected_candidates": 1, "malformed_unresolved_rows": 0, "duplicate_digests_skipped": 0, "unselected_unresolved_candidates": 0, "selection_exhausted": True, "threshold_only": False, "status_counts": {"EXACT_PROVEN": 1}, "retry_required": False, "retry_reasons": { "unresolved_candidates": 0, "unselected_unresolved_candidates": 0, "operational_errors": 0, }, "certify": False, "stage4_candidates": 1, "certified_wins": 0, "operational_errors": 0, } if any(summary.get(key) != value for key, value in summary_expected.items()): raise ValueError("Stage 3 summary fields changed") stage3_budget = summary["worker_budget"]["stage3"] if { "candidate_workers": stage3_budget.get("candidate_workers"), "direction_workers": stage3_budget.get("direction_workers"), "configured_solver_workers": stage3_budget.get("configured_solver_workers"), "admitted_solver_workers": stage3_budget.get("admitted_solver_workers"), "max_total_workers": summary["worker_budget"].get("max_total_workers"), } != { "candidate_workers": 1, "direction_workers": 2, "configured_solver_workers": 2, "admitted_solver_workers": 2, "max_total_workers": 2, }: raise ValueError("Stage 3 worker budget changed") wall = summary["hard_wall_budget"] if ( float(wall.get("direction_timeout_s", -1)) != 21600.0 or float(wall.get("candidate_timeout_s", -1)) != 134400.0 or float(wall.get("termination_grace_s", -1)) != 600.0 ): raise ValueError("Stage 3 hard-wall budget changed") results = summary.get("results") if ( not isinstance(results, list) or len(results) != 1 or results[0].get("canonical_digest") != CANONICAL_DIGEST or results[0].get("status") != "EXACT_PROVEN" or results[0].get("completed_proof_units") != 2 or results[0].get("expected_proof_units") != 27 or "error" in results[0] or "hard_wall" in results[0] ): raise ValueError("Stage 3 result summary changed") typed_claim = claim_from_sector_sat_artifact(aggregate) typed_request = typed_claim[REQUEST_FIELD] if canonical_value_sha256(typed_claim) != EXPECTED_TYPED_CLAIM_SHA256: raise ValueError("typed Stage 3 claim changed") if canonical_value_sha256(typed_request) != EXPECTED_TYPED_REQUEST_SHA256: raise ValueError("typed Stage 3 request changed") typed_expected = { "coverage_mode": "global", "requested_coverage_mode": "first-nonzero", "requested_lower_backend": "distqldpc", "lower_bound_backend": "distqldpc", "lower_bound_threshold": 15, "required_distance": 16, "stage3_status": "EXACT_PROVEN", "target_mode": "scalar-fom-inclusive-v1", "use_translation_anchors": True, "use_construction_anchors": False, "anchor_cover_cubes": None, "distqldpc_exact_distances": [16], "distqldpc_conflict": False, "distqldpc_conflict_details": None, "low_witnesses": [], "escalation_decisions": [], "stage3_artifact_sha256": EXPECTED_TYPED_ARTIFACT_SHA256, } if any(typed_request.get(key) != value for key, value in typed_expected.items()): raise ValueError("typed Stage 3 request semantics changed") if { "canonical_digest": typed_claim.get("canonical_digest"), "n": typed_claim.get("n"), "k": typed_claim.get("k"), "required_distance": typed_claim.get("required_distance"), } != { "canonical_digest": CANONICAL_DIGEST, "n": 210, "k": 10, "required_distance": 16, }: raise ValueError("typed Stage 3 claim parameters changed") typed_lower = typed_request["lower_bound_decisions"] typed_upper = typed_request["upper_witness"] if ( len(typed_lower) != 1 or typed_lower[0]["solver_evidence"]["evidence_sha256"] != RESUMED_LOWER_EVIDENCE_SHA256 or typed_lower[0]["solver_evidence"]["exact_distance"] != 16 or typed_upper["solver_evidence"]["evidence_sha256"] != RESUMED_UPPER_EVIDENCE_SHA256 or typed_upper["solver_evidence"]["objective"] != 16 ): raise ValueError("typed Stage 3 evidence identities changed") if lower.get("evidence_sha256") != RAW_LOWER_EVIDENCE_SHA256: raise ValueError("raw lower terminal evidence changed") if upper.get("evidence_sha256") != RAW_UPPER_EVIDENCE_SHA256: raise ValueError("raw upper terminal evidence changed") aggregate_expected = { "coverage_mode": "global", "requested_coverage_mode": "first-nonzero", "requested_lower_backend": "distqldpc", "lower_bound_backend": "distqldpc", "lower_bound_threshold": 15, "expected_units": 27, "attempted_units": 23, "terminal_units": 2, "retryable_units": 21, "expected_directions": 27, "completed_directions": 2, "expected_lower_decisions": 1, "completed_lower_decisions": 1, "expected_lower_partitions": 1, "completed_lower_partitions": 1, "upper_unsat_decisions": [], "threshold_only": False, "distqldpc_exact_distances": [16], "distqldpc_conflict": False, "distqldpc_conflict_details": None, "low_witnesses": [], } if any(aggregate.get(key) != value for key, value in aggregate_expected.items()): raise ValueError("Stage 3 aggregate terminal state changed") code = build_bb_code( 21, 5, [(7, 3), (18, 4), (20, 0)], [(2, 3), (18, 1), (19, 2)], geometry={"schema_version": 1, "family": "twisted_torus", "twist": 3}, ) hx, hz, lx, lz = ( np.ascontiguousarray(np.asarray(value, dtype=np.uint8) & 1) for value in get_code_matrices(code) ) gx, gz = lz, lx matrices = {"Hx": hx, "Hz": hz, "Gx": gx, "Gz": gz} expected_dist_hashes = lower["instance"]["matrix_files"] for name, matrix in matrices.items(): if dist_array_sha256(name, matrix) != expected_dist_hashes[name]["array_sha256"]: raise ValueError(f"{name} does not match the sealed solver instance") checkpoint_identity = lower["instance"]["checkpoint_identity"] verifier_args = { "max_weight": 15, "cardinality_mode": "mto", "expected_checkpoint_identity": checkpoint_identity, "expected_binary_sha256": DISTQLDPC_BINARY_SHA256, "expected_source_commit": DISTQLDPC_SOURCE_COMMIT, } exact_failures = verify_distqldpc_exact_evidence( lower, hx, hz, lx, lz, **verifier_args ) lower_failures = verify_distqldpc_lower_evidence( lower, hx, hz, lx, lz, **verifier_args ) if exact_failures or lower_failures: raise ValueError( f"raw DistQLDPC terminal replay failed: {exact_failures}; " f"{lower_failures}" ) for name in ("Hx", "Hz"): matrix = matrices[name] generated = { "content_sha256": content_sha256(matrix), "file_sha256": sha256_bytes(matrix_market_gzip(name, matrix)), } if generated != EXPECTED_MATRIX_RECORDS[name.lower()]: raise ValueError(f"deterministic {name} public matrix changed") rank_x, rank_z = gf2_rank(hx), gf2_rank(hz) if (rank_x, rank_z) != (100, 100): raise ValueError("unexpected check ranks") if np.any((hx @ hz.T) & 1): raise ValueError("CSS checks do not commute") if np.any((hx @ gx.T) & 1) or np.any((hz @ gz.T) & 1): raise ValueError("logical representatives do not commute with checks") if not np.array_equal((gz @ gx.T) & 1, np.eye(10, dtype=np.uint8)): raise ValueError("logical representatives fail duality") packed = bytes.fromhex(upper["operator"]["packed_hex"]) operator = np.unpackbits( np.frombuffer(packed, dtype=np.uint8), bitorder="little" )[:210].astype(np.uint8) if int(operator.sum()) != 16 or np.any((hz @ operator) & 1): raise ValueError("upper witness is invalid") syndrome = ((gx @ operator) & 1).astype(int).tolist() if syndrome != upper["logical_syndrome"] or not any(syndrome): raise ValueError("upper witness is not a nontrivial X logical") checks = { "css_commutation": True, "commutation_violations": 0, "rank_x": rank_x, "rank_z": rank_z, "k_recomputed": 210 - rank_x - rank_z, "max_check_weight": max( max(map(int, hx.sum(axis=1))), max(map(int, hz.sum(axis=1))), ), "max_sector_qubit_degree": max( max(map(int, hx.sum(axis=0))), max(map(int, hz.sum(axis=0))), ), "max_qubit_degree": max(map(int, hx.sum(axis=0) + hz.sum(axis=0))), "logical_basis_complete": True, "logical_duality": True, } if checks != { "css_commutation": True, "commutation_violations": 0, "rank_x": 100, "rank_z": 100, "k_recomputed": 10, "max_check_weight": 6, "max_sector_qubit_degree": 3, "max_qubit_degree": 6, "logical_basis_complete": True, "logical_duality": True, }: raise ValueError(f"unexpected matrix checks: {checks}") matrix_records = { name.lower(): matrix_record(root, name, matrix) for name, matrix in matrices.items() } public_source = { "qcode_commit": QCODE_COMMIT, "stage3_aggregate_byte_sha256": EXPECTED_SOURCE_SHA256["aggregate"], "stage3_aggregate_self_seal_sha256": aggregate["artifact_sha256"], "stage3_typed_request_artifact_sha256": EXPECTED_TYPED_ARTIFACT_SHA256, "stage3_typed_claim_sha256": EXPECTED_TYPED_CLAIM_SHA256, "stage3_typed_request_sha256": EXPECTED_TYPED_REQUEST_SHA256, "stage3_lower_terminal_byte_sha256": EXPECTED_SOURCE_SHA256["lower-terminal"], "stage3_lower_raw_terminal_evidence_sha256": RAW_LOWER_EVIDENCE_SHA256, "stage3_lower_resumed_evidence_sha256": RESUMED_LOWER_EVIDENCE_SHA256, "stage3_upper_terminal_byte_sha256": EXPECTED_SOURCE_SHA256["upper-terminal"], "stage3_upper_raw_terminal_evidence_sha256": RAW_UPPER_EVIDENCE_SHA256, "stage3_upper_resumed_evidence_sha256": RESUMED_UPPER_EVIDENCE_SHA256, "stage3_summary_byte_sha256": EXPECTED_SOURCE_SHA256["stage3-summary.json"], "stage3_ranked_byte_sha256": EXPECTED_SOURCE_SHA256["stage3-ranked.jsonl"], "stage3_threshold_byte_sha256": EXPECTED_SOURCE_SHA256["stage3-thresholds.jsonl"], "known_answer_gate_sha256": KNOWN_ANSWER_GATE_SHA256, "known_answer_trust_sha256": KNOWN_ANSWER_TRUST_SHA256, } construction = { "family": "css-bb", "representation_id": "css-bb-twisted-torus-generator-v1", "ell": 21, "m": 5, "geometry": {"schema_version": 1, "family": "twisted_torus", "twist": 3}, "A_terms": [[7, 3], [18, 4], [20, 0]], "B_terms": [[2, 3], [18, 1], [19, 2]], } record: dict[str, Any] = { "schema_version": 1, "record_kind": "stage3_typed_exact_fom_gt_12", "evidence_class": "STAGE3_TYPED_EXACT_PENDING_STRICT_GATE", "source_stage": "stage3_direction_audit", "source_status": "EXACT_PROVEN", "release_status": "PENDING_STAGE4_STAGE5", "candidate_id": CANDIDATE_ID, "canonical_digest": CANONICAL_DIGEST, "code": "[[210,10,16]]", "construction": construction, "parameters": {"n": 210, "k": 10}, "distance": { "status": "EXACT_PROVEN", "exact": 16, "lower_bound": 16, "upper_bound": 16, "lower_bound_backend": "DistQLDPC/MaxCDCL", "upper_bound_backend": "python-sat/cadical195", }, "fom": { "exact": { "numerator": 256, "denominator": 21, "decimal": 256 / 21, }, "excess_over_12": { "numerator": 4, "denominator": 21, "decimal": 4 / 21, }, "strict_integer_margin": 40, }, "target": { "strict_predicate": "k*d*d > 12*n", "required_distance": 16, "left_hand_side": 2560, "right_hand_side": 2520, "passes_strict_target": True, "certified_win": False, }, "source_target": { "mode": candidate["target"]["mode"], "strict": candidate["target"]["strict"], "binding_sha256": candidate["target"]["binding_sha256"], "required_distance": candidate["target"]["required_distance"], }, "matrices": matrix_records, "matrix_checks": checks, "novelty": { "status": candidate["novelty"]["status"], "novel": candidate["novelty"]["novel"], "registry_version": candidate["novelty"]["registry_version"], "registry_file_sha256": REGISTRY_FILE_SHA256, "registry_internal_sha256": REGISTRY_INTERNAL_SHA256, "matched_entries": candidate["novelty"]["matched_entries"], "source_stage3_replayed": candidate["novelty"]["replayed_from_construction"], "release_current_registry_replayed": False, "scope": "pinned known-code registry with explicit construction/matrix replay", }, "known_answer_context": { "gate_file_sha256": KNOWN_ANSWER_GATE_SHA256, "trust_file_sha256": KNOWN_ANSWER_TRUST_SHA256, "release_replayed": False, }, "authority": { "stage3_typed_handoff_replay": True, "exact_under_pinned_solver_trust_model": True, "pipeline_stage4_certificate": False, "portable_unsat_proof_certificate": False, "pipeline_stage5_final_gate": False, "pipeline_promotion": False, "independent_release_gate_complete": False, "publication_certificate": False, "public_dataset_record": True, }, "source": public_source, } record["record_sha256"] = canonical_sha256(record, "record_sha256") safe_backend = { "distribution": lower["backend"]["distribution"], "interface": lower["backend"]["interface"], "repository": lower["backend"]["repository"], "source_commit": lower["backend"]["source_commit"], "binary_sha256": lower["backend"]["binary_sha256"], "binary_size": lower["backend"]["file_size"], "identity_sha256": lower["backend"]["identity_sha256"], } if safe_backend["binary_sha256"] != DISTQLDPC_BINARY_SHA256: raise ValueError("DistQLDPC binary pin changed") if safe_backend["source_commit"] != DISTQLDPC_SOURCE_COMMIT: raise ValueError("DistQLDPC source pin changed") evidence: dict[str, Any] = { "schema_version": 1, "record_kind": "stage3_typed_exact_fom_gt_12_evidence", "evidence_class": "STAGE3_TYPED_EXACT_PENDING_STRICT_GATE", "source_status": "EXACT_PROVEN", "release_status": "PENDING_STAGE4_STAGE5", "authority": record["authority"], "candidate_id": CANDIDATE_ID, "canonical_digest": CANONICAL_DIGEST, "distance_claim": { "status": "EXACT_PROVEN", "exact": 16, "lower_bound": 16, "upper_bound": 16, }, "stage3_typed_handoff": { "gate": aggregate["gate"], "status": aggregate["status"], "backend": aggregate["lower_bound_backend"], "lower_bound_threshold": aggregate["lower_bound_threshold"], "attempted_proof_units": aggregate["attempted_units"], "completed_proof_units": aggregate["terminal_units"], "expected_proof_units": aggregate["expected_units"], "source_retryable_units_at_terminal": aggregate["retryable_units"], "summary_retry_required": summary["retry_required"], "terminal_reason": "distqldpc_exact_plus_upper_witness", "distqldpc_exact_distances": aggregate["distqldpc_exact_distances"], "distqldpc_conflict": aggregate["distqldpc_conflict"], "distqldpc_conflict_details": aggregate["distqldpc_conflict_details"], "low_witnesses": aggregate["low_witnesses"], "typed_replay_verified": True, **public_source, }, "lower_bound_evidence": { "evidence_kind": lower["evidence_kind"], "formulation": lower["formulation"], "outcome": lower["outcome"], "exact_distance": lower["exact_distance"], "lower_bound": lower["lower_bound"], "upper_bound": lower["upper_bound"], "threshold_infeasible": lower["threshold_infeasible"], "decision_complete": lower["decision_complete"], "retryable": lower["retryable"], "returncode": lower["returncode"], "timed_out": lower["timed_out"], "hard_timeout_s": lower["hard_timeout_s"], "elapsed_s": lower["elapsed_s"], "cardinality_mode": lower["instance"]["solver_execution"]["cardinality_mode"], "parsed_output": lower["parsed_output"], "stdout_sha256": lower["stdout_sha256"], "stderr_sha256": lower["stderr_sha256"], "raw_terminal_replay_verified": True, "raw_terminal_evidence_sha256": lower["evidence_sha256"], "aggregate_resumed_evidence_sha256": RESUMED_LOWER_EVIDENCE_SHA256, "terminal_file_sha256": EXPECTED_SOURCE_SHA256["lower-terminal"], "instance_binding_sha256": lower["instance"]["binding_sha256"], "checkpoint_identity": checkpoint_identity, "logical_detector": lower["instance"]["logical_detector"], "solver_instance_array_sha256": { name: expected_dist_hashes[name]["array_sha256"] for name in ("Hx", "Hz", "Gx", "Gz") }, "runtime_source": lower["instance"]["solver_execution"]["runtime_source"], "backend": safe_backend, }, "upper_bound_evidence": { "evidence_kind": upper["evidence_kind"], "formulation": upper["formulation"], "outcome": upper["outcome"], "sector": upper["sector"], "objective": upper["objective"], "decision_complete": upper["decision_complete"], "retryable": upper["retryable"], "anchor_indices": upper["anchor_indices"], "operator": upper["operator"], "logical_syndrome": upper["logical_syndrome"], "backend": upper["backend"], "cnf": upper["cnf"], "raw_terminal_evidence_sha256": upper["evidence_sha256"], "aggregate_resumed_evidence_sha256": RESUMED_UPPER_EVIDENCE_SHA256, "terminal_file_sha256": EXPECTED_SOURCE_SHA256["upper-terminal"], "instance_binding_sha256": upper["instance"]["binding_sha256"], }, "symmetry": { "translation_verified": aggregate["translation_symmetry"]["verified"], "orbit_representatives": aggregate["translation_symmetry"]["orbit_representatives"], "xz_sector_isometry_verified": aggregate["xz_sector_isometry"]["verified"], "xz_sector_isometry_sha256": aggregate["xz_sector_isometry"]["report_sha256"], "covered_sectors": aggregate["xz_sector_isometry"]["covered_sectors"], }, "limitations": { "portable_unsat_certificate": ( "Not available. The lower bound is a replay-bound result under the " "pinned DistQLDPC/MaxCDCL binary and runtime trust model." ), "independent_checks": ( "The public verifier reconstructs Hx/Hz, checks CSS ranks and " "commutation, validates the complete logical basis, and replays " "the weight-16 upper witness. It cannot independently certify " "the solver-derived lower bound without a portable proof trace." ), }, } evidence["evidence_sha256"] = canonical_sha256(evidence, "evidence_sha256") data_path = root / "data" / "stage3_typed_exact_fom_gt_12.jsonl" evidence_path = root / "evidence" / "stage3_typed_exact_proofs.jsonl" write_jsonl_one(data_path, record) write_jsonl_one(evidence_path, evidence) matrix_index = { "schema_version": 1, "record_kind": "stage3_typed_exact_matrix_index", "candidate_id": CANDIDATE_ID, "canonical_digest": CANONICAL_DIGEST, "n": 210, "k": 10, "matrices": matrix_records, } matrix_index["record_sha256"] = canonical_sha256( matrix_index, "record_sha256" ) matrix_index_path = ( root / "evidence" / "stage3_typed_exact_matrix_index.jsonl" ) write_jsonl_one(matrix_index_path, matrix_index) release_files = [ "README.md", "THIRD_PARTY_NOTICES.md", "docs/REPRODUCE.md", "docs/SCHEMA.md", "data/stage3_typed_exact_fom_gt_12.jsonl", "evidence/stage3_typed_exact_proofs.jsonl", "evidence/stage3_typed_exact_matrix_index.jsonl", *[matrix_records[name]["path"] for name in ("hx", "hz", "gx", "gz")], "docs/STAGE3_TYPED_EXACT_FOM_GT_12.md", "scripts/verify_dataset.py", "scripts/verify_stage3_typed_exact_fom_gt_12.py", "scripts/build_exact_fom_gt_12_release.py", ] manifest: dict[str, Any] = { "schema_version": 1, "gate": "qcode-public-stage3-typed-exact-fom-gt-12-v1", "status": "STAGE3_TYPED_EXACT_PENDING_STRICT_GATE", "source_status": "EXACT_PROVEN", "release_status": "PENDING_STAGE4_STAGE5", "certified_win": False, "publication_certificate": False, "created_date_utc": "2026-08-19", "dataset_base_commit": HF_BASE_COMMIT, "candidate": { "candidate_id": CANDIDATE_ID, "canonical_digest": CANONICAL_DIGEST, "code": "[[210,10,16]]", "exact_fom_numerator": 256, "exact_fom_denominator": 21, }, "authority": record["authority"], "source": public_source, "files": [], } for relative in release_files: path = root / relative item: dict[str, Any] = { "path": relative, "bytes": path.stat().st_size, "sha256": sha256_file(path), } if relative.endswith(".jsonl"): item["rows"] = len( [line for line in path.read_text(encoding="utf-8").splitlines() if line] ) manifest["files"].append(item) manifest["manifest_sha256"] = canonical_sha256(manifest, "manifest_sha256") manifest_path = root / "manifests" / "stage3_typed_exact_fom_gt_12.json" manifest_path.write_text( json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8", ) sums_path = root / "manifests" / "SHA256SUMS" existing_order = [] for line in sums_path.read_text(encoding="utf-8").splitlines(): if not line: continue _old, relative = line.split(" ", 1) existing_order.append(relative) additions = [ *release_files, "manifests/stage3_typed_exact_fom_gt_12.json", ] order = existing_order + [item for item in additions if item not in existing_order] sums_path.write_text( "".join(f"{sha256_file(root / relative)} {relative}\n" for relative in order), encoding="utf-8", ) print( json.dumps( { "candidate_id": CANDIDATE_ID, "code": "[[210,10,16]]", "fom": 256 / 21, "record_sha256": record["record_sha256"], "evidence_sha256": evidence["evidence_sha256"], "manifest_sha256": manifest["manifest_sha256"], }, sort_keys=True, ) ) def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("root", type=Path) parser.add_argument("source_run", type=Path) parser.add_argument("qcode_root", type=Path) args = parser.parse_args() build(args.root, args.source_run, args.qcode_root) if __name__ == "__main__": main()