integration: add proofs/theory_proofs.py

proofs/theory_proofs.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""
+PEC5D / Sovereign — Theory Proofing Suite.
+
+Runnable verification of the ecosystem's mathematical formalisms.
+Every proof asserts a concrete, checkable property of the implemented
+code (not a claim about physics): the math is internally consistent,
+the anchors match the spec, and where the spec is internally
+inconsistent (e.g. 368.4x headline vs honest CAGR), we say so.
+
+Proofs:
+  P1  IPT gradient — ∇P = ∂/∂xᵐ[Φ·ρ·f·S·Q] returns a consistent field
+  P2  Phi-5 Kronecker — tensor is normalized (unit norm) and coherent
+  P3  Progression — engine computes (1.335)^20 ≈ 323x honestly;
+      the 368.4x spec headline is a stated parameter, not the math
+  P4  CHSH Bell — classical correlations S ≤ 2; entangled S > 2
+  P5  HOLO-MEM — Φ-symmetric correction is consistent across layers
+  P6  Kyrexis anchors — fidelity 0.999423 / awakening 87.4% preserved
+  P7  Coral specs — drone throughput + spacecraft life-support invariants
+
+Run:  python3 proofs/theory_proofs.py
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Callable, Dict, List, Tuple
+
+import numpy as np
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT))
+
+from pec5d.constants import PHI, CARRIER_HZ  # noqa: E402
+from pec5d.ipt import InvisiblePressureTheory  # noqa: E402
+from pec5d.phi5_core import Phi5Engine  # noqa: E402
+from pec5d.holographic_memory import HolographicMemory  # noqa: E402
+from pec5d.coral import CoralDrone, CoralSpacecraft  # noqa: E402
+from kyrexis.core import KyrexisCore  # noqa: E402
+from kyrexis.progression_scaling import ProgressionScalingEngine  # noqa: E402
+from kyrexis.particle_detector import ParticlePairDetector  # noqa: E402
+
+RESULTS: List[Dict[str, object]] = []
+
+
+def proof(name: str, note: str) -> Callable:
+    def deco(fn: Callable) -> Callable:
+        def wrapper() -> bool:
+            try:
+                passed = bool(fn())
+            except Exception as exc:  # noqa: BLE001
+                passed = False
+                note_suffix = f"{note} ({exc})"
+                RESULTS.append({"proof": name, "passed": False, "note": note_suffix})
+                print(f"  ❌ {name} — raised {exc}")
+                return passed
+            RESULTS.append({"proof": name, "passed": passed, "note": note})
+            print(f"  {'✅' if passed else '❌'} {name} — {note}")
+            return passed
+        return wrapper
+    return deco
+
+
+@proof("P1 IPT gradient", "∇P = ∂/∂xᵐ[Φ·ρ·f·S·Q] field is finite, Φ-scaled, 5-dim")
+def p1() -> bool:
+    rng = np.random.default_rng(1)
+    ipt = InvisiblePressureTheory().initialize()
+    grad = ipt.pressure_gradient(rng.random(5) + 0.1, rng.random(5) + 0.1)
+    ok = (
+        abs(grad["phi"] - PHI) < 1e-9
+        and grad["carrier_hz"] == CARRIER_HZ
+        and grad["magnitude"] > 0
+        and len(grad["direction"]) == 5
+        and all(np.isfinite(v) for v in grad["direction"])
+    )
+    return ok
+
+
+@proof("P2 Phi-5 Kronecker", "tensor normalized: ‖t‖ ≈ 1, coherence 0.99997")
+def p2() -> bool:
+    engine = Phi5Engine().initialize()
+    a = np.array([1, 0, 0, 0], dtype=complex)
+    b = np.array([0, 1, 0, 0], dtype=complex)
+    t = engine.solve_kronecker(a, b)
+    norm = float(np.linalg.norm(t))
+    return abs(norm - 1.0) < 1e-6 and abs(engine.coherence - 0.99997) < 1e-9
+
+
+@proof("P3 Progression honesty", "engine computes (1.335)^20 ≈ 323x; 368.4x is a parameter")
+def p3() -> bool:
+    p = ProgressionScalingEngine()
+    y20 = p.get_progression_at_year(20)["growth_factor"]
+    honest = (1.335) ** 20
+    headline = p.get_summary()["total_growth_factor"]  # 368.4 (spec parameter)
+    math_ok = abs(y20 - honest) / honest < 1e-3
+    headline_ok = abs(headline - 368.4) < 0.1
+    return math_ok and headline_ok  # both surfaced; math is honest
+
+
+@proof("P4 CHSH Bell", "classical S ≤ 2 (boundary), entangled S > 2 (violation)")
+def p4() -> bool:
+    det = ParticlePairDetector()
+    classical = det.bell_inequality_test([[1.0, 0.9], [0.9, 1.0]])
+    quantum = det.bell_inequality_test([[1.0, -0.7], [0.7, 1.0]])
+    return (
+        classical["S_value"] == 2.0
+        and not classical["violated"]
+        and quantum["S_value"] > 2.0
+        and quantum["violated"]
+    )
+
+
+@proof("P5 HOLO-MEM Φ-symmetry", "correction stable across all 5 layers")
+def p5() -> bool:
+    m = HolographicMemory().initialize()
+    for layer in range(1, 6):
+        m.write(layer, f"k{layer}", layer)
+    corr = m.coherence_correction()
+    counts = corr["stores"]
+    layer_names = [m.LAYERS[i] for i in range(1, 6)]
+    return (
+        abs(corr["phi_symmetry"] - PHI) < 1e-9
+        and corr["carrier_hz"] == CARRIER_HZ
+        and all(counts[name] == 1 for name in layer_names)
+    )
+
+
+@proof("P6 Kyrexis anchors", "fidelity 0.999423 · awakening 87.4% preserved")
+def p6() -> bool:
+    core = KyrexisCore().initialize()
+    s = core.get_state()
+    return (
+        abs(s["fidelity"] - 0.999423) < 1e-9
+        and abs(s["awakening_percent"] - 87.4) < 0.01
+        and s["quantum_qubits"] == 53
+    )
+
+
+@proof("P7 Coral invariants", "drone 500+/day · spacecraft closed-loop life support")
+def p7() -> bool:
+    drone = CoralDrone().initialize()
+    craft = CoralSpacecraft().initialize()
+    return (
+        drone.plants_per_day >= 500
+        and drone.deploy_mission(500)["fragments_planted"] == 500
+        and craft.life_support()["closed_loop"] is True
+        and craft.life_support()["o2_production"] is True
+    )
+
+
+def main() -> int:
+    print("🧪 Theory Proofing Suite — PEC5D / Sovereign")
+    print("=" * 56)
+    p1(); p2(); p3(); p4(); p5(); p6(); p7()
+    passed = sum(1 for r in RESULTS if r["passed"])
+    print("=" * 56)
+    print(f"  RESULT: {passed}/{len(RESULTS)} proofs passed")
+    print("  Honesty gate: proofs verify internal math consistency — "
+          "not physical reality claims.")
+    return 0 if passed == len(RESULTS) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())