app.py

# app.py
# Unified Codex Artifact: Numba RFT Hardware-Scale Demo + PyTorch MOM Kernel + Lineage Hashing
# Author: Liam Grinstead — NexFrame AI, RFT, MOM, Codex
#
# This file combines:
# 1) A Numba-accelerated RFT simulation over hardware scales (Ψ_r, energy, ledger) with honest timing.
# 2) A PyTorch MOM collapse kernel with feedback, event histories, raster onset, and manifest sealing.
# 3) Gradio Blocks UI with two tabs, codex-ready summaries, and optional snapshot hashes.
#
# Notes:
# - GFLOPS in both paths are labeled as “estimated” unless you replace with exact op counts.
# - Timing excludes plotting and hashing.
# - Deterministic seeds are used for reproducibility.

import json
import hashlib
import tempfile
import time

import numpy as np
import gradio as gr

# --- Numba (optional import with graceful fallback for CPU-only runs) ---
try:
    import numba as nb
    NUMBA_AVAILABLE = True
except Exception:
    NUMBA_AVAILABLE = False

# --- PyTorch for MOM kernel ---
import torch
import matplotlib.pyplot as plt

# =========================================================================================
# Part A: RFT (Numba) — Hardware-scale Ψ_r simulation
# =========================================================================================

if NUMBA_AVAILABLE:
    @nb.njit(parallel=True, fastmath=True)
    def rft_simulation_numba(
        hardware_scale_input, steps_input,
        Psi_r_init, tau_eff, delta_tau_pred, epsilon_c,
        phi_loop, eta_sync, omega_n, lambda_m,
        alpha_nonlin, beta_nonlin, gamma_nonlin, delta_nonlin, epsilon_nonlin, zeta_nonlin, kappa_nonlin, mu_nonlin, n_nonlin,
        ops_per_sec_base, flops_base
    ):
        num_scales = hardware_scale_input.shape[0]
        Psi_r = np.full((num_scales, steps_input), Psi_r_init, dtype=np.float64)
        energy = np.full((num_scales, steps_input), 100.0, dtype=np.float64)
        ledger_size = np.zeros((num_scales, steps_input), dtype=np.int64)

        prod = omega_n * lambda_m
        if prod <= 0.0:
            prod = 1e-12
        log_term = np.log(prod)

        for scale_idx in nb.prange(num_scales):
            scale = hardware_scale_input[scale_idx]
            for step in range(1, steps_input):
                scale_efficiency = 1 - 0.0002 * (scale - 1)
                if scale_efficiency < 0.5:
                    scale_efficiency = 0.5

                current_psi_r = Psi_r[scale_idx, step - 1]

                ops_per_sec = ops_per_sec_base * scale * scale_efficiency * (1 + 0.05 * current_psi_r)

                phase_entropy = current_psi_r * epsilon_c

                # Nonlinear term (unused in state update but computed for conceptual completeness)
                numerator = (current_psi_r ** alpha_nonlin) * (tau_eff ** beta_nonlin) * (phi_loop ** delta_nonlin) * (log_term ** zeta_nonlin)
                denominator = ((delta_tau_pred + epsilon_c) ** gamma_nonlin) * (eta_sync ** epsilon_nonlin) * (1 + mu_nonlin * (phase_entropy ** n_nonlin))
                _ = numerator / denominator  # kept as a placeholder for future coupling

                # Energy loss if the phase exceeds baseline
                energy_loss = 0.01 * (current_psi_r - Psi_r_init) if current_psi_r > Psi_r_init else 0.0
                energy_val = energy[scale_idx, step - 1] - energy_loss
                if energy_val < 0.0:
                    energy_val = 0.0
                energy[scale_idx, step] = energy_val

                # Ledger growth (synthetic, narratable)
                ledger_growth = int(scale * 5 + (step % 10))
                ledger_size[scale_idx, step] = ledger_size[scale_idx, step - 1] + ledger_growth

                # Phase update
                Psi_r[scale_idx, step] = current_psi_r + 0.0005 * energy_loss + 0.00001 * ops_per_sec / 1e6

        return Psi_r, energy, ledger_size


def run_rft_hardware_scale(
    num_scales_to_simulate: int,
    simulation_steps: int,
    psi_r_init_val: float,
    tau_eff_val: float,
    delta_tau_pred_val: float,
    epsilon_c_val: float,
    phi_loop_val: float,
    eta_sync_val: float,
    omega_n_val: float,
    lambda_m_val: float,
    alpha_exp: float,
    beta_exp: float,
    gamma_exp: float,
    delta_exp: float,
    epsilon_exp: float,
    zeta_exp: float,
    kappa_exp: float,
    mu_exp: float,
    n_exp: int,
    seed: int = 42,
    include_hash: bool = True
):
    np.random.seed(seed)
    hardware_scale = np.linspace(1, 1000, num_scales_to_simulate)
    ops_per_sec_base = 1e6
    flops_base = 2e6

    # Optional warmup to avoid JIT timing skew
    if NUMBA_AVAILABLE:
        _ = rft_simulation_numba(
            hardware_scale_input=hardware_scale[:2],
            steps_input=5,
            Psi_r_init=psi_r_init_val,
            tau_eff=tau_eff_val,
            delta_tau_pred=delta_tau_pred_val,
            epsilon_c=epsilon_c_val,
            phi_loop=phi_loop_val,
            eta_sync=eta_sync_val,
            omega_n=omega_n_val,
            lambda_m=lambda_m_val,
            alpha_nonlin=alpha_exp,
            beta_nonlin=beta_exp,
            gamma_nonlin=gamma_exp,
            delta_nonlin=delta_exp,
            epsilon_nonlin=epsilon_exp,
            zeta_nonlin=zeta_exp,
            kappa_nonlin=kappa_exp,
            mu_nonlin=mu_exp,
            n_nonlin=n_exp,
            ops_per_sec_base=ops_per_sec_base,
            flops_base=flops_base
        )

    start = time.perf_counter()
    if NUMBA_AVAILABLE:
        Psi_r_res, energy_res, ledger_res = rft_simulation_numba(
            hardware_scale_input=hardware_scale,
            steps_input=simulation_steps,
            Psi_r_init=psi_r_init_val,
            tau_eff=tau_eff_val,
            delta_tau_pred=delta_tau_pred_val,
            epsilon_c=epsilon_c_val,
            phi_loop=phi_loop_val,
            eta_sync=eta_sync_val,
            omega_n=omega_n_val,
            lambda_m=lambda_m_val,
            alpha_nonlin=alpha_exp,
            beta_nonlin=beta_exp,
            gamma_nonlin=gamma_exp,
            delta_nonlin=delta_exp,
            epsilon_nonlin=epsilon_exp,
            zeta_nonlin=zeta_exp,
            kappa_nonlin=kappa_exp,
            mu_nonlin=mu_exp,
            n_nonlin=n_exp,
            ops_per_sec_base=ops_per_sec_base,
            flops_base=flops_base
        )
    else:
        # Fallback pure NumPy implementation (slower, but keeps app functional)
        num_scales = hardware_scale.shape[0]
        Psi_r_res = np.full((num_scales, simulation_steps), psi_r_init_val, dtype=np.float64)
        energy_res = np.full((num_scales, simulation_steps), 100.0, dtype=np.float64)
        ledger_res = np.zeros((num_scales, simulation_steps), dtype=np.int64)
        prod = omega_n_val * lambda_m_val
        if prod <= 0.0:
            prod = 1e-12
        log_term = np.log(prod)
        for scale_idx in range(num_scales):
            scale = hardware_scale[scale_idx]
            for step in range(1, simulation_steps):
                scale_eff = 1 - 0.0002 * (scale - 1)
                if scale_eff < 0.5:
                    scale_eff = 0.5
                current_psi = Psi_r_res[scale_idx, step - 1]
                ops_per_sec = ops_per_sec_base * scale * scale_eff * (1 + 0.05 * current_psi)
                phase_entropy = current_psi * epsilon_c_val
                numerator = (current_psi ** alpha_exp) * (tau_eff_val ** beta_exp) * (phi_loop_val ** delta_exp) * (log_term ** zeta_exp)
                denominator = ((delta_tau_pred_val + epsilon_c_val) ** gamma_exp) * (eta_sync_val ** epsilon_exp) * (1 + mu_exp * (phase_entropy ** n_exp))
                _ = numerator / denominator
                energy_loss = 0.01 * (current_psi - psi_r_init_val) if current_psi > psi_r_init_val else 0.0
                energy_val = energy_res[scale_idx, step - 1] - energy_loss
                if energy_val < 0.0:
                    energy_val = 0.0
                energy_res[scale_idx, step] = energy_val
                ledger_growth = int(scale * 5 + (step % 10))
                ledger_res[scale_idx, step] = ledger_res[scale_idx, step - 1] + ledger_growth
                Psi_r_res[scale_idx, step] = current_psi + 0.0005 * energy_loss + 0.00001 * ops_per_sec / 1e6

    elapsed = max(time.perf_counter() - start, 1e-9)

    # Final metrics at max scale
    max_scale_idx = num_scales_to_simulate - 1
    final_step = simulation_steps - 1
    psi_r_final = float(Psi_r_res[max_scale_idx, final_step])
    energy_final = float(energy_res[max_scale_idx, final_step])
    ledger_final = int(ledger_res[max_scale_idx, final_step])

    scale = hardware_scale[max_scale_idx]
    scale_efficiency = max(1 - 0.0002 * (scale - 1), 0.5)
    ops_per_sec_final = ops_per_sec_base * scale * scale_efficiency * (1 + 0.05 * psi_r_final)
    flops_final = flops_base * scale * scale_efficiency * (1 + 0.05 * psi_r_final)
    total_estimated_flops = flops_final * simulation_steps * num_scales_to_simulate
    avg_gflops_per_sec = total_estimated_flops / (elapsed * 1e9)

    # Plot
    fig, ax = plt.subplots(figsize=(7, 4))
    ax.plot(hardware_scale, Psi_r_res[:, -1], color="#3b82f6")
    ax.set_title("Final Ψ_r vs Hardware Scale")
    ax.set_xlabel("Hardware Scale (SPUs)")
    ax.set_ylabel("Final Ψ_r")
    ax.grid(True, alpha=0.3)
    plt.tight_layout()
    _, plot_path = tempfile.mkstemp(suffix=".png")
    plt.savefig(plot_path)
    plt.close(fig)

    # Manifest + hash
    run_ipurl = None
    if include_hash:
        manifest = {
            "num_scales": int(num_scales_to_simulate),
            "steps": int(simulation_steps),
            "Psi_r_init": float(psi_r_init_val),
            "tau_eff": float(tau_eff_val),
            "delta_tau_pred": float(delta_tau_pred_val),
            "epsilon_c": float(epsilon_c_val),
            "phi_loop": float(phi_loop_val),
            "eta_sync": float(eta_sync_val),
            "omega_n": float(omega_n_val),
            "lambda_m": float(lambda_m_val),
            "alpha": float(alpha_exp),
            "beta": float(beta_exp),
            "gamma": float(gamma_exp),
            "delta": float(delta_exp),
            "epsilon": float(epsilon_exp),
            "zeta": float(zeta_exp),
            "kappa": float(kappa_exp),
            "mu": float(mu_exp),
            "n": int(n_exp),
            "seed": int(seed),
            "elapsed_seconds": float(elapsed),
            "avg_gflops_per_sec_est": float(avg_gflops_per_sec),
            "psi_r_final": float(psi_r_final),
            "energy_final": float(energy_final),
            "ledger_final": int(ledger_final),
            "psi_r_head": [float(x) for x in Psi_r_res[max_scale_idx, :10]]
        }
        serialized = json.dumps(manifest, sort_keys=True, separators=(",", ":")).encode("utf-8")
        run_ipurl = f"rft-numba:v1:{hashlib.sha512(serialized).hexdigest()}"

    summary = (
        f"RFT Hardware-Scale Simulation\n"
        f"- Simulation Time: {elapsed:.6f} s\n"
        f"- Max Scale: {hardware_scale[max_scale_idx]:.1f} SPUs\n"
        f"- Final Ψ_r: {psi_r_final:.6f}\n"
        f"- Final Energy (%): {energy_final:.6f}\n"
        f"- Final Ledger Size: {ledger_final}\n"
        f"- Estimated Peak Ops/sec: {ops_per_sec_final:.2e}\n"
        f"- Estimated Peak FLOPS: {flops_final:.2e}\n"
        f"- Naive Average GFLOPS/sec: {avg_gflops_per_sec:.2f}\n"
        + (f"- Run IPURL: {run_ipurl}\n" if run_ipurl else "")
    )

    return summary, plot_path


# =========================================================================================
# Part B: PyTorch MOM kernel — Collapse dynamics + histories + raster onset
# =========================================================================================

def fused_mom_update_cpu(m_root_t, A_t, Q_t, alpha_t, gamma_t, omega_t,
                         dt, eps, sigma_const, theta_global, k_shred_global,
                         event_counts_t=None, event_buffer_t=None):
    # Types
    m_root_t = m_root_t.to(torch.float32)
    A_t = A_t.to(torch.float32)
    Q_t = Q_t.to(torch.float32)
    alpha_t = alpha_t.to(torch.float32)
    gamma_t = gamma_t.to(torch.float32)
    omega_t = omega_t.to(torch.float32)

    # Expand
    alpha_exp = alpha_t.unsqueeze(0)
    gamma_exp = gamma_t.unsqueeze(0)
    omega_exp = omega_t.unsqueeze(0)
    m_root_exp = m_root_t.unsqueeze(1)

    # Dynamics
    A_dot = alpha_exp * m_root_exp - gamma_exp * A_t + sigma_const * Q_t
    f_drive = sigma_const * m_root_exp * omega_exp * A_t
    Q_dot = f_drive - Q_t

    A_t.add_(dt * A_dot)
    Q_t.add_(dt * Q_dot)

    # Shred trigger
    Xi = (omega_exp * A_t).sum(dim=1)
    Xi_norm = Xi / (m_root_t + eps)
    shred_mask = Xi_norm >= theta_global

    if torch.any(shred_mask):
        eta_values = torch.zeros_like(Xi_norm)
        eta_calc = 1.0 - torch.exp(-k_shred_global * (Xi_norm[shred_mask] - theta_global))
        eta_values[shred_mask] = torch.clamp(eta_calc, 0.0, 1.0)

        diss = 0.01 * m_root_t * eta_values
        m_post = (1.0 - eta_values) * m_root_t - diss
        m_post = torch.clamp(m_post, min=0.0)

        m_root_t[shred_mask] = m_post[shred_mask]

        shred_count = int(torch.sum(shred_mask).item())
        if event_counts_t is not None:
            if isinstance(event_counts_t, torch.Tensor):
                if event_counts_t.dtype not in (torch.int64, torch.int32):
                    event_counts_t = event_counts_t.to(torch.int64)
                event_counts_t.add_(shred_count)
            else:
                event_counts_t += shred_count

        # Optional: write indices into event buffer (pack iteration externally)
        if event_buffer_t is not None and isinstance(event_buffer_t, torch.Tensor):
            # This is a simple increment-only counter; you can replace with actual raster indexing scheme.
            pass

    return m_root_t, A_t, Q_t, event_counts_t


class MOMKernel:
    def __init__(self):
        self.kernel = fused_mom_update_cpu
        self.device = torch.device('cpu')

    def __call__(self, m_root_t, A_t, Q_t, alpha_t, gamma_t, omega_t,
                 dt, eps, sigma_const, theta_global, k_shred_global,
                 event_counts_t=None, event_buffer_t=None):
        return self.kernel(m_root_t, A_t, Q_t, alpha_t, gamma_t, omega_t,
                           dt, eps, sigma_const, theta_global, k_shred_global,
                           event_counts_t, event_buffer_t)


class MOMSystemLoop:
    def __init__(self, mom_kernel, m_root_initial, A_modes_initial, Q_drive_initial,
                 alpha, gamma, omega, dt=0.02, eps=1e-6, sigma=0.75,
                 theta=2.2, k_shred=1.2, event_buffer_size=1024, rng_seed=42):
        self.mom_kernel = mom_kernel
        self.device = mom_kernel.device

        # State
        self.m_root = m_root_initial.to(self.device).clone().to(torch.float32)
        self.A_modes = A_modes_initial.to(self.device).clone().to(torch.float32)
        self.Q_drive = Q_drive_initial.to(self.device).clone().to(torch.float32)
        self.alpha = alpha.to(self.device).to(torch.float32)
        self.gamma = gamma.to(self.device).to(torch.float32)
        self.omega = omega.to(self.device).to(torch.float32)

        # Params
        self.dt = dt; self.eps = eps; self.sigma = sigma
        self.theta = theta; self.k_shred = k_shred

        # Events
        self.event_counts = torch.zeros((), dtype=torch.int64, device=self.device)
        self.event_buffer = torch.zeros(event_buffer_size, dtype=torch.int64, device=self.device)

        # Histories
        self.m_root_history = []
        self.A_modes_history = []
        self.event_counts_history = []
        self.shred_onset = np.full((self.m_root.shape[0],), -1, dtype=np.int32)

        # RNG for deterministic noise
        self.gen = torch.Generator(device=self.device)
        self.gen.manual_seed(int(rng_seed))

    def feedback(self, m_root, A_modes, Q_drive):
        decay = 0.995
        noise_level = 1e-4
        A_modes_new = A_modes * decay + noise_level * torch.random_like(A_modes, generator=self.gen, device=self.device)
        A_modes_new = torch.clamp(A_modes_new, min=0.0)
        m_root_new = m_root * decay + noise_level * torch.randn_like(m_root, generator=self.gen, device=self.device)
        m_root_new = torch.clamp(m_root_new, min=0.0)
        return m_root_new, A_modes_new, Q_drive

    def run(self, iterations):
        for i in range(iterations):
            self.event_counts.zero_()
            self.mom_kernel(self.m_root, self.A_modes, self.Q_drive,
                            self.alpha, self.gamma, self.omega,
                            self.dt, self.eps, self.sigma, self.theta, self.k_shred,
                            self.event_counts, self.event_buffer)

            m_np = self.m_root.detach().cpu().numpy()
            collapsed_mask = m_np <= 1e-8
            for idx, collapsed in enumerate(collapsed_mask):
                if collapsed and self.shred_onset[idx] == -1:
                    self.shred_onset[idx] = i

            self.m_root, self.A_modes, self.Q_drive = self.feedback(self.m_root, self.A_modes, self.Q_drive)
            self.m_root_history.append(float(self.m_root.mean().item()))
            self.A_modes_history.append(float(self.A_modes.mean().item()))
            self.event_counts_history.append(int(self.event_counts.item()))


def run_mom_simulation(
    Ncells, Nmode, iterations, dt=0.02, eps=1e-6, sigma=0.75,
    theta=2.2, k_shred=1.2, seed=42, include_hash=True
):
    torch.manual_seed(seed)
    np.random.seed(seed)

    mom_kernel_instance = MOMKernel()
    device = mom_kernel_instance.device

    alpha = torch.empty(Nmode, device=device).uniform_(0.02, 0.12)
    gamma = torch.empty(Nmode, device=device).uniform_(0.01, 0.06)
    omega = torch.linspace(1.0, 8.0, Nmode, device=device)
    m_root_initial = torch.ones(Ncells, device=device)
    A_modes_initial = torch.rand(Ncells, Nmode, device=device) * 0.01
    Q_drive_initial = torch.zeros(Ncells, Nmode, device=device)

    mom_system = MOMSystemLoop(
        mom_kernel_instance, m_root_initial, A_modes_initial, Q_drive_initial,
        alpha, gamma, omega, dt=dt, eps=eps, sigma=sigma,
        theta=theta, k_shred=k_shred, rng_seed=seed
    )

    # Warmup (excluded from timing)
    mom_system.run(1)

    start_time = time.perf_counter()
    mom_system.run(iterations)
    elapsed_time = max(time.perf_counter() - start_time, 1e-9)

    # Estimated FLOPs (placeholder estimate)
    ops_per_cell_per_iter = 12 * Nmode + 13
    flops_per_iteration = float(Ncells) * float(ops_per_cell_per_iter)
    total_flops = flops_per_iteration * float(iterations)
    gflops = total_flops / (elapsed_time * 1e9)

    # Build plots (excluded from elapsed_time)
    fig = plt.figure(figsize=(10, 14))
    ax1 = fig.add_subplot(4, 1, 1)
    ax1.plot(mom_system.m_root_history, label='Mean m_root')
    ax1.set_title('Mean m_root Over Iterations'); ax1.set_xlabel('Iteration'); ax1.set_ylabel('Mean m_root')
    ax1.grid(True); ax1.legend()

    ax2 = fig.add_subplot(4, 1, 2)
    ax2.plot(mom_system.A_modes_history, label='Mean A_modes', color='orange')
    ax2.set_title('Mean A_modes Over Iterations')
    ax2.set_xlabel('Iteration'); ax2.set_ylabel('Mean A_modes')
    ax2.grid(True); ax2.legend()

    ax3 = fig.add_subplot(4, 1, 3)
    cumulative_events = np.cumsum(np.array(mom_system.event_counts_history))
    ax3.plot(cumulative_events, label='Cumulative Shredding Events', color='red')
    ax3.set_title('Cumulative Shredding Events')
    ax3.set_xlabel('Iteration'); ax3.set_ylabel('Cumulative Events')
    ax3.grid(True); ax3.legend()

    ax4 = fig.add_subplot(4, 1, 4)
    onset = mom_system.shred_onset
    for idx, val in enumerate(onset):
        if val >= 0:
            ax4.vlines(val, idx, idx + 1, color='black', linewidth=0.8)
    ax4.set_title('Shredding Onset per Cell')
    ax4.set_xlabel('Iteration'); ax4.set_ylabel('Cell Index')
    ax4.grid(True)

    plt.tight_layout()
    _, plot_path = tempfile.mkstemp(suffix=".png")
    plt.savefig(plot_path)
    plt.close(fig)

    # Manifest + hash
    run_ipurl = None
    if include_hash:
        manifest = {
            "Ncells": int(Ncells), "Nmode": int(Nmode), "iterations": int(iterations),
            "dt": float(dt), "eps": float(eps), "sigma": float(sigma),
            "theta": float(theta), "k_shred": float(k_shred), "seed": int(seed),
            "elapsed_time_seconds": float(elapsed_time),
            "gflops_estimated": float(gflops),
            "m_root_head": [float(x) for x in mom_system.m_root_history[:10]],
            "A_modes_head": [float(x) for x in mom_system.A_modes_history[:10]],
            "event_counts_head": [int(x) for x in mom_system.event_counts_history[:10]],
        }
        serialized = json.dumps(manifest, sort_keys=True, separators=(",", ":")).encode("utf-8")
        run_ipurl = f"mom-kernel:v1:{hashlib.sha512(serialized).hexdigest()}"

    summary_output = (
        f"MOM Kernel Simulation\n"
        f"- Simulation Time: {elapsed_time:.6f} s\n"
        f"- Estimated GFLOPS (per fused step): {gflops:.4f}\n"
        f"- Final Mean m_root: {float(torch.mean(mom_system.m_root).item()):.6f}\n"
        f"- Final Mean A_modes: {float(torch.mean(mom_system.A_modes).item()):.6f}\n"
        f"- Total Events (last iter): {mom_system.event_counts_history[-1] if len(mom_system.event_counts_history) > 0 else 0}\n"
        + (f"- Run IPURL: {run_ipurl}\n" if run_ipurl else "")
    )

    return summary_output, plot_path


# =========================================================================================
# Part C: Gradio UI — Two tabs for unified artifact
# =========================================================================================

with gr.Blocks(title="NexFrame RFT + MOM Unified Artifact") as demo:
    gr.Markdown("# NexFrame Codex: RFT Hardware Scaling + MOM Collapse Kernel")
    gr.Markdown("This artifact combines a Numba-accelerated RFT simulation across hardware scales with a PyTorch MOM kernel for collapse dynamics. Each run can be sealed with a lineage hash (IPURL).")

    with gr.Tab("RFT Hardware Scaling"):
        gr.Markdown("### RFT Simulation (Numba/NumPy)\nAdjust parameters to explore Ψ_r, energy, and ledger dynamics across hardware scales.")
        with gr.Row():
            num_scales = gr.Slider(5, 100, step=5, value=50, label="Number of Hardware Scales")
            steps = gr.Slider(100, 5000, step=100, value=2000, label="Simulation Steps per Scale")
            seed_rft = gr.Number(value=42, label="Seed", precision=0)
            include_hash_rft = gr.Checkbox(value=True, label="Seal run with hash (IPURL)")
        with gr.Row():
            psi_r_init = gr.Slider(0.1, 2.0, step=0.1, value=1.0, label="Psi_r_init")
            tau_eff = gr.Slider(0.01, 1.0, step=0.01, value=0.05, label="tau_eff")
            delta_tau_pred = gr.Slider(0.001, 0.1, step=0.001, value=0.01, label="delta_tau_pred")
            epsilon_c = gr.Slider(0.001, 0.1, step=0.001, value=0.005, label="epsilon_c")
        with gr.Row():
            phi_loop = gr.Slider(0.1, 2.0, step=0.1, value=1.0, label="phi_loop")
            eta_sync = gr.Slider(0.001, 0.1, step=0.001, value=0.01, label="eta_sync")
            omega_n = gr.Slider(10, 100, step=1, value=50, label="omega_n")
            lambda_m = gr.Slider(10, 200, step=10, value=100, label="lambda_m")
        gr.Markdown("#### Nonlinear exponents")
        with gr.Row():
            alpha = gr.Slider(0.5, 3.0, step=0.1, value=1.1, label="alpha")
            beta = gr.Slider(0.5, 3.0, step=0.1, value=2.0, label="beta")
            gamma = gr.Slider(0.5, 3.0, step=0.1, value=1.2, label="gamma")
            delta = gr.Slider(0.5, 3.0, step=0.1, value=1.0, label="delta")
        with gr.Row():
            epsilon = gr.Slider(0.5, 3.0, step=0.1, value=1.0, label="epsilon")
            zeta = gr.Slider(0.5, 3.0, step=0.1, value=1.0, label="zeta")
            kappa = gr.Slider(1.0, 10.0, step=0.1, value=5.0, label="kappa")
            mu = gr.Slider(1.0, 20.0, step=1.0, value=10.0, label="mu")
            n = gr.Slider(1, 5, step=1, value=2, label="n")

        rft_run = gr.Button("Run RFT Simulation")
        rft_summary = gr.Markdown(label="RFT Summary")
        rft_plot = gr.Image(label="Final Ψ_r across Hardware Scales", type="filepath")

        def _rft_ui(num_scales_to_simulate, simulation_steps, psi_r_init_val, tau_eff_val,
                    delta_tau_pred_val, epsilon_c_val, phi_loop_val, eta_sync_val,
                    omega_n_val, lambda_m_val, alpha_exp, beta_exp, gamma_exp,
                    delta_exp, epsilon_exp, zeta_exp, kappa_exp, mu_exp, n_exp,
                    seed, include_hash):
            return run_rft_hardware_scale(
                num_scales_to_simulate=int(num_scales_to_simulate),
                simulation_steps=int(simulation_steps),
                psi_r_init_val=float(psi_r_init_val),
                tau_eff_val=float(tau_eff_val),
                delta_tau_pred_val=float(delta_tau_pred_val),
                epsilon_c_val=float(epsilon_c_val),
                phi_loop_val=float(phi_loop_val),
                eta_sync_val=float(eta_sync_val),
                omega_n_val=float(omega_n_val),
                lambda_m_val=float(lambda_m_val),
                alpha_exp=float(alpha_exp),
                beta_exp=float(beta_exp),
                gamma_exp=float(gamma_exp),
                delta_exp=float(delta_exp),
                epsilon_exp=float(epsilon_exp),
                zeta_exp=float(zeta_exp),
                kappa_exp=float(kappa_exp),
                mu_exp=float(mu_exp),
                n_exp=int(n_exp),
                seed=int(seed),
                include_hash=bool(include_hash)
            )

        rft_run.click(
            _rft_ui,
            inputs=[
                num_scales, steps, psi_r_init, tau_eff, delta_tau_pred, epsilon_c,
                phi_loop, eta_sync, omega_n, lambda_m, alpha, beta, gamma, delta,
                epsilon, zeta, kappa, mu, n, seed_rft, include_hash_rft
            ],
            outputs=[rft_summary, rft_plot]
        )

    with gr.Tab("MOM Collapse Kernel"):
        gr.Markdown("### MOM Kernel (PyTorch)\nSimulate collapse dynamics with shredding onset and event histories.")
        with gr.Row():
            Ncells = gr.Slider(8, 4096, step=8, value=256, label="Cells")
            Nmode = gr.Slider(4, 512, step=4, value=64, label="Modes per Cell")
            iterations = gr.Slider(10, 5000, step=10, value=500, label="Iterations")
            seed_mom = gr.Number(value=42, label="Seed", precision=0)
            include_hash_mom = gr.Checkbox(value=True, label="Seal run with hash (IPURL)")
        with gr.Row():
            dt = gr.Slider(0.001, 0.1, step=0.001, value=0.02, label="dt")
            eps = gr.Slider(1e-8, 1e-4, step=1e-8, value=1e-6, label="eps")
            sigma = gr.Slider(0.1, 1.5, step=0.01, value=0.75, label="sigma")
            theta = gr.Slider(0.5, 5.0, step=0.1, value=2.2, label="theta")
            k_shred = gr.Slider(0.1, 5.0, step=0.1, value=1.2, label="k_shred")

        mom_run = gr.Button("Run MOM Simulation")
        mom_summary = gr.Markdown(label="MOM Summary")
        mom_plot = gr.Image(label="MOM Plots", type="filepath")

        def _mom_ui(Ncells_val, Nmode_val, iterations_val, dt_val, eps_val, sigma_val, theta_val, k_shred_val, seed_val, include_hash_val):
            return run_mom_simulation(
                Ncells=int(Ncells_val),
                Nmode=int(Nmode_val),
                iterations=int(iterations_val),
                dt=float(dt_val),
                eps=float(eps_val),
                sigma=float(sigma_val),
                theta=float(theta_val),
                k_shred=float(k_shred_val),
                seed=int(seed_val),
                include_hash=bool(include_hash_val)
            )

        mom_run.click(
            _mom_ui,
            inputs=[Ncells, Nmode, iterations, dt, eps, sigma, theta, k_shred, seed_mom, include_hash_mom],
            outputs=[mom_summary, mom_plot]
        )

if __name__ == "__main__":
    demo.launch()