""" helix_router.py — the Polycentria Dual-Helix architecture applied where it works. Same pattern as the factorization bench (Helix A proposes candidates, Helix B certifies exactly), but the problem is now a ROUTING / sequence-optimization task over a structured 720-node manifold — and here the geometry is *informative*, so the Oracle Bias is genuinely positive. (In the ECDLP/factoring case the embedding couldn't see the hidden mod-p structure, so ε ≤ 0. Here the objective IS a function of the geometric features, so a geometric heuristic should — and, measured below, does — beat random search.) Setup (the SHD-CCP vocabulary, made concrete): * 720 nodes ("codon voxel packets") placed on the verified golden Clifford torus, arranged as 12 nested layers × 60 — node n at toroidal angles set by golden-ratio spread, lifted to R^4 with the exact golden radii r1²=(φ+2)/5, r2²=(3-φ)/5. * "travel cost" between packets = quadrance (squared distance) on that torus. * each node carries a reward with geometric structure (high near a few hotspots). * a "route" is a budget of K hops collecting distinct rewards minus λ·travel. * "compressed past data" = a visit-frequency prior distilled from past good routes, stored as a small toroidal summary (Quaternion-Chain-Compression-style) and used to bias candidate selection when current rewards are only noisily observed. Helix A (oracle): sample routes with P(next) ∝ exp((r̂ − λ·quadrance + α·prior)/τ). Helix B (certifier): EXACT route value; the reported best route's value is exact. We give the oracle and a uniform-random baseline the SAME exact-evaluation budget and measure the routing Oracle Bias ε = mean best value(oracle) − mean best value(random). Pure Python 3 standard library. python3 helix_router.py """ import math import random random.seed(20260628) PHI = (1 + 5 ** 0.5) / 2 R1 = math.sqrt((PHI + 2) / 5) # exact golden Clifford-torus radii (verified module) R2 = math.sqrt((3 - PHI) / 5) N_NODES = 720 LAYERS = 12 PER_LAYER = N_NODES // LAYERS # 60 # --------------------------------------------------------------------------- # # The 720-node golden toroidal manifold # --------------------------------------------------------------------------- # def node_pos(n): """Place node n on the golden Clifford torus in R^4. Major angle uses golden spread (low-discrepancy); minor angle indexes the 12 nested layers.""" layer = n // PER_LAYER a = (n * (PHI - 1)) % 1.0 # golden-angle major coordinate b = layer / LAYERS # 12-nested minor coordinate return (R1 * math.cos(2*math.pi*a), R1 * math.sin(2*math.pi*a), R2 * math.cos(2*math.pi*b), R2 * math.sin(2*math.pi*b)) POS = [node_pos(n) for n in range(N_NODES)] def quadrance(m, n): pm, pn = POS[m], POS[n] return sum((pm[k] - pn[k]) ** 2 for k in range(4)) # precompute the CAND nearest packets to each node (geometric locality), once. CAND = 48 NEAR = [sorted(range(N_NODES), key=lambda m, nn=n: quadrance(nn, m))[:CAND] for n in range(N_NODES)] def field_from(hotspots, sigma): f = [0.0] * N_NODES for n in range(N_NODES): f[n] = sum(math.exp(-quadrance(n, h) / sigma) for h in hotspots) return f # A PERSISTENT terrain shared across instances (this is what "past data" can learn); # each instance adds fresh per-instance hotspots + heavy observation noise. _terrain_rng = random.Random(101) PERSIST = field_from(_terrain_rng.sample(range(N_NODES), 3), sigma=0.25) # --------------------------------------------------------------------------- # # Problem instance: persistent terrain + fresh hotspots, observed under noise # --------------------------------------------------------------------------- # def make_instance(rng, sigma=0.25, noise=0.4, obs_frac=1.0): """Persistent terrain + fresh per-instance hotspots. Only a fraction `obs_frac` of packets have an observed (noisy) reward; the rest are UNSEEN (obs=0). A learned prior earns its keep precisely by filling those gaps from past data.""" fresh = field_from(rng.sample(range(N_NODES), 2), sigma) reward = [PERSIST[n] + fresh[n] for n in range(N_NODES)] obs = [(max(0.0, reward[n] + rng.gauss(0, noise)) if rng.random() < obs_frac else 0.0) for n in range(N_NODES)] return reward, obs # --------------------------------------------------------------------------- # # Helix B — exact route value (the certifier) # --------------------------------------------------------------------------- # LAMBDA = 0.6 K_HOPS = 12 def route_value(route, reward): """EXACT objective: distinct rewards collected − λ·total travel quadrance.""" seen = set() collected = 0.0 for n in route: if n not in seen: seen.add(n) collected += reward[n] travel = sum(quadrance(route[t], route[t+1]) for t in range(len(route)-1)) return collected - LAMBDA * travel # --------------------------------------------------------------------------- # # Helix A — candidate route proposers # --------------------------------------------------------------------------- # def propose_random(rng, M, start): return [[start] + [rng.randrange(N_NODES) for _ in range(K_HOPS)] for _ in range(M)] def propose_oracle(rng, M, start, obs, prior=None, alpha=0.0, tau=0.4): """Geometric policy sampling: from the precomputed local candidate set, pick the next packet with P ∝ exp((obs − λ·quadrance + α·prior)/τ). M diverse high-heuristic routes.""" routes = [] for _ in range(M): route = [start] cur = start for _ in range(K_HOPS): cands = NEAR[cur] # CAND nearest packets, precomputed scores = [] for n in cands: s = obs[n] - LAMBDA * quadrance(cur, n) if prior is not None: s += alpha * prior[n] scores.append(s / tau) mx = max(scores) w = [math.exp(s - mx) for s in scores] r = rng.random() * sum(w) acc = 0.0 pick = cands[-1] for n, wi in zip(cands, w): acc += wi if acc >= r: pick = n break route.append(pick) cur = pick routes.append(route) return routes # --------------------------------------------------------------------------- # # "Compressed past data" — a visit-frequency prior, stored as a small summary # --------------------------------------------------------------------------- # def learn_prior_from_history(rng, n_past=8, top_T=48): """Solve several PAST instances (same hotspot family), aggregate which packets the good routes visit, and COMPRESS to a small summary: the top-T packets + per-layer means. Returns (prior over all nodes, stored_floats) to report the compression ratio.""" visit = [0.0] * N_NODES for _ in range(n_past): reward, obs = make_instance(rng) # a "good" past route found by the oracle (no prior yet) cands = propose_oracle(rng, 40, rng.randrange(N_NODES), obs) best = max(cands, key=lambda rt: route_value(rt, reward)) for n in set(best): visit[n] += 1.0 # compress: keep top-T node frequencies + 12 per-layer averages top = sorted(range(N_NODES), key=lambda n: visit[n], reverse=True)[:top_T] layer_mean = [0.0] * LAYERS for n in range(N_NODES): layer_mean[n // PER_LAYER] += visit[n] layer_mean = [s / PER_LAYER for s in layer_mean] # reconstruct a smooth prior from the compressed summary prior = [layer_mean[n // PER_LAYER] for n in range(N_NODES)] for n in top: prior[n] += visit[n] mx = max(prior) or 1.0 prior = [p / mx for p in prior] stored_floats = top_T + LAYERS # vs N_NODES if stored raw return prior, stored_floats # --------------------------------------------------------------------------- # # Experiment # --------------------------------------------------------------------------- # def main(): print("Helix Router — Polycentria Dual-Helix on the 720-node golden toroidal manifold") print("=" * 74) print(f" {N_NODES} packets = {LAYERS} nested layers × {PER_LAYER}; golden Clifford torus") print(f" r1²=(φ+2)/5={R1*R1:.4f}, r2²=(3-φ)/5={R2*R2:.4f}; route = {K_HOPS} hops, λ={LAMBDA}") import statistics def band(diffs): return 2 * statistics.pstdev(diffs) / math.sqrt(len(diffs)) rng = random.Random(7) prior, stored = learn_prior_from_history(rng) print(f"\n Compressed past-data prior (persistent terrain): stored {stored} floats " f"vs {N_NODES} raw ({N_NODES/stored:.1f}× compression)") TRIALS, M = 80, 40 # equal exact-evaluation budget M for every method R, O, OM = [], [], [] for _ in range(TRIALS): reward, obs = make_instance(rng, obs_frac=0.30) # only 30% of rewards seen start = rng.randrange(N_NODES) bo = lambda routes: max(route_value(rt, reward) for rt in routes) # Helix B: exact R.append(bo(propose_random(rng, M, start))) O.append(bo(propose_oracle(rng, M, start, obs))) OM.append(bo(propose_oracle(rng, M, start, obs, prior=prior, alpha=1.5))) mR, mO, mOM = (sum(x)/TRIALS for x in (R, O, OM)) eps_geo = mO - mR print(f"\n Best route value at equal budget (M={M} evals, {TRIALS} instances, 30% rewards seen):") print(f" {'method':<32}{'mean best':>11}{'Δ vs random (±2σ)':>24}") print(f" {'random':<32}{mR:>11.3f}{'—':>24}") print(f" {'oracle (geometry)':<32}{mO:>11.3f}{f'+{eps_geo:.3f} (±{band([a-b for a,b in zip(O,R)]):.3f})':>24}") print(f" {'oracle + compressed memory':<32}{mOM:>11.3f}{f'+{mOM-mR:.3f} (±{band([a-b for a,b in zip(OM,R)]):.3f})':>24}") print(f"\n Does the compressed prior help? Memory lift = (oracle+memory) − oracle,") print(f" swept over how much of the reward field is observed (prior fills the gaps):") print(f" {'% rewards seen':>15}{'memory lift':>14}{'±2σ':>9}{' significant?':>15}") for frac in (1.0, 0.5, 0.25, 0.10): diffs = [] for _ in range(TRIALS): reward, obs = make_instance(rng, obs_frac=frac) start = rng.randrange(N_NODES) bo = lambda routes: max(route_value(rt, reward) for rt in routes) o = bo(propose_oracle(rng, M, start, obs)) om = bo(propose_oracle(rng, M, start, obs, prior=prior, alpha=1.5)) diffs.append(om - o) lift = sum(diffs)/len(diffs); bd = band(diffs) print(f" {int(frac*100):>14}%{lift:>14.3f}{bd:>9.3f}{(' yes' if lift>bd else ' within noise'):>15}") print("\n" + "=" * 74) print("FINDINGS (measured):") print(f" • Routing Oracle Bias ε = {eps_geo:+.2f} > 0, many σ — the geometric oracle decisively") print(f" BEATS random search at equal budget. This is the architecture working as intended:") print(f" the objective is a function of the embedding's features, so geometric proximity is") print(f" a genuinely useful candidate filter — the OPPOSITE of the mod-p case (ε≤0) where it") print(f" could not see the hidden structure.") print(f" • Compressed past-data prior ({N_NODES/stored:.0f}× compression of the persistent terrain): NOT a") print(f" significant lift here — it stays within the 2σ band at every observation level. It") print(f" does show a clean monotonic trend (mildly NEGATIVE when all rewards are seen, rising") print(f" toward positive as observation gets sparse), matching the principle that a prior") print(f" helps only when present data is missing — but it never clears significance in this") print(f" regime. Honest read: the geometry is the real win; stored history is marginal here.") print(" • Helix B keeps every reported route value EXACT — the oracle is never trusted") print(" blindly. Same safety discipline as the factoring bench; here, a useful purpose.") if __name__ == "__main__": main()