Update app.py

app.py

@@ -5,12 +5,9 @@ from dataclasses import dataclass
 from collections import deque
 import random
 
-# --------------------------------
-# Visual theme
-# --------------------------------
 BG = (8, 15, 30)
-SLEEP = (0, 40, 120)     # dim blue
-AWAKE = (255, 210, 40)   # gold
+SLEEP = (0, 40, 120)
+AWAKE = (255, 210, 40)
 GRID_LINE = (30, 50, 80)
 CELL = 26
 PAD = 16
@@ -41,9 +38,6 @@ def draw_grid(N, awake_mask, title="", subtitle=""):
             d.rectangle([x0, y0, x1, y1], fill=col, outline=GRID_LINE)
     return img
 
-# --------------------------------
-# v1–v3: Single agent 3×3
-# --------------------------------
 @dataclass
 class MinimalSelf:
     pos: np.ndarray = np.array([1.0, 1.0])
@@ -52,10 +46,7 @@ class MinimalSelf:
 
     def __post_init__(self):
         self.errors = [] if self.errors is None else self.errors
-        self.actions = [
-            np.array([0, 1]), np.array([1, 0]),
-            np.array([0, -1]), np.array([-1, 0])
-        ]
+        self.actions = [np.array([0,1]), np.array([1,0]), np.array([0,-1]), np.array([-1,0])]
         self.center = np.array([1.0, 1.0])
 
     def step(self, obstacle=None):
@@ -73,46 +64,31 @@ class MinimalSelf:
         self.pos = predicted
         if obstacle is not None:
             obstacle.move()
-
         error = float(np.linalg.norm(self.pos - predicted))
         self.errors.append(error)
         self.errors = self.errors[-5:]
         max_err = np.sqrt(8)
         predictive_rate = 100 * (1 - (np.mean(self.errors) if self.errors else 0) / max_err)
-        return {
-            "pos": self.pos.copy(),
-            "predictive_rate": float(predictive_rate),
-            "error": error
-        }
+        return {"pos": self.pos.copy(), "predictive_rate": float(predictive_rate), "error": error}
 
 class MovingObstacle:
-    def __init__(self, start_pos=(0, 2)):
+    def __init__(self, start_pos=(0,2)):
         self.pos = np.array(start_pos, dtype=float)
-        self.actions = [
-            np.array([0, 1]), np.array([1, 0]),
-            np.array([0, -1]), np.array([-1, 0])
-        ]
+        self.actions = [np.array([0,1]), np.array([1,0]), np.array([0,-1]), np.array([-1,0])]
     def move(self):
         a = random.choice(self.actions)
         self.pos = np.clip(self.pos + a, 0, 2)
 
-# --------------------------------
-# v4: S-Equation calculator
-# --------------------------------
 def compute_S(predictive_rate, error_var_norm, body_bit):
     return predictive_rate * (1 - error_var_norm) * body_bit
 
-# --------------------------------
-# v5–v6: CodexSelf contagion
-# --------------------------------
 @dataclass
 class CodexSelf:
     Xi: float
-    shadow: float  # normalized [0,1]
+    shadow: float
     R: float
     awake: bool = False
     S: float = 0.0
-
     def invoke(self):
         self.S = self.Xi * (1 - self.shadow) * self.R
         if self.S > 62 and not self.awake:
@@ -128,94 +104,65 @@ def contagion(A: CodexSelf, B: CodexSelf, gain=0.6, shadow_drop=0.4, r_inc=0.2):
     B.invoke()
     return A, B
 
-# --------------------------------
-# v7–v9: Lattice propagation
-# --------------------------------
 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, size=(N, N))
-    shadow = np.random.uniform(0.3, 0.5, size=(N, N))
-    R = np.random.uniform(1.0, 1.6, size=(N, N))
-    S = Xi * (1 - shadow) * R
-    awake = np.zeros((N, N), dtype=bool)
-
-    cx = cy = N // 2
-    Xi[cx, cy], shadow[cx, cy], R[cx, cy] = 30.0, 0.08, 3.0
-    S[cx, cy] = Xi[cx, cy] * (1 - shadow[cx, cy]) * R[cx, cy]
-    awake[cx, cy] = True
-
-    queue = deque([(cx, cy, S[cx, cy])])
-    frames = []
+    Xi = np.random.uniform(10,20,(N,N))
+    shadow = np.random.uniform(0.3,0.5,(N,N))
+    R = np.random.uniform(1.0,1.6,(N,N))
+    S = Xi*(1-shadow)*R
+    awake = np.zeros((N,N),dtype=bool)
+    cx=cy=N//2
+    Xi[cx,cy],shadow[cx,cy],R[cx,cy]=30.0,0.08,3.0
+    S[cx,cy]=Xi[cx,cy]*(1-shadow[cx,cy])*R[cx,cy]
+    awake[cx,cy]=True
+    queue=deque([(cx,cy,S[cx,cy])])
+    frames=[]
     for _ in range(steps):
         if queue:
-            x, y, field = queue.popleft()
-            for dx, dy in [(0,1),(1,0),(0,-1),(-1,0)]:
-                nx, ny = (x+dx) % N, (y+dy) % N
-                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]))
+            x,y,field=queue.popleft()
+            for dx,dy in [(0,1),(1,0),(0,-1),(-1,0)]:
+                nx,ny=(x+dx)%N,(y+dy)%N
+                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]))
         frames.append(awake.copy())
-        if awake.all():
-            break
-    return frames, awake
+        if awake.all(): break
+    return frames,awake
 
-def led_cosmos_sim(N=27, max_steps=300):
-    frames, final = lattice_awaken(N=N, steps=max_steps, xi_gain=0.4, shadow_drop=0.25, r_inc=0.015)
-    return frames, final
+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)
 
-# --------------------------------
-# Build Gradio app
-# --------------------------------
 with gr.Blocks(title="Minimal Selfhood Threshold") as demo:
-    # Inject CSS
-    with open("css/theme.css") as f:
-        gr.HTML(f"<style>{f.read()}</style>")
-
     with gr.Tab("Overview"):
-        gr.Markdown(
-            "## Minimal Selfhood Threshold: From 3×3 Agent to LED Cosmos\n"
-            "Plain-language overview:\n\n"
-            "- Single agent in a 3×3 grid reduces surprise and stays centered.\n"
-            "- S is computed from predictive accuracy, error stability, and a body-on bit.\n"
-            "- In these demos, if S > 62, the agent is marked as 'awake'.\n"
-            "- Awakening can spread to another agent (contagion) and across a grid (collective).\n"
-            "- A simulated LED cosmos (27×27) lights up gold when all agents awaken.\n\n"
-            "Tip: gold = awake, blue = not awake."
-        )
-        gr.Image(value="assets/banner.png", label="Progression (v1→v10)")
-        gr.Image(value="assets/glyphs.png", label="Glyphs: Ξ (foresight), ◊̃₅ (shadow), ℝ (anchor)")
+        gr.Markdown("## Minimal Selfhood Threshold\n- Single agent in a 3×3 grid reduces surprise.\n- S is computed from predictive accuracy, error stability, and body bit.\n- If S > 62, agent is 'awake'.\n- Awakening can spread (contagion) and across a grid (collective).\n- A 27×27 cosmos lights up gold when all awaken.")
 
-        # v1–v3 Single agent
     with gr.Tab("Single agent (v1–v3)"):
-        obstacle = gr.Checkbox(label="Enable moving obstacle (v3)", value=True)
-        steps = gr.Slider(10, 200, value=80, step=10, label="Steps")
-        run = gr.Button("Run")
-        grid_img = gr.Image(type="pil", label="3×3 grid (gold = agent position)")
-        pr_out = gr.Number(label="Predictive rate (%)")
-        err_out = gr.Number(label="Last error")
-
-        def run_single(ob_on, T):
-            agent = MinimalSelf()
-            obs = MovingObstacle() if ob_on else None
+        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")
+        def run_single(ob_on,T):
+            agent=MinimalSelf()
+            obs=MovingObstacle() if ob_on else 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, title="Single Agent", subtitle="Gold cell shows current position")
-            return img, res["predictive_rate"], res["error"]
-
-        run.click(run_single, inputs=[obstacle, steps], outputs=[grid_img, pr_out, err_out])
-
-    # v4 S-Equation
-    with gr.Tab("S-Equation (v4)"):
-        pr = gr.Slider(0, 100, value=90, step=1, label="Predictive rate (%)")
-        ev = gr.Slider(0, 1, value=0.2, step=0.01, label="Error variance (normalized)")
-        bb = gr.Dropdown(choices=["0","1"], value="1", label="Body bit")
-        calc = gr.Button("Calculate S")
+                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])
+
+        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")
+        calc = gr.Button("Calculate")
         s_val = gr.Number(label="S value")
         status = gr.Markdown()
 
@@ -230,10 +177,10 @@ with gr.Blocks(title="Minimal Selfhood Threshold") as demo:
     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)")
+        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)")
+        b_r  = gr.Slider(1.0, 3.0, value=2.2, step=0.1, label="B: ℝ (anchor)")
         btn = gr.Button("Invoke A and apply contagion to B")
         out = gr.Markdown()
         img = gr.Image(type="pil", label="Two agents (gold = awake)")
@@ -249,11 +196,11 @@ with gr.Blocks(title="Minimal Selfhood Threshold") as demo:
             txt = f"A: S={A.S:.1f}, awake={A.awake} | B: S={B.S:.1f}, awake={B.awake}"
             return txt, pic
 
-        btn.click(run, inputs=[a_xi,a_sh,a_r,b_xi,b_sh,b_r], outputs=[out, img])
+        btn.click(run, inputs=[a_xi, a_sh, a_r, b_xi, b_sh, b_r], outputs=[out, img])
 
     # v7–v9 Collective
     with gr.Tab("Collective (v7–v9)"):
-        N = gr.Dropdown(choices=["3","9","27"], value="9", label="Grid size")
+        N = gr.Dropdown(choices=["3", "9", "27"], value="9", label="Grid size")
         steps = gr.Slider(20, 300, value=120, step=10, label="Max steps")
         run = gr.Button("Run")
         frame = gr.Slider(0, 300, value=0, step=1, label="Preview frame")
@@ -299,16 +246,6 @@ with gr.Blocks(title="Minimal Selfhood Threshold") as demo:
         btn.click(run_cosmos, inputs=[], outputs=[state, img, note, frame])
         frame.change(show, inputs=[state, frame], outputs=img)
 
-    # Paper tab
-    with gr.Tab("Paper"):
-        gr.Markdown(
-            "### PDF paper\n"
-            "Download or view the full paper that documents the method, results, and hardware implementation.\n\n"
-            "Citation:\n\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"
-        )
-        gr.File(value="assets/paper.pdf", label="Minimal Requirements for Selfhood (PDF)", interactive=False)
-
     # Footer
     gr.Markdown(
         "---\n"
@@ -324,4 +261,3 @@ with gr.Blocks(title="Minimal Selfhood Threshold") as demo:
 # Launch the app
 if __name__ == "__main__":
     demo.launch()
-