proofs/theory_proofs.py

#!/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())