Update app.py

app.py

@@ -106,7 +106,6 @@ def simulate_neo(
         dist = float(np.linalg.norm(meas))
 
         speed = float(np.linalg.norm(vel))
-        # uncertainty proxy: noise relative to alert radius + a mild speed term
         uncertainty = clamp((noise_km / max(alert_km, 1.0)) * 2.0 + (speed / 200.0) * 0.2, 0.0, 1.0)
 
         baseline_alert = dist <= alert_km
@@ -251,7 +250,6 @@ def simulate_jitter(
             "jitter_rft_next": jitter_rft_next,
         })
 
-        # Run the plant under RFT to reflect "using the RFT agent"
         jitter = jitter_rft_next
         jitter_rate *= 0.92
 
@@ -321,13 +319,11 @@ def simulate_landing(
 ):
     set_seed(seed)
 
-    # State
     alt = 1000.0
     vv = -45.0
     x = 60.0
     xv = 0.0
 
-    # Integral term helps remove persistent bias
     ix = 0.0
 
     anomalies = 0
@@ -341,9 +337,6 @@ def simulate_landing(
     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)
@@ -382,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
@@ -485,7 +476,6 @@ def simulate_landing(
 # ===============================================================
 # 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)
     kcx = kernel.shape[0] // 2
@@ -544,13 +534,11 @@ class QuantumConsciousAgent:
         self.grid_size = grid_size
         self.move_kernel = move_kernel.astype(float)
 
-        # "probability field" + initial collapse
         self.pos_prob = np.zeros((grid_size, grid_size), dtype=float)
         x, y = np.random.randint(grid_size), np.random.randint(grid_size)
         self.pos_prob[x, y] = 1.0
         self.x, self.y = int(x), int(y)
 
-        # energy + override state
         self.energy_max = float(energy_max)
         self.energy = float(energy_max)
         self.energy_regen = float(energy_regen)
@@ -564,7 +552,8 @@ class QuantumConsciousAgent:
         self.dt_internal = float(dt_internal)
         self.override_threshold = float(override_threshold)
 
-        self.psi_override = (0.1 + 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
 
@@ -573,17 +562,19 @@ class QuantumConsciousAgent:
         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
+
     def sense_predators(self, predators):
         perceived = []
         for p in predators:
             if random.random() < self.sense_noise_prob:
-                # drop this predator (sensor miss)
                 continue
             perceived.append((p.x, p.y))
         return perceived
 
     def compute_threat(self, perceived):
-        # threat = probability mass near predators (radius window)
         threat = 0.0
         radius = 2
         for (px, py) in perceived:
@@ -594,21 +585,36 @@ class QuantumConsciousAgent:
         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)
-        # same structural shape as your PDF: H = alpha*T - beta*E + small recursion term
-        H = self.alpha * T - self.beta * E + 0.01 * (abs(self.psi_override) ** 2)
-        self.psi_override *= np.exp(-1j * H * self.dt_internal)
+
+        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
 
     def get_override_probability(self):
-        return float(abs(self.psi_override) ** 2)
+        return float(min(abs(self.psi_override) ** 2, 1.0))
 
     def apply_override(self, perceived):
-        # diffuse probability a little (kernel), then suppress regions near predators
         field = numpy_convolve2d_toroidal(self.pos_prob, self.move_kernel)
         field = np.maximum(field, 0.0)
 
-        # suppress predator neighborhoods
         for (px, py) in perceived:
             for dx in range(-2, 3):
                 for dy in range(-2, 3):
@@ -619,21 +625,18 @@ class QuantumConsciousAgent:
 
         s = float(field.sum())
         if s <= 0:
-            # fallback to uniform
             field[:] = 1.0 / (self.grid_size * self.grid_size)
         else:
             field /= s
 
         self.pos_prob = field
 
-        # collapse away from predator cells explicitly
         flat = self.pos_prob.flatten().copy()
         for (px, py) in perceived:
             flat[px * self.grid_size + py] = 0.0
 
         tot = float(flat.sum())
         if tot <= 0:
-            # if all got zeroed (rare), just random move
             self.move()
             return
 
@@ -649,28 +652,28 @@ class QuantumConsciousAgent:
     def regen_energy(self):
         boost = self.quantum_energy_boost()
         self.energy = clamp(self.energy + self.energy_regen + boost, 0.0, self.energy_max)
-        # occasional full regen (as in your runs)
         if self.energy < self.energy_max and random.random() < 0.05:
             self.energy = self.energy_max
 
     def move_consciously(self, predators, group_coherence: float):
         if self.energy <= 0:
             self.move()
-            return 0, 0.0, 0.0  # acted?, P_ov, threat
+            return 0, 0.0, 0.0
 
         perceived = self.sense_predators(predators)
         self.update_override_state(perceived)
+
         P_ov = self.get_override_probability()
         threat = self.compute_threat(perceived)
 
         acted = 0
-        if (P_ov > self.override_threshold) and (self.energy > 0):
+        if (P_ov >= self.override_threshold) and (self.energy > 0):
             effective_cost = self.base_override_cost * (1.0 - float(group_coherence))
             if self.energy >= effective_cost:
                 self.overrides += 1
                 self.energy -= effective_cost
                 self.apply_override(perceived)
-                self.psi_override = (0.1 + 0j)
+                self.psi_override = (0.08 + 0j)  # reset after a collapse action
                 acted = 1
             else:
                 self.move()
@@ -725,30 +728,19 @@ def simulate_predator(
     ]
     predators = [Predator(grid_size) for _ in range(int(num_predators))]
 
-    reflex_collisions_cum = []
-    conscious_collisions_cum = []
-    conscious_overrides_avg = []
-    conscious_energy_avg = []
-    conscious_threat_avg = []
-    conscious_pov_avg = []
-    conscious_actions_avg = []
-
     rows = []
     ops_proxy = 0
 
     for t in range(int(steps)):
-        # predators move first
         for p in predators:
             p.move()
 
-        # reflex move + collision check
         for a in reflex_agents:
             a.move()
             for p in predators:
                 if a.x == p.x and a.y == p.y:
                     a.collisions += 1
 
-        # conscious move + collision check
         actions = []
         povs = []
         threats = []
@@ -772,15 +764,6 @@ def simulate_predator(
         avg_pov = float(np.mean(povs)) if povs else 0.0
         avg_act = float(np.mean(actions)) if actions else 0.0
 
-        reflex_collisions_cum.append(reflex_collisions)
-        conscious_collisions_cum.append(conscious_collisions)
-        conscious_overrides_avg.append(avg_overrides)
-        conscious_energy_avg.append(avg_energy)
-        conscious_threat_avg.append(avg_threat)
-        conscious_pov_avg.append(avg_pov)
-        conscious_actions_avg.append(avg_act)
-
-        # log row (one line per step)
         rows.append({
             "t": t,
             "reflex_collisions_cum": reflex_collisions,
@@ -796,7 +779,6 @@ def simulate_predator(
     df = pd.DataFrame(rows)
     csv_path = df_to_csv_file(df, f"predator_log_seed{seed}.csv")
 
-    # Plot 1: collisions (cumulative)
     fig1 = plt.figure(figsize=(10, 4))
     ax = fig1.add_subplot(111)
     ax.plot(df["t"], df["reflex_collisions_cum"], label="Reflex collisions (cum)")
@@ -807,7 +789,6 @@ def simulate_predator(
     ax.legend()
     p_col = save_plot(fig1, f"predator_collisions_seed{seed}.png")
 
-    # Plot 2: overrides + energy
     fig2 = plt.figure(figsize=(10, 4))
     ax = fig2.add_subplot(111)
     ax.plot(df["t"], df["avg_conscious_overrides"], label="Avg overrides (conscious)")
@@ -818,7 +799,6 @@ def simulate_predator(
     ax.legend()
     p_ov = save_plot(fig2, f"predator_overrides_energy_seed{seed}.png")
 
-    # Plot 3: threat + P_override + actions
     fig3 = plt.figure(figsize=(10, 4))
     ax = fig3.add_subplot(111)
     ax.plot(df["t"], df["avg_conscious_threat"], label="Avg threat")
@@ -832,7 +812,6 @@ def simulate_predator(
 
     heatmap_path = None
     if show_heatmap and len(conscious_agents) > 0:
-        # show the final probability field of agent 0
         field = conscious_agents[0].pos_prob
         fig4 = plt.figure(figsize=(6, 5))
         ax = fig4.add_subplot(111)
@@ -875,7 +854,6 @@ def run_benchmarks(
 ):
     seed = int(seed)
 
-    # NEO
     s_rft, _, neo_imgs, neo_csv = simulate_neo(
         seed=seed,
         steps=neo_steps,
@@ -891,7 +869,6 @@ def run_benchmarks(
     neo_rft = int(neo_df["rft_alert"].sum())
     neo_candidates = int(neo_df["rft_candidate"].sum())
 
-    # Jitter
     j_sum, jit_imgs, jit_csv = simulate_jitter(
         seed=seed,
         steps=jit_steps,
@@ -903,7 +880,6 @@ def run_benchmarks(
         tau_gain=tau_gain
     )
 
-    # Landing
     l_sum, land_imgs, land_csv = simulate_landing(
         seed=seed,
         steps=land_steps,
@@ -953,7 +929,7 @@ def run_benchmarks(
         f"- Landing: final offset={l_sum['final_landing_offset_m']:.2f} m (goal 10 m), anomalies={l_sum['total_anomalies_detected']}, actions={l_sum['total_control_actions']}\n"
     )
 
-    all_imgs = neo_imgs + jit_imgs + land_imgs  # 3 + 3 + 4 = 10
+    all_imgs = neo_imgs + jit_imgs + land_imgs
     return txt, score, score_path, all_imgs, [neo_csv, jit_csv, land_csv]
 
 # -----------------------------
@@ -1142,7 +1118,6 @@ def ui_run_predator(seed, grid_size, steps, num_reflex, num_conscious, num_preda
         show_heatmap=bool(show_heatmap)
     )
     summary_txt = json.dumps(summary, indent=2)
-    # imgs: 3 or 4
     img1 = imgs[0] if len(imgs) > 0 else None
     img2 = imgs[1] if len(imgs) > 1 else None
     img3 = imgs[2] if len(imgs) > 2 else None
@@ -1170,7 +1145,6 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
     gr.Markdown(HOME_MD)
 
     with gr.Tabs():
-        # ----------------------------------------------------------
         with gr.Tab("Live Console"):
             gr.Markdown(LIVE_MD)
 
@@ -1230,7 +1204,6 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
                 ]
             )
 
-        # ----------------------------------------------------------
         with gr.Tab("NEO Agent"):
             gr.Markdown(
                 "# Near-Earth Object (NEO) Alerting Agent\n"
@@ -1263,7 +1236,6 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
                 outputs=[out_neo_summary, out_neo_debug, out_neo_img1, out_neo_img2, out_neo_img3, out_neo_csv]
             )
 
-        # ----------------------------------------------------------
         with gr.Tab("Satellite Jitter Agent"):
             gr.Markdown(
                 "# Satellite Jitter Reduction\n"
@@ -1295,7 +1267,6 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
                 outputs=[out_j_summary, out_j_img1, out_j_img2, out_j_img3, out_j_csv]
             )
 
-        # ----------------------------------------------------------
         with gr.Tab("Starship Landing Harness"):
             gr.Markdown(
                 "# Starship-style Landing Harness (Simplified)\n"
@@ -1330,7 +1301,6 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
                 outputs=[out_l_summary, out_l_img1, out_l_img2, out_l_img3, out_l_img4, out_l_csv]
             )
 
-        # ----------------------------------------------------------
         with gr.Tab("Predator Avoidance"):
             gr.Markdown(
                 "# Predator Avoidance (Reflex vs RFT)\n"
@@ -1353,7 +1323,7 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
                 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.01, step=0.005, label="Override threshold (P_ov)")
+                    override_threshold = gr.Slider(0.0, 1.0, value=0.02, step=0.005, label="Override threshold (P_ov)")
 
                 with gr.Row():
                     alpha = gr.Slider(0.0, 50.0, value=15.0, step=0.5, label="alpha (threat gain)")
@@ -1392,7 +1362,6 @@ with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing / Predator)"
                 outputs=[out_p_summary, out_p_img1, out_p_img2, out_p_img3, out_p_img4, out_p_csv]
             )
 
-        # ----------------------------------------------------------
         with gr.Tab("Theory → Practice"):
             gr.Markdown(THEORY_PRACTICE_MD)