Create app.py

app.py

@@ -0,0 +1,337 @@
+import numpy as np
+import time
+import torch
+import matplotlib.pyplot as plt
+import tempfile
+import hashlib
+import json
+import gradio as gr
+
+# -----------------------------
+# Part A: RFT Simulation Kernel
+# -----------------------------
+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):
+    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)
+
+    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)
+
+    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)
+
+    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
+
+    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):
+        self.mom_kernel = mom_kernel
+        self.device = mom_kernel.device
+        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)
+        self.dt = dt; self.eps = eps; self.sigma = sigma
+        self.theta = theta; self.k_shred = k_shred
+        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)
+        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)
+
+    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.randn_like(A_modes, 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, 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_rft_simulation(Ncells, Nmode, iterations, dt=0.02, eps=1e-6, sigma=0.75,
+                       theta=2.2, k_shred=1.2, seed=42):
+    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)
+    start_time = time.time()
+    mom_system.run(iterations)
+    elapsed_time = max(time.time() - start_time, 1e-9)
+    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)
+    return {
+        'final_m_root': mom_system.m_root.cpu().numpy(),
+        'final_A_modes': mom_system.A_modes.cpu().numpy(),
+        'final_Q_drive': mom_system.Q_drive.cpu().numpy(),
+        'm_root_history': np.array(mom_system.m_root_history),
+        'A_modes_history': np.array(mom_system.A_modes_history),
+        'event_counts_history': np.array(mom_system.event_counts_history),
+        'shred_onset': mom_system.shred_onset,
+        'elapsed_time_seconds': float(elapsed_time),
+        'gflops': float(gflops),
+    }
+
+def rft_simulation_interface(Ncells, Nmode, iterations, dt, eps, sigma, theta, k_shred):
+    try:
+        results = run_rft_simulation(Ncells, Nmode, iterations, dt, eps, sigma, theta, k_shred)
+        fig = plt.figure(figsize=(10, 14))
+        ax1 = fig.add_subplot(4, 1, 1)
+        ax1.plot(results['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(results['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()
+
+        # Plot 3: Cumulative Shredding Events
+        ax3 = fig.add_subplot(4, 1, 3)
+        cumulative_events = np.cumsum(results['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()
+
+        # Plot 4: Raster of shredding onset per cell
+        ax4 = fig.add_subplot(4, 1, 4)
+        onset = results['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)
+
+        summary_output = (
+            f"Simulation completed in {results['elapsed_time_seconds']:.2f} seconds.\n\n"
+            f"Estimated GFLOPS: {results['gflops']:.2f}\n"
+            f"Final Mean m_root: {np.mean(results['final_m_root']):.6f}\n"
+            f"Final Mean A_modes: {np.mean(results['final_A_modes']):.6f}\n"
+            f"Total Events (last iteration): {results['event_counts_history'][-1] if len(results['event_counts_history']) > 0 else 0}\n\n"
+            f"-- Historical Data (first 5 values) --\n"
+            f"Mean m_root history: {results['m_root_history'][:5].tolist()}\n"
+            f"Mean A_modes history: {results['A_modes_history'][:5].tolist()}\n"
+            f"Event counts history: {results['event_counts_history'][:5].tolist()}"
+        )
+    except Exception as e:
+        summary_output = f"Error during RFT simulation: {e}"
+        plot_path = None
+
+    return summary_output, plot_path
+
+# -----------------------------
+# Part B: Entanglement/IPURL Simulation
+# -----------------------------
+class Agent:
+    def __init__(self, agent_id, alpha, beta, energy_init, energy_threshold):
+        self.agent_id = agent_id
+        self.alpha = alpha
+        self.beta = beta
+        self.energy = energy_init
+        self.energy_threshold = energy_threshold
+        self.phi = 0.0
+        self.override_log = []
+
+    def intrinsic_update(self, dt):
+        theta = 1 if self.energy > self.energy_threshold else 0
+        dphi = (-self.alpha * self.phi + self.beta * theta) * dt
+        self.phi += dphi
+        self.energy -= abs(self.phi) * dt * 0.1
+        self.energy = max(self.energy, 0)
+        self.log_override()
+
+    def entanglement_update(self, influence, dt):
+        self.phi += influence * dt
+        self.energy -= abs(influence) * dt * 0.05
+        self.energy = max(self.energy, 0)
+        self.log_override()
+
+    def log_override(self):
+        self.override_log.append({
+            'phi': self.phi,
+            'energy': self.energy,
+            'override': self.phi > 0,
+        })
+
+def hash_override_log(agent):
+    serialized = json.dumps(agent.override_log, sort_keys=True, separators=(',', ':')).encode('utf-8')
+    return hashlib.sha512(serialized).hexdigest()
+
+def simulate(agents, coupling_matrix, dt=0.01, steps=1000):
+    n = len(agents)
+    for step in range(steps):
+        phis = np.array([agent.phi for agent in agents])
+        for agent in agents:
+            agent.intrinsic_update(dt)
+        for i, agent in enumerate(agents):
+            influence = sum(coupling_matrix[i, j] * phis[j] for j in range(n) if j != i)
+            agent.entanglement_update(influence, dt)
+
+def run_entanglement_simulation(alpha_vals, beta_vals, thresholds, steps=1000, dt=0.01):
+    agents = [
+        Agent('reflex', alpha_vals[0], beta_vals[0], energy_init=100, energy_threshold=thresholds[0]),
+        Agent('instinct', alpha_vals[1], beta_vals[1], energy_init=100, energy_threshold=thresholds[1]),
+        Agent('conscious', alpha_vals[2], beta_vals[2], energy_init=100, energy_threshold=thresholds[2]),
+        Agent('meta', alpha_vals[3], beta_vals[3], energy_init=100, energy_threshold=thresholds[3]),
+    ]
+    coupling_matrix = np.array([
+        [0.0, 0.1, 0.2, 0.3],
+        [0.1, 0.0, 0.4, 0.5],
+        [0.2, 0.4, 0.0, 0.6],
+        [0.3, 0.5, 0.6, 0.0],
+    ])
+    simulate(agents, coupling_matrix, dt=dt, steps=steps)
+    ipurls = [f"rft-ipurl:v1:{agent.agent_id}:{hash_override_log(agent)}" for agent in agents]
+    return "\n".join(ipurls)
+
+# -----------------------------
+# Gradio Interface
+# -----------------------------
+with gr.Blocks(title="Codex Simulation Suite") as iface:
+    with gr.Tab("RFT Simulation"):
+        gr.Markdown("""
+        ### Rendered Frame Theory (RFT) Simulation
+        RFT models collapse dynamics in adaptive systems. Each cell evolves through coupled updates,
+        feedback loops, and shredding events when stress crosses a threshold. The plots show mean values,
+        cumulative events, and shredding onset per cell.
+        """)
+        with gr.Row():
+            with gr.Column():
+                Ncells_slider = gr.Slider(16, 512, step=16, value=64, label="⚡ Number of Cells")
+                Nmode_slider = gr.Slider(2, 32, step=2, value=8, label="🔮 Number of Modes")
+                iterations_slider = gr.Slider(10, 200, step=10, value=50, label="♾ Iterations")
+                dt_slider = gr.Slider(0.001, 0.1, step=0.001, value=0.02, label="⌛ Time Step")
+                eps_slider = gr.Slider(1e-7, 1e-4, step=1e-7, value=1e-6, label="🧿 Epsilon")
+                sigma_slider = gr.Slider(0.1, 1.0, step=0.05, value=0.75, label="🌌 Sigma")
+                theta_slider = gr.Slider(0.1, 5.0, step=0.1, value=2.2, label="🔭 Theta")
+                k_shred_slider = gr.Slider(0.1, 5.0, step=0.1, value=1.2, label="🌀 K_shred")
+                run_button = gr.Button("Run RFT Simulation")
+            with gr.Column():
+                summary_output_textbox = gr.Textbox(label="Simulation Summary", lines=15)
+                plot_output_image = gr.Image(label="Simulation Plots", type="filepath")
+        run_button.click(
+            fn=rft_simulation_interface,
+            inputs=[Ncells_slider, Nmode_slider, iterations_slider, dt_slider, eps_slider,
+                    sigma_slider, theta_slider, k_shred_slider],
+            outputs=[summary_output_textbox, plot_output_image]
+        )
+
+    with gr.Tab("Entanglement/IPURL Simulation"):
+        gr.Markdown("""
+        ### Override Log & Entanglement Simulation
+        This prototype models symbolic agents (reflex, instinct, conscious, meta) with intrinsic dynamics
+        and entanglement influences. Each agent logs override states, which are sealed into reproducible
+        IPURL hashes. The output shows cryptographic lineage entries for each agent.
+        """)
+        alpha_inputs = [gr.Number(value=0.1, label="Alpha Reflex"),
+                        gr.Number(value=0.1, label="Alpha Instinct"),
+                        gr.Number(value=0.2, label="Alpha Conscious"),
+                        gr.Number(value=0.3, label="Alpha Meta")]
+        beta_inputs = [gr.Number(value=0.0, label="Beta Reflex"),
+                       gr.Number(value=0.5, label="Beta Instinct"),
+                       gr.Number(value=1.0, label="Beta Conscious"),
+                       gr.Number(value=1.5, label="Beta Meta")]
+        thresholds = [gr.Number(value=10, label="Threshold Reflex"),
+                      gr.Number(value=20, label="Threshold Instinct"),
+                      gr.Number(value=30, label="Threshold Conscious"),
+                      gr.Number(value=40, label="Threshold Meta")]
+        steps_slider = gr.Slider(minimum=100, maximum=10000, step=100, value=5000, label="♾ Steps")
+        run_button2 = gr.Button("Run Entanglement Simulation")
+        ipurl_output = gr.Textbox(label="IPURL Entries", lines=10)
+
+        run_button2.click(
+            fn=lambda a1,a2,a3,a4,b1,b2,b3,b4,t1,t2,t3,t4,steps: run_entanglement_simulation(
+                [a1,a2,a3,a4],[b1,b2,b3,b4],[t1,t2,t3,t4],steps),
+            inputs=alpha_inputs+beta_inputs+thresholds+[steps_slider],
+            outputs=ipurl_output
+        )
+
+# -----------------------------
+# Launch
+# -----------------------------
+if __name__ == "__main__":
+    iface.launch()