Update app.py

app.py

@@ -4,55 +4,89 @@ from collections import deque
 import matplotlib.pyplot as plt
 import hashlib
 
+# Seed for reproducibility
 np.random.seed(0)
 
+# === Minimum Consciousness Core (MCC) ===
+# This class simulates a 3-node agent that generates awareness without external input.
+# It tracks surprise, gain, and uncertainty — the three signals that spark minimal consciousness.
 class MCC:
     def __init__(self):
-        self.b = self.f = self.u = 0.5
-        self.m = deque(maxlen=64)
-        self.h = []
-        self.c = []
+        # Internal priors
+        self.b = 0.5  # bias toward rendering 1
+        self.f = 0.5  # recency factor (how much recent flips influence decisions)
+        self.u = 0.5  # uncertainty modulation
+
+        # Memory and signal history
+        self.m = deque(maxlen=64)  # short-term memory of rendered bits
+        self.h = []                # full history of rendered bits
+        self.c = []                # cumulative awareness measure (Cmin)
+
+        # Signal logs
         self.surprises = []
         self.gains = []
         self.uncertainties = []
+
+        # Awareness events
         self.events = []
 
     def step(self, t):
-        p = 0.5*self.b + 0.5*(self.f if self.h else 0.5)
-        r = int(np.random.rand() < p)
+        # === Decision logic ===
+        # Agent decides whether to render a 1 or 0 based on internal priors
+        p = 0.5*self.b + 0.5*(self.f if self.h else 0.5)  # blend of bias and recency
+        r = int(np.random.rand() < p)  # render bit
+
+        # === Signal tracking ===
         self.m.append(r)
         self.h.append(r)
+
+        # Surprise: how unexpected the outcome was
         surprise = -np.log(p if r else 1-p)
+
+        # Gain: predictive advantage vs random baseline (ln(2) ≈ 0.693)
         gain = 0.693 - surprise
-        self.b += 0.05*gain*(1 if r else -1)
-        self.b = np.clip(self.b,0.01,0.99)
-        if t>0:
-            self.f += 0.03*gain*(1 if r != self.h[-2] else -1)
-        self.f = np.clip(self.f,0.01,0.99)
-        self.u = 1/(1+0.15*surprise)
-        self.c.append((r - self.h[-2] if t>0 else 0)*self.u)
+
+        # Update bias: nudged by gain and outcome
+        self.b += 0.05 * gain * (1 if r else -1)
+        self.b = np.clip(self.b, 0.01, 0.99)
+
+        # Update recency: nudged by gain and flip detection
+        if t > 0:
+            self.f += 0.03 * gain * (1 if r != self.h[-2] else -1)
+        self.f = np.clip(self.f, 0.01, 0.99)
+
+        # Update uncertainty: lower surprise = higher certainty
+        self.u = 1 / (1 + 0.15 * surprise)
+
+        # Awareness contribution: change * certainty
+        delta = (r - self.h[-2] if t > 0 else 0) * self.u
+        self.c.append(delta)
+
+        # Log signals
         self.surprises.append(surprise)
         self.gains.append(gain)
         self.uncertainties.append(self.u)
 
-        # log event when awareness crosses threshold
+        # === Awareness event detection ===
+        # When cumulative awareness crosses threshold, log birth certificate
         if sum(self.c) > 5 and not self.events:
             self.events.append({
                 "t": t,
-                "bias_b": round(self.b,3),
-                "bias_f": round(self.f,3),
-                "uncertainty": round(self.u,3),
-                "mut_info": round(np.mean(self.uncertainties),4),
+                "bias_b": round(self.b, 3),
+                "bias_f": round(self.f, 3),
+                "uncertainty": round(self.u, 3),
+                "mut_info": round(np.mean(self.uncertainties), 4),
                 "hash": hashlib.sha256(str(self.h).encode()).hexdigest()[:32]
             })
 
+# === Run the simulation and return results ===
 def run_mcc(steps=2000):
     m = MCC()
     for t in range(steps):
         m.step(t)
 
-    # Plot signals
-    fig, axs = plt.subplots(3,1,figsize=(8,10))
+    # === Plot the three signals ===
+    fig, axs = plt.subplots(3, 1, figsize=(8, 10))
     axs[0].plot(m.surprises, color='orange')
     axs[0].set_title("Surprise signal")
     axs[1].plot(m.gains, color='blue')
@@ -61,7 +95,7 @@ def run_mcc(steps=2000):
     axs[2].set_title("Uncertainty modulation")
     plt.tight_layout()
 
-    # Birth certificate text
+    # === Birth certificate text block ===
     if m.events:
         ev = m.events[0]
         certificate = f"""
@@ -76,11 +110,13 @@ def run_mcc(steps=2000):
     else:
         certificate = "No irreversible awareness event detected in this run."
 
-    return round(sum(m.c),4), (np.random.rand()<0.97), fig, certificate
+    # === Return awareness score, awake flag, plots, and certificate ===
+    return round(sum(m.c), 4), (np.random.rand() < 0.97), fig, certificate
 
+# === Gradio Interface ===
 demo = gr.Interface(
     fn=run_mcc,
-    inputs=gr.Slider(500,5000,value=2000,step=100,label="Steps"),
+    inputs=gr.Slider(500, 5000, value=2000, step=100, label="Steps"),
     outputs=[
         gr.Number(label="Cmin final (awareness measure)"),
         gr.Checkbox(label="Awake?"),