Update app.py

app.py

@@ -23,7 +23,7 @@ class SimEngine:
         self.n_upper       = 3
         self.n_lower       = 3
         self.back_alpha    = 0.45
-        self.cross_connect = False   # ← new
+        self.cross_connect = False
         self.running       = False
         self.batch_queue   = collections.deque()
         self.logs          = []
@@ -31,6 +31,7 @@ class SimEngine:
         self.current_error      = 0.0
         self.current_prediction = 0.0
         self.history            = []
+        self.merge_map          = {}
         self._init_mesh()
 
     # ── TOPOLOGY ──────────────────────────────────────────────────────────────
@@ -63,7 +64,6 @@ class SimEngine:
             self.nodes[f'B{d}']['x'] = 3.0
 
         self.springs = {}
-        # Vertical springs (always)
         for d in range(1, n+1):
             for j in range(1, self.n_upper+1):
                 uid = f'U{d}_{j}'
@@ -74,54 +74,89 @@ 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)
 
-        # Lateral springs (only when cross_connect=True)
-        if self.cross_connect and n > 1:
-            self._add_lateral_springs()
+        # 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()
 
-    # ── LATERAL SPRING HELPERS ────────────────────────────────────────────────
+    # ── NODE MERGE ────────────────────────────────────────────────────────────
 
-    def _lateral_keys(self):
-        """All lateral spring keys for current topology."""
-        keys = []
-        n = self.n_inputs
+    def _compute_merge_map(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}.
+        """
+        mm = {}
+        n  = self.n_inputs
         if n < 2:
-            return keys
+            return mm
         for d in range(1, n):
-            for j in range(1, self.n_upper+1):
-                keys.append((f'U{d}_{j}', f'U{d+1}_{j}'))
-            for j in range(1, self.n_lower+1):
-                keys.append((f'L{d}_{j}', f'L{d+1}_{j}'))
-        return keys
+            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
 
-    def _add_lateral_springs(self):
-        """Add lateral springs without disturbing existing vertical springs."""
-        for key in self._lateral_keys():
-            if key not in self.springs:
-                self.springs[key] = round(random.uniform(0.85, 1.15), 4)
+    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 _remove_lateral_springs(self):
-        """Remove lateral springs, preserving vertical springs."""
-        lateral = set(self._lateral_keys())
-        for key in lateral:
-            self.springs.pop(key, None)
+    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))]
+
+    # ── CROSS CONNECT TOGGLE ────────────────────────────────���─────────────────
 
     def toggle_cross_connect(self):
         """
-        Toggle cross_connect ON/OFF.
-        ON  → adds lateral springs between same-row hidden nodes of adjacent dims.
-        OFF → removes lateral springs.
-        Existing vertical spring values are never touched.
+        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)
         if self.cross_connect:
-            self._add_lateral_springs()
             self.add_log(
-                f"Cross-connect ON — {len(self._lateral_keys())} lateral springs added"
+                f"Cross-connect ON — {ns} shared "
+                f"{'vertex' if ns == 1 else 'vertices'} "
+                f"(structural merge, no extra springs)"
             )
         else:
-            n_removed = len([k for k in self._lateral_keys() if k in self.springs])
-            self._remove_lateral_springs()
-            self.add_log(f"Cross-connect OFF — {n_removed} lateral springs removed")
+            self.add_log("Cross-connect OFF — independent parallel hourglasses")
 
     # ── LOGGING ───────────────────────────────────────────────────────────────
 
@@ -141,8 +176,7 @@ class SimEngine:
     def _to_vec(self, val, n):
         if isinstance(val, (list, tuple)):
             v = [float(x) for x in val]
-            if len(v) >= n:
-                return v[:n]
+            if len(v) >= n: return v[:n]
             return v + [v[-1]] * (n - len(v))
         return [float(val)] * n
 
@@ -186,98 +220,76 @@ class SimEngine:
                 c['anchored'] = False
                 c['x']        = 0.0
 
-    # ── ELASTIC DISPLAY PHYSICS ───────────────────────────────────────────────
-    # Refactored to accumulate all forces first then integrate.
-    # This lets lateral forces slot in cleanly alongside vertical forces.
+    # ── 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
         n     = self.n_inputs
 
         for _ in range(n_steps):
-            forces = {}
-            for nid, nd in self.nodes.items():
-                if not nd['anchored']:
-                    forces[nid] = 0.0
+            forces = {nid: 0.0 for nid, nd in self.nodes.items()
+                      if not nd['anchored']}
 
-            # ── Vertical forces (per dimension) ───────────────────────────
             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  = f'U{d}_{j}'
-                    rest = self.springs[(f'A{d}', uid)] * A_val
-                    f    = FWD_K * (rest - self.nodes[uid]['x'])
+                    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'])
                     if alpha > 0:
-                        kuc = self.springs[(uid, f'C{d}')]
+                        kuc = self._spring(uid_raw, f'C{d}')
                         f  += alpha * kuc * (C_val - self.nodes[uid]['x'])
-                    forces[uid] = forces.get(uid, 0.0) + f
+                    if uid in forces:
+                        forces[uid] += f
 
                 for j in range(1, self.n_lower+1):
-                    lid  = f'L{d}_{j}'
-                    rest = self.springs[(f'B{d}', lid)] * B_val
-                    f    = FWD_K * (rest - self.nodes[lid]['x'])
+                    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'])
                     if alpha > 0:
-                        klc = self.springs[(lid, f'C{d}')]
+                        klc = self._spring(lid_raw, f'C{d}')
                         f  += alpha * klc * (C_val - self.nodes[lid]['x'])
-                    forces[lid] = forces.get(lid, 0.0) + f
+                    if lid in forces:
+                        forces[lid] += f
 
                 c = self.nodes[f'C{d}']
                 if not c['anchored']:
                     rest_c = (
-                        sum(self.springs[(f'U{d}_{j}', f'C{d}')] * self.nodes[f'U{d}_{j}']['x']
+                        sum(self._spring(f'U{d}_{j}', f'C{d}') *
+                            self.nodes[self._resolve(f'U{d}_{j}')]['x']
                             for j in range(1, self.n_upper+1)) +
-                        sum(self.springs[(f'L{d}_{j}', f'C{d}')] * self.nodes[f'L{d}_{j}']['x']
+                        sum(self._spring(f'L{d}_{j}', f'C{d}') *
+                            self.nodes[self._resolve(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'])
-
-            # ── Lateral forces (cross_connect only) ───────────────────────
-            # Each lateral spring K(u1, u2) pulls u1 toward u2 and vice-versa.
-            # This is standard Hooke: F = K*(x_other - x_self).
-            # Effect: adjacent-dimension hidden nodes share mechanical state —
-            # tension in one dimension's hidden layer propagates sideways.
-            if self.cross_connect and n > 1:
-                for d in range(1, n):
-                    for j in range(1, self.n_upper+1):
-                        u1, u2 = f'U{d}_{j}', f'U{d+1}_{j}'
-                        key = (u1, u2)
-                        if key in self.springs:
-                            k  = self.springs[key]
-                            dx = self.nodes[u2]['x'] - self.nodes[u1]['x']
-                            forces[u1] = forces.get(u1, 0.0) + k * dx
-                            forces[u2] = forces.get(u2, 0.0) - k * dx
-                    for j in range(1, self.n_lower+1):
-                        l1, l2 = f'L{d}_{j}', f'L{d+1}_{j}'
-                        key = (l1, l2)
-                        if key in self.springs:
-                            k  = self.springs[key]
-                            dx = self.nodes[l2]['x'] - self.nodes[l1]['x']
-                            forces[l1] = forces.get(l1, 0.0) + k * dx
-                            forces[l2] = forces.get(l2, 0.0) - k * dx
-
-            # ── Integrate ─────────────────────────────────────────────────
+                    forces[f'C{d}'] = forces.get(f'C{d}', 0.0) + \
+                                      FWD_K * (rest_c - c['x'])
+
             max_v = 0.0
             for nid, f in forces.items():
                 nd        = self.nodes[nid]
                 nd['vel'] = nd['vel'] * DAMPING + f * DT
                 nd['x']  += nd['vel'] * DT
                 max_v     = max(max_v, abs(nd['vel']))
-
             if max_v < SETTLE:
                 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):
-        """
-        When cross_connect=False: exact K*input (analytic, same as before).
-        When cross_connect=True:  hidden values read from elastic-settled
-                                  node positions — they already encode lateral
-                                  cross-dimensional mixing.
-        """
         n     = self.n_inputs
         preds = []
         ff    = {}
@@ -287,29 +299,31 @@ class SimEngine:
             B_val = self.nodes[f'B{d}']['x']
 
             for j in range(1, self.n_upper+1):
-                uid = f'U{d}_{j}'
-                ff[uid] = (self.nodes[uid]['x'] if self.cross_connect
-                           else self.springs[(f'A{d}', uid)] * A_val)
+                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)
 
             for j in range(1, self.n_lower+1):
-                lid = f'L{d}_{j}'
-                ff[lid] = (self.nodes[lid]['x'] if self.cross_connect
-                           else self.springs[(f'B{d}', lid)] * B_val)
+                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)
 
             if self.architecture == 'multiplicative':
                 nm   = max(self.n_upper, self.n_lower)
                 pred = 0.0
                 for i in range(nm):
-                    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]
+                    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]
             else:
                 pred = (
-                    sum(self.springs[(f'U{d}_{j}', f'C{d}')] * ff[f'U{d}_{j}']
+                    sum(self._spring(f'U{d}_{j}', f'C{d}') * ff[f'U{d}_{j}']
                         for j in range(1, self.n_upper+1)) +
-                    sum(self.springs[(f'L{d}_{j}', f'C{d}')] * ff[f'L{d}_{j}']
+                    sum(self._spring(f'L{d}_{j}', f'C{d}') * ff[f'L{d}_{j}']
                         for j in range(1, self.n_lower+1))
                 )
             preds.append(pred)
@@ -317,11 +331,14 @@ 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.
 
     def _lms_update(self, errors, ff):
         n = self.n_inputs
 
-        # ── Vertical springs (same as before) ─────────────────────────────
         for d in range(1, n+1):
             err   = errors[d-1]
             A_val = self.nodes[f'A{d}']['x']
@@ -330,57 +347,40 @@ class SimEngine:
 
             if self.architecture == 'additive':
                 for j in range(1, self.n_upper+1):
-                    uid = f'U{d}_{j}'
-                    grads[(f'A{d}', uid)]    = self.springs[(uid,     f'C{d}')] * A_val
-                    grads[(uid,     f'C{d}')] = self.springs[(f'A{d}', uid)]    * A_val
+                    uid_raw = f'U{d}_{j}'
+                    uid     = self._resolve(uid_raw)
+                    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
                 for j in range(1, self.n_lower+1):
-                    lid = f'L{d}_{j}'
-                    grads[(f'B{d}', lid)]    = self.springs[(lid,     f'C{d}')] * B_val
-                    grads[(lid,     f'C{d}')] = self.springs[(f'B{d}', lid)]    * B_val
+                    lid_raw = f'L{d}_{j}'
+                    lid     = self._resolve(lid_raw)
+                    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
             else:
                 nm = max(self.n_upper, self.n_lower)
                 for i in range(nm):
-                    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
-                    grads[(lid,     f'C{d}')] = Lv * ku * Uv
+                    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]
+                    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
+                    grads[(lid, f'C{d}')] = Lv * ku * Uv
 
             norm_sq = sum(g*g for g in grads.values()) + 1e-10
             mu      = err / norm_sq
             for key, g in grads.items():
-                self.springs[key] -= mu * g
-                self.springs[key]  = max(-30.0, min(30.0, self.springs[key]))
-
-        # ── Lateral spring update (cross_connect only) ─────────────────────
-        # Uses a cross-error Hebbian rule:
-        #   ΔK(u1,u2) ∝ -(e_d * x_u2 + e_{d+1} * x_u1)
-        # Interpretation: tighten lateral coupling when both neighbouring dims
-        # would benefit from sharing information; loosen when they conflict.
-        if self.cross_connect and n > 1:
-            lr_lat = 0.005
-            for d in range(1, n):
-                e1 = errors[d-1]; e2 = errors[d]
-                for j in range(1, self.n_upper+1):
-                    key = (f'U{d}_{j}', f'U{d+1}_{j}')
-                    if key in self.springs:
-                        x1 = ff.get(f'U{d}_{j}',   0.0)
-                        x2 = ff.get(f'U{d+1}_{j}', 0.0)
-                        grad = e1 * x2 + e2 * x1
-                        self.springs[key] -= lr_lat * grad / (grad**2 + 1e-10)**0.5
-                        self.springs[key]  = max(-30.0, min(30.0, self.springs[key]))
-                for j in range(1, self.n_lower+1):
-                    key = (f'L{d}_{j}', f'L{d+1}_{j}')
-                    if key in self.springs:
-                        x1 = ff.get(f'L{d}_{j}',   0.0)
-                        x2 = ff.get(f'L{d+1}_{j}', 0.0)
-                        grad = e1 * x2 + e2 * x1
-                        self.springs[key] -= lr_lat * grad / (grad**2 + 1e-10)**0.5
-                        self.springs[key]  = max(-30.0, min(30.0, self.springs[key]))
+                if key in self.springs:
+                    self.springs[key] -= mu * g
+                    self.springs[key]  = max(-30.0, min(30.0, self.springs[key]))
 
     # ── PHYSICS STEP ──────────────────────────────────────────────────────────
 
@@ -440,7 +440,8 @@ class SimEngine:
 
     def generate_batch(self, count=30):
         self.batch_queue.clear()
-        n = self.n_inputs
+        n  = self.n_inputs
+        ns = len(self.merge_map)
         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)]
@@ -449,9 +450,10 @@ class SimEngine:
         p = self.batch_queue.popleft()
         self.set_problem(p['a'], p['b'], p.get('c'))
         self.running = True
-        cx = 'X' if self.cross_connect else '·'
+        tag = f'M{ns}' if self.cross_connect and ns else '·'
         self.add_log(
-            f"▶ {count} | {self.dataset_type} | D={n} U{self.n_upper}·L{self.n_lower} [{cx}]"
+            f"▶ {count} | {self.dataset_type} | "
+            f"D={n} U{self.n_upper}·L{self.n_lower} [{tag}]"
         )
 
 
@@ -475,9 +477,8 @@ 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()}
-    n = engine.n_inputs
-    n_lat = len([k for k in engine.springs if
-                 k[0][0] in ('U','L') and k[1][0] in ('U','L') and k[0][0] == k[1][0]])
+    n  = engine.n_inputs
+    ns = len(engine.merge_map)
     return {
         'nodes':         engine.nodes,
         'springs':       springs_out,
@@ -497,7 +498,7 @@ async def get_state():
         'n_lower':       engine.n_lower,
         'back_alpha':    engine.back_alpha,
         'cross_connect': engine.cross_connect,
-        'n_lateral':     n_lat,
+        'n_shared':      ns,
         'queue_size':    len(engine.batch_queue),
     }
 
@@ -512,13 +513,12 @@ async def set_mode(data: dict):
 
 @app.post("/toggle_cross")
 async def toggle_cross():
-    engine.running = False
     engine.toggle_cross_connect()
     return {
         "ok":            True,
         "cross_connect": engine.cross_connect,
         "n_springs":     len(engine.springs),
-        "n_lateral":     len(engine._lateral_keys()),
+        "n_shared":      len(engine.merge_map),
     }
 
 
@@ -547,9 +547,10 @@ async def config(data: dict):
         engine.running = False
         engine._init_mesh()
         engine.logs = []
+        ns = len(engine.merge_map)
         engine.add_log(
             f"Mesh rebuilt: D={new_ni} U{new_nu}·L{new_nl} "
-            f"cross={'ON' if engine.cross_connect else 'OFF'}"
+            f"cross={'ON ('+str(ns)+' shared)' if engine.cross_connect else 'OFF'}"
         )
     else:
         engine.add_log(
@@ -569,9 +570,10 @@ 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)
     engine.add_log(
         f"Topology → D={engine.n_inputs} U{engine.n_upper}·L{engine.n_lower} "
-        f"cross={'ON' if engine.cross_connect else 'OFF'}"
+        f"cross={'ON ('+str(ns)+' shared)' if engine.cross_connect else 'OFF'}"
     )
     return {
         "ok":      True,