#!/usr/bin/env python3
"""
Topological Swarm Control: Deterministic Hodge–de Rham Safety Proof Plate

This program:
1. validates the scalar safety relations;
2. verifies the unrolled time-varying tracking-error bound;
3. verifies exponential fallback convergence;
4. renders a publication-grade proof plate;
5. writes a machine-readable certificate.

The proof distinguishes:
- theorem-level consequences of persistence stability;
- a policy reserve factor of 1/2 that yields the document's factor 4;
- exact linear-algebra consequences of the fallback law.
"""

from pathlib import Path
import json, hashlib
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import FancyBboxPatch

OUT = Path(__file__).resolve().parent
PNG = OUT / "Topological_Swarm_Control_Proof_Plate.png"
CERT = OUT / "Topological_Swarm_Control_Certificate.json"

# ---------------------------------------------------------------------
# I. Parameters and exact deductions
# ---------------------------------------------------------------------
pers_q = 2.5
tau_p = 0.5
v_max = 4.0
T_mix = 0.04
alpha = 1.7
dt = 0.05
margin = pers_q - tau_p

assert margin > 0 and v_max > 0 and T_mix > 0 and alpha > 0 and dt > 0

# Persistence stability gives |pers_q(t+h)-pers_q(t)| <= 2 v_max |h|.
# A full-margin theorem therefore permits h <= margin/(2 v_max).
dt_stability = margin / (2.0 * v_max)

# The source architecture spends only half the available persistence margin.
reserve_fraction = 0.5
dt_safe = reserve_fraction * dt_stability
v_star = reserve_fraction * margin / (2.0 * T_mix)

assert np.isclose(dt_safe, margin / (4.0 * v_max))
assert np.isclose(v_star, margin / (4.0 * T_mix))
nominal_gate = bool(T_mix < dt_safe)

# ---------------------------------------------------------------------
# II. Dynamic mixing error recursion and exact unrolling
# ---------------------------------------------------------------------
rho = 0.82
gamma = 0.35
E0 = 0.9
T_seq = np.array([0.040, 0.055, 0.090, 0.050, 0.120, 0.045], dtype=float)
T_bar = 0.050
Wv = np.array([1.10, 0.95, 1.30, 0.80, 1.15, 0.70], dtype=float)
deltaT = np.abs(T_seq - T_bar)
a = rho ** (dt / T_seq)
b = gamma * deltaT * Wv

E = np.empty(len(T_seq) + 1)
E[0] = E0
for k in range(len(T_seq)):
    E[k+1] = a[k] * E[k] + b[k]

prod_all = np.prod(a)
unrolled = prod_all * E0
for j in range(len(T_seq)):
    tail = np.prod(a[j+1:]) if j + 1 < len(T_seq) else 1.0
    unrolled += b[j] * tail

unroll_residual = abs(E[-1] - unrolled)
assert unroll_residual < 1e-12

# ---------------------------------------------------------------------
# III. Fallback law and kernel-residual contraction
# ---------------------------------------------------------------------
# A concrete safe operator with nontrivial kernel:
K_safe = np.diag([1.0, 2.0, 0.0, 0.0])
v0 = np.array([1.2, -0.7, 0.5, 1.1])
v_anchor = np.array([0.0, 0.0, -0.4, 0.8])
assert np.linalg.norm(K_safe @ v_anchor) == 0.0

n = np.arange(0, 101)
s = n * dt
decay = np.exp(-alpha * s)
V = decay[:, None] * v0 + (1.0 - decay[:, None]) * v_anchor
residual = np.linalg.norm((K_safe @ V.T).T, axis=1)
predicted_residual = decay * np.linalg.norm(K_safe @ v0)
fallback_identity_residual = np.max(np.abs(residual - predicted_residual))
assert fallback_identity_residual < 1e-12
assert residual[-1] < residual[0]

# ---------------------------------------------------------------------
# IV. Machine certificate
# ---------------------------------------------------------------------
payload = {
    "title": "Topological Swarm Control: Deterministic Hodge–de Rham Safety Proof",
    "evidence": {
        "persistence_stability": "theorem-level, under point-cloud speed bound",
        "factor_four_dwell_time": "theorem plus explicit 1/2 reserve policy",
        "dynamic_error_unrolling": "exact scalar recursion identity",
        "fallback_kernel_contraction": "exact for linear K_safe and anchor in ker(K_safe)"
    },
    "parameters": {
        "pers_q": pers_q, "tau_p": tau_p, "margin": margin,
        "v_max": v_max, "T_mix": T_mix, "reserve_fraction": reserve_fraction,
        "alpha": alpha, "dt": dt
    },
    "results": {
        "dt_stability_full_margin": dt_stability,
        "dt_safe_reserved": dt_safe,
        "v_star_reserved": v_star,
        "nominal_gate_Tmix_lt_dtsafe": nominal_gate,
        "dynamic_unroll_residual": unroll_residual,
        "fallback_identity_residual": fallback_identity_residual,
        "fallback_initial_kernel_residual": float(residual[0]),
        "fallback_final_kernel_residual": float(residual[-1])
    }
}
canonical = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()
payload["sha256"] = hashlib.sha256(canonical).hexdigest()
CERT.write_text(json.dumps(payload, indent=2), encoding="utf-8")

# ---------------------------------------------------------------------
# V. Proof plate
# ---------------------------------------------------------------------
plt.rcParams.update({
    "font.family": "DejaVu Sans",
    "mathtext.fontset": "dejavusans",
})

fig = plt.figure(figsize=(16, 20), dpi=180)
ax = fig.add_axes([0, 0, 1, 1])
ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
ax.axis("off")
fig.patch.set_facecolor("#07111f")
ax.set_facecolor("#07111f")

gold = "#d7b45a"
blue = "#79b8ff"
green = "#76d39b"
white = "#f4f7fb"
muted = "#aebbd0"
panel = "#0d1b2d"
line = "#27435f"
violet = "#b69cff"

def box(x, y, w, h, title, body, accent=blue, body_size=15):
    ax.add_patch(FancyBboxPatch(
        (x, y), w, h,
        boxstyle="round,pad=0.008,rounding_size=0.012",
        linewidth=1.5, edgecolor=accent, facecolor=panel
    ))
    ax.text(x+0.018, y+h-0.035, title, fontsize=19, fontweight="bold",
            color=accent, va="top")
    ax.text(x+0.018, y+h-0.072, body, fontsize=body_size, color=white,
            va="top", linespacing=1.45)

ax.text(0.05, 0.966, "TOPOLOGICAL SWARM CONTROL", fontsize=33,
        fontweight="bold", color=gold, va="top")
ax.text(0.05, 0.932, "Deterministic Hodge–de Rham Safety Architecture",
        fontsize=22, color=white, va="top")
ax.text(0.05, 0.905,
        "Machine-checked deductions • persistence gate • dynamic mixing envelope • invariant fallback",
        fontsize=14, color=muted, va="top")
ax.plot([0.05, 0.95], [0.888, 0.888], color=gold, lw=2)

body1 = (
r"Assume $\max_i\|x_i(t+h)-x_i(t)\|\leq v_{\max}|h|$." "\n"
r"Persistence stability gives $d_B(D_t,D_{t+h})\leq v_{\max}|h|$." "\n"
r"Because persistence is death minus birth:" "\n"
r"$|\mathrm{pers}_q(t+h)-\mathrm{pers}_q(t)|\leq 2v_{\max}|h|$." "\n\n"
r"Full-margin theorem:  $\Delta t\leq(\mathrm{pers}_q-\tau_p)/(2v_{\max})$." "\n"
r"Half-margin reserve policy:  ${\Delta t_{\rm safe}=(\mathrm{pers}_q-\tau_p)/(4v_{\max})}$."
)
box(0.05, 0.676, 0.90, 0.185, "I. DETERMINISTIC PERSISTENCE GATE", body1, blue, 15)

body2 = (
r"Complete one mixing horizon before the reserved" "\n"
r"persistence margin expires:" "\n"
r"$T_{\rm mix}<\Delta t_{\rm safe}$." "\n\n"
r"Solving for speed:" "\n"
r"${v_*=(\mathrm{pers}_q-\tau_p)/(4T_{\rm mix})}$." "\n\n"
f"Witness: margin={margin:.3f},  "
f"$\\Delta t_{{safe}}$={dt_safe:.4f}" "\n"
f"$v_*$={v_star:.4f},  gate={'PASS' if nominal_gate else 'FAIL'}."
)
box(0.05, 0.493, 0.44, 0.155, "II. CERTIFIED SPEED / MIXING CONDITION", body2, green, 10.8)

body3 = (
r"Let $E_{k+1}\leq a_kE_k+b_k$," "\n"
r"$a_k=\rho^{\Delta t/T_{\rm mix}[k]}$," "\n"
r"$b_k=\gamma\,\delta T[k]\,\|Wv[k]\|$." "\n\n"
r"Repeated substitution gives" "\n"
r"$E_M\leq(\prod a_k)E_0+$" "\n"
r"$\sum_j b_j\prod_{m>j}a_m$." "\n\n"
f"Machine residual: {unroll_residual:.2e}."
)
box(0.51, 0.493, 0.44, 0.155, "III. TIME-VARYING ERROR ENVELOPE", body3, violet, 10.8)

body4 = (
r"On violation, set $s=(k-k_0)\Delta t$ and" "\n"
r"$v_{\rm safe}(s)=e^{-\alpha s}v_0+(1-e^{-\alpha s})v_{\rm anchor}$," "\n"
r"with $v_{\rm anchor}\in\ker K_{\rm safe}$." "\n\n"
r"Then exactly" "\n"
r"$K_{\rm safe}v_{\rm safe}(s)=e^{-\alpha s}K_{\rm safe}v_0$," "\n"
r"so $\|K_{\rm safe}v_{\rm safe}(s)\|=e^{-\alpha s}\|K_{\rm safe}v_0\|\to0$." "\n\n"
f"Machine residual: {fallback_identity_residual:.2e}."
)
box(0.05, 0.286, 0.90, 0.175, "IV. FAULT-TOLERANT KERNEL CONTRACTION", body4, gold, 15)

# Bottom certificate strip
ax.add_patch(FancyBboxPatch(
    (0.05, 0.075), 0.90, 0.175,
    boxstyle="round,pad=0.01,rounding_size=0.012",
    linewidth=1.5, edgecolor=line, facecolor="#091625"
))
ax.text(0.07, 0.226, "LOGICAL DEDUCTIONS", color=blue, fontsize=18,
        fontweight="bold", va="top")
deductions = [
    "1. Randomized motion trials are unnecessary once a uniform vertex-speed bound is certified.",
    "2. The factor 4 is not forced by stability alone; it encodes an explicit 50% persistence-margin reserve.",
    "3. The dynamic error formula is the exact unrolling of a nonautonomous affine contraction.",
    "4. The fallback need not begin in the safe kernel: its unsafe component decays exponentially.",
    "5. If the pre-fault state already lies in ker(K_safe), the entire fallback trajectory remains in the kernel.",
    "6. The construction is classical operator theory; no quantum simulation is required for these guarantees."
]
yy = 0.196
for d in deductions:
    ax.text(0.075, yy, d, fontsize=12.5, color=white, va="top")
    yy -= 0.0215

ax.text(0.07, 0.088,
        f"SHA-256  {payload['sha256']}",
        fontsize=8.5, color=muted, family="monospace", va="bottom")
ax.text(0.93, 0.088, "E0 analytic • E1 numerical reconstruction",
        fontsize=9.5, color=green, ha="right", va="bottom")

fig.savefig(PNG, dpi=180, facecolor=fig.get_facecolor(), bbox_inches="tight")
print(PNG)
print(CERT)