"""Verify the anchored claims of arXiv 2507.06161 (Sinkhorn Normalization of Diffusion Kernels). C1 Theorem 4.1: a symmetric positive smoothing operator can be rescaled by a diagonal matrix (symmetric Sinkhorn) into a valid diffusion operator (axioms hold). C2 Theorem 4.2: Sinkhorn-normalized Gaussian/exponential kernels converge (Q1 -> 1). C3 Symmetric Sinkhorn needs only ~5-10 iterations to reach error < 1e-6. C4 The normalized operator satisfies symmetry, mass conservation, entrywise positivity, and spectral damping (spectrum subset [0,1]). C5 Demonstrations across point clouds, GMMs, voxels, and jaw geometry. C6 Armadillo surface-and-volume spectral consistency and resolution divergence. """ from __future__ import annotations import copy import csv import hashlib import os, json import numpy as np from pathlib import Path import platform import subprocess import sys sys.path.insert(0, os.path.dirname(__file__)) from core import (gaussian_kernel, exponential_kernel, heat_kernel, symmetric_sinkhorn, axiom_symmetry, axiom_mass_conservation, axiom_spectrum, axiom_positivity, is_diffusion_operator) from resolution import ARTIFACT_DIR, print_summary, run_resolution_contract, write_artifacts from armadillo import ( ARTIFACT_ROOT, print_armadillo_summary, run_armadillo, write_armadillo_artifacts, ) from spectra import ( print_spectral_summary, run_spectral_analysis, write_spectral_artifacts, ) from claim5_jaw import run_claim5_jaw RNG = np.random.default_rng(2026) OUT = os.path.join(os.path.dirname(__file__), "..", "..", "outputs") os.makedirs(OUT, exist_ok=True) rep: dict = {"claims": {}} TOL = 1e-6 def make_instances(): """A battery of smoothing operators (Gaussian/exponential on point clouds + heat kernel).""" inst = {} for name, n, d, sig in [("gauss_2d", 60, 2, 0.5), ("gauss_3d", 50, 3, 0.7), ("gauss_gmm", 80, 2, 0.4), ("exp_2d", 60, 2, 0.6)]: if "gmm" in name: c = RNG.choice([0, 1, 2], n) cents = RNG.normal(size=(3, d)) * 2 X = cents[c] + RNG.normal(size=(n, d)) * 0.3 else: X = RNG.normal(size=(n, d)) if "exp" in name: inst[name] = exponential_kernel(X, sig) else: inst[name] = gaussian_kernel(X, sig) # heat kernel from a random graph Laplacian n = 40 A = (RNG.random((n, n)) < 0.2).astype(float); A = np.triu(A, 1); A = A + A.T L = np.diag(A.sum(1)) - A inst["heat_graph"] = heat_kernel(L, 0.5) return inst # --------------------------------------------------------------------------- # def claim_C1(): """Theorem 4.1: the symmetric Sinkhorn diagonal rescaling EXISTS and turns each smoothing operator into a diffusion operator (all 4 axioms hold).""" res = {"instances": []} ok_all = True for name, S in make_instances().items(): Q, lam, niter, err, _ = symmetric_sinkhorn(S) good = is_diffusion_operator(Q, tol=1e-6) and err < 1e-6 ok_all = ok_all and good lo, hi = axiom_spectrum(Q) res["instances"].append({"kernel": name, "iterations": niter, "final_err": err, "lam_positive": bool(np.all(lam > 0)), "spectrum": [round(lo, 6), round(hi, 6)], "is_diffusion_operator": good, "VERDICT": "VERIFIED" if good else "FAIL"}) res["VERDICT"] = "VERIFIED" if ok_all else "FAIL" rep["claims"]["C1_diagonal_rescaling"] = res return ok_all def claim_C2(): """Theorem 4.2: Sinkhorn-normalized Gaussian and exponential kernels converge (the row-sum error Q1-1 decreases monotonically to 0).""" res = {"instances": []} ok_all = True X = RNG.normal(size=(50, 2)) for name, S in [("gaussian", gaussian_kernel(X, 0.5)), ("exponential", exponential_kernel(X, 0.6))]: Q, lam, niter, err, errs = symmetric_sinkhorn(S, tol=1e-14, max_iter=200) # convergence: final error ~0 and (mostly) decreasing final_small = errs[-1] < 1e-10 # check monotone-ish decrease over the first 15 iterations (allow tiny non-monotonicity) early = errs[:15] decreased = early[-1] < early[0] good = final_small and decreased ok_all = ok_all and good res["instances"].append({"kernel": name, "iters_to_1e-14": niter, "final_err": errs[-1], "err_curve_first10": [f"{e:.2e}" for e in errs[:10]], "converges": good, "VERDICT": "VERIFIED" if good else "FAIL"}) res["VERDICT"] = "VERIFIED" if ok_all else "FAIL" rep["claims"]["C2_convergence"] = res return ok_all def claim_C3(): """The symmetric Sinkhorn algorithm empirically requires only ~5-10 iterations to reduce the (mass-weighted average) normalization error below 1e-3 = 0.1% (eq. 34).""" res = {"instances": []} iters = [] for name, S in make_instances().items(): n = S.shape[0] lam = np.ones(n) mean_errs = [] for it in range(1, 31): Q = lam[:, None] * S * lam[None, :] r = Q @ np.ones(n) mean_errs.append(float(np.mean(np.abs(r - 1.0)))) # eq. 34 (uniform mass) if mean_errs[-1] < 1e-3: break lam = lam / np.sqrt(np.maximum(r, 1e-300)) k = next((i for i, e in enumerate(mean_errs, 1) if e < 1e-3), len(mean_errs)) iters.append(k) res["instances"].append({"kernel": name, "iters_to_1e-3_avg": k, "mean_err_curve": [f"{e:.2e}" for e in mean_errs[:8]]}) res["iters_min"] = int(min(iters)); res["iters_max"] = int(max(iters)); res["iters_mean"] = float(np.mean(iters)) # Claim: "5-10 iterations are SUFFICIENT". Means convergence within ~10 iters for every # instance (a kernel that is already near-balanced converging faster, e.g. heat_graph in 1, # does not contradict sufficiency). Typical point-cloud kernels land in 5-8. gauss_iters = [k for name, k in zip(make_instances().keys(), iters) if "heat" not in name] res["pointcloud_iters"] = gauss_iters res["sufficient_within_10"] = bool(max(iters) <= 10) res["typical_in_5_to_10"] = bool(min(gauss_iters) >= 4 and max(gauss_iters) <= 10) ok = res["sufficient_within_10"] and res["typical_in_5_to_10"] res["VERDICT"] = "VERIFIED" if ok else "FAIL" rep["claims"]["C3_iteration_count"] = res return ok def claim_C4(): """The normalized operator satisfies the four diffusion properties: symmetry, mass conservation, entrywise positivity, spectral damping (spectrum in [0,1]).""" res = {"instances": []} ok_all = True for name, S in make_instances().items(): Q, lam, niter, err, _ = symmetric_sinkhorn(S) sym = axiom_symmetry(Q) mass = axiom_mass_conservation(Q) lo, hi = axiom_spectrum(Q) pos = axiom_positivity(Q) good = (sym < TOL and mass < TOL and lo >= -TOL and hi <= 1 + TOL and pos >= -TOL) ok_all = ok_all and good res["instances"].append({"kernel": name, "symmetry_err": sym, "mass_err": mass, "spectrum": [round(lo, 6), round(hi, 6)], "min_offdiag": round(pos, 6), "all_four_hold": good, "VERDICT": "VERIFIED" if good else "FAIL"}) res["VERDICT"] = "VERIFIED" if ok_all else "FAIL" rep["claims"]["C4_four_properties"] = res return ok_all def claim_C5(): """Demonstration on synthetic point clouds and a Gaussian mixture model: the Sinkhorn-normalized operator is a valid diffusion operator on these, and the leading eigenvector (low-frequency mode) is smooth (a sanity demonstration).""" res = {} # GMM point cloud: two clusters n = 100 c = RNG.choice([0, 1], n); cents = np.array([[0, 0], [3, 3.0]]) X = cents[c] + RNG.normal(size=(n, 2)) * 0.4 S = gaussian_kernel(X, 0.5) Q, lam, niter, err, _ = symmetric_sinkhorn(S) res["gmm_valid_diffusion"] = bool(is_diffusion_operator(Q, tol=1e-6)) # leading eigenvector (largest eigenvalue ~1) varies smoothly over the point cloud eivals, eivecs = np.linalg.eigh((Q + Q.T) / 2) lead = eivecs[:, -1] # smoothness: total variation along nearest-neighbor graph is small relative to range from scipy.spatial import cKDTree tree = cKDTree(X) _, nn = tree.query(X, k=2) tv = np.mean(np.abs(lead - lead[nn[:, 1]])) res["gmm_leading_mode_TV"] = float(tv) res["gmm_leading_mode_smooth"] = bool(tv < 0.3 * (lead.max() - lead.min())) ok = res["gmm_valid_diffusion"] and res["gmm_leading_mode_smooth"] res["VERDICT"] = "VERIFIED" if ok else "FAIL" rep["claims"]["C5_point_cloud_demo"] = res return ok if __name__ == "__main__": print("RECONSTRUCTED_BASELINE=true") print("SOURCE_SPACE_REVISION=0d4740f85ae95f1097a44734c29e51b3a65e656f") print("C1 diagonal rescaling (axioms hold):", claim_C1()) for t in rep["claims"]["C1_diagonal_rescaling"]["instances"]: print(f" {t['kernel']:12s} iters={t['iterations']} err={t['final_err']:.2e} " f"spectrum={t['spectrum']} diffusion={t['is_diffusion_operator']} {t['VERDICT']}") print("C2 legacy fixed-n Sinkhorn iteration proxy:", claim_C2()) for t in rep["claims"]["C2_convergence"]["instances"]: print(f" {t['kernel']:11s} iters_to_1e-14={t['iters_to_1e-14']} final_err={t['final_err']:.2e} " f"curve={t['err_curve_first10'][:5]} {t['VERDICT']}") print("C3 iteration count (~5-10):", claim_C3(), {k: v for k, v in rep["claims"]["C3_iteration_count"].items() if k != 'instances'}) print("C4 four properties:", claim_C4()) for t in rep["claims"]["C4_four_properties"]["instances"]: print(f" {t['kernel']:12s} sym={t['symmetry_err']:.1e} mass={t['mass_err']:.1e} " f"spec={t['spectrum']} min_offdiag={t['min_offdiag']} {t['VERDICT']}") print("C5 point-cloud demo:", claim_C5(), rep["claims"]["C5_point_cloud_demo"]) with open(os.path.join(OUT, "verdict.json"), "w", encoding="utf-8") as handle: json.dump(rep, handle, indent=2) print("\nSaved outputs/verdict.json") # Cumulative child evidence: directly test the normalized operators as # sampling resolution increases, rather than fixed-n iteration convergence. resolution_result = run_resolution_contract() write_artifacts(resolution_result) print_summary(resolution_result) raw_path = ARTIFACT_DIR / "raw_results.json" primary_path = ARTIFACT_DIR / "verifier_output.json" independent_path = ARTIFACT_DIR / "independent_checker_output.json" primary = subprocess.run( [ sys.executable, str(Path(__file__).with_name("verify_resolution.py")), str(raw_path), str(primary_path), ], check=False, ) independent = subprocess.run( [ sys.executable, str(Path(__file__).with_name("check_resolution_independent.py")), str(raw_path), str(independent_path), ], check=False, ) negative_payload = copy.deepcopy(resolution_result) negative_payload["cases"] = negative_payload["negative_control"]["cases"] negative_raw_path = ARTIFACT_DIR / "negative_control_raw.json" negative_raw_path.write_text( json.dumps(negative_payload, indent=2) + "\n", encoding="utf-8" ) negative_primary_path = ARTIFACT_DIR / "negative_primary.json" negative_independent_path = ARTIFACT_DIR / "negative_independent.json" negative_primary = subprocess.run( [ sys.executable, str(Path(__file__).with_name("verify_resolution.py")), str(negative_raw_path), str(negative_primary_path), ], check=False, ) negative_independent = subprocess.run( [ sys.executable, str(Path(__file__).with_name("check_resolution_independent.py")), str(negative_raw_path), str(negative_independent_path), ], check=False, ) negative_record = { "control": "fixed_resolution_relabelled_as_increasing", "expected_rejected": True, "primary_exit_code": negative_primary.returncode, "independent_exit_code": negative_independent.returncode, "rejected_by_both": ( negative_primary.returncode != 0 and negative_independent.returncode != 0 ), "primary": json.loads(negative_primary_path.read_text(encoding="utf-8")), "independent": json.loads( negative_independent_path.read_text(encoding="utf-8") ), } (ARTIFACT_DIR / "negative_control_output.json").write_text( json.dumps(negative_record, indent=2) + "\n", encoding="utf-8" ) passed = ( primary.returncode == 0 and independent.returncode == 0 and negative_record["rejected_by_both"] ) verdict = "VERIFIED" if passed else "BLOCKED" eval_text = ( "# Claim 2 evaluation\n\n" f"Verdict: `{verdict}`\n\n" "This verdict applies to the explicit machine-checkable configured " "contract. The universal theorem remains broader than any finite " "numerical reproduction; see `limitations_and_deviations.md`.\n" ) (ARTIFACT_DIR / "EVAL.md").write_text(eval_text, encoding="utf-8") print("NEGATIVE_CONTROL=" + json.dumps(negative_record, sort_keys=True)) print("CLAIM_2_VERDICT=" + verdict) if not passed: raise SystemExit(1) config = json.loads( (Path(__file__).resolve().parents[1] / "config.json").read_text( encoding="utf-8" ) ) cumulative_failure = False if config.get("large_scale_variant") == "armadillo_surface": armadillo_result = run_armadillo(config) armadillo_raw = write_armadillo_artifacts(armadillo_result) print_armadillo_summary(armadillo_result) primary_armadillo_path = ( ARTIFACT_ROOT / "claim_1" / "verifier_output.json" ) independent_armadillo_path = ( ARTIFACT_ROOT / "claim_1" / "independent_checker_output.json" ) primary_armadillo = subprocess.run( [ sys.executable, str(Path(__file__).with_name("verify_armadillo.py")), str(armadillo_raw), str(primary_armadillo_path), ], check=False, ) independent_armadillo = subprocess.run( [ sys.executable, str(Path(__file__).with_name("check_armadillo.py")), str(armadillo_raw), str(independent_armadillo_path), ], check=False, ) negative_armadillo = copy.deepcopy(armadillo_result) for kernel_record in negative_armadillo["kernels"]: kernel_record["top_eigenvalues"][-1] = 1.2 for normalization_record in kernel_record["normalizations"]: if normalization_record["normalization"] == "sinkhorn": normalization_record["mass_max_error"] = 0.05 negative_raw = ARTIFACT_ROOT / "claim_1" / "negative_control_raw.json" negative_raw.write_text( json.dumps(negative_armadillo, indent=2) + "\n", encoding="utf-8", ) negative_primary_path = ( ARTIFACT_ROOT / "claim_1" / "negative_primary.json" ) negative_independent_path = ( ARTIFACT_ROOT / "claim_1" / "negative_independent.json" ) negative_primary = subprocess.run( [ sys.executable, str(Path(__file__).with_name("verify_armadillo.py")), str(negative_raw), str(negative_primary_path), ], check=False, ) negative_independent = subprocess.run( [ sys.executable, str(Path(__file__).with_name("check_armadillo.py")), str(negative_raw), str(negative_independent_path), ], check=False, ) negative_pass = ( negative_primary.returncode != 0 and negative_independent.returncode != 0 ) negative_record = { "control": "corrupted_mass_and_spectral_metrics", "expected_rejected": True, "primary_exit_code": negative_primary.returncode, "independent_exit_code": negative_independent.returncode, "rejected_by_both": negative_pass, } for claim_id in (1, 3, 4): claim_directory = ARTIFACT_ROOT / f"claim_{claim_id}" (claim_directory / "negative_control_output.json").write_text( json.dumps(negative_record, indent=2) + "\n", encoding="utf-8", ) primary_payload = json.loads( primary_armadillo_path.read_text(encoding="utf-8") ) independent_payload = json.loads( independent_armadillo_path.read_text(encoding="utf-8") ) for claim_id in (3, 4): claim_directory = ARTIFACT_ROOT / f"claim_{claim_id}" (claim_directory / "verifier_output.json").write_text( json.dumps(primary_payload, indent=2) + "\n", encoding="utf-8", ) ( claim_directory / "independent_checker_output.json" ).write_text( json.dumps(independent_payload, indent=2) + "\n", encoding="utf-8", ) all_passed = ( primary_armadillo.returncode == 0 and independent_armadillo.returncode == 0 and negative_pass ) for claim_id in (1, 3, 4): claim_passed = ( all_passed and primary_payload["claim_status"][str(claim_id)] and independent_payload["claim_status"][str(claim_id)] ) claim_verdict = "VERIFIED" if claim_passed else "BLOCKED" eval_text = ( f"# Claim {claim_id} evaluation\n\n" f"Verdict: `{claim_verdict}`\n\n" "See the raw metrics, both verifier outputs, negative control, " "and limitations in this directory.\n" ) (ARTIFACT_ROOT / f"claim_{claim_id}" / "EVAL.md").write_text( eval_text, encoding="utf-8" ) print(f"CLAIM_{claim_id}_VERDICT={claim_verdict}") print("ARMADILLO_NEGATIVE_CONTROL=" + json.dumps(negative_record)) if not all_passed: raise SystemExit(1) if config.get("spectral_analysis", {}).get("enabled", False): spectral_result = run_spectral_analysis(config) spectral_raw = write_spectral_artifacts(spectral_result) print_spectral_summary(spectral_result) spectral_primary_path = ( ARTIFACT_ROOT / "claim_6" / "verifier_output.json" ) spectral_independent_path = ( ARTIFACT_ROOT / "claim_6" / "independent_checker_output.json" ) spectral_primary = subprocess.run( [ sys.executable, str(Path(__file__).with_name("verify_spectra.py")), str(spectral_raw), str(spectral_primary_path), ], check=False, ) spectral_independent = subprocess.run( [ sys.executable, str(Path(__file__).with_name("check_spectra_independent.py")), str(spectral_raw), str(spectral_independent_path), ], check=False, ) negative_spectral = copy.deepcopy(spectral_result) def corrupt_modality( modality_record: dict, comparison_record: dict ) -> None: modality_record["estimated_laplacian_eigenvalues"] = list( reversed( modality_record["estimated_laplacian_eigenvalues"] ) ) comparison_record["pearson_indices_2_to_15"] = 0.0 comparison_record[ "median_relative_error_indices_2_to_15" ] = 1.0 comparison_record[ "first_index_after_10_relative_error_above_25pct" ] = 11 for diagnostics in modality_record.get( "eigenspaces", {} ).values(): diagnostics["median_canonical_correlation"] = 0.0 diagnostics["minimum_canonical_correlation"] = 0.0 raw_grams = diagnostics.get("raw_grams") if raw_grams is not None: cross = np.asarray(raw_grams["cross"]) raw_grams["cross"] = np.zeros_like(cross).tolist() for modality in ("point_5000", "gmm_500", "surface_voxels"): corrupt_modality( negative_spectral["modalities"][modality], negative_spectral["comparisons_to_cotan"][modality], ) for modality in ( "volume_point_5000", "volume_gmm_500", "volume_voxels", ): corrupt_modality( negative_spectral["modalities"][modality], negative_spectral["comparisons_to_fem"][modality], ) for seed_record in negative_spectral["volume_seed_sweep"]: for modality in ( "volume_point_5000", "volume_gmm_500", "volume_voxels", ): corrupt_modality( seed_record["modalities"][modality], seed_record["comparisons_to_fem"][modality], ) negative_spectral_raw = ( ARTIFACT_ROOT / "claim_6" / "negative_control_raw.json" ) negative_spectral_raw.write_text( json.dumps(negative_spectral, indent=2) + "\n", encoding="utf-8", ) negative_spectral_primary_path = ( ARTIFACT_ROOT / "claim_6" / "negative_primary.json" ) negative_spectral_independent_path = ( ARTIFACT_ROOT / "claim_6" / "negative_independent.json" ) negative_spectral_primary = subprocess.run( [ sys.executable, str(Path(__file__).with_name("verify_spectra.py")), str(negative_spectral_raw), str(negative_spectral_primary_path), ], check=False, ) negative_spectral_independent = subprocess.run( [ sys.executable, str( Path(__file__).with_name( "check_spectra_independent.py" ) ), str(negative_spectral_raw), str(negative_spectral_independent_path), ], check=False, ) spectral_negative_pass = ( negative_spectral_primary.returncode != 0 and negative_spectral_independent.returncode != 0 ) spectral_primary_payload = json.loads( spectral_primary_path.read_text(encoding="utf-8") ) spectral_independent_payload = json.loads( spectral_independent_path.read_text(encoding="utf-8") ) spectral_actual_pass = ( spectral_primary.returncode == 0 and spectral_independent.returncode == 0 and spectral_primary_payload["claim_6_contract_pass"] and spectral_independent_payload["claim_6_contract_pass"] ) spectral_full_pass = ( spectral_actual_pass and spectral_negative_pass ) claim_6_verdict = ( "VERIFIED" if spectral_full_pass else "FALSIFIED" if spectral_negative_pass and not spectral_actual_pass else "BLOCKED" ) spectral_negative_record = { "control": ( "reversed_all_surface_and_volume_spectra_and_zeroed_" "cross_grams" ), "expected_rejected": True, "primary_exit_code": negative_spectral_primary.returncode, "independent_exit_code": negative_spectral_independent.returncode, "rejected_by_both": spectral_negative_pass, } claim_6_directory = ARTIFACT_ROOT / "claim_6" (claim_6_directory / "negative_control_output.json").write_text( json.dumps(spectral_negative_record, indent=2) + "\n", encoding="utf-8", ) claim_5_directory = ARTIFACT_ROOT / "claim_5" claim_5_directory.mkdir(parents=True, exist_ok=True) claim_5_raw_record, claim_5_negative_raw_record = ( run_claim5_jaw(config, spectral_result) ) claim_5_raw_path = claim_5_directory / "raw_results.json" claim_5_negative_raw_path = ( claim_5_directory / "negative_control_raw.json" ) claim_5_raw_path.write_text( json.dumps(claim_5_raw_record, indent=2) + "\n", encoding="utf-8", ) claim_5_negative_raw_path.write_text( json.dumps(claim_5_negative_raw_record, indent=2) + "\n", encoding="utf-8", ) claim_5_primary_path = ( claim_5_directory / "verifier_output.json" ) claim_5_independent_path = ( claim_5_directory / "independent_checker_output.json" ) claim_5_primary = subprocess.run( [ sys.executable, str(Path(__file__).with_name("verify_claim5.py")), str(claim_5_raw_path), str(claim_5_primary_path), ], check=False, ) claim_5_independent = subprocess.run( [ sys.executable, str( Path(__file__).with_name( "check_claim5_independent.py" ) ), str(claim_5_raw_path), str(claim_5_independent_path), ], check=False, ) claim_5_negative_primary_path = ( claim_5_directory / "negative_primary.json" ) claim_5_negative_independent_path = ( claim_5_directory / "negative_independent.json" ) claim_5_negative_primary = subprocess.run( [ sys.executable, str(Path(__file__).with_name("verify_claim5.py")), str(claim_5_negative_raw_path), str(claim_5_negative_primary_path), ], check=False, ) claim_5_negative_independent = subprocess.run( [ sys.executable, str( Path(__file__).with_name( "check_claim5_independent.py" ) ), str(claim_5_negative_raw_path), str(claim_5_negative_independent_path), ], check=False, ) claim_5_primary_payload = json.loads( claim_5_primary_path.read_text(encoding="utf-8") ) claim_5_independent_payload = json.loads( claim_5_independent_path.read_text(encoding="utf-8") ) claim_5_actual_pass = ( claim_5_primary.returncode == 0 and claim_5_independent.returncode == 0 and claim_5_primary_payload["claim_5_contract_pass"] and claim_5_independent_payload["claim_5_contract_pass"] ) claim_5_negative_pass = ( claim_5_negative_primary.returncode != 0 and claim_5_negative_independent.returncode != 0 ) claim_5_full_pass = ( claim_5_actual_pass and claim_5_negative_pass ) claim_5_verdict = ( "VERIFIED" if claim_5_full_pass else "FALSIFIED" if claim_5_negative_pass and not claim_5_actual_pass else "BLOCKED" ) claim_5_negative_record = { "control": ( "omit Sinkhorn scaling on the same OpenMandible jaw " "voxels and Gaussian kernel" ), "expected_rejected": True, "primary_exit_code": claim_5_negative_primary.returncode, "independent_exit_code": ( claim_5_negative_independent.returncode ), "rejected_by_both": claim_5_negative_pass, } ( claim_5_directory / "negative_control_output.json" ).write_text( json.dumps(claim_5_negative_record, indent=2) + "\n", encoding="utf-8", ) claim_5_contract = { "claim_id": 5, "verdicts": ["VERIFIED", "FALSIFIED", "BLOCKED"], "source_anchor": ( "Figure 1, Figure 3, Sections 5-6, and Eq.6" ), "required_modalities": { "point_cloud_count": 5000, "covariance_aware_gmm_count": 500, "sparse_voxel_jaw": True, }, "jaw_contract": { "real_anatomical_source": True, "minimum_triangles": 40000, "minimum_nonempty_voxels": 1000, "maximum_occupancy_fraction": 0.25, "minimum_largest_6_connected_component_fraction": 0.75, "mass_error_max": 2e-10, "constant_error_max": 2e-10, "signal_minimum": -2e-10, "spectral_interval": [-2e-8, 1.00000002], "monotone_l2_smoothing": True, "monotone_q_roughness": True, "dirac_spatial_spreading": True, }, "dataset_substitution": ( "OpenMandible cortical bone is a declared independent " "jaw source because the paper does not name or release " "the Figure 1 scan." ), } (claim_5_directory / "claim_contract.json").write_text( json.dumps(claim_5_contract, indent=2) + "\n", encoding="utf-8", ) summary = claim_5_primary_payload["summary"] with (claim_5_directory / "raw_results.csv").open( "w", newline="", encoding="utf-8" ) as stream: writer = csv.DictWriter( stream, fieldnames=["metric", "value"], ) writer.writeheader() for name, value in summary.items(): writer.writerow({"metric": name, "value": value}) (claim_5_directory / "source_audit.md").write_text( "# Claim 5 source audit\n\n" "The paper demonstrates point clouds, covariance-aware " "Gaussian mixtures (Eq.6), and sparse voxels. Figure 1 calls " "the voxel example a jaw bone but does not identify or release " "the underlying scan. Figure 3 fixes the Armadillo scales at " "5,000 points, 500 Gaussians, and voxel edge 0.05.\n\n" "The reproduction retains those paper-scale Armadillo " "modalities and adds the peer-reviewed OpenMandible cortical " "bone model (DOI 10.1016/j.dental.2021.01.009), pinned to " "repository commit e1f8cef196adb29149a2193ffb0cb05dab631420 " "and SHA-256 " "5c58e2c84797bf06ff18291b692e4a62fc3e39f67212a93429a6dfa15e2b5d5e." "\n", encoding="utf-8", ) (claim_5_directory / "method.md").write_text( "# Claim 5 method\n\n" "The hash-pinned OpenMandible ASCII STL is normalized to the " "unit ball and sampled area-proportionally with a fixed seed. " "Samples are rasterized onto a sparse 40^3 grid with edge " "0.05. A Gaussian of sigma 0.05 is applied by separable " "matrix-free convolution and symmetrically Sinkhorn-scaled. " "A unit-mass voxel Dirac is diffused for 0, 1, 2, 4, and 8 " "steps. The contract checks positivity, mass and constant " "preservation, spectral damping, spatial spreading, and " "monotone L2 and diffusion-Dirichlet roughness. An independent " "checker reconstructs every signal from the raw voxel indices, " "weights, and scaling. The negative control omits Sinkhorn " "scaling while holding all other inputs fixed.\n", encoding="utf-8", ) (claim_5_directory / "limitations_and_deviations.md").write_text( "# Claim 5 limitations and deviations\n\n" "The paper's Figure 1 jaw scan is unidentified and absent from " "both the arXiv source bundle and the currently public author " "repository. OpenMandible is therefore a declared independent " "real-jaw substitution, not the authors' original data. The " "experiment verifies the stated modality/capability claim but " "does not claim pixel- or geometry-level replication of " "Figure 1. CPU SciPy convolution replaces the paper's Taichi " "sparse implementation while preserving the same symmetric " "Gaussian operator contract.\n", encoding="utf-8", ) claim_5_eval = ( "# Claim 5 evaluation\n\n" f"Verdict: `{claim_5_verdict}`\n\n" f"Primary contract passed: `{claim_5_primary_payload['claim_5_contract_pass']}`. " f"Independent raw recomputation passed: " f"`{claim_5_independent_payload['claim_5_contract_pass']}`. " f"Both checkers rejected the unnormalized negative control: " f"`{claim_5_negative_pass}`.\n\n" "This is a capability reproduction on a peer-reviewed real " "jaw geometry, with the non-identical jaw-source substitution " "declared explicitly.\n" ) claim_6_eval = ( "# Claim 6 evaluation\n\n" f"Verdict: `{claim_6_verdict}`\n\n" f"Full surface-and-volume spectral contract passed: " f"`{spectral_full_pass}`. The protocol includes the paper-scale " "5,000 point samples, 500-component covariance-aware GMMs, " "0.05 voxels, 40 eigenvalues, surface cotan and volumetric " "tetrahedral-FEM references, three deterministic volume seeds, " "eigenspace checks, independent recomputation from raw spectra " "and Gram matrices, and a rejected negative control. See " "`limitations.md` for declared implementation deviations.\n" ) (ARTIFACT_ROOT / "claim_5" / "EVAL.md").write_text( claim_5_eval, encoding="utf-8" ) (ARTIFACT_ROOT / "claim_6" / "EVAL.md").write_text( claim_6_eval, encoding="utf-8" ) print( "SPECTRAL_NEGATIVE_CONTROL=" + json.dumps(spectral_negative_record) ) print( "CLAIM5_NEGATIVE_CONTROL=" + json.dumps(claim_5_negative_record) ) print(f"CLAIM_5_VERDICT={claim_5_verdict}") print(f"CLAIM_6_VERDICT={claim_6_verdict}") cumulative_failure = not ( claim_5_full_pass and spectral_full_pass ) lock_path = Path(__file__).resolve().parents[2] / "uv.lock" lock_hash = hashlib.sha256(lock_path.read_bytes()).hexdigest() git_result = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=Path(__file__).resolve().parents[2], check=True, capture_output=True, text=True, ) common_environment = { "git_sha": git_result.stdout.strip(), "fixed_command": "uv run python repro/src/verify.py", "python": sys.version, "platform": platform.platform(), "processor": platform.processor(), "logical_cpu_count": os.cpu_count(), "numpy": np.__version__, "uv_lock_sha256": lock_hash, "deterministic_seed": 20260723, "compute_backend": ( "orx-managed CPU run; exact backend is recorded in run metadata" ), "gpu_used": False, } for claim_id in range(1, 7): claim_directory = ARTIFACT_ROOT / f"claim_{claim_id}" claim_directory.mkdir(parents=True, exist_ok=True) (claim_directory / "environment.json").write_text( json.dumps(common_environment, indent=2) + "\n", encoding="utf-8", ) print("COMMON_ENVIRONMENT=" + json.dumps(common_environment, sort_keys=True)) if cumulative_failure: raise SystemExit(1)