Update app.py

app.py

@@ -12,6 +12,7 @@ DT          = 0.12
 MICRO       = 6
 SETTLE      = 0.004
 CONV_THRESH = 0.02
+BRIDGE_K    = 0.20   # passive bridge spring constant — soft coupling, not learned
 
 
 class SimEngine:
@@ -31,7 +32,7 @@ class SimEngine:
         self.current_error      = 0.0
         self.current_prediction = 0.0
         self.history            = []
-        self.merge_map          = {}
+        self.bridge_springs     = {}
         self._init_mesh()
 
     # ── TOPOLOGY ──────────────────────────────────────────────────────────────
@@ -51,6 +52,7 @@ class SimEngine:
         self.current_error      = 0.0
         self.current_prediction = 0.0
         self.history            = []
+        self.bridge_springs     = {}
         self.layers             = self._build_layers()
         n = self.n_inputs
 
@@ -74,86 +76,51 @@ class SimEngine:
                 self.springs[(f'B{d}', lid)]    = round(random.uniform(0.85, 1.15), 4)
                 self.springs[(lid,     f'C{d}')] = round(random.uniform(0.85, 1.15), 4)
 
-        # Structural merge: co-located nodes become shared vertices
-        self.merge_map = self._compute_merge_map() if self.cross_connect else {}
-        if self.merge_map:
-            self._apply_merge()
+        if self.cross_connect:
+            self._add_bridge_nodes()
 
-    # ── NODE MERGE ────────────────────────────────────────────────────────────
+    # ── BRIDGE NODES ──────────────────────────────────────────────────────────
 
-    def _compute_merge_map(self):
+    def _add_bridge_nodes(self):
         """
-        The rightmost upper hidden node of dim d and the leftmost upper
-        hidden node of dim d+1 are visually co-located → one shared vertex.
-        Same for lower.  Only applies when ≥2 hidden nodes per side so the
-        boundary node is distinct from the centre node.
-        Returns {removed_id: canonical_id}.
+        For each adjacent dimension pair (d, d+1), insert two passive bridge
+        vertices:
+          XU{d}  — sits between U{d}_{n_upper} and U{d+1}_1 (upper hidden layer)
+          XL{d}  — sits between L{d}_{n_lower} and L{d+1}_1 (lower hidden layer)
+
+        Bridge springs are FIXED at BRIDGE_K and never touched by LMS.
+        Each bridge node settles to a position driven by its two neighbours,
+        and in turn exerts a soft reaction pull on those neighbours — creating
+        a passive physical information channel between dimensions without
+        interfering with per-dimension gradient descent.
         """
-        mm = {}
-        n  = self.n_inputs
+        n = self.n_inputs
         if n < 2:
-            return mm
+            return
         for d in range(1, n):
-            if self.n_upper >= 2:
-                mm[f'U{d+1}_1'] = f'U{d}_{self.n_upper}'
-            if self.n_lower >= 2:
-                mm[f'L{d+1}_1'] = f'L{d}_{self.n_lower}'
-        return mm
+            xuid = f'XU{d}'
+            self.nodes[xuid] = {'x': 0.0, 'vel': 0.0, 'anchored': False}
+            self.bridge_springs[(xuid, f'U{d}_{self.n_upper}')] = BRIDGE_K
+            self.bridge_springs[(xuid, f'U{d+1}_1')]            = BRIDGE_K
 
-    def _apply_merge(self):
-        """
-        Retarget all spring keys through merge_map and remove duplicate nodes.
-        e.g. (A2, U2_1) → (A2, U1_3).  If two remapped keys collide
-        (should not happen with this rule) their constants are averaged.
-        """
-        mm = self.merge_map
-        new_springs = {}
-        for (u, v), k in self.springs.items():
-            key = (mm.get(u, u), mm.get(v, v))
-            if key in new_springs:
-                new_springs[key] = (new_springs[key] + k) / 2.0
-            else:
-                new_springs[key] = k
-        self.springs = new_springs
-
-        removed = set(mm.keys())
-        for rid in removed:
-            self.nodes.pop(rid, None)
-        self.layers = [
-            [nid for nid in layer if nid not in removed]
-            for layer in self.layers
-        ]
-
-    # ── MERGE HELPERS ─────────────────────────────────────────────────────────
-
-    def _resolve(self, nid):
-        """Resolve a node ID to its canonical (possibly merged) ID."""
-        return self.merge_map.get(nid, nid)
-
-    def _spring(self, u, v):
-        """Spring constant lookup with automatic merge-map resolution."""
-        return self.springs[(self._resolve(u), self._resolve(v))]
+            xlid = f'XL{d}'
+            self.nodes[xlid] = {'x': 0.0, 'vel': 0.0, 'anchored': False}
+            self.bridge_springs[(xlid, f'L{d}_{self.n_lower}')] = BRIDGE_K
+            self.bridge_springs[(xlid, f'L{d+1}_1')]            = BRIDGE_K
 
     # ── CROSS CONNECT TOGGLE ──────────────────────────────────────────────────
 
     def toggle_cross_connect(self):
-        """
-        Toggle structural node merging ON/OFF.
-        ON  → overlapping boundary hidden nodes become one shared vertex
-              with springs to both neighbouring inputs/outputs.
-        OFF → fully independent parallel hourglasses (original behaviour).
-        Rebuilds the mesh (topology change); spring values reset.
-        """
         self.cross_connect = not self.cross_connect
         self.running = False
         self._init_mesh()
         self.logs = []
-        ns = len(self.merge_map)
+        nb = len(self.bridge_springs) // 2  # each bridge has 2 springs
         if self.cross_connect:
             self.add_log(
-                f"Cross-connect ON — {ns} shared "
-                f"{'vertex' if ns == 1 else 'vertices'} "
-                f"(structural merge, no extra springs)"
+                f"Cross-connect ON — {nb} passive bridge "
+                f"{'vertex' if nb == 1 else 'vertices'} "
+                f"(k={BRIDGE_K}, not learned)"
             )
         else:
             self.add_log("Cross-connect OFF — independent parallel hourglasses")
@@ -206,8 +173,9 @@ class SimEngine:
         for d in range(1, n+1):
             self.nodes[f'A{d}']['x'] = a_vec[d-1]
             self.nodes[f'B{d}']['x'] = b_vec[d-1]
+        # Reset all hidden + bridge nodes
         for nid, nd in self.nodes.items():
-            if nid[0] in ('U', 'L'):
+            if nid[0] in ('U', 'L', 'X'):
                 nd['x'] = 0.0; nd['vel'] = 0.0
         c_vec = self._to_vec(c_target, n) if c_target is not None else None
         for d in range(1, n+1):
@@ -221,10 +189,6 @@ class SimEngine:
                 c['x']        = 0.0
 
     # ── ELASTIC STEP ──────────────────────────────────────────────────────────
-    # Forces are accumulated first, then integrated — clean slot for any
-    # future force contributions.  Merge-aware: all node lookups resolve
-    # through merge_map so shared vertices accumulate forces from every
-    # dimension that owns them.
 
     def _elastic_step(self, n_steps):
         alpha = self.back_alpha
@@ -234,46 +198,53 @@ class SimEngine:
             forces = {nid: 0.0 for nid, nd in self.nodes.items()
                       if not nd['anchored']}
 
+            # Standard hourglass forces (unchanged — no merge resolution needed)
             for d in range(1, n+1):
                 A_val = self.nodes[f'A{d}']['x']
                 B_val = self.nodes[f'B{d}']['x']
                 C_val = self.nodes[f'C{d}']['x']
 
                 for j in range(1, self.n_upper+1):
-                    uid_raw = f'U{d}_{j}'
-                    uid     = self._resolve(uid_raw)
-                    ak      = self._spring(f'A{d}', uid_raw)
-                    f       = FWD_K * (ak * A_val - self.nodes[uid]['x'])
+                    uid = f'U{d}_{j}'
+                    ak  = self.springs[(f'A{d}', uid)]
+                    f   = FWD_K * (ak * A_val - self.nodes[uid]['x'])
                     if alpha > 0:
-                        kuc = self._spring(uid_raw, f'C{d}')
+                        kuc = self.springs[(uid, f'C{d}')]
                         f  += alpha * kuc * (C_val - self.nodes[uid]['x'])
-                    if uid in forces:
-                        forces[uid] += f
+                    forces[uid] += f
 
                 for j in range(1, self.n_lower+1):
-                    lid_raw = f'L{d}_{j}'
-                    lid     = self._resolve(lid_raw)
-                    bk      = self._spring(f'B{d}', lid_raw)
-                    f       = FWD_K * (bk * B_val - self.nodes[lid]['x'])
+                    lid = f'L{d}_{j}'
+                    bk  = self.springs[(f'B{d}', lid)]
+                    f   = FWD_K * (bk * B_val - self.nodes[lid]['x'])
                     if alpha > 0:
-                        klc = self._spring(lid_raw, f'C{d}')
+                        klc = self.springs[(lid, f'C{d}')]
                         f  += alpha * klc * (C_val - self.nodes[lid]['x'])
-                    if lid in forces:
-                        forces[lid] += f
+                    forces[lid] += f
 
                 c = self.nodes[f'C{d}']
                 if not c['anchored']:
                     rest_c = (
-                        sum(self._spring(f'U{d}_{j}', f'C{d}') *
-                            self.nodes[self._resolve(f'U{d}_{j}')]['x']
+                        sum(self.springs[(f'U{d}_{j}', f'C{d}')] *
+                            self.nodes[f'U{d}_{j}']['x']
                             for j in range(1, self.n_upper+1)) +
-                        sum(self._spring(f'L{d}_{j}', f'C{d}') *
-                            self.nodes[self._resolve(f'L{d}_{j}')]['x']
+                        sum(self.springs[(f'L{d}_{j}', f'C{d}')] *
+                            self.nodes[f'L{d}_{j}']['x']
                             for j in range(1, self.n_lower+1))
                     )
                     forces[f'C{d}'] = forces.get(f'C{d}', 0.0) + \
                                       FWD_K * (rest_c - c['x'])
 
+            # Bridge forces — symmetric Hooke's law, passive (not learned)
+            # Bridge node pulled toward both neighbours; each neighbour gets
+            # an equal-and-opposite soft reaction pull toward the bridge.
+            for (bnode, peer), k in self.bridge_springs.items():
+                xb       = self.nodes[bnode]['x']
+                xp       = self.nodes[peer]['x']
+                spring_f = FWD_K * k * (xp - xb)
+                if bnode in forces: forces[bnode] += spring_f
+                if peer  in forces: forces[peer]  -= spring_f  # weak reaction
+
             max_v = 0.0
             for nid, f in forces.items():
                 nd        = self.nodes[nid]
@@ -284,10 +255,6 @@ class SimEngine:
                 break
 
     # ── FEEDFORWARD ───────────────────────────────────────────────────────────
-    # cross_connect=False → analytic K*input (original behaviour)
-    # cross_connect=True  → settled node positions used; shared vertices
-    #                        already encode cross-dimensional mixing from
-    #                        receiving forces from both neighbouring inputs.
 
     def _feedforward(self):
         n     = self.n_inputs
@@ -299,31 +266,31 @@ class SimEngine:
             B_val = self.nodes[f'B{d}']['x']
 
             for j in range(1, self.n_upper+1):
-                uid_raw = f'U{d}_{j}'
-                uid     = self._resolve(uid_raw)
-                ff[uid_raw] = (self.nodes[uid]['x'] if self.cross_connect
-                               else self._spring(f'A{d}', uid_raw) * A_val)
+                uid     = f'U{d}_{j}'
+                # With cross_connect the node's settled position already
+                # encodes the soft bridge influence — use it directly.
+                ff[uid] = (self.nodes[uid]['x'] if self.cross_connect
+                           else self.springs[(f'A{d}', uid)] * A_val)
 
             for j in range(1, self.n_lower+1):
-                lid_raw = f'L{d}_{j}'
-                lid     = self._resolve(lid_raw)
-                ff[lid_raw] = (self.nodes[lid]['x'] if self.cross_connect
-                               else self._spring(f'B{d}', lid_raw) * B_val)
+                lid     = f'L{d}_{j}'
+                ff[lid] = (self.nodes[lid]['x'] if self.cross_connect
+                           else self.springs[(f'B{d}', lid)] * B_val)
 
             if self.architecture == 'multiplicative':
                 nm   = max(self.n_upper, self.n_lower)
                 pred = 0.0
                 for i in range(nm):
-                    uid_raw = f'U{d}_{(i % self.n_upper)+1}'
-                    lid_raw = f'L{d}_{(i % self.n_lower)+1}'
-                    ku      = self._spring(uid_raw, f'C{d}')
-                    kl      = self._spring(lid_raw, f'C{d}')
-                    pred   += ku * ff[uid_raw] * kl * ff[lid_raw]
+                    uid  = f'U{d}_{(i % self.n_upper)+1}'
+                    lid  = f'L{d}_{(i % self.n_lower)+1}'
+                    ku   = self.springs[(uid, f'C{d}')]
+                    kl   = self.springs[(lid, f'C{d}')]
+                    pred += ku * ff[uid] * kl * ff[lid]
             else:
                 pred = (
-                    sum(self._spring(f'U{d}_{j}', f'C{d}') * ff[f'U{d}_{j}']
+                    sum(self.springs[(f'U{d}_{j}', f'C{d}')] * ff[f'U{d}_{j}']
                         for j in range(1, self.n_upper+1)) +
-                    sum(self._spring(f'L{d}_{j}', f'C{d}') * ff[f'L{d}_{j}']
+                    sum(self.springs[(f'L{d}_{j}', f'C{d}')] * ff[f'L{d}_{j}']
                         for j in range(1, self.n_lower+1))
                 )
             preds.append(pred)
@@ -331,10 +298,9 @@ class SimEngine:
         return preds, ff
 
     # ── LMS UPDATE ────────────────────────────────────────────────────────────
-    # Each dimension's error drives its own spring gradients independently.
-    # Shared vertices have springs from both dimensions updated separately
-    # — the merge means those canonical spring keys already exist in
-    # self.springs, so the updates land correctly with no special casing.
+    # Bridge springs are never in self.springs so they are never touched here.
+    # Each dimension's LMS update is fully independent — no cross-gradient
+    # bleed, no error inflation.
 
     def _lms_update(self, errors, ff):
         n = self.n_inputs
@@ -347,29 +313,25 @@ class SimEngine:
 
             if self.architecture == 'additive':
                 for j in range(1, self.n_upper+1):
-                    uid_raw = f'U{d}_{j}'
-                    uid     = self._resolve(uid_raw)
+                    uid     = f'U{d}_{j}'
                     ak_key  = (f'A{d}', uid)
                     uc_key  = (uid, f'C{d}')
-                    grads[ak_key] = self._spring(uid_raw, f'C{d}') * A_val
-                    grads[uc_key] = self._spring(f'A{d}', uid_raw) * A_val
+                    grads[ak_key] = self.springs[uc_key] * A_val
+                    grads[uc_key] = self.springs[ak_key] * A_val
                 for j in range(1, self.n_lower+1):
-                    lid_raw = f'L{d}_{j}'
-                    lid     = self._resolve(lid_raw)
+                    lid     = f'L{d}_{j}'
                     bk_key  = (f'B{d}', lid)
                     lc_key  = (lid, f'C{d}')
-                    grads[bk_key] = self._spring(lid_raw, f'C{d}') * B_val
-                    grads[lc_key] = self._spring(f'B{d}', lid_raw) * B_val
+                    grads[bk_key] = self.springs[lc_key] * B_val
+                    grads[lc_key] = self.springs[bk_key] * B_val
             else:
                 nm = max(self.n_upper, self.n_lower)
                 for i in range(nm):
-                    uid_raw = f'U{d}_{(i % self.n_upper)+1}'
-                    lid_raw = f'L{d}_{(i % self.n_lower)+1}'
-                    uid     = self._resolve(uid_raw)
-                    lid     = self._resolve(lid_raw)
-                    ku      = self._spring(uid_raw, f'C{d}')
-                    kl      = self._spring(lid_raw, f'C{d}')
-                    Uv      = ff[uid_raw]; Lv = ff[lid_raw]
+                    uid = f'U{d}_{(i % self.n_upper)+1}'
+                    lid = f'L{d}_{(i % self.n_lower)+1}'
+                    ku  = self.springs[(uid, f'C{d}')]
+                    kl  = self.springs[(lid, f'C{d}')]
+                    Uv  = ff[uid]; Lv = ff[lid]
                     grads[(f'A{d}', uid)] = ku * A_val * kl * Lv
                     grads[(f'B{d}', lid)] = kl * B_val * ku * Uv
                     grads[(uid, f'C{d}')] = Uv * kl * Lv
@@ -441,7 +403,7 @@ class SimEngine:
     def generate_batch(self, count=30):
         self.batch_queue.clear()
         n  = self.n_inputs
-        ns = len(self.merge_map)
+        nb = len(self.bridge_springs) // 2
         for _ in range(count):
             a_vec = [round(random.uniform(1.0, 10.0), 2) for _ in range(n)]
             b_vec = [round(random.uniform(1.0, 10.0), 2) for _ in range(n)]
@@ -450,7 +412,7 @@ class SimEngine:
         p = self.batch_queue.popleft()
         self.set_problem(p['a'], p['b'], p.get('c'))
         self.running = True
-        tag = f'M{ns}' if self.cross_connect and ns else '·'
+        tag = f'B{nb}' if self.cross_connect and nb else '·'
         self.add_log(
             f"▶ {count} | {self.dataset_type} | "
             f"D={n} U{self.n_upper}·L{self.n_lower} [{tag}]"
@@ -477,29 +439,32 @@ async def get_ui():
 @app.get("/state")
 async def get_state():
     springs_out = {f"{u}→{v}": round(k, 5) for (u, v), k in engine.springs.items()}
+    bridge_out  = {f"{u}→{v}": round(k, 5) for (u, v), k in engine.bridge_springs.items()}
     n  = engine.n_inputs
-    ns = len(engine.merge_map)
+    nb = len(engine.bridge_springs) // 2
     return {
-        'nodes':         engine.nodes,
-        'springs':       springs_out,
-        'layers':        engine.layers,
-        'error':         engine.current_error,
-        'prediction':    engine.current_prediction,
-        'predictions':   [round(engine.nodes[f'C{d}']['x'], 4) for d in range(1, n+1)],
-        'iter':          engine.iteration,
-        'logs':          engine.logs,
-        'history':       engine.history[-80:],
-        'running':       engine.running,
-        'mode':          engine.mode,
-        'architecture':  engine.architecture,
-        'dataset_type':  engine.dataset_type,
-        'n_inputs':      n,
-        'n_upper':       engine.n_upper,
-        'n_lower':       engine.n_lower,
-        'back_alpha':    engine.back_alpha,
-        'cross_connect': engine.cross_connect,
-        'n_shared':      ns,
-        'queue_size':    len(engine.batch_queue),
+        'nodes':          engine.nodes,
+        'springs':        springs_out,
+        'bridge_springs': bridge_out,
+        'layers':         engine.layers,
+        'error':          engine.current_error,
+        'prediction':     engine.current_prediction,
+        'predictions':    [round(engine.nodes[f'C{d}']['x'], 4) for d in range(1, n+1)],
+        'iter':           engine.iteration,
+        'logs':           engine.logs,
+        'history':        engine.history[-80:],
+        'running':        engine.running,
+        'mode':           engine.mode,
+        'architecture':   engine.architecture,
+        'dataset_type':   engine.dataset_type,
+        'n_inputs':       n,
+        'n_upper':        engine.n_upper,
+        'n_lower':        engine.n_lower,
+        'back_alpha':     engine.back_alpha,
+        'cross_connect':  engine.cross_connect,
+        'n_bridges':      nb,
+        'bridge_k':       BRIDGE_K,
+        'queue_size':     len(engine.batch_queue),
     }
 
 
@@ -518,7 +483,8 @@ async def toggle_cross():
         "ok":            True,
         "cross_connect": engine.cross_connect,
         "n_springs":     len(engine.springs),
-        "n_shared":      len(engine.merge_map),
+        "n_bridges":     len(engine.bridge_springs) // 2,
+        "bridge_k":      BRIDGE_K,
     }
 
 
@@ -547,10 +513,10 @@ async def config(data: dict):
         engine.running = False
         engine._init_mesh()
         engine.logs = []
-        ns = len(engine.merge_map)
+        nb = len(engine.bridge_springs) // 2
         engine.add_log(
             f"Mesh rebuilt: D={new_ni} U{new_nu}·L{new_nl} "
-            f"cross={'ON ('+str(ns)+' shared)' if engine.cross_connect else 'OFF'}"
+            f"cross={'ON ('+str(nb)+' bridges)' if engine.cross_connect else 'OFF'}"
         )
     else:
         engine.add_log(
@@ -570,13 +536,13 @@ async def set_layer(data: dict):
     elif layer == 'lower':  engine.n_lower  = max(1, min(16, engine.n_lower  + delta))
     engine.running = False
     engine._init_mesh()
-    ns = len(engine.merge_map)
+    nb = len(engine.bridge_springs) // 2
     engine.add_log(
         f"Topology → D={engine.n_inputs} U{engine.n_upper}·L{engine.n_lower} "
-        f"cross={'ON ('+str(ns)+' shared)' if engine.cross_connect else 'OFF'}"
+        f"cross={'ON ('+str(nb)+' bridges)' if engine.cross_connect else 'OFF'}"
     )
     return {
-        "ok":      True,
+        "ok":       True,
         "n_inputs": engine.n_inputs,
         "n_upper":  engine.n_upper,
         "n_lower":  engine.n_lower,