Update app.py

app.py

@@ -49,13 +49,6 @@ def tau_eff_adaptive(
     gain: float = 1.2,
     cap: float = 4.0
 ):
-    """
-    τ_eff is implemented here as a timing/decision delay modifier.
-    - base: baseline τ_eff
-    - slow_by: explicit slow-down term
-    - gain: reaction strength to uncertainty
-    - cap: prevents absurd values
-    """
     u = clamp(float(uncertainty), 0.0, 1.0)
     tau = base + slow_by + gain * u
     return clamp(tau, base, cap)
@@ -64,11 +57,6 @@ def rft_confidence(uncertainty: float):
     return clamp(1.0 - float(uncertainty), 0.0, 1.0)
 
 def rft_gate(conf: float, tau_eff: float, threshold: float):
-    """
-    Collapse gate:
-    - higher τ_eff makes the gate stricter
-    - threshold is the minimum confidence needed
-    """
     conf = float(conf)
     tau_eff = float(tau_eff)
     effective = threshold + 0.08 * (tau_eff - 1.0)
@@ -474,8 +462,9 @@ def simulate_landing(
     return summary, [p_alt, p_x, p_w, p_a], csv_path
 
 # ===============================================================
-# Predator Avoidance (Reflex vs QuantumConscious "RFT-style")
+# Predator Avoidance (Reflex vs RFT-style Adaptive Agents)
 # ===============================================================
+
 def numpy_convolve2d_toroidal(array: np.ndarray, kernel: np.ndarray) -> np.ndarray:
     out = np.zeros_like(array, dtype=float)
     kcx = kernel.shape[0] // 2
@@ -515,21 +504,21 @@ class ReflexAgent:
         self.x = (self.x + dx) % self.grid_size
         self.y = (self.y + dy) % self.grid_size
 
-class QuantumConsciousAgent:
+class RFTAdaptiveAgent:
     def __init__(
         self,
         grid_size: int,
         move_kernel: np.ndarray,
         energy_max: float,
         energy_regen: float,
-        base_override_cost: float,
-        quantum_boost_prob: float,
-        quantum_boost_amount: float,
+        base_collapse_cost: float,
+        boost_prob: float,
+        boost_amount: float,
         sense_noise_prob: float,
         alpha: float,
         beta: float,
         dt_internal: float,
-        override_threshold: float
+        collapse_threshold: float
     ):
         self.grid_size = grid_size
         self.move_kernel = move_kernel.astype(float)
@@ -542,27 +531,24 @@ class QuantumConsciousAgent:
         self.energy_max = float(energy_max)
         self.energy = float(energy_max)
         self.energy_regen = float(energy_regen)
-        self.base_override_cost = float(base_override_cost)
-        self.quantum_boost_prob = float(quantum_boost_prob)
-        self.quantum_boost_amount = float(quantum_boost_amount)
+        self.base_collapse_cost = float(base_collapse_cost)
+        self.boost_prob = float(boost_prob)
+        self.boost_amount = float(boost_amount)
         self.sense_noise_prob = float(sense_noise_prob)
 
         self.alpha = float(alpha)
         self.beta = float(beta)
         self.dt_internal = float(dt_internal)
-        self.override_threshold = float(override_threshold)
+        self.collapse_threshold = float(collapse_threshold)
 
-        # Start low so P_override is not pinned at the threshold.
-        self.psi_override = (0.08 + 0j)  # |psi|^2 = 0.0064
-        self.overrides = 0
+        self.psi_action = (0.08 + 0j)  # |psi|^2 = 0.0064 baseline
+        self.collapse_actions = 0
         self.collisions = 0
 
     def move(self):
         dx, dy = random.choice([(0,1), (0,-1), (1,0), (-1,0)])
         self.x = (self.x + dx) % self.grid_size
         self.y = (self.y + dy) % self.grid_size
-
-        # Keep pos_prob consistent with actual state (otherwise threat stays meaningless)
         self.pos_prob.fill(0.0)
         self.pos_prob[self.x, self.y] = 1.0
 
@@ -584,34 +570,27 @@ class QuantumConsciousAgent:
             threat += float(sub.sum())
         return threat
 
-    def update_override_state(self, perceived):
-        """
-        Make P_override responsive (amplitude changes), not phase-only.
-        Threat pushes amplitude up; energy pushes it down.
-        """
+    def update_action_state(self, perceived):
         T = self.compute_threat(perceived)
         E = self.energy / max(self.energy_max, 1e-9)
 
         drive = (self.alpha * T) - (self.beta * E)
 
-        # amplitude pump/decay (bounded)
         exp_term = clamp(drive, -6.0, 6.0) * 0.22 * self.dt_internal
         amp = math.exp(exp_term)
         amp = clamp(amp, 0.75, 1.35)
 
-        # keep a "quantum-style" phase evolution too
-        H = drive + 0.01 * (abs(self.psi_override) ** 2)
-        self.psi_override *= amp * np.exp(-1j * H * self.dt_internal)
+        H = drive + 0.01 * (abs(self.psi_action) ** 2)
+        self.psi_action *= amp * np.exp(-1j * H * self.dt_internal)
 
-        # cap magnitude so probability stays within [0,1]
-        mag = abs(self.psi_override)
+        mag = abs(self.psi_action)
         if mag > 1.0:
-            self.psi_override /= mag
+            self.psi_action /= mag
 
-    def get_override_probability(self):
-        return float(min(abs(self.psi_override) ** 2, 1.0))
+    def get_action_probability(self):
+        return float(min(abs(self.psi_action) ** 2, 1.0))
 
-    def apply_override(self, perceived):
+    def apply_collapse_action(self, perceived):
         field = numpy_convolve2d_toroidal(self.pos_prob, self.move_kernel)
         field = np.maximum(field, 0.0)
 
@@ -644,62 +623,62 @@ class QuantumConsciousAgent:
         idx = np.random.choice(self.grid_size * self.grid_size, p=flat)
         self.x, self.y = divmod(int(idx), self.grid_size)
 
-    def quantum_energy_boost(self):
-        if random.random() < self.quantum_boost_prob:
-            return float(self.quantum_boost_amount)
+    def energy_boost(self):
+        if random.random() < self.boost_prob:
+            return float(self.boost_amount)
         return 0.0
 
     def regen_energy(self):
-        boost = self.quantum_energy_boost()
+        boost = self.energy_boost()
         self.energy = clamp(self.energy + self.energy_regen + boost, 0.0, self.energy_max)
         if self.energy < self.energy_max and random.random() < 0.05:
             self.energy = self.energy_max
 
-    def move_consciously(self, predators, group_coherence: float):
+    def step_rft(self, predators, group_coherence: float):
         if self.energy <= 0:
             self.move()
             return 0, 0.0, 0.0
 
         perceived = self.sense_predators(predators)
-        self.update_override_state(perceived)
+        self.update_action_state(perceived)
 
-        P_ov = self.get_override_probability()
+        P_act = self.get_action_probability()
         threat = self.compute_threat(perceived)
 
         acted = 0
-        if (P_ov >= self.override_threshold) and (self.energy > 0):
-            effective_cost = self.base_override_cost * (1.0 - float(group_coherence))
+        if (P_act >= self.collapse_threshold) and (self.energy > 0):
+            effective_cost = self.base_collapse_cost * (1.0 - float(group_coherence))
             if self.energy >= effective_cost:
-                self.overrides += 1
+                self.collapse_actions += 1
                 self.energy -= effective_cost
-                self.apply_override(perceived)
-                self.psi_override = (0.08 + 0j)  # reset after a collapse action
+                self.apply_collapse_action(perceived)
+                self.psi_action = (0.08 + 0j)
                 acted = 1
             else:
                 self.move()
         else:
             self.move()
 
-        return acted, P_ov, threat
+        return acted, P_act, threat
 
 def simulate_predator(
     seed: int,
     grid_size: int,
     steps: int,
     num_reflex: int,
-    num_conscious: int,
+    num_rft: int,
     num_predators: int,
     group_coherence: float,
     sense_noise_prob: float,
-    override_threshold: float,
+    collapse_threshold: float,
     alpha: float,
     beta: float,
     dt_internal: float,
     energy_max: float,
-    base_override_cost: float,
+    base_collapse_cost: float,
     energy_regen: float,
-    quantum_boost_prob: float,
-    quantum_boost_amount: float,
+    boost_prob: float,
+    boost_amount: float,
     show_heatmap: bool
 ):
     set_seed(seed)
@@ -709,22 +688,22 @@ def simulate_predator(
                             [0, 0.2, 0]], dtype=float)
 
     reflex_agents = [ReflexAgent(grid_size) for _ in range(int(num_reflex))]
-    conscious_agents = [
-        QuantumConsciousAgent(
+    rft_agents = [
+        RFTAdaptiveAgent(
             grid_size=grid_size,
             move_kernel=move_kernel,
             energy_max=energy_max,
             energy_regen=energy_regen,
-            base_override_cost=base_override_cost,
-            quantum_boost_prob=quantum_boost_prob,
-            quantum_boost_amount=quantum_boost_amount,
+            base_collapse_cost=base_collapse_cost,
+            boost_prob=boost_prob,
+            boost_amount=boost_amount,
             sense_noise_prob=sense_noise_prob,
             alpha=alpha,
             beta=beta,
             dt_internal=dt_internal,
-            override_threshold=override_threshold
+            collapse_threshold=collapse_threshold
         )
-        for _ in range(int(num_conscious))
+        for _ in range(int(num_rft))
     ]
     predators = [Predator(grid_size) for _ in range(int(num_predators))]
 
@@ -742,13 +721,13 @@ def simulate_predator(
                     a.collisions += 1
 
         actions = []
-        povs = []
+        probs = []
         threats = []
-        for a in conscious_agents:
-            acted, P_ov, threat = a.move_consciously(predators, group_coherence)
+        for a in rft_agents:
+            acted, P_act, threat = a.step_rft(predators, group_coherence)
             a.regen_energy()
             actions.append(acted)
-            povs.append(P_ov)
+            probs.append(P_act)
             threats.append(threat)
             for p in predators:
                 if a.x == p.x and a.y == p.y:
@@ -757,22 +736,22 @@ def simulate_predator(
         ops_proxy += 18
 
         reflex_collisions = int(sum(a.collisions for a in reflex_agents))
-        conscious_collisions = int(sum(a.collisions for a in conscious_agents))
-        avg_overrides = float(np.mean([a.overrides for a in conscious_agents])) if conscious_agents else 0.0
-        avg_energy = float(np.mean([a.energy for a in conscious_agents])) if conscious_agents else 0.0
+        rft_collisions = int(sum(a.collisions for a in rft_agents))
+        avg_actions = float(np.mean([a.collapse_actions for a in rft_agents])) if rft_agents else 0.0
+        avg_energy = float(np.mean([a.energy for a in rft_agents])) if rft_agents else 0.0
         avg_threat = float(np.mean(threats)) if threats else 0.0
-        avg_pov = float(np.mean(povs)) if povs else 0.0
-        avg_act = float(np.mean(actions)) if actions else 0.0
+        avg_prob = float(np.mean(probs)) if probs else 0.0
+        avg_act_rate = float(np.mean(actions)) if actions else 0.0
 
         rows.append({
             "t": t,
             "reflex_collisions_cum": reflex_collisions,
-            "conscious_collisions_cum": conscious_collisions,
-            "avg_conscious_overrides": avg_overrides,
-            "avg_conscious_energy": avg_energy,
-            "avg_conscious_threat": avg_threat,
-            "avg_conscious_P_override": avg_pov,
-            "avg_conscious_action": avg_act,
+            "rft_collisions_cum": rft_collisions,
+            "avg_rft_actions": avg_actions,
+            "avg_rft_energy": avg_energy,
+            "avg_rft_threat": avg_threat,
+            "avg_rft_P_action": avg_prob,
+            "avg_rft_action_rate": avg_act_rate,
             "predators_positions": "|".join([f"{p.x},{p.y}" for p in predators]),
         })
 
@@ -782,7 +761,7 @@ def simulate_predator(
     fig1 = plt.figure(figsize=(10, 4))
     ax = fig1.add_subplot(111)
     ax.plot(df["t"], df["reflex_collisions_cum"], label="Reflex collisions (cum)")
-    ax.plot(df["t"], df["conscious_collisions_cum"], label="Conscious collisions (cum)")
+    ax.plot(df["t"], df["rft_collisions_cum"], label="RFT collisions (cum)")
     ax.set_title("Predator Avoidance: Collisions (Reflex vs RFT)")
     ax.set_xlabel("t (step)")
     ax.set_ylabel("collisions (cum)")
@@ -791,32 +770,32 @@ def simulate_predator(
 
     fig2 = plt.figure(figsize=(10, 4))
     ax = fig2.add_subplot(111)
-    ax.plot(df["t"], df["avg_conscious_overrides"], label="Avg overrides (conscious)")
-    ax.plot(df["t"], df["avg_conscious_energy"], label="Avg energy (conscious)")
-    ax.set_title("Predator Avoidance: Overrides + Energy (Conscious)")
+    ax.plot(df["t"], df["avg_rft_actions"], label="Avg actions (RFT)")
+    ax.plot(df["t"], df["avg_rft_energy"], label="Avg energy (RFT)")
+    ax.set_title("Predator Avoidance: Actions + Energy (RFT)")
     ax.set_xlabel("t (step)")
     ax.set_ylabel("value")
     ax.legend()
-    p_ov = save_plot(fig2, f"predator_overrides_energy_seed{seed}.png")
+    p_act = save_plot(fig2, f"predator_actions_energy_seed{seed}.png")
 
     fig3 = plt.figure(figsize=(10, 4))
     ax = fig3.add_subplot(111)
-    ax.plot(df["t"], df["avg_conscious_threat"], label="Avg threat")
-    ax.plot(df["t"], df["avg_conscious_P_override"], label="Avg P_override")
-    ax.plot(df["t"], df["avg_conscious_action"], label="Avg action rate")
-    ax.set_title("Predator Avoidance: Threat vs Override Probability vs Action Rate")
+    ax.plot(df["t"], df["avg_rft_threat"], label="Avg threat")
+    ax.plot(df["t"], df["avg_rft_P_action"], label="Avg P_action")
+    ax.plot(df["t"], df["avg_rft_action_rate"], label="Avg action rate")
+    ax.set_title("Predator Avoidance: Threat vs P_action vs Action Rate")
     ax.set_xlabel("t (step)")
     ax.set_ylabel("value")
     ax.legend()
     p_thr = save_plot(fig3, f"predator_threat_seed{seed}.png")
 
     heatmap_path = None
-    if show_heatmap and len(conscious_agents) > 0:
-        field = conscious_agents[0].pos_prob
+    if show_heatmap and len(rft_agents) > 0:
+        field = rft_agents[0].pos_prob
         fig4 = plt.figure(figsize=(6, 5))
         ax = fig4.add_subplot(111)
         im = ax.imshow(field, aspect="auto")
-        ax.set_title("Conscious Agent[0]: Final probability field (pos_prob)")
+        ax.set_title("RFT Agent[0]: Final probability field (pos_prob)")
         ax.set_xlabel("y")
         ax.set_ylabel("x")
         fig4.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
@@ -827,16 +806,16 @@ def simulate_predator(
         "grid_size": int(grid_size),
         "steps": int(steps),
         "num_reflex": int(num_reflex),
-        "num_conscious": int(num_conscious),
+        "num_rft": int(num_rft),
         "num_predators": int(num_predators),
         "final_reflex_collisions": int(df["reflex_collisions_cum"].iloc[-1]) if len(df) else 0,
-        "final_conscious_collisions": int(df["conscious_collisions_cum"].iloc[-1]) if len(df) else 0,
-        "final_avg_conscious_overrides": float(df["avg_conscious_overrides"].iloc[-1]) if len(df) else 0.0,
-        "final_avg_conscious_energy": float(df["avg_conscious_energy"].iloc[-1]) if len(df) else 0.0,
+        "final_rft_collisions": int(df["rft_collisions_cum"].iloc[-1]) if len(df) else 0,
+        "final_avg_rft_actions": float(df["avg_rft_actions"].iloc[-1]) if len(df) else 0.0,
+        "final_avg_rft_energy": float(df["avg_rft_energy"].iloc[-1]) if len(df) else 0.0,
         "ops_proxy": int(ops_proxy),
     }
 
-    imgs = [p_col, p_ov, p_thr]
+    imgs = [p_col, p_act, p_thr]
     if heatmap_path is not None:
         imgs.append(heatmap_path)
 
@@ -951,7 +930,7 @@ This Space contains:
 - **NEO alerting**
 - **Satellite jitter reduction**
 - **Starship-style landing harness**
-- **Predator avoidance** (Reflex vs RFT-style "QuantumConscious" agents)
+- **Predator avoidance** (Reflex vs RFT-style adaptive agents)
 
 No SciPy. No hidden dependencies. No model weights.
 """
@@ -1091,30 +1070,30 @@ def ui_run_landing(seed, steps, dt, wind_max, thrust_noise, kp_base, kp_rft, gat
     summary_txt = json.dumps(summary, indent=2)
     return summary_txt, imgs[0], imgs[1], imgs[2], imgs[3], csv_path
 
-def ui_run_predator(seed, grid_size, steps, num_reflex, num_conscious, num_predators,
-                    group_coherence, sense_noise_prob, override_threshold,
+def ui_run_predator(seed, grid_size, steps, num_reflex, num_rft, num_predators,
+                    group_coherence, sense_noise_prob, collapse_threshold,
                     alpha, beta, dt_internal,
-                    energy_max, base_override_cost, energy_regen,
-                    quantum_boost_prob, quantum_boost_amount,
+                    energy_max, base_collapse_cost, energy_regen,
+                    boost_prob, boost_amount,
                     show_heatmap):
     summary, imgs, csv_path = simulate_predator(
         seed=int(seed),
         grid_size=int(grid_size),
         steps=int(steps),
         num_reflex=int(num_reflex),
-        num_conscious=int(num_conscious),
+        num_rft=int(num_rft),
         num_predators=int(num_predators),
         group_coherence=float(group_coherence),
         sense_noise_prob=float(sense_noise_prob),
-        override_threshold=float(override_threshold),
+        collapse_threshold=float(collapse_threshold),
         alpha=float(alpha),
         beta=float(beta),
         dt_internal=float(dt_internal),
         energy_max=float(energy_max),
-        base_override_cost=float(base_override_cost),
+        base_collapse_cost=float(base_collapse_cost),
         energy_regen=float(energy_regen),
-        quantum_boost_prob=float(quantum_boost_prob),
-        quantum_boost_amount=float(quantum_boost_amount),
+        boost_prob=float(boost_prob),
+        boost_amount=float(boost_amount),
         show_heatmap=bool(show_heatmap)
     )
     summary_txt = json.dumps(summary, indent=2)
@@ -1306,7 +1285,7 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
                 "# Predator Avoidance (Reflex vs RFT)\n"
                 "Grid world with roaming predators.\n"
                 "Reflex agents: random walk.\n"
-                "Conscious agents: probability field + threat-weighted override.\n"
+                "RFT agents: probability field + threat-weighted collapse action.\n"
             )
 
             with gr.Row():
@@ -1316,28 +1295,28 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
 
             with gr.Row():
                 num_reflex = gr.Slider(0, 50, value=10, step=1, label="Reflex agents")
-                num_conscious = gr.Slider(0, 20, value=3, step=1, label="Conscious agents")
+                num_rft = gr.Slider(0, 20, value=3, step=1, label="RFT agents")
                 num_predators = gr.Slider(1, 20, value=3, step=1, label="Predators")
 
             with gr.Accordion("RFT / Agent parameters", open=True):
                 with gr.Row():
                     group_coherence = gr.Slider(0.0, 0.95, value=0.30, step=0.01, label="Group coherence")
                     sense_noise_prob = gr.Slider(0.0, 0.9, value=0.10, step=0.01, label="Sense noise probability")
-                    override_threshold = gr.Slider(0.0, 1.0, value=0.02, step=0.005, label="Override threshold (P_ov)")
+                    collapse_threshold = gr.Slider(0.0, 1.0, value=0.02, step=0.005, label="Collapse threshold (P_action)")
 
                 with gr.Row():
                     alpha = gr.Slider(0.0, 50.0, value=15.0, step=0.5, label="alpha (threat gain)")
                     beta = gr.Slider(0.0, 10.0, value=0.5, step=0.05, label="beta (energy term)")
-                    dt_internal = gr.Slider(0.01, 1.0, value=0.2, step=0.01, label="override dt")
+                    dt_internal = gr.Slider(0.01, 1.0, value=0.2, step=0.01, label="internal dt")
 
                 with gr.Row():
                     energy_max = gr.Slider(1.0, 300.0, value=100.0, step=1.0, label="Energy max")
-                    base_override_cost = gr.Slider(0.0, 10.0, value=1.0, step=0.1, label="Base override cost")
+                    base_collapse_cost = gr.Slider(0.0, 10.0, value=1.0, step=0.1, label="Base action cost")
                     energy_regen = gr.Slider(0.0, 1.0, value=0.05, step=0.01, label="Energy regen")
 
                 with gr.Row():
-                    quantum_boost_prob = gr.Slider(0.0, 1.0, value=0.10, step=0.01, label="Quantum boost probability")
-                    quantum_boost_amount = gr.Slider(0.0, 50.0, value=5.0, step=0.5, label="Quantum boost amount")
+                    boost_prob = gr.Slider(0.0, 1.0, value=0.10, step=0.01, label="Boost probability")
+                    boost_amount = gr.Slider(0.0, 50.0, value=5.0, step=0.5, label="Boost amount")
                     show_heatmap = gr.Checkbox(value=True, label="Show probability field heatmap (agent[0])")
 
             run_p = gr.Button("Run Predator Simulation")
@@ -1345,19 +1324,19 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
             out_p_summary = gr.Textbox(label="Summary JSON", lines=12)
             with gr.Row():
                 out_p_img1 = gr.Image(label="Collisions (cumulative)")
-                out_p_img2 = gr.Image(label="Overrides + Energy")
+                out_p_img2 = gr.Image(label="Actions + Energy")
             with gr.Row():
-                out_p_img3 = gr.Image(label="Threat / P_override / Action rate")
+                out_p_img3 = gr.Image(label="Threat / P_action / Action rate")
                 out_p_img4 = gr.Image(label="Final probability field (optional)")
             out_p_csv = gr.File(label="Download Predator CSV log")
 
             run_p.click(
                 ui_run_predator,
-                inputs=[seed_p, grid_size, steps_p, num_reflex, num_conscious, num_predators,
-                        group_coherence, sense_noise_prob, override_threshold,
+                inputs=[seed_p, grid_size, steps_p, num_reflex, num_rft, num_predators,
+                        group_coherence, sense_noise_prob, collapse_threshold,
                         alpha, beta, dt_internal,
-                        energy_max, base_override_cost, energy_regen,
-                        quantum_boost_prob, quantum_boost_amount,
+                        energy_max, base_collapse_cost, energy_regen,
+                        boost_prob, boost_amount,
                         show_heatmap],
                 outputs=[out_p_summary, out_p_img1, out_p_img2, out_p_img3, out_p_img4, out_p_csv]
             )