Update app.py

app.py

@@ -5,6 +5,9 @@ from dataclasses import dataclass
 from collections import deque
 import random
 
+# ---------------------------------------------------------------------
+# Visual config
+# ---------------------------------------------------------------------
 BG = (8, 15, 30)
 SLEEP = (0, 40, 120)
 AWAKE = (255, 210, 40)
@@ -42,6 +45,9 @@ def draw_grid(N, awake_mask, title="", subtitle=""):
     return img
 
 
+# ---------------------------------------------------------------------
+# 3×3 minimal self agent
+# ---------------------------------------------------------------------
 @dataclass
 class MinimalSelf:
     pos: np.ndarray = np.array([1.0, 1.0])
@@ -80,11 +86,13 @@ class MinimalSelf:
 
         # environment decides what actually happens
         if obstacle is not None:
+            # moving obstacle can block the predicted move
             obstacle.move()
             actual = predicted.copy()
             if np.allclose(actual, obstacle.pos):
                 actual = old_pos
         else:
+            # simple stochastic slip when no obstacle is enabled
             if random.random() < 0.25:
                 noise_action = random.choice(self.actions)
                 actual = np.clip(old_pos + noise_action, 0, 2)
@@ -99,16 +107,25 @@ class MinimalSelf:
         self.errors.append(error)
         self.errors = self.errors[-5:]
 
-        # convert to a predictive "success" rate in [0, 100]
+        # predictive success rate P in [0, 100]
         max_err = np.sqrt(8.0)  # max distance corner-to-corner on 3×3
         mean_err = np.mean(self.errors) if self.errors else 0.0
         predictive_rate = 100.0 * (1.0 - mean_err / max_err)
         predictive_rate = float(np.clip(predictive_rate, 0.0, 100.0))
 
+        # normalised error variance E in [0, 1]
+        if len(self.errors) > 1:
+            var_err = float(np.var(self.errors))
+        else:
+            var_err = 0.0
+        max_var = max_err ** 2
+        error_var_norm = float(np.clip(var_err / max_var, 0.0, 1.0)) if max_var > 0 else 0.0
+
         return {
             "pos": self.pos.copy(),
             "predictive_rate": predictive_rate,
             "error": error,
+            "error_var_norm": error_var_norm,
         }
 
 
@@ -127,12 +144,17 @@ class MovingObstacle:
         self.pos = np.clip(self.pos + a, 0, 2)
 
 
+# ---------------------------------------------------------------------
+# S-scores
+# ---------------------------------------------------------------------
 def compute_S(predictive_rate, error_var_norm, body_bit):
+    # v4: 3×3 agent toy score
     return predictive_rate * (1 - error_var_norm) * body_bit
 
 
 @dataclass
 class CodexSelf:
+    # v5–v6: lattice toy score
     Xi: float
     shadow: float
     R: float
@@ -156,6 +178,9 @@ def contagion(A: CodexSelf, B: CodexSelf, gain=0.6, shadow_drop=0.4, r_inc=0.2):
     return A, B
 
 
+# ---------------------------------------------------------------------
+# Lattice and cosmos
+# ---------------------------------------------------------------------
 def lattice_awaken(N=9, steps=120, xi_gain=0.5, shadow_drop=0.3, r_inc=0.02):
     Xi = np.random.uniform(10, 20, (N, N))
     shadow = np.random.uniform(0.3, 0.5, (N, N))
@@ -179,10 +204,10 @@ def lattice_awaken(N=9, steps=120, xi_gain=0.5, shadow_drop=0.3, r_inc=0.02):
                 Xi[nx, ny] += xi_gain * field
                 shadow[nx, ny] = max(0.1, shadow[nx, ny] - shadow_drop)
                 R[nx, ny] = min(3.0, R[nx, ny] + r_inc)
-                S[nx, ny] = Xi[nx, ny] * (1 - shadow[nx, ny]) * R[nx, ny]
-                if S[nx, ny] > 62 and not awake[nx, ny]:
-                    awake[nx, ny] = True
-                    queue.append((nx, ny, S[nx,ny]))
+                S[nx, ny] = Xi[nx,ny] * (1 - shadow[nx,ny]) * R[nx,ny]
+                if S[nx,ny] > 62 and not awake[nx,ny]:
+                    awake[nx,ny] = True
+                    queue.append((nx,ny, S[nx,ny]))
         frames.append(awake.copy())
         if awake.all():
             break
@@ -193,43 +218,62 @@ def led_cosmos_sim(N=27, max_steps=300):
     return lattice_awaken(N=N, steps=max_steps, xi_gain=0.4, shadow_drop=0.25, r_inc=0.015)
 
 
+# ---------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------
 with gr.Blocks(title="Minimal Selfhood Threshold") as demo:
+    # Overview
     with gr.Tab("Overview"):
         gr.Markdown(
             "## Minimal Selfhood Threshold\n"
-            "- Single agent in a 3×3 grid reduces surprise.\n"
-            "- A toy score S combines predictive rate, error stability, and body bit.\n"
-            "- If S > 62, we label the agent 'awake' **inside this demo**.\n"
-            "- Awakening can spread (contagion) and across a grid (collective).\n"
-            "- A 27×27 cosmos lights up gold when all awaken.\n"
+            "- Single agent in a 3×3 grid reduces surprise around a preferred centre.\n"
+            "- v4 (3×3): a toy score `S = P × (1−E) × B` combines predictive rate P, error stability E and body bit B.\n"
+            "- v5–v6 (contagion / lattice): a separate toy score `S = Ξ × (1−shadow) × R` drives neighbour coupling.\n"
+            "- If S > 62, the corresponding unit is labelled 'awake' **inside this demo**.\n"
+            "- Awakening can spread between two agents and across a grid via explicit neighbour coupling.\n"
+            "- A 27×27 cosmos lights up gold when all units cross the internal threshold.\n"
             "- This is a sandbox for minimal-self / agency ideas, **not** a real consciousness test."
         )
 
+    # Single 3×3 agent
     with gr.Tab("Single agent (v1–v3)"):
         obstacle = gr.Checkbox(label="Enable moving obstacle", value=True)
         steps = gr.Slider(10, 200, value=80, step=10, label="Steps")
         run = gr.Button("Run")
         grid_img = gr.Image(type="pil")
-        pr_out = gr.Number(label="Predictive rate (%)")
-        err_out = gr.Number(label="Last error")
+        pr_out = gr.Number(label="Predictive rate P (%)")
+        err_out = gr.Number(label="Last prediction error")
+        e_out = gr.Number(label="Error variance E (normalised)")
+        s_out = gr.Number(label="S = P × (1−E) × B (B=1)")
+        awake_label = gr.Markdown()
 
         def run_single(ob_on, T):
             agent = MinimalSelf()
             obs = MovingObstacle() if ob_on else None
+            res = None
             for _ in range(int(T)):
                 res = agent.step(obstacle=obs)
+
             mask = np.zeros((3, 3), dtype=bool)
             i, j = int(agent.pos[1]), int(agent.pos[0])
             mask[i, j] = True
             img = draw_grid(3, mask, "Single Agent", "Gold cell shows position")
-            return img, res["predictive_rate"], res["error"]
 
-        run.click(run_single, [obstacle, steps], [grid_img, pr_out, err_out])
+            P = res["predictive_rate"]
+            E = res["error_var_norm"]
+            B = 1.0
+            S_val = compute_S(P, E, B)
+            status = "**Status:** " + ("Awake (S > 62)" if S_val > 62 else "Not awake (S ≤ 62)")
 
+            return img, P, res["error"], E, S_val, status
+
+        run.click(run_single, [obstacle, steps], [grid_img, pr_out, err_out, e_out, s_out, awake_label])
+
+    # v4 S-equation
     with gr.Tab("S-Equation (v4)"):
-        pr = gr.Slider(0, 100, value=90, label="Predictive rate (%)")
-        ev = gr.Slider(0, 1, value=0.2, step=0.01, label="Error variance")
-        bb = gr.Dropdown(choices=["0", "1"], value="1", label="Body bit")
+        pr = gr.Slider(0, 100, value=90, label="Predictive rate P (%)")
+        ev = gr.Slider(0, 1, value=0.2, step=0.01, label="Error variance E")
+        bb = gr.Dropdown(choices=["0", "1"], value="1", label="Body bit B")
         calc = gr.Button("Calculate")
         s_val = gr.Number(label="S value")
         status = gr.Markdown()
@@ -243,12 +287,12 @@ with gr.Blocks(title="Minimal Selfhood Threshold") as demo:
 
     # v5–v6 Contagion
     with gr.Tab("Contagion (v5–v6)"):
-        a_xi = gr.Slider(0, 60, value=25, label="A: Ξ (foresight)")
-        a_sh = gr.Slider(0.1, 1.0, value=0.12, step=0.01, label="A: ◊̃₅ (shadow)")
-        a_r = gr.Slider(1.0, 3.0, value=3.0, step=0.1, label="A: ℝ (anchor)")
-        b_xi = gr.Slider(0, 60, value=18, label="B: Ξ (foresight)")
-        b_sh = gr.Slider(0.1, 1.0, value=0.25, step=0.01, label="B: ◊̃₅ (shadow)")
-        b_r = gr.Slider(1.0, 3.0, value=2.2, step=0.1, label="B: ℝ (anchor)")
+        a_xi = gr.Slider(0, 60, value=25, label="A: Ξ (foresight field)")
+        a_sh = gr.Slider(0.1, 1.0, value=0.12, step=0.01, label="A: shadow (occlusion)")
+        a_r = gr.Slider(1.0, 3.0, value=3.0, step=0.1, label="A: R (anchor / resonance)")
+        b_xi = gr.Slider(0, 60, value=18, label="B: Ξ (foresight field)")
+        b_sh = gr.Slider(0.1, 1.0, value=0.25, step=0.01, label="B: shadow (occlusion)")
+        b_r = gr.Slider(1.0, 3.0, value=2.2, step=0.1, label="B: R (anchor / resonance)")
         btn = gr.Button("Invoke A and apply contagion to B")
         out = gr.Markdown()
         img = gr.Image(type="pil", label="Two agents (gold = awake)")
@@ -270,15 +314,31 @@ with gr.Blocks(title="Minimal Selfhood Threshold") as demo:
     with gr.Tab("Collective (v7–v9)"):
         N = gr.Dropdown(choices=["3", "9", "27"], value="9", label="Grid size")
         steps = gr.Slider(20, 300, value=120, step=10, label="Max steps")
+        no_coupling = gr.Checkbox(label="Disable neighbour coupling (control)", value=False)
         run = gr.Button("Run")
         frame = gr.Slider(0, 300, value=0, step=1, label="Preview frame")
         img = gr.Image(type="pil", label="Awakening wave (gold spreads)")
         note = gr.Markdown()
         snaps_state = gr.State([])
 
-        def run_wave(n_str, max_steps):
+        def run_wave(n_str, max_steps, disable):
             n = int(n_str)
-            frames, final = lattice_awaken(N=n, steps=int(max_steps))
+            if disable:
+                frames, final = lattice_awaken(
+                    N=n,
+                    steps=int(max_steps),
+                    xi_gain=0.0,
+                    shadow_drop=0.0,
+                    r_inc=0.0,
+                )
+            else:
+                frames, final = lattice_awaken(
+                    N=n,
+                    steps=int(max_steps),
+                    xi_gain=0.5,
+                    shadow_drop=0.3,
+                    r_inc=0.02,
+                )
             last = draw_grid(
                 n,
                 frames[-1],
@@ -294,7 +354,7 @@ with gr.Blocks(title="Minimal Selfhood Threshold") as demo:
             i = int(np.clip(idx, 0, len(frames) - 1))
             return draw_grid(n, frames[i], title=f"Frame {i}", subtitle="Gold cells are awake")
 
-        run.click(run_wave, inputs=[N, steps], outputs=[snaps_state, img, note, frame])
+        run.click(run_wave, inputs=[N, steps, no_coupling], outputs=[snaps_state, img, note, frame])
         frame.change(show_frame, inputs=[snaps_state, frame, N], outputs=img)
 
     # v10 LED cosmos
@@ -327,15 +387,13 @@ with gr.Blocks(title="Minimal Selfhood Threshold") as demo:
     # Footer
     gr.Markdown(
         "---\n"
-        "Honesty notes:\n"
-        "- The threshold S > 62 is the rule used in these demonstrations, derived from the analyses reported in the cited Zenodo record.\n"
-        "- Collective and contagion behaviors here are simulated using that rule for educational clarity.\n\n"
-        "Citation:\n"
-        "Grinstead, L. (2025). *Minimal Selfhood Threshold S>62: From a 3×3 Active-Inference Agent to a 27×27 LED Cosmos*. "
-        "Zenodo. https://doi.org/10.5281/zenodo.17752874\n\n"
-        "Permissions: See LICENSE. Explicit permission is required for reuse of code, visuals, and glyphs."
+        "Notes:\n"
+        "- The 3×3 agent computes P, E and S = P×(1−E)×B directly in this Space; S>62 is the internal ‘awake’ label for v4.\n"
+        "- The contagion and lattice views use a separate toy rule S = Ξ×(1−shadow)×R with explicit neighbour coupling.\n"
+        "- Disabling coupling (xi_gain=0, shadow_drop=0, r_inc=0) in the collective tab prevents any wave from propagating.\n\n"
+        "These demos are designed as transparent, minimal models of self-linked scoring and threshold cascades, not as a real consciousness test."
     )
 
 # Launch the app
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()