Update app.py

app.py

@@ -49,6 +49,13 @@ 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)
@@ -57,6 +64,11 @@ 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)
@@ -311,6 +323,7 @@ def simulate_landing(
     vv = -45.0
     x = 60.0
     xv = 0.0
+
     ix = 0.0
 
     anomalies = 0
@@ -319,13 +332,11 @@ def simulate_landing(
     rows = []
 
     g = -9.81
+
     LAT_CTRL = 0.95
     WIND_PUSH = 0.28
     VERT_CTRL = 0.22
 
-    OVERRIDE_X = 18.0
-    OVERRIDE_ALT = 260.0
-
     for t in range(int(steps)):
         gust = math.sin(0.08 * t) + 0.55 * math.sin(0.21 * t + 0.7)
         wind = (wind_max * 0.75) * gust + np.random.normal(0.0, 0.65)
@@ -349,7 +360,6 @@ def simulate_landing(
             anomaly_types.append("High lateral error near ground")
         if meas_alt < 150 and abs(meas_vv) > 15:
             anomaly_types.append("High descent rate near ground")
-
         is_anomaly = len(anomaly_types) > 0
         if is_anomaly:
             anomalies += 1
@@ -365,9 +375,7 @@ def simulate_landing(
         if meas_alt < 600:
             ix = clamp(ix + (meas_x * dt) * 0.0025, -40.0, 40.0)
 
-        do_action = rft_gate(conf, tau, gate_threshold)
-        must_act = (abs(meas_x) > OVERRIDE_X) or (meas_alt < OVERRIDE_ALT)
-        do_action = bool(do_action or must_act)
+        do_action = bool(rft_gate(conf, tau, gate_threshold))
 
         u_rft_x = 0.0
         u_rft_v = 0.0
@@ -466,7 +474,7 @@ def simulate_landing(
     return summary, [p_alt, p_x, p_w, p_a], csv_path
 
 # ===============================================================
-# Predator Avoidance (Reflex vs QuantumObserver "RFT-style")
+# Predator Avoidance (Reflex vs QuantumConscious "RFT-style")
 # ===============================================================
 def numpy_convolve2d_toroidal(array: np.ndarray, kernel: np.ndarray) -> np.ndarray:
     out = np.zeros_like(array, dtype=float)
@@ -507,7 +515,7 @@ class ReflexAgent:
         self.x = (self.x + dx) % self.grid_size
         self.y = (self.y + dy) % self.grid_size
 
-class QuantumObserverAgent:
+class QuantumConsciousAgent:
     def __init__(
         self,
         grid_size: int,
@@ -544,7 +552,8 @@ class QuantumObserverAgent:
         self.dt_internal = float(dt_internal)
         self.override_threshold = float(override_threshold)
 
-        self.psi_override = (0.08 + 0j)
+        # 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.collisions = 0
 
@@ -552,6 +561,8 @@ class QuantumObserverAgent:
         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
 
@@ -574,17 +585,25 @@ class QuantumObserverAgent:
         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.
+        """
         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)
 
+        # cap magnitude so probability stays within [0,1]
         mag = abs(self.psi_override)
         if mag > 1.0:
             self.psi_override /= mag
@@ -636,7 +655,7 @@ class QuantumObserverAgent:
         if self.energy < self.energy_max and random.random() < 0.05:
             self.energy = self.energy_max
 
-    def move_observer(self, predators, group_coherence: float):
+    def move_consciously(self, predators, group_coherence: float):
         if self.energy <= 0:
             self.move()
             return 0, 0.0, 0.0
@@ -654,7 +673,7 @@ class QuantumObserverAgent:
                 self.overrides += 1
                 self.energy -= effective_cost
                 self.apply_override(perceived)
-                self.psi_override = (0.08 + 0j)
+                self.psi_override = (0.08 + 0j)  # reset after a collapse action
                 acted = 1
             else:
                 self.move()
@@ -668,7 +687,7 @@ def simulate_predator(
     grid_size: int,
     steps: int,
     num_reflex: int,
-    num_observer: int,
+    num_conscious: int,
     num_predators: int,
     group_coherence: float,
     sense_noise_prob: float,
@@ -690,8 +709,8 @@ def simulate_predator(
                             [0, 0.2, 0]], dtype=float)
 
     reflex_agents = [ReflexAgent(grid_size) for _ in range(int(num_reflex))]
-    observer_agents = [
-        QuantumObserverAgent(
+    conscious_agents = [
+        QuantumConsciousAgent(
             grid_size=grid_size,
             move_kernel=move_kernel,
             energy_max=energy_max,
@@ -705,7 +724,7 @@ def simulate_predator(
             dt_internal=dt_internal,
             override_threshold=override_threshold
         )
-        for _ in range(int(num_observer))
+        for _ in range(int(num_conscious))
     ]
     predators = [Predator(grid_size) for _ in range(int(num_predators))]
 
@@ -725,8 +744,8 @@ def simulate_predator(
         actions = []
         povs = []
         threats = []
-        for a in observer_agents:
-            acted, P_ov, threat = a.move_observer(predators, group_coherence)
+        for a in conscious_agents:
+            acted, P_ov, threat = a.move_consciously(predators, group_coherence)
             a.regen_energy()
             actions.append(acted)
             povs.append(P_ov)
@@ -738,9 +757,9 @@ def simulate_predator(
         ops_proxy += 18
 
         reflex_collisions = int(sum(a.collisions for a in reflex_agents))
-        observer_collisions = int(sum(a.collisions for a in observer_agents))
-        avg_overrides = float(np.mean([a.overrides for a in observer_agents])) if observer_agents else 0.0
-        avg_energy = float(np.mean([a.energy for a in observer_agents])) if observer_agents else 0.0
+        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
         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
@@ -748,12 +767,12 @@ def simulate_predator(
         rows.append({
             "t": t,
             "reflex_collisions_cum": reflex_collisions,
-            "observer_collisions_cum": observer_collisions,
-            "avg_observer_overrides": avg_overrides,
-            "avg_observer_energy": avg_energy,
-            "avg_observer_threat": avg_threat,
-            "avg_observer_P_override": avg_pov,
-            "avg_observer_action": avg_act,
+            "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,
             "predators_positions": "|".join([f"{p.x},{p.y}" for p in predators]),
         })
 
@@ -763,7 +782,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["observer_collisions_cum"], label="Observer collisions (cum)")
+    ax.plot(df["t"], df["conscious_collisions_cum"], label="Conscious collisions (cum)")
     ax.set_title("Predator Avoidance: Collisions (Reflex vs RFT)")
     ax.set_xlabel("t (step)")
     ax.set_ylabel("collisions (cum)")
@@ -772,9 +791,9 @@ def simulate_predator(
 
     fig2 = plt.figure(figsize=(10, 4))
     ax = fig2.add_subplot(111)
-    ax.plot(df["t"], df["avg_observer_overrides"], label="Avg overrides (observer)")
-    ax.plot(df["t"], df["avg_observer_energy"], label="Avg energy (observer)")
-    ax.set_title("Predator Avoidance: Overrides + Energy (Observer)")
+    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.set_xlabel("t (step)")
     ax.set_ylabel("value")
     ax.legend()
@@ -782,9 +801,9 @@ def simulate_predator(
 
     fig3 = plt.figure(figsize=(10, 4))
     ax = fig3.add_subplot(111)
-    ax.plot(df["t"], df["avg_observer_threat"], label="Avg threat")
-    ax.plot(df["t"], df["avg_observer_P_override"], label="Avg P_override")
-    ax.plot(df["t"], df["avg_observer_action"], label="Avg action rate")
+    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.set_xlabel("t (step)")
     ax.set_ylabel("value")
@@ -792,12 +811,12 @@ def simulate_predator(
     p_thr = save_plot(fig3, f"predator_threat_seed{seed}.png")
 
     heatmap_path = None
-    if show_heatmap and len(observer_agents) > 0:
-        field = observer_agents[0].pos_prob
+    if show_heatmap and len(conscious_agents) > 0:
+        field = conscious_agents[0].pos_prob
         fig4 = plt.figure(figsize=(6, 5))
         ax = fig4.add_subplot(111)
         im = ax.imshow(field, aspect="auto")
-        ax.set_title("Observer Agent[0]: Final probability field (pos_prob)")
+        ax.set_title("Conscious 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)
@@ -808,12 +827,12 @@ def simulate_predator(
         "grid_size": int(grid_size),
         "steps": int(steps),
         "num_reflex": int(num_reflex),
-        "num_observer": int(num_observer),
+        "num_conscious": int(num_conscious),
         "num_predators": int(num_predators),
         "final_reflex_collisions": int(df["reflex_collisions_cum"].iloc[-1]) if len(df) else 0,
-        "final_observer_collisions": int(df["observer_collisions_cum"].iloc[-1]) if len(df) else 0,
-        "final_avg_observer_overrides": float(df["avg_observer_overrides"].iloc[-1]) if len(df) else 0.0,
-        "final_avg_observer_energy": float(df["avg_observer_energy"].iloc[-1]) if len(df) else 0.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,
         "ops_proxy": int(ops_proxy),
     }
 
@@ -824,7 +843,7 @@ def simulate_predator(
     return summary, imgs, csv_path
 
 # -----------------------------
-# Benchmarks (NEO/Jitter/Landing)
+# Benchmarks
 # -----------------------------
 def run_benchmarks(
     seed: int,
@@ -932,7 +951,7 @@ This Space contains:
 - **NEO alerting**
 - **Satellite jitter reduction**
 - **Starship-style landing harness**
-- **Predator avoidance** (Reflex vs RFT-style "QuantumObserver" agents)
+- **Predator avoidance** (Reflex vs RFT-style "QuantumConscious" agents)
 
 No SciPy. No hidden dependencies. No model weights.
 """
@@ -1072,7 +1091,7 @@ 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_observer, num_predators,
+def ui_run_predator(seed, grid_size, steps, num_reflex, num_conscious, num_predators,
                     group_coherence, sense_noise_prob, override_threshold,
                     alpha, beta, dt_internal,
                     energy_max, base_override_cost, energy_regen,
@@ -1083,7 +1102,7 @@ def ui_run_predator(seed, grid_size, steps, num_reflex, num_observer, num_predat
         grid_size=int(grid_size),
         steps=int(steps),
         num_reflex=int(num_reflex),
-        num_observer=int(num_observer),
+        num_conscious=int(num_conscious),
         num_predators=int(num_predators),
         group_coherence=float(group_coherence),
         sense_noise_prob=float(sense_noise_prob),
@@ -1287,7 +1306,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"
-                "Observer agents: probability field + threat-weighted override.\n"
+                "Conscious agents: probability field + threat-weighted override.\n"
             )
 
             with gr.Row():
@@ -1297,7 +1316,7 @@ 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_observer = gr.Slider(0, 20, value=3, step=1, label="Observer agents")
+                num_conscious = gr.Slider(0, 20, value=3, step=1, label="Conscious agents")
                 num_predators = gr.Slider(1, 20, value=3, step=1, label="Predators")
 
             with gr.Accordion("RFT / Agent parameters", open=True):
@@ -1334,7 +1353,7 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
 
             run_p.click(
                 ui_run_predator,
-                inputs=[seed_p, grid_size, steps_p, num_reflex, num_observer, num_predators,
+                inputs=[seed_p, grid_size, steps_p, num_reflex, num_conscious, num_predators,
                         group_coherence, sense_noise_prob, override_threshold,
                         alpha, beta, dt_internal,
                         energy_max, base_override_cost, energy_regen,