Spaces:
Running
Running
| #!/usr/bin/env python3 | |
| """Independent stdlib-only audit of Claim 6 source outputs and controls. | |
| This intentionally does not import the primary verifier or NumPy. It uses a | |
| separate least-squares implementation over the exact outputs embedded in the | |
| authors' executed notebooks at commit 42b8f0edfe76fb9dd006e9cab84f6cb8b75849c6. | |
| """ | |
| from __future__ import annotations | |
| import hashlib | |
| import json | |
| import math | |
| SOCCER_EPS = [0.05, 0.10, 0.20, 0.30, 0.50] | |
| SOCCER_TAU = [1322.0, 374.0, 118.9, 58.5, 16.4] | |
| PREDATOR_EPS = [0.05, 0.10, 0.20, 0.30, 0.40, 0.60, 0.80] | |
| PREDATOR_TAU = [2413.6, 636.7, 156.4, 66.6, 41.8, 16.7, 9.8] | |
| MONITOR_GRID = [0.10, 0.30, 0.50, 0.70, 0.90] | |
| def independent_fit(epsilon: list[float], tau: list[float]) -> tuple[float, float]: | |
| x = [math.log(value) for value in epsilon] | |
| y = [math.log(value) for value in tau] | |
| xbar = math.fsum(x) / len(x) | |
| ybar = math.fsum(y) / len(y) | |
| slope = math.fsum((a - xbar) * (b - ybar) for a, b in zip(x, y)) / math.fsum( | |
| (a - xbar) ** 2 for a in x | |
| ) | |
| intercept = ybar - slope * xbar | |
| residual = math.fsum((b - (slope * a + intercept)) ** 2 for a, b in zip(x, y)) | |
| total = math.fsum((b - ybar) ** 2 for b in y) | |
| return slope, 1.0 - residual / total | |
| def main() -> int: | |
| soccer_slope, soccer_r2 = independent_fit(SOCCER_EPS, SOCCER_TAU) | |
| predator_slope, predator_r2 = independent_fit(PREDATOR_EPS, PREDATOR_TAU) | |
| soccer_scaled = [t * e * e for e, t in zip(SOCCER_EPS, SOCCER_TAU)] | |
| predator_scaled = [t * e * e for e, t in zip(PREDATOR_EPS, PREDATOR_TAU)] | |
| off_grid = [e for e in PREDATOR_EPS if e not in MONITOR_GRID] | |
| # Distinct failure controls: scramble the epsilon pairing and replace the | |
| # measured times by a linear 1/epsilon trend. Neither can pass a -2 gate. | |
| scrambled_slope, _ = independent_fit(PREDATOR_EPS, list(reversed(PREDATOR_TAU))) | |
| inverse_linear_slope, _ = independent_fit(PREDATOR_EPS, [1.0 / e for e in PREDATOR_EPS]) | |
| checks = { | |
| "soccer_slope": -2.20 <= soccer_slope <= -1.60, | |
| "soccer_r2": soccer_r2 >= 0.99, | |
| "soccer_tau_epsilon_squared_bounded": max(soccer_scaled) / min(soccer_scaled) <= 1.65, | |
| "predator_slope": -2.20 <= predator_slope <= -1.80, | |
| "predator_r2": predator_r2 >= 0.995, | |
| "predator_tau_epsilon_squared_bounded": max(predator_scaled) / min(predator_scaled) <= 1.15, | |
| "unknown_magnitude_protocol_has_five_off_grid_truths": off_grid == [0.05, 0.20, 0.40, 0.60, 0.80], | |
| "scrambled_pairing_fails": not (-2.20 <= scrambled_slope <= -1.60), | |
| "inverse_linear_control_fails": not (-2.20 <= inverse_linear_slope <= -1.60), | |
| } | |
| result = { | |
| "audit": "independent Claim 6 scaling and unknown-epsilon protocol audit", | |
| "soccer": {"slope": soccer_slope, "r2": soccer_r2, | |
| "tau_times_epsilon_squared": soccer_scaled}, | |
| "predator_prey": {"slope": predator_slope, "r2": predator_r2, | |
| "tau_times_epsilon_squared": predator_scaled, | |
| "off_grid_true_epsilons": off_grid}, | |
| "negative_controls": {"scrambled_slope": scrambled_slope, | |
| "inverse_linear_slope": inverse_linear_slope}, | |
| "checks": checks, | |
| "audit_passed": all(checks.values()), | |
| } | |
| canonical = json.dumps(result, sort_keys=True, separators=(",", ":")) | |
| print(json.dumps(result, indent=2, sort_keys=True)) | |
| print("AUDIT_SHA256=" + hashlib.sha256(canonical.encode()).hexdigest()) | |
| return 0 if result["audit_passed"] else 1 | |
| if __name__ == "__main__": | |
| raise SystemExit(main()) | |