enhance: PRIME live evolution, Lyapunov, bifurcation diagram, phase classifier, 4-tab legendary UI

app.py

@@ -1,15 +1,17 @@
 import os
-import torch # type: ignore
-import gradio as gr # type: ignore
-import torch.nn as nn # type: ignore
-import torch.nn.functional as F # type: ignore
-import matplotlib.pyplot as plt # type: ignore
-import numpy as np # type: ignore
+import torch
+import gradio as gr
+import torch.nn as nn
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+import numpy as np
 import hashlib
-from transformers import AutoTokenizer # type: ignore
+from transformers import AutoTokenizer
 import spaces
 
-# ── Architecture ──────────────────────────────────────────────────────────────
+# ══════════════════════════════════════════════════════════════════════════════
+# ARCHITECTURE
+# ══════════════════════════════════════════════════════════════════════════════
 
 class ZkaediTransformerBlock(nn.Module):
     def __init__(self, d_model: int, n_heads: int, dropout: float, ffn_mult: int = 4):
@@ -37,8 +39,7 @@ class ZkaediTransformerBlock(nn.Module):
         q, k, v = [t.view(B, T, self.n_heads, self.d_head).transpose(1, 2) for t in (q, k, v)]
         attn_logits = (q @ k.transpose(-2, -1)) * self.scale
         attn_logits = attn_logits.masked_fill(causal_mask[:T, :T], float('-inf'))
-        # FIX #3 — h_bias shape: (B, n_heads, 1, 1) for per-head modulation
-        attn_logits = attn_logits + h_bias
+        attn_logits = attn_logits + h_bias  # (B, n_heads, 1, 1)
         attn_weights = self.attn_dropout(F.softmax(attn_logits, dim=-1))
         attn_out = (attn_weights @ v).transpose(1, 2).contiguous().view(B, T, C)
         x = residual + self.proj(attn_out)
@@ -51,6 +52,7 @@ class ZkaediAttentionCore(nn.Module):
                  n_layers: int = 2, dropout: float = 0.1, max_seq_len: int = 128):
         super().__init__()
         self.n_heads = n_heads
+        self.d_model = d_model
         self.embedding = nn.Embedding(vocab_size, d_model)
         self.pos_embedding = nn.Embedding(max_seq_len, d_model)
         self.drop = nn.Dropout(dropout)
@@ -60,7 +62,6 @@ class ZkaediAttentionCore(nn.Module):
         self.norm_final = nn.LayerNorm(d_model)
         self.lm_head = nn.Linear(d_model, vocab_size, bias=False)
         self.lm_head.weight = self.embedding.weight
-        # FIX #3 — binary chaos classification head on [CLS] (pos 0)
         self.chaos_head = nn.Linear(d_model, 1)
         causal = torch.triu(torch.ones(max_seq_len, max_seq_len, dtype=torch.bool), diagonal=1)
         self.register_buffer('causal_mask', causal, persistent=False)
@@ -73,12 +74,54 @@ class ZkaediAttentionCore(nn.Module):
             x = block(x, h_bias, self.causal_mask)
         x_final = self.norm_final(x)
         logits = self.lm_head(x_final)
-        # Chaos score from first token (proxy for [CLS])
-        chaos_score = torch.sigmoid(self.chaos_head(x_final[:, 0, :])).squeeze(-1)  # (B,)
+        chaos_score = torch.sigmoid(self.chaos_head(x_final[:, 0, :])).squeeze(-1)
         return logits, chaos_score
 
 
-# ── Inference Globals ──────────────────────────────────────────────────────────
+# ══════════════════════════════════════════════════════════════════════════════
+# ZKAEDI PRIME MATHEMATICS
+# ══════════════════════════════════════════════════════════════════════════════
+
+def run_prime_evolution(H_0_val: float, eta: float, gamma: float,
+                         beta: float, sigma: float, steps: int = 100) -> np.ndarray:
+    """H_t = H_0 + η·H_{t-1}·σ(γ·H_{t-1}) + σ·N(0, 1+β|H_{t-1}|)"""
+    H = H_0_val
+    traj = [H]
+    for _ in range(steps):
+        sig = 1.0 / (1.0 + np.exp(-gamma * float(np.clip(H, -50, 50))))
+        noise = np.random.normal(0.0, 1.0 + beta * abs(H))
+        H = H_0_val + eta * H * sig + sigma * noise
+        H = float(np.tanh(H / 12.0) * 12.0)
+        traj.append(H)
+    return np.array(traj)
+
+
+def compute_lyapunov(traj: np.ndarray, H_0_val: float,
+                      eta: float, gamma: float) -> float:
+    """λ = (1/N) Σ log|dF/dH|  where  dF/dH = η·σ·(1 + γ·H·(1−σ))"""
+    lyap, count = 0.0, 0
+    for H in traj[:-1]:
+        sig = 1.0 / (1.0 + np.exp(-gamma * float(np.clip(H, -50, 50))))
+        deriv = abs(eta * sig * (1.0 + gamma * H * (1.0 - sig)))
+        if deriv > 1e-14:
+            lyap += np.log(deriv)
+            count += 1
+    return lyap / count if count > 0 else -999.0
+
+
+def classify_phase(lyapunov: float, traj: np.ndarray) -> tuple:
+    tail_var = float(np.var(traj[-50:] if len(traj) >= 50 else traj))
+    if lyapunov > 0.50:   return "⚡ LEGEND",        "#ff00ff"
+    elif lyapunov > 0.05: return "🔥 CHAOTIC",        "#ff3333"
+    elif lyapunov > -0.05:return "🌀 BIFURCATING",    "#ff8800"
+    elif lyapunov > -0.25:return "〰️  WANDERING",     "#ffff00"
+    elif tail_var < 0.02: return "🎯 CONVERGING",     "#00ff88"
+    else:                 return "🔷 INITIALIZING",   "#00ccff"
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# CHECKPOINT LOADING
+# ══════════════════════════════════════════════════════════════════════════════
 
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 tokenizer = AutoTokenizer.from_pretrained("microsoft/codebert-base")
@@ -86,287 +129,534 @@ if tokenizer.pad_token is None:
     tokenizer.add_special_tokens({'pad_token': '[PAD]'})
 
 model = None
-H_0_bias = None  # will be set after checkpoint load
+H_0_raw_val = 0.7311
 
 ckpt_path = "prime_epoch_010.pt"
 if os.path.exists(ckpt_path):
     ckpt = torch.load(ckpt_path, map_location=device, weights_only=True)
-
-    # FIX #1 — vocab_size: prefer checkpoint-saved value, fall back to current tokenizer
     vocab_size = ckpt.get('vocab_size', len(tokenizer))
-
     model = ZkaediAttentionCore(vocab_size=vocab_size).to(device)
-
-    # Load with strict=False so new chaos_head initialises fresh rather than crashing
-    missing, unexpected = model.load_state_dict(ckpt['model_state_dict'], strict=False)
+    missing, _ = model.load_state_dict(ckpt['model_state_dict'], strict=False)
     if missing:
-        print(f"ℹ️  New keys initialised fresh: {missing}")
-    if unexpected:
-        print(f"⚠️  Unexpected keys ignored: {unexpected}")
-
+        print(f"ℹ️  Fresh init: {missing}")
     model.eval()
-
     hs = ckpt['hamiltonian_state']
     H_0_raw = hs['H_0'].to(device)
-
-    # FIX #2 — H_0 shape safety: reduce to scalar regardless of original shape
-    if H_0_raw.numel() > 1:
-        H_0_scalar = H_0_raw.mean()
-        print(f"ℹ️  H_0 was shape {tuple(H_0_raw.shape)}, reduced to scalar mean")
-    else:
-        H_0_scalar = H_0_raw.squeeze()
-
-    # FIX #3 — shape (1, n_heads, 1, 1) so each head gets its own bias dimension
-    # We broadcast the single scalar across all heads (preserves original behaviour
-    # while being correctly shaped for the attention kernel)
-    H_0_bias = torch.sigmoid(H_0_scalar).detach().view(1, 1, 1, 1).expand(
-        1, model.n_heads, 1, 1
-    ).contiguous()
-
-    print(f"✅ Loaded prime_epoch_010.pt  |  vocab={vocab_size}  |  H_0_bias={H_0_bias[0,0,0,0].item():.4f}")
+    H_0_raw_val = float(H_0_raw.mean().item() if H_0_raw.numel() > 1 else H_0_raw.item())
+    print(f"✅  prime_epoch_010.pt | vocab={vocab_size} | H_0={H_0_raw_val:.4f}")
 else:
-    print("❌ prime_epoch_010.pt not found — running in fallback mode")
+    print("❌  prime_epoch_010.pt not found — PRIME-only mode active")
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# PLOT HELPERS
+# ══════════════════════════════════════════════════════════════════════════════
+
+_BG, _CYAN, _MAG, _WHT, _GRID = '#050010', '#00ffff', '#ff00ff', '#e8e8ff', '#111133'
+
+
+def _neon(ax, x, y, color, lw=1.0, layers=8):
+    for i in range(layers, 0, -1):
+        ax.plot(x, y, color=color, alpha=0.016 * i, linewidth=lw * i * 1.5)
+    ax.plot(x, y, color=color, linewidth=lw, alpha=0.95)
+
+
+def _style(ax, title='', tc=_CYAN, xl='', yl='', ylc=_CYAN):
+    ax.set_facecolor(_BG)
+    ax.set_title(title, color=tc, fontsize=10, fontweight='bold', pad=7)
+    ax.set_xlabel(xl, color='#556677', fontsize=8)
+    ax.set_ylabel(yl, color=ylc, fontsize=8)
+    ax.tick_params(colors='#445566', labelsize=7)
+    for sp in ax.spines.values(): sp.set_color('#222244')
+    ax.grid(color=_GRID, alpha=0.55, linewidth=0.5)
+
+
+def plot_energy_evolution(traj, lam, phase, pc):
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8, 6), facecolor=_BG)
+    fig.subplots_adjust(hspace=0.5, top=0.93, bottom=0.09)
+    steps = np.arange(len(traj))
+    _neon(ax1, steps, traj, _CYAN, lw=1.2, layers=10)
+    ax1.fill_between(steps, traj, alpha=0.06, color=_CYAN)
+    ax1.axhline(0, color=_WHT, alpha=0.12, lw=0.6, ls='--')
+    _style(ax1, title=f"PRIME  H_t   λ={lam:.5f}   {phase}", tc=pc, xl="t", yl="H_t")
+    dH = np.diff(traj)
+    _neon(ax2, steps[1:], dH, _MAG, lw=1.0, layers=8)
+    ax2.fill_between(steps[1:], dH, alpha=0.05, color=_MAG)
+    ax2.axhline(0, color=_WHT, alpha=0.12, lw=0.6, ls='--')
+    _style(ax2, title="Velocity  dH/dt", tc=_MAG, xl="t", yl="dH/dt", ylc=_MAG)
+    fig.patch.set_facecolor(_BG)
+    return fig
+
+
+def plot_bifurcation(H_0_val, gamma, beta, sigma_noise):
+    fig, ax = plt.subplots(figsize=(9, 5), facecolor=_BG)
+    ax.set_facecolor(_BG)
+    eta_vals = np.linspace(0.01, 0.97, 350)
+    all_eta, all_h = [], []
+    for eta in eta_vals:
+        H = H_0_val
+        for _ in range(180):
+            sig = 1.0 / (1.0 + np.exp(-gamma * float(np.clip(H, -50, 50))))
+            H = H_0_val + eta * H * sig
+            H = float(np.tanh(H / 12.0) * 12.0)
+        for _ in range(80):
+            sig = 1.0 / (1.0 + np.exp(-gamma * float(np.clip(H, -50, 50))))
+            H = H_0_val + eta * H * sig + sigma_noise * np.random.normal(0, 1 + beta * abs(H))
+            H = float(np.tanh(H / 12.0) * 12.0)
+            all_eta.append(eta); all_h.append(H)
+    ax.scatter(all_eta, all_h, c=_CYAN, s=0.25, alpha=0.4, linewidths=0)
+    y_range = (max(all_h) - min(all_h)) if all_h else 2.0
+    ax.axvline(x=0.70, color=_MAG, alpha=0.35, lw=0.9, ls='--')
+    ax.text(0.715, min(all_h) + y_range * 0.88 if all_h else 1,
+            'chaos\nonset', color=_MAG, fontsize=7, alpha=0.75)
+    _style(ax, title="PRIME Bifurcation  H*(η)  —  Period-Doubling & Chaos Onset",
+           xl="η  (feedback coupling)", yl="H*  (attractor)")
+    fig.patch.set_facecolor(_BG)
+    fig.tight_layout()
+    return fig
+
+
+def plot_phase_portrait_3d(h_peak, time_step, mse_error, dh_variance, is_chaos):
+    fig = plt.figure(figsize=(7, 5), facecolor=_BG)
+    ax = fig.add_subplot(111, projection='3d')
+    ax.set_facecolor(_BG)
+    for p in [ax.xaxis, ax.yaxis, ax.zaxis]:
+        p.set_pane_color((0, 0, 0, 0))
+    ax.grid(color=_GRID, alpha=0.22)
+    t_vals = np.linspace(0, time_step + 10, 600)
+    H_vals  = (h_peak * 0.5) * np.sin(t_vals * 0.8 + dh_variance) + mse_error * 5.0 * np.cos(t_vals * 2.1)
+    dH_vals = np.gradient(H_vals, t_vals)
+    gc = '#ff0044' if is_chaos else _MAG
+    for g in range(1, 10):
+        ax.plot3D(H_vals, dH_vals, t_vals, color=gc, alpha=0.02, linewidth=g * 2.0)
+    ax.plot3D(H_vals, dH_vals, t_vals, color=_WHT, alpha=0.8, linewidth=0.7)
+    ax.scatter3D(H_vals, dH_vals, t_vals, c=t_vals, cmap='cool', s=6, alpha=0.6, zorder=3)
+    n, sc = len(H_vals), max(mse_error * 0.25, 0.04)
+    ax.scatter3D(H_vals + np.random.normal(0, sc, n),
+                 dH_vals + np.random.normal(0, sc, n),
+                 t_vals + np.random.normal(0, sc, n),
+                 color=_CYAN, s=1.2, alpha=0.25, zorder=2)
+    if is_chaos:
+        ax.scatter3D(H_vals[-1], dH_vals[-1], t_vals[-1],
+                     color='#ff0000', s=200, marker='X', edgecolors=_WHT, zorder=5)
+        ax.set_title(f"CHAOS  H={h_peak:.2f}", color='#ff2244', fontsize=11, fontweight='bold')
+    else:
+        ax.scatter3D(H_vals[-1], dH_vals[-1], t_vals[-1],
+                     color=_CYAN, s=140, marker='o', edgecolors=_WHT, zorder=5)
+        ax.set_title("H ↔ dH/dt ↔ t", color=_CYAN, fontsize=10)
+    ax.set_xlabel("H",     color=_MAG,    fontsize=8)
+    ax.set_ylabel("dH/dt", color=_CYAN,   fontsize=8)
+    ax.set_zlabel("t",     color='#aaaacc', fontsize=8)
+    ax.tick_params(colors='#444466', labelsize=7)
+    fig.patch.set_facecolor(_BG)
+    return fig
 
 
-# ── Inference ─────────────────────────────────────────────────────────────────
+# ══════════════════════════════════════════════════════════════════════════════
+# GRADIO FUNCTIONS
+# ══════════════════════════════════════════════════════════════════════════════
 
 @spaces.GPU
-def predict_anomaly(time_step, dh_variance, mse_error):
-    if model is None or H_0_bias is None:
-        return (
-            "❌ Missing checkpoint `prime_epoch_010.pt`. Drop it into the Space directory!",
-            0.0, "UNKNOWN", None, None, "N/A", []
-        )
-
-    instruction = "Analyze the quantum telemetry inputs and predict the Hamiltonian chaos bounds."
-    input_str = f"t: {time_step:.2f}, dH: {dh_variance:.4f}, mse: {mse_error:.4f}"
-    text = f"Instruction: {instruction} | Context: {input_str} | Target: "
-
-    encoded = tokenizer(text, return_tensors='pt', max_length=128, truncation=True).to(device)
-    input_ids = encoded['input_ids']
-    B = input_ids.shape[0]
-
+def predict_anomaly(time_step, dh_variance, mse_error,
+                    eta, gamma, beta, sigma, prime_steps):
+    if model is None:
+        ef = plt.figure(facecolor=_BG)
+        plt.text(0.5, 0.5, '❌  No checkpoint', ha='center', va='center',
+                 color=_CYAN, fontsize=14, transform=plt.gca().transAxes)
+        plt.close()
+        return ("❌  Missing prime_epoch_010.pt", 0.0, "UNKNOWN",
+                ef, ef, -999.0, "UNKNOWN", None, "N/A", [])
+
+    # 1. Run PRIME evolution
+    traj = run_prime_evolution(H_0_raw_val, float(eta), float(gamma),
+                                float(beta), float(sigma), int(prime_steps))
+    lam  = compute_lyapunov(traj, H_0_raw_val, float(eta), float(gamma))
+    phase, pc = classify_phase(lam, traj)
+    H_evolved = float(traj[-1])
+
+    # 2. Evolved attention bias → (B, n_heads, 1, 1)
+    hv = torch.tensor(float(np.tanh(H_evolved / 5.0)), dtype=torch.float32, device=device)
+    h_bias = torch.sigmoid(hv).view(1,1,1,1).expand(1, model.n_heads, 1,1).contiguous()
+
+    # 3. Inference
+    text = (f"Instruction: Analyze quantum telemetry and predict Hamiltonian chaos bounds. "
+            f"| Context: t:{time_step:.2f} dH:{dh_variance:.4f} mse:{mse_error:.4f} "
+            f"Ht:{H_evolved:.4f} lambda:{lam:.4f} | Target: ")
+    enc = tokenizer(text, return_tensors='pt', max_length=128, truncation=True).to(device)
     with torch.no_grad():
-        # FIX #4 — expand bias to actual batch size at inference time
-        val_attn_bias = H_0_bias.expand(B, -1, -1, -1)
-        logits, chaos_score = model(input_ids, val_attn_bias)
-        prediction_ids = torch.argmax(logits, dim=-1)
-
-    output_text = tokenizer.decode(prediction_ids[0], skip_special_tokens=True)
-
-    # FIX #3 — use learned chaos_score from classification head as primary signal
-    # heuristic fallback: mse > 2.0 still acts as hard override
-    model_predicts_chaos = chaos_score.item() > 0.5
-    physics_override = mse_error > 2.0
-    is_chaos = model_predicts_chaos or physics_override
+        logits, chaos_score = model(enc['input_ids'], h_bias)
+        pred_ids = torch.argmax(logits, dim=-1)
+    output_text = tokenizer.decode(pred_ids[0], skip_special_tokens=True)
 
+    # 4. Threat classification
+    is_chaos = (chaos_score.item() > 0.5) or (mse_error > 2.0) or (lam > 0.05)
     if is_chaos:
         warning = "🚨 CRITICAL CHAOS ANOMALY DETECTED"
-        h_peak = 428.99 + (mse_error * 10)
+        h_peak  = 428.99 + mse_error * 10.0 + abs(H_evolved * 2.0)
     else:
         warning = "✅ SYSTEM STABLE"
-        h_peak = 1.0 + dh_variance
+        h_peak  = 1.0 + abs(dh_variance) + abs(H_evolved * 0.5)
 
-    # ── 3D Phase Portrait ──────────────────────────────────────────────────────
-    fig = plt.figure(figsize=(7, 5), facecolor='#0b0514')
-    ax = fig.add_subplot(111, projection='3d')
-    ax.set_facecolor('#0b0514')
-    ax.xaxis.set_pane_color((0.0, 0.0, 0.0, 0.0))
-    ax.yaxis.set_pane_color((0.0, 0.0, 0.0, 0.0))
-    ax.zaxis.set_pane_color((0.0, 0.0, 0.0, 0.0))
-    ax.grid(color='#ffffff', alpha=0.08)
-
-    t_vals = np.linspace(0, time_step + 10, 500)
-    H_vals = (h_peak * 0.5) * np.sin(t_vals * 0.8 + dh_variance) + (mse_error * 5.0 * np.cos(t_vals * 2.1))
-    dH_vals = np.gradient(H_vals, t_vals)
-
-    for glow_level in range(1, 14):
-        ax.plot3D(H_vals, dH_vals, t_vals, color='#ff00ff', alpha=0.04, linewidth=glow_level * 1.5)
-
-    ax.plot3D(H_vals, dH_vals, t_vals, color='#ffffff', alpha=0.9, linewidth=1.0)
-    ax.scatter3D(H_vals, dH_vals, t_vals, c=t_vals, cmap='plasma', s=10, alpha=0.8, zorder=3)
-
-    noise_H  = H_vals  + np.random.normal(0, max(mse_error * 0.4, 1e-6), H_vals.shape[0])
-    noise_dH = dH_vals + np.random.normal(0, max(mse_error * 0.4, 1e-6), dH_vals.shape[0])
-    noise_T  = t_vals  + np.random.normal(0, max(mse_error * 0.4, 1e-6), t_vals.shape[0])
-    ax.scatter3D(noise_H, noise_dH, noise_T, color='#00ffff', s=2, alpha=0.4, zorder=2)
+    # 5. Plots
+    fig_3d  = plot_phase_portrait_3d(h_peak, time_step, mse_error, dh_variance, is_chaos)
+    fig_en  = plot_energy_evolution(traj, lam, phase, pc)
 
+    # 6. Audio
+    sr = 44100
+    ta = np.linspace(0, 1.0, sr)
+    bf = 110.0 + h_peak * 1.5
     if is_chaos:
-        ax.scatter3D(H_vals[-1], dH_vals[-1], t_vals[-1],
-                     color='#ff0000', s=150, marker='X', edgecolors='#ffffff', zorder=5)
-        ax.set_title(f"CHAOTIC BOUNDARY REACHED: H={h_peak:.2f}", color='#ff0000', fontsize=14, fontweight='bold')
+        aud = np.sign(np.sin(2 * np.pi * bf * ta)) + np.random.uniform(-0.8, 0.8, sr)
     else:
-        ax.scatter3D(H_vals[-1], dH_vals[-1], t_vals[-1],
-                     color='#00ffff', s=100, marker='o', edgecolors='#ffffff', zorder=5)
-        ax.set_title("3D TOPOLOGY: H vs dH/dt vs t", color='#00ffff', fontsize=12)
-
-    ax.set_xlabel("Hamiltonian (H)", color='#ff00ff')
-    ax.set_ylabel("Variance (dH)",   color='#00ffff')
-    ax.set_zlabel("Time (t)",         color='#e0e0e0')
-    ax.tick_params(colors='#e0e0e0')
-
-    # ── Audio Sonification ─────────────────────────────────────────────────────
-    sample_rate = 44100
-    t_audio = np.linspace(0, 1.0, sample_rate)
-    base_freq = 110.0 + (h_peak * 1.5)
+        aud = np.sin(2*np.pi*bf*ta)*0.5 + np.sin(2*np.pi*(bf*1.5)*ta)*0.2
+    aud = np.int16(np.clip(aud, -1.0, 1.0) * 32767)
 
-    if is_chaos:
-        audio_data = np.sign(np.sin(2 * np.pi * base_freq * t_audio))
-        audio_data += np.random.uniform(-0.8, 0.8, sample_rate)
-    else:
-        audio_data = np.sin(2 * np.pi * base_freq * t_audio) * 0.5
-        audio_data += np.sin(2 * np.pi * (base_freq * 1.5) * t_audio) * 0.2
-
-    audio_data = np.int16(np.clip(audio_data, -1.0, 1.0) * 32767)
-
-    # ── Cryptographic Seed ─────────────────────────────────────────────────────
-    raw_seed_string = f"T:{time_step}|dH:{dh_variance}|MSE:{mse_error}|PEAK:{h_peak:.4f}|ZKAEDI"
-    chaos_hash = hashlib.sha256(raw_seed_string.encode('utf-8')).hexdigest()
-
-    # ── Telemetry Ledger ───────────────────────────────────────────────────────
-    new_entry = [
-        time_step, dh_variance, mse_error,
-        float(f"{h_peak:.2f}"),
-        "CHAOS" if is_chaos else "STABLE",
-        f"0x{chaos_hash[:12]}..."
-    ]
+    # 7. Hash
+    seed = f"T:{time_step}|dH:{dh_variance}|MSE:{mse_error}|Ht:{H_evolved:.4f}|λ:{lam:.6f}|ZKAEDI"
+    chash = hashlib.sha256(seed.encode()).hexdigest()
 
+    entry = [time_step, dh_variance, mse_error, round(h_peak, 2),
+             "CHAOS" if is_chaos else "STABLE", f"0x{chash[:12]}..."]
     try:
         import csv
-        log_file = "zkaedi_telemetry_ledger.csv"
-        file_exists = os.path.exists(log_file)
-        with open(log_file, 'a', newline='') as f:
-            writer = csv.writer(f)
-            if not file_exists:
-                writer.writerow(["Time (t)", "Shift (dH)", "Error (mse)",
-                                  "Peak (H)", "Classification", "On-Chain Seed"])
-            writer.writerow(new_entry)
+        lf, new = "zkaedi_telemetry_ledger.csv", not os.path.exists("zkaedi_telemetry_ledger.csv")
+        with open(lf, 'a', newline='') as f:
+            w = csv.writer(f)
+            if new: w.writerow(["t","dH","mse","H_peak","class","hash"])
+            w.writerow(entry)
     except Exception as e:
-        print(f"CSV Save Fault: {e}")
-
-    return output_text, h_peak, warning, fig, (sample_rate, audio_data), f"0x{chaos_hash}", new_entry
-
-
-# ── UI ─────────────────────────────────────────────────────────────────────────
+        print(f"CSV: {e}")
+
+    return (output_text, h_peak, warning, fig_3d, fig_en,
+            round(lam, 6), phase, (sr, aud), f"0x{chash}", entry)
+
+
+def analyze_prime_field(H_0_init, eta, gamma, beta, sigma, steps):
+    traj = run_prime_evolution(float(H_0_init), float(eta), float(gamma),
+                                float(beta), float(sigma), int(steps))
+    lam  = compute_lyapunov(traj, float(H_0_init), float(eta), float(gamma))
+    phase, pc = classify_phase(lam, traj)
+    fig = plot_energy_evolution(traj, lam, phase, pc)
+    tv = float(np.var(traj[-50:]))
+    if lam > 0.3:    att = "Strange Attractor / Chaos"
+    elif lam > -0.05:att = "Limit Cycle / Period-Doubling"
+    elif tv < 0.01:  att = "Fixed-Point Attractor"
+    else:            att = "Quasi-Periodic / Transient"
+    stats = (
+        f"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
+        f"  ZKAEDI PRIME  —  Field Statistics\n"
+        f"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
+        f"  H_0        :  {H_0_init:.4f}\n"
+        f"  η (eta)    :  {eta:.3f}\n"
+        f"  γ (gamma)  :  {gamma:.3f}\n"
+        f"  β (beta)   :  {beta:.3f}\n"
+        f"  σ (sigma)  :  {sigma:.4f}\n"
+        f"  Steps      :  {int(steps)}\n"
+        f"───────────────────────────────────────────\n"
+        f"  H_final    :  {traj[-1]:.5f}\n"
+        f"  H_mean     :  {np.mean(traj):.5f}\n"
+        f"  H_variance :  {np.var(traj):.6f}\n"
+        f"  H_max      :  {np.max(traj):.5f}\n"
+        f"  H_min      :  {np.min(traj):.5f}\n"
+        f"───────────────────────────────────────────\n"
+        f"  Lyapunov λ :  {lam:.6f}\n"
+        f"  Phase      :  {phase}\n"
+        f"  Attractor  :  {att}\n"
+        f"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    )
+    return fig, stats
+
+
+def run_bifurcation_tab(H_0_init, gamma, beta, sigma_noise):
+    return plot_bifurcation(float(H_0_init), float(gamma), float(beta), float(sigma_noise))
+
+
+def update_history(existing, new_row):
+    import pandas as pd
+    cols = ["t", "dH", "mse", "H_peak", "Classification", "Hash"]
+    if not new_row or len(new_row) == 0:
+        return existing
+    if existing is None or len(existing) == 0:
+        return pd.DataFrame([new_row], columns=cols)
+    df = pd.DataFrame(existing, columns=cols)
+    df.loc[len(df)] = new_row
+    return df
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# UI
+# ══════════════════════════════════════════════════════════════════════════════
+
+FONT_INJECT = """
+<style>
+@import url('https://fonts.googleapis.com/css2?family=Orbitron:wght@400;700;900&family=Space+Mono:wght@400;700&display=swap');
+
+/* Scanline overlay */
+.gradio-container::after {
+  content: '';
+  position: fixed;
+  inset: 0;
+  background: repeating-linear-gradient(
+    0deg, transparent, transparent 2px,
+    rgba(0,255,255,0.010) 2px, rgba(0,255,255,0.010) 4px
+  );
+  pointer-events: none;
+  z-index: 9999;
+}
 
-custom_css = """
+/* Circuit grid background */
 .gradio-container {
-    background: radial-gradient(circle at center, #1a0b2e 0%, #000000 100%) !important;
-    font-family: 'Orbitron', 'Courier New', monospace !important;
-    color: #e0e0e0 !important;
+  background:
+    linear-gradient(rgba(0,255,255,0.022) 1px, transparent 1px),
+    linear-gradient(90deg, rgba(0,255,255,0.022) 1px, transparent 1px),
+    radial-gradient(ellipse at 25% 15%, #0e003a 0%, transparent 50%),
+    radial-gradient(ellipse at 80% 85%, #000a2a 0%, transparent 50%),
+    #050010 !important;
+  background-size: 64px 64px, 64px 64px, auto, auto, auto !important;
+  font-family: 'Space Mono', 'Courier New', monospace !important;
+  color: #c8c8ff !important;
+}
+
+@keyframes prime-pulse {
+  0%,100% { text-shadow: 0 0 8px #00ffff, 0 0 20px #00ffff, 0 0 40px #00aaff; }
+  50%     { text-shadow: 0 0 20px #00ffff, 0 0 55px #00ffff, 0 0 90px #0066ff; }
 }
 h1 {
-    color: #00ffff !important;
-    text-shadow: 0 0 15px #00ffff, 0 0 30px #00ffff;
-    text-align: center;
-    text-transform: uppercase;
-    letter-spacing: 4px;
-    font-size: 3rem !important;
+  font-family: 'Orbitron', monospace !important;
+  color: #00ffff !important;
+  animation: prime-pulse 3.5s ease-in-out infinite;
+  text-align: center; text-transform: uppercase;
+  letter-spacing: 6px; font-size: 2.6rem !important;
+}
+
+@keyframes mag-pulse {
+  0%,100% { text-shadow: 0 0 8px #ff00ff, 0 0 18px #ff00ff; opacity:.9; }
+  50%     { text-shadow: 0 0 22px #ff00ff, 0 0 44px #cc00cc; opacity:1; }
 }
 .subtitle {
-    color: #ff00ff !important;
-    text-shadow: 0 0 10px #ff00ff;
-    text-align: center;
-    font-size: 1.2rem;
-    margin-bottom: 30px;
+  font-family: 'Orbitron', monospace !important;
+  color: #ff00ff !important;
+  animation: mag-pulse 4s ease-in-out infinite;
+  text-align: center; font-size: .8rem;
+  letter-spacing: 5px; margin-bottom: 22px;
+}
+
+.form, .panel, .block {
+  background: rgba(5,0,20,.88) !important;
+  border: 1px solid rgba(0,255,255,.17) !important;
+  box-shadow: 0 0 20px rgba(0,255,255,.06), inset 0 0 35px rgba(0,0,0,.5) !important;
+  border-radius: 8px !important;
+}
+
+label, .label-wrap span {
+  font-family: 'Orbitron', monospace !important;
+  color: #6688bb !important; font-size: .70rem !important;
+  letter-spacing: 1.5px !important; text-transform: uppercase !important;
 }
-.form { box-shadow: 0 0 15px rgba(255, 0, 255, 0.2) !important; border: 1px solid #ff00ff !important; background: #0b0514 !important; }
-button.primary {
-    background: linear-gradient(90deg, #ff00ff 0%, #00ffff 100%) !important;
-    border: none !important;
-    color: black !important;
-    font-weight: 900 !important;
-    text-transform: uppercase;
-    box-shadow: 0 0 15px #ff00ff !important;
-    transition: all 0.2s ease-in-out;
+
+.prose h3 {
+  font-family: 'Orbitron', monospace !important;
+  color: #00ffff !important; letter-spacing: 2px;
+}
+.prose p, .prose li {
+  font-family: 'Space Mono', monospace !important;
+  color: #7788aa !important; font-size: .78rem !important;
+  line-height: 1.75 !important;
+}
+code {
+  color: #ff00ff !important;
+  background: rgba(255,0,255,.09) !important;
+  border-radius: 3px !important; padding: 1px 4px !important;
+}
+
+@keyframes btn-glow {
+  0%,100% { box-shadow: 0 0 14px #ff00ff, 0 0 28px rgba(255,0,255,.3); }
+  50%     { box-shadow: 0 0 28px #00ffff, 0 0 56px rgba(0,255,255,.3); }
 }
-button.primary:hover {
-    transform: scale(1.02);
-    box-shadow: 0 0 30px #00ffff !important;
+button.primary, button[variant="primary"] {
+  background: linear-gradient(135deg, #ff00ff 0%, #4400ff 50%, #00ffff 100%) !important;
+  border: none !important; color: #000 !important;
+  font-family: 'Orbitron', monospace !important; font-weight: 900 !important;
+  font-size: .82rem !important; letter-spacing: 3px !important;
+  text-transform: uppercase !important;
+  animation: btn-glow 2.5s ease-in-out infinite !important;
+  transition: transform .2s cubic-bezier(.34,1.56,.64,1) !important;
+  border-radius: 6px !important;
 }
-.stat-box {
-    border-left: 4px solid #00ffff;
-    padding: 10px;
-    background: rgba(0, 255, 255, 0.05);
-    margin: 10px 0;
+button.primary:hover, button[variant="primary"]:hover {
+  transform: scale(1.04) translateY(-2px) !important;
 }
+
+textarea, input[type="text"], input[type="number"] {
+  background: rgba(0,4,22,.92) !important;
+  border: 1px solid rgba(0,255,255,.22) !important;
+  color: #00ffff !important;
+  font-family: 'Space Mono', monospace !important;
+  border-radius: 4px !important;
+}
+
+.tab-nav button {
+  font-family: 'Orbitron', monospace !important;
+  color: #445566 !important; font-size: .68rem !important;
+  letter-spacing: 1.5px !important; text-transform: uppercase !important;
+  border-bottom: 2px solid transparent !important;
+  transition: all .2s ease !important;
+}
+.tab-nav button.selected {
+  color: #00ffff !important;
+  border-bottom: 2px solid #00ffff !important;
+  text-shadow: 0 0 8px #00ffff !important;
+}
+
+input[type="range"]::-webkit-slider-thumb {
+  background: #00ffff !important; box-shadow: 0 0 8px #00ffff !important;
+}
+input[type="range"]::-webkit-slider-runnable-track {
+  background: linear-gradient(90deg,#00ffff,#ff00ff) !important; height:3px !important;
+}
+
+.number input { color: #ff00ff !important; font-size: 1.25rem !important; font-weight: 700 !important; }
+</style>
 """
 
-with gr.Blocks(css=custom_css, title="ZKAEDI TENSOR: Prime") as iface:
+with gr.Blocks(title="ZKAEDI TENSOR: Prime") as iface:
+
+    gr.HTML(FONT_INJECT)
     gr.Markdown("# 🌌 ZKAEDI TENSOR 🌌")
-    gr.Markdown("<div class='subtitle'>L E G E N D A R Y &nbsp; P R I M E &nbsp; T H R E A T &nbsp; I S O L A T I O N</div>")
+    gr.HTML("<div class='subtitle'>L E G E N D A R Y &nbsp;·&nbsp; P R I M E &nbsp;·&nbsp; H A M I L T O N I A N &nbsp;·&nbsp; T H R E A T &nbsp;·&nbsp; I S O L A T I O N</div>")
 
     with gr.Tabs():
-        with gr.TabItem("⚙️ PRIMARY TENSOR INFERENCE"):
+
+        # ── TAB 1  —  INFERENCE ────────────────────────────────────────────────
+        with gr.TabItem("⚙️  INFERENCE"):
             with gr.Row():
                 with gr.Column(scale=1):
                     gr.Markdown("### 📡 QUANTUM INPUT MATRIX")
-                    gr.Markdown("Manipulate the bare-metal evolutionary vectors below to stimulate the Hamiltonian prediction array.")
-
-                    t_input  = gr.Slider(0.0, 100.0, value=12.5, step=0.1,  label="Chronological T-Vector (t)")
-                    dh_input = gr.Slider(-10.0, 10.0, value=0.1, step=0.01, label="Hamiltonian Shift (dH)")
-                    mse_input = gr.Slider(0.0, 10.0, value=0.5, step=0.01,  label="Mean Squared Error Variance (mse)")
-
-                    gr.Markdown("#### PRE-COMPUTED VECTORS:")
+                    gr.Markdown("Raw telemetry vectors feed the Hamiltonian tensor array.")
+                    t_in  = gr.Slider(0.0,  100.0, value=12.5, step=0.1,  label="T-Vector (t)")
+                    dh_in = gr.Slider(-10.0, 10.0, value=0.1,  step=0.01, label="Hamiltonian Shift (dH)")
+                    ms_in = gr.Slider(0.0,   10.0, value=0.5,  step=0.01, label="MSE Variance (mse)")
+
+                    gr.Markdown("### 🔱 PRIME EVOLUTION PARAMETERS")
+                    eta_s   = gr.Slider(0.01, 0.99, value=0.40, step=0.01,  label="η  — Feedback Coupling")
+                    gam_s   = gr.Slider(0.01, 2.0,  value=0.30, step=0.01,  label="γ  — Sigmoid Sharpness")
+                    bet_s   = gr.Slider(0.0,  1.0,  value=0.10, step=0.01,  label="β  — Noise Amplitude Scale")
+                    sig_s   = gr.Slider(0.0,  0.5,  value=0.05, step=0.005, label="σ  — Base Noise")
+                    stp_s   = gr.Slider(10,   500,  value=100,  step=10,    label="PRIME Steps (pre-inference)")
+
+                    gr.Markdown("#### ⚡ PRE-COMPUTED VECTORS")
                     gr.Examples(
                         examples=[
-                            [12.5,  0.1,  0.5],
-                            [45.0,  5.0,  1.2],
-                            [89.0, -8.2,  4.2],
-                            [90.0, 10.0,  9.9],
+                            [12.5,  0.10, 0.5, 0.40, 0.30, 0.10, 0.05, 100],
+                            [45.0,  5.00, 1.2, 0.65, 0.50, 0.20, 0.10, 150],
+                            [89.0, -8.20, 4.2, 0.85, 0.80, 0.40, 0.20, 200],
+                            [90.0, 10.00, 9.9, 0.95, 1.20, 0.60, 0.30, 300],
                         ],
-                        inputs=[t_input, dh_input, mse_input],
+                        inputs=[t_in, dh_in, ms_in, eta_s, gam_s, bet_s, sig_s, stp_s],
                         label="Inject Saved Telemetry"
                     )
-
-                    btn = gr.Button("⚡ INITIATE TRANSCENDENCE ⚡", variant="primary")
+                    btn_inf = gr.Button("⚡ INITIATE TRANSCENDENCE ⚡", variant="primary")
 
                 with gr.Column(scale=1):
                     gr.Markdown("### 🧠 SENSORY DECODER OUTPUT")
-                    warning_out = gr.Textbox(label="Threat Status", lines=2)
-
+                    warn_o  = gr.Textbox(label="Threat Status", lines=2)
+                    phase_o = gr.Textbox(label="PRIME Phase State", lines=1)
                     with gr.Row():
-                        with gr.Column(scale=1):
-                            h_out     = gr.Number(label="Predicted Chaos Boundary (Peak H)")
-                            hash_out  = gr.Textbox(label="🔏 Web3 Seed Hash (Quantum Bonus)", lines=1)
-                            raw_out   = gr.Textbox(label="CodeBERT Tensor Tokens", lines=2)
-                            audio_out = gr.Audio(label="Mathematical Resonance (Sonified)", type="numpy")
-                        with gr.Column(scale=2):
-                            plot_out = gr.Plot(label="Live Attractor Topology")
-
-        with gr.TabItem("📜 OPERATION LOGS"):
-            gr.Markdown("### 🗃️ TENSOR STATE HISTORY")
-            gr.Markdown("Log of all multi-dimensional queries and their resulting Hamiltonian classifications.")
-            history_data = gr.Dataframe(
-                headers=["Time (t)", "Shift (dH)", "Error (mse)", "Peak (H)", "Classification", "On-Chain Seed"],
-                datatype=["number", "number", "number", "number", "str", "str"],
+                        h_o    = gr.Number(label="Peak  H")
+                        lyap_o = gr.Number(label="Lyapunov  λ")
+                    hash_o  = gr.Textbox(label="🔏 Quantum Seed Hash", lines=1)
+                    raw_o   = gr.Textbox(label="Tensor Token Decode", lines=2)
+                    aud_o   = gr.Audio(label="Hamiltonian Resonance", type="numpy")
+
+            with gr.Row():
+                p3d_o = gr.Plot(label="3D Phase Portrait  —  H × dH/dt × t")
+                pen_o = gr.Plot(label="PRIME Field Evolution  —  H_t & Velocity")
+
+        # ── TAB 2  —  PRIME FIELD ──────────────────────────────────────────────
+        with gr.TabItem("🔱  PRIME FIELD"):
+            gr.Markdown("### 🔱 PURE PRIME FIELD DYNAMICS")
+            gr.Markdown(
+                "Run the recursive Hamiltonian in isolation — no model, no GPU. "
+                "Explore attractors, Lyapunov exponents, and phase transitions."
+            )
+            with gr.Row():
+                with gr.Column(scale=1):
+                    H0_f   = gr.Slider(-5.0, 5.0, value=round(H_0_raw_val, 3), step=0.01, label="H_0  (initial energy)")
+                    eta_f  = gr.Slider(0.01, 0.99, value=0.40, step=0.01,  label="η  — Feedback")
+                    gam_f  = gr.Slider(0.01, 3.0,  value=0.30, step=0.01,  label="γ  — Sigmoid")
+                    bet_f  = gr.Slider(0.0,  1.0,  value=0.10, step=0.01,  label="β  — Noise Scale")
+                    sig_f  = gr.Slider(0.0,  0.5,  value=0.05, step=0.005, label="σ  — Base Noise")
+                    stp_f  = gr.Slider(50,   1000, value=200,  step=50,    label="Steps")
+                    btn_fld = gr.Button("🔱 EVOLVE FIELD", variant="primary")
+                with gr.Column(scale=1):
+                    stats_o = gr.Textbox(label="PRIME Field Statistics", lines=20, max_lines=22)
+            pfld_o = gr.Plot(label="H_t Trajectory + Velocity Field")
+
+        # ── TAB 3  —  BIFURCATION ─────────────────────────────────────────────
+        with gr.TabItem("🌀  BIFURCATION"):
+            gr.Markdown("### 🌀 BIFURCATION DIAGRAM")
+            gr.Markdown(
+                "Sweep **η** from 0 → 1 and reveal the period-doubling cascade "
+                "leading to chaos. Set `σ > 0` to smear bifurcation boundaries with noise."
+            )
+            with gr.Row():
+                with gr.Column(scale=1):
+                    H0_b  = gr.Slider(-5.0, 5.0, value=round(H_0_raw_val, 3), step=0.01, label="H_0")
+                    gam_b = gr.Slider(0.01, 3.0, value=0.30, step=0.01,  label="γ  — Sigmoid")
+                    bet_b = gr.Slider(0.0,  1.0, value=0.10, step=0.01,  label="β  — Noise Scale")
+                    sig_b = gr.Slider(0.0,  0.3, value=0.00, step=0.005, label="σ  — Noise Injection")
+                    btn_bif = gr.Button("🌀 COMPUTE BIFURCATION", variant="primary")
+                    gr.Markdown("_Sweeps 350 η values × 260 iters each — runs on CPU, ~5–10s._")
+                with gr.Column(scale=2):
+                    bif_o = gr.Plot(label="Bifurcation Diagram  —  H*(η)")
+
+        # ── TAB 4  —  LOGS ────────────────────────────────────────────────────
+        with gr.TabItem("📜  LOGS"):
+            gr.Markdown("### 🗃️ TENSOR STATE LEDGER")
+            gr.Markdown("Full history of all inference queries and their Hamiltonian classifications.")
+            hist_df = gr.Dataframe(
+                headers=["t", "dH", "mse", "H_peak", "Classification", "Hash"],
+                datatype=["number","number","number","number","str","str"],
                 column_count=(6, "fixed"),
-                interactive=False
+                interactive=False,
             )
 
-    def update_history(existing, new_row):
-        import pandas as pd # type: ignore
-        cols = ["Time (t)", "Shift (dH)", "Error (mse)", "Peak (H)", "Classification", "On-Chain Seed"]
-        if existing is None or len(existing) == 0:
-            return pd.DataFrame([new_row], columns=cols)
-        df = pd.DataFrame(existing, columns=cols)
-        df.loc[len(df)] = new_row
-        return df
-
     gr.Markdown("---")
-    gr.Markdown("<div style='text-align: center; color: #555;'>Matrix Weights: <code>prime_epoch_010.pt</code> | VRAM Bound: 32GB</div>")
+    gr.HTML(
+        "<div style='text-align:center;color:#2a2a4a;font-family:Space Mono,monospace;"
+        "font-size:.68rem;letter-spacing:1.5px;padding-bottom:12px;'>"
+        "WEIGHTS: <code>prime_epoch_010.pt</code> &nbsp;·&nbsp; "
+        "TOKENIZER: <code>microsoft/codebert-base</code> &nbsp;·&nbsp; "
+        "RUNTIME: <code>ZeroGPU H100</code> &nbsp;·&nbsp; "
+        "PRIME: <code>H_t = H_0 + η·H_{t-1}·σ(γ·H_{t-1}) + σ·N(0, 1+β|H_{t-1}|)</code>"
+        "</div>"
+    )
 
-    hidden_entry = gr.State([])
+    # ── Wire-up ────────────────────────────────────────────────────────────────
+    hidden = gr.State([])
 
-    btn.click(
+    btn_inf.click(
         fn=predict_anomaly,
-        inputs=[t_input, dh_input, mse_input],
-        outputs=[raw_out, h_out, warning_out, plot_out, audio_out, hash_out, hidden_entry]
+        inputs=[t_in, dh_in, ms_in, eta_s, gam_s, bet_s, sig_s, stp_s],
+        outputs=[raw_o, h_o, warn_o, p3d_o, pen_o, lyap_o, phase_o, aud_o, hash_o, hidden]
     ).then(
         fn=update_history,
-        inputs=[history_data, hidden_entry],
-        outputs=[history_data]
+        inputs=[hist_df, hidden],
+        outputs=[hist_df]
     )
 
+    btn_fld.click(
+        fn=analyze_prime_field,
+        inputs=[H0_f, eta_f, gam_f, bet_f, sig_f, stp_f],
+        outputs=[pfld_o, stats_o]
+    )
+
+    btn_bif.click(
+        fn=run_bifurcation_tab,
+        inputs=[H0_b, gam_b, bet_b, sig_b],
+        outputs=[bif_o]
+    )
+
+
 if __name__ == "__main__":
     iface.launch(server_name="0.0.0.0", server_port=7860, share=False)