From 1afe68ea9a03e62306796e882acfd4a99f8b3d8c Mon Sep 17 00:00:00 2001 From: Joel Pulikkan Date: Fri, 9 Oct 2026 14:09:11 -0400 Subject: [PATCH] Note what entrance gauges and completed banks can absorb (no new kappa) The published bank endpoint replaces exactly the entrance-gauge correction F_A T_sigma F_A^-1; gauges need content that is both don't-care and restored, which targets and sources are not. Records why PR208's priced rungs need a different lemma, with two measured near-misses (auxiliary re-gauging under banks, target gauges). Co-Authored-By: Claude Opus 5.5 --- research/bank-gauge-boundary/README.md | 47 ++++++++ research/bank-gauge-boundary/regauge.py | 140 ++++++++++++++++++++++++ 2 files changed, 187 insertions(+) create mode 100644 research/bank-gauge-boundary/README.md create mode 100644 research/bank-gauge-boundary/regauge.py diff --git a/research/bank-gauge-boundary/README.md b/research/bank-gauge-boundary/README.md new file mode 100644 index 0000000000..c378e81282 --- /dev/null +++ b/research/bank-gauge-boundary/README.md @@ -0,0 +1,47 @@ +# What entrance gauges and completed banks can absorb (no new κ) + +A scoping note for the paired-cube words of #168 v4, #200 and #207–#213. **No κ is claimed, and no certificate changes.** + +#208 prices "bank-absorption rungs" (for example, absorbing the bit word's rank-22 family for +2.52%) and leaves open which families a bank may absorb. This note says where the published mechanism stops. The absorbable families are already absorbed on the current words. The priced rungs need a lemma outside this mechanism. + +## 1. What the published bank removes + +By `notes/paired-cube-sharing.tex`, a role entering with gauge T_σ has the exact operator U = F_A T_σ⁻¹. Its forward correction F_A U⁻¹ = F_A T_σ F_A⁻¹ has Fourier rank dim σ, and its three stage blocks tensor into **one** child of width 3·dim σ: the exterior. #186 and #207 replace exactly this correction with the S_P bank endpoint, and say so: "Exactly the 2200 rank60 gauge exteriors are removed. Every internal chain increment, source and target connector, centre copy, original data endpoint … remains." + +`notes/paired-cube-bit.tex` gives the converse. A role corrected at the zero frame has no exterior, and pays its first transition as an ordinary internal child. + +So, under this mechanism, **the bankable children are exactly the gauge exteriors.** On #207's word the surviving genuine entrance gauges number 2,200, and all of them are banked. The 1,760 rank-21 recipient gauges are internal splices (#186). + +## 2. When a register may carry an entrance gauge + +The correction F_A T_σ F_A⁻¹ fixes the frame because the role's scalar contract **restores its own entrance value**. Its raw entrance z is read as T_σ ẑ, and it exits as F_A ẑ, a function of ẑ alone. Two other register classes fail this test. + +- **Targets** accumulate. A target entering at gauge τ would end as T·T_τ⁻¹·y_old + T·f(x). + - One end correction cannot apply T_τ to the old part while leaving the new part alone. + - A start correction applied jointly on all three stage blocks breaks the gates. In stage j, a target is added to registers whose inactive blocks were not transformed the same way, so the inactive offsets no longer cancel. +- **Sources** are restored, but their values are *consumed*. Read as T_τ x̂, the injections would deliver x̂ ≠ x. + +An entrance gauge, and with it a bank, therefore needs content that is **both don't-care and restored**, i.e. auxiliary dirt. This is a property of the gauge/bank mechanism, not an impossibility proof for other constructions. + +## 3. Consequences for #208's rungs + +#208's own allocation classifies the rank-22 family (and every later rung's) as "internal / target / center / compensating / terminal-substitution dirt". Its verdict is "not buildable with the construction as published". Sections 1–2 give the reason. None of those children is an entrance-gauge exterior, and the target, source and internal ones fail the gauge test of section 2. A rung needs a mechanism other than gauge reinterpretation. + +## 4. Two measured near-misses + +These are float discovery scores on our #173 bit word (p = 12, R = 22,120). They show the boundary is binding in practice, not only in principle. + +- **Re-selecting auxiliary gauges once exteriors are free (banks).** + - There are 3,552 ungauged, non-source auxiliary roles outside phase one that have targets. Their feasible σ lies in the first-operation frame ∩ each target's first event frame. No role has an empty adjoint. + - Ignoring target cost, the upper bound is +4.17%. + - A gauge read at σ inserts an event into each of the role's 4–9 targets, splitting their first increments. The best nested selection loses 1.46%. + - A greedy pass that accepts a role only when the exact float saving rises accepts **zero** roles. +- **Target entrance gauges** (section 2) would price at +3.9%, or +4.5% merged with the final rank-two complement child. They are invalid for the reason given in section 2. + +The pricing scripts are short and read the #173 package (`research/paired-cube-bit-rl-module`). They are in `regauge.py` here and need numpy. + +## Scope + +All interfaces of the cited words remain as stated by their authors. Sections 1 and 2 restate and apply the published sharing and bank arguments; they do not prove optimality of any construction. Credit goes to an664 (#128 completed-core sharing), icekylinx (paired cubes, general Clifford frames), the #186/#207 bank authors (Dugongue and others), chafreaky (#200 word), and maxime-fleury (#208 pricing). + +Prepared by Joel Pulikkan (GamingPuzzled) with Anthropic Claude assistance; Apache-2.0. diff --git a/research/bank-gauge-boundary/regauge.py b/research/bank-gauge-boundary/regauge.py new file mode 100644 index 0000000000..42ed08feee --- /dev/null +++ b/research/bank-gauge-boundary/regauge.py @@ -0,0 +1,140 @@ +#!/usr/bin/env python3 +"""Float discovery pricing for README section 4 (auxiliary re-gauging under banks; target entrance gauges). + +Copyright 2026 Joel Pulikkan (GamingPuzzled). Apache-2.0. Prepared with Anthropic Claude assistance. +Reads the PR173 package research/paired-cube-bit-rl-module (set PR173 to its path). Discovery only; no certificate. +""" +import os +import sys,math +from collections import Counter,defaultdict +sys.path.insert(0,os.environ.get('PR173','research/paired-cube-bit-rl-module')) +from word import Candidate +c=Candidate([]);C=c.C;C.decoder();C.geometry();M=c.module;h=c.h;w,g=c.w,c.g +rf=w['root_frame'] +# target events in time order: gauge reads (by readtime), side roots, deliveries +ev=defaultdict(list) +for b in sorted(c.order,key=lambda b:c.readtime[b]): + for t in c.gauge[b]['targets']: ev[t].append(c.gauge[b]['frame']) +dl=defaultdict(list) +for e in C.k['entries']: dl[e['deliver_after_root']].append(e) +for j,r in enumerate(g['roots']): + if r['kind']=='center': continue + for t in r['targets']: ev[t].append(rf[j]) + for e in dl.get(j,[]): + for t in e['receivers']: ev[t].append(e['deliver_frame']) +adj=c.adjoint() +first_op={} +for i,(a,b,x) in enumerate(c.ops): + for s in (a,b): first_op.setdefault(s,i) +src=set(c.source.values());p1=set() +for i in c.phase1: p1.update(c.ops[i][:2]) +cand=[s for s in range(c.R) if s not in c.gauge and s not in src and s not in p1 and s in first_op and adj[s]] +cache={} +def inter(fs): + k=tuple(sorted(set(fs))) + if k not in cache: + A=[r for f in k for r in C.A[f]];B,_=M.kernel(A,h);cache[k]=len(B) + return cache[k] +dims=Counter();firstd=Counter();gain_rank=0 +for s in cand: + F=c.opframe[first_op[s]] + fs=[F]+[ev[t][0] for t in adj[s] if ev[t]] + f=inter(fs);dims[f]+=1;firstd[C.dimf[F]]+=1 +print('ungauged non-source roles with targets',len(cand),'of R',c.R,'| existing gauges',len(c.gauge)) +print('first-op dims',sorted(firstd.items())) +print('feasible sigma dims (read before all target events)',sorted(dims.items())) +print('targets per role',Counter(min(len(adj[s]),9) for s in cand).most_common(6)) +empty=[s for s in range(c.R) if s not in c.gauge and s not in src and s in first_op and not adj[s]] +print('ungauged roles with EMPTY adjoint',len(empty),'in phase1',sum(s in p1 for s in empty),'root roles',sum(s in c.rootroles for s in empty)) +print('their first-op dims',sorted(Counter(C.dimf[c.opframe[first_op[s]]] for s in empty).items())) +print('sources',len(src),'gauges',len(c.gauge),'phase1 roles',len(p1),'roots',len(c.rootroles)) +import math +row=c.row();H={int(k):n for k,n in row['child_histogram'].items()};W=row['W_per_vertex'];m=72 +def sav(H,W): + g=lambda a:math.fsum(n*r*math.exp(a*math.log(m/r)) for r,n in H.items() if n)-W*m + lo,hi=0.,2e-2 + for _ in range(80): + mid=(lo+hi)/2;lo,hi=(mid,hi) if g(mid)<0 else (lo,mid) + return lo +# 1) bank existing gauges: remove 5720 exterior children of width 60, W -= 5720*60/72 +Hb=dict(H);Hb[60]-=5720;Wb=W-5720*60/72;ab=sav(Hb,Wb);print('banked existing gauges: %.6e (vs unbanked %.6e)'%(ab,sav(H,W))) +# 2) regauge candidates at sigma f: first transition r->r-f (3 copies), exterior 3f banked (free): mass -3f, W -3f/72 +Hr=dict(Hb);Wr=Wb +for s in cand: + F=c.opframe[first_op[s]];r=C.dimf[F];f=inter([F]+[ev[t][0] for t in adj[s] if ev[t]]) + if f<=0: continue + # previous increment into first op frame from start (0) is r + Hr[r]-=3 + if r-f: Hr[r-f]=Hr.get(r-f,0)+3 + Wr-=3*f/72 +assert all(n>=0 for n in Hr.values()) +print('regauge upper bound (no target-split cost): %.6e gain %+.3f%%'%(sav(Hr,Wr),100*(sav(Hr,Wr)/ab-1))) +# exact-ish: frames per role sigma (actual subspace), nested chains on targets +def interF(fs): + A=[r for f in set(fs) for r in C.A[f]];B,_=M.kernel(A,h) + return c.register(B) if B else None +info=[] +for s in cand: + F=c.opframe[first_op[s]];r=C.dimf[F] + sg=interF([F]+[ev[t][0] for t in adj[s] if ev[t]]) + if sg is None: continue + f=C.dimf[sg];info.append((f,s,sg,r)) +info.sort(key=lambda z:-z[0]) +chains=defaultdict(list) # target -> accepted sigma frames +acc=[] +for f,s,sg,r in info: + ok=all(all(C.sub(sg,o) or C.sub(o,sg) for o in chains[t]) for t in adj[s]) + if ok: + acc.append((f,s,sg,r)) + for t in adj[s]: chains[t].append(sg) +print('accepted',len(acc),'of',len(info)) +# rebuild: role side +Hx=dict(Hb);Wx=Wb +for f,s,sg,r in acc: + Hx[r]-=3 + if r-f: Hx[r-f]=Hx.get(r-f,0)+3 + Wx-=3*f/72 +# target side: first increment d1 of each touched target split along its distinct sigma dims +for t,fs in chains.items(): + d1=C.dimf[ev[t][0]];ds=sorted(set(C.dimf[x] for x in fs)) + Hx[d1]-=3;prev=0 + for d in ds+[d1]: + if d>prev: Hx[d-prev]=Hx.get(d-prev,0)+3 + prev=d +assert all(n>=0 for n in Hx.values()) +ax=sav(Hx,Wx);print('regauge with nested target splits: %.6e gain %+.3f%% over banked'%(ax,100*(ax/ab-1))) +# marginal greedy: accept only if exact saving improves +def tsplit(d1,ds): + out=Counter();prev=0 + for d in sorted(set(ds))+[d1]: + if d>prev: out[d-prev]+=3 + prev=d + return out +Hg=Counter(Hb);Wg=Wb;cur=ab;chains2=defaultdict(list);n=0 +for f,s,sg,r in info: + if not all(all(C.sub(sg,o) or C.sub(o,sg) for o in chains2[t]) for t in adj[s]): continue + H2=Counter(Hg);H2[r]-=3 + if r-f: H2[r-f]+=3 + for t in adj[s]: + d1=C.dimf[ev[t][0]];old=[C.dimf[x] for x in chains2[t]] + if old: H2.subtract(tsplit(d1,old)) + else: H2[d1]-=3 + H2.update(tsplit(d1,old+[f])) + W2=Wg-3*f/72;a2=sav(+H2,W2) + if a2>cur: + Hg,Wg,cur=+H2,W2,a2;n+=1 + for t in adj[s]: chains2[t].append(sg) +print('marginal greedy accepted',n,'saving %.6e gain %+.3f%% over banked'%(cur,100*(cur/ab-1))) +# target entrance gauges: tau_t = first event frame E_t; first increment d1 (3 copies) -> one fused child 3*d1 +v=c.v;Ht=Counter(Hb);n=0;d1s=Counter() +for t in range(v): + if not ev[t]: continue + d1=C.dimf[ev[t][0]];Ht[d1]-=3;Ht[3*d1]+=1;n+=1;d1s[d1]+=1 +print('targets',n,'first-event dims',sorted(d1s.items())) +at=sav(+Ht,Wb);print('target gauges, fused correction child (unbanked): %+.3f%%'%(100*(at/ab-1))) +# variant: correction merged into the existing rank-2 final complement child of each data bank target +Hm=Counter(Ht) +for t in range(v): + if not ev[t]: continue + d1=C.dimf[ev[t][0]];Hm[3*d1]-=1;Hm[2]-=1;Hm[3*d1+2]+=1 +am=sav(+Hm,Wb);print(' ... merged with final rank-2 complement: %+.3f%%'%(100*(am/ab-1)))