#!/usr/bin/env python3 """Validate the prepared files locally; no network calls or general proof claims.""" from fractions import Fraction import hashlib import json import math from pathlib import Path import re from urllib.parse import unquote ROOT = Path(__file__).resolve().parents[1] def no_constant(value): raise ValueError(f"Nonstandard JSON constant: {value}") def unique_pairs(pairs): result = {} for key,value in pairs: if key in result: raise ValueError(f"Duplicate JSON key: {key}") result[key]=value return result def loads(text): return json.loads(text,parse_constant=no_constant,object_pairs_hook=unique_pairs) def load(path): return loads(path.read_text(encoding="utf-8")) def fail(message): raise ValueError(message) def require(condition, message): if not condition: fail(message) def safe_path(base, relative): path=(base/relative).resolve() require(path.is_relative_to(base.resolve()),f"Path escapes root: {relative}") require(path.is_file(),f"Missing file: {relative}") return path def sha(path): return hashlib.sha256(path.read_bytes()).hexdigest() def matches(value, kind): if kind=="boolean": return isinstance(value,bool) if kind=="integer": return isinstance(value,int) and not isinstance(value,bool) if kind=="number": return isinstance(value,(float,int)) and not isinstance(value,bool) and math.isfinite(value) if kind=="string": return isinstance(value,str) if kind=="object": return isinstance(value,dict) if kind=="null": return value is None if kind=="array": return isinstance(value,list) if kind.startswith("array["): return isinstance(value,list) and all(matches(v,kind[6:-1]) for v in value) fail(f"Unsupported schema kind: {kind}") def verify_manifest(base): manifest=safe_path(base,"SHA256SUMS.txt") names=set() for line in manifest.read_text(encoding="utf-8").splitlines(): expected, relative=line.split(" ",1) require(relative not in names,f"Duplicate manifest path: {relative}") names.add(relative) require(sha(safe_path(base,relative))==expected,f"Hash mismatch: {relative}") actual={p.relative_to(base).as_posix() for p in base.rglob("*") if p.is_file() and p!=manifest and "__pycache__" not in p.parts and p.suffix!=".pyc"} require(actual==names,f"Manifest coverage mismatch: missing={sorted(actual-names)}, extra={sorted(names-actual)}") return len(names) def polynomial(coeffs, z): return sum((Fraction(c)*z**i for i,c in enumerate(coeffs)), Fraction(0)) def main(): schema=load(ROOT/"DATA_SCHEMA.json") configs=schema["configurations"] require(set(configs)=={"tomography_exact","suite_metrics","joint_loss_log_grid","joint_loss_survival_grid","tomography_conditioning","claims","research_sections"},"Unexpected configurations") rows_by_config={} total=0 for name,config in configs.items(): require(config["split"]=="test",f"Unexpected split for {name}") text=safe_path(ROOT,config["path"]).read_text(encoding="utf-8") rows=[loads(line) for line in text.splitlines()] require(len(rows)==config["rows"],f"Row count mismatch: {name}") ids=set() for row in rows: require(set(row)==set(config["fields"]),f"Field mismatch: {name}") for key,kind in config["fields"].items(): require(matches(row[key],kind),f"Type mismatch: {name}.{key}") if key.endswith("_json"): loads(row[key]) require(row["record_id"] not in ids,f"Duplicate record ID: {name}") ids.add(row["record_id"]) safe_path(ROOT,row["source_file"]) for source in config["source_files"]: require(sha(safe_path(ROOT,source["path"]))==source["sha256"],f"Source hash mismatch: {source['path']}") rows_by_config[name]=rows total+=len(rows) require(total==schema["total_rows"],"Total row count mismatch") response_checks=0 original=load(ROOT/"research/v3/results/tomography_check.json") for index,row in enumerate(rows_by_config["tomography_exact"]): fixture=original["fixtures"][index] require(all(row[k]==v for k,v in fixture.items()),f"Tomography source changed: {index}") m=row["m"] require(row["rank"]==2*m,"Unexpected interpolation rank") require(len(row["t"])==len(row["r"])==m,"Tomography mode length") require(len(row["probe_z"])==len(row["probe_response_exact"])==2*m,"Tomography response length") t=list(map(Fraction,row["t"])); r=list(map(Fraction,row["r"])) require(all(v>0 for v in t+r) and len(set(t))==m and t==sorted(t),"Invalid visible measure") z_values=list(map(Fraction,row["probe_z"])) require(len(set(z_values))==2*m and all(z>0 for z in z_values),"Invalid probes") require(len(row["P_ascending"])==m and len(row["Q_ascending"])==m+1 and Fraction(row["Q_ascending"][-1])==1,"Invalid rational-function degrees") for field in ["t","r","probe_z","P_ascending","Q_ascending","probe_response_exact"]: require(all(str(Fraction(value))==value for value in row[field]),f"Noncanonical Fraction: {field}") # Two independent representations must match on every probe. for z,expected in zip(z_values,row["probe_response_exact"]): spectral=sum((w*v/(z+v) for v,w in zip(t,r)),Fraction(0)) quotient=polynomial(row["P_ascending"],z)/polynomial(row["Q_ascending"],z) require(spectral==quotient==Fraction(expected),"Exact response mismatch") response_checks+=1 ledger=load(ROOT/"CLAIM_LEDGER.json") claims=ledger["claims"] require(len(claims)==len(rows_by_config["claims"]),"Claim export count mismatch") tex=(ROOT/"research/Avenyra_Geometric_Memory_Physics.tex").read_text(encoding="utf-8") report_labels=set(re.findall(r"\\label\{([^}]+)\}",tex)) evidence_count=0 for claim,row in zip(claims,rows_by_config["claims"]): require(claim["id"]==row["record_id"] and claim["statement"]==row["statement"],"Claim export mismatch") ref=claim["report_reference"] for key in ["section_label","statement_label"]: if ref.get(key): require(ref[key] in report_labels,f"Missing report anchor: {ref[key]}") for label in ref.get("equation_labels",[]): require(label in report_labels,f"Missing equation: {label}") for evidence in claim["evidence"]: safe_path(ROOT,evidence["path"]) evidence_count+=1 sections=rows_by_config["research_sections"] for row in sections: require(row["text_latex"] in tex,"Section text changed") require(row["title_latex"]==re.match(r"\\section\{([^}\n]+)\}",row["text_latex"]).group(1),"Section title mismatch") import yaml card=(ROOT/"README.md").read_text(encoding="utf-8") require(card.startswith("---\n"),"Missing card front matter") metadata=yaml.safe_load(card.split("---",2)[1]) require("license" not in metadata,"Unexpected license grant metadata") listed={c["config_name"]:c for c in metadata["configs"]} require(set(listed)==set(configs),"Metadata configuration mismatch") require([c["config_name"] for c in metadata["configs"] if c.get("default")] == ["claims"],"Unexpected default") for name,config in configs.items(): require(listed[name]["data_files"]==[{"split":"test","path":config["path"]}],f"Metadata path mismatch: {name}") require(total<1000 and metadata["size_categories"]==["n<1K"],"Size category mismatch") markdown_links=0 for path in ROOT.glob("*.md"): text=path.read_text(encoding="utf-8") # Check actual link destinations, not bare source filenames or bibliography URLs. for target in re.findall(r"\]\(([^)]+)\)",text): target=target.split(" \",",1)[0] if target.startswith(("https://","http://","mailto:","#")): continue target=unquote(target.split("#",1)[0]) require(bool(target),f"Empty Markdown path: {path.name}") safe_path(path.parent,target) markdown_links+=1 require(not re.search(r"/workspace/|libfile_|sandbox:|OPENAI_LIBRARY",text),f"Private runtime detail: {path.name}") for path in ROOT.rglob("*.py"): compile(path.read_text(encoding="utf-8"),str(path),"exec") core_hashes=verify_manifest(ROOT/"research") release_hashes=verify_manifest(ROOT) print(json.dumps({"status":"passed","configurations":len(configs),"export_rows":total,"exact_probe_response_checks":response_checks,"claims":len(claims),"claim_evidence_paths":evidence_count,"markdown_links":markdown_links,"research_manifest_entries":core_hashes,"release_manifest_entries":release_hashes,"remote_hub_viewer_tested":False},indent=2)) if __name__=="__main__": main()