| |
| from __future__ import annotations |
| import argparse, gzip, hashlib, json, sys |
| from pathlib import Path |
|
|
| def sha(path): |
| h=hashlib.sha256() |
| with path.open("rb") as f: |
| for block in iter(lambda:f.read(1<<20),b""): h.update(block) |
| return h.hexdigest() |
|
|
| def load_mtx(path): |
| with gzip.open(path,"rt",encoding="ascii") as f: |
| header=f.readline().strip() |
| assert header=="%%MatrixMarket matrix coordinate integer general",(path,header) |
| line=f.readline() |
| while line.startswith("%"): line=f.readline() |
| rows,cols,nnz=map(int,line.split()); out=[[0]*cols for _ in range(rows)] |
| seen=0 |
| for line in f: |
| if not line.strip(): continue |
| r,c,v=map(int,line.split()); assert v==1 |
| out[r-1][c-1]^=1; seen+=1 |
| assert seen==nnz |
| return out |
|
|
| def rank(a): |
| a=[sum((v&1)<<j for j,v in enumerate(row)) for row in a] |
| out=0 |
| while a: |
| pivot=max(a) |
| if not pivot: break |
| bit=1<<(pivot.bit_length()-1); out+=1 |
| a=[x^pivot if x&bit else x for x in a if x!=pivot] |
| return out |
|
|
| def content_sha(a): |
| shape=[len(a),len(a[0]) if a else 0] |
| header=json.dumps({"dtype":"uint8-gf2","shape":shape},sort_keys=True,separators=(",",":")) |
| raw=bytes(v&1 for row in a for v in row) |
| return hashlib.sha256(header.encode()+b"\n"+raw).hexdigest() |
|
|
| def in_row_space(a,bits): return rank(a+[bits])==rank(a) |
| def parity(row,bits): return sum(x&y for x,y in zip(row,bits))&1 |
|
|
| def main(root): |
| sums=root/"manifests/SHA256SUMS"; checked=0 |
| for line in sums.read_text().splitlines(): |
| expected,rel=line.split(" ",1); path=root/rel |
| assert sha(path)==expected,(rel,"file sha mismatch"); checked+=1 |
| candidates={} |
| for line in (root/"data/candidates.jsonl").read_text().splitlines(): |
| row=json.loads(line); cid=row["candidate_id"]; assert cid not in candidates; candidates[cid]=row |
| proofs={json.loads(line)["candidate_id"]:json.loads(line) for line in (root/"evidence/proofs.jsonl").read_text().splitlines()} |
| assert candidates.keys()==proofs.keys() |
| for cid,row in candidates.items(): |
| mx=row["matrices"]; hx=load_mtx(root/mx["hx_path"]); hz=load_mtx(root/mx["hz_path"]) |
| assert sha(root/mx["hx_path"])==mx["hx_file_sha256"] |
| assert sha(root/mx["hz_path"])==mx["hz_file_sha256"] |
| assert content_sha(hx)==mx["hx_content_sha256"] |
| assert content_sha(hz)==mx["hz_content_sha256"] |
| n=row["parameters"]["n"]; assert len(hx[0])==len(hz[0])==n |
| rx,rz=rank(hx),rank(hz); assert rx==row["matrix_checks"]["rank_x"] and rz==row["matrix_checks"]["rank_z"] |
| assert n-rx-rz==row["parameters"]["k"] |
| assert all(parity(x,z)==0 for x in hx for z in hz) |
| k=row["parameters"]["k"]; target=row["target"]["required_distance"] |
| assert k*(target-1)*(target-1)<=12*n and k*target*target>12*n |
| for key in ("lower_bound","upper_bound","exact"): |
| d=row["distance"][key]; f=row["fom"][key] |
| assert (d is None)==(f is None) |
| if d is not None: assert abs(f-k*d*d/n)<1e-12 |
| proof=proofs[cid] |
| witnesses=[] |
| report=proof.get("logical_basis_upper_bound_evidence") or {} |
| if isinstance(report.get("witness"),dict): witnesses.append(report["witness"]) |
| audit=proof.get("trusted_audit") or {} |
| if isinstance(audit.get("symplectic_weight_witness"),dict): witnesses.append(audit["symplectic_weight_witness"]) |
| oracle=proof.get("formal_lower_bound_evidence") or {} |
| if oracle.get("outcome")=="SAT" and isinstance(oracle.get("witness"),dict): witnesses.append(oracle["witness"]) |
| for witness in witnesses: |
| bits=witness.get("bits"); side=witness.get("side") or witness.get("sector") |
| if not isinstance(bits,list): continue |
| assert len(bits)==n and sum(bits)==int(witness["weight"]) |
| if side=="X": assert all(parity(row,bits)==0 for row in hz) and not in_row_space(hx,bits) |
| elif side=="Z": assert all(parity(row,bits)==0 for row in hx) and not in_row_space(hz,bits) |
| manifest=json.loads((root/"manifests/selection.json").read_text()) |
| assert manifest["selected_candidates"]==len(candidates) |
| assert manifest["certified_fom_gt_12_count"]==sum(r["target"]["certified_win"] for r in candidates.values()) |
| stage3_lane=root/"data/stage3_typed_exact_fom_gt_12.jsonl" |
| if stage3_lane.is_file(): |
| scripts_dir=str(Path(__file__).resolve().parent) |
| if scripts_dir not in sys.path: |
| sys.path.insert(0,scripts_dir) |
| from verify_stage3_typed_exact_fom_gt_12 import verify as verify_stage3_lane |
| verify_stage3_lane(root) |
| print(f"PASS: {checked} file hashes, {len(candidates)} candidates, all matrices and witnesses verified") |
|
|
| if __name__=="__main__": |
| p=argparse.ArgumentParser(); p.add_argument("root",type=Path,nargs="?",default=Path(".")); a=p.parse_args(); main(a.root.resolve()) |
|
|
