From 64ec2a7293bb9c260d187883f120d0140864fbbd Mon Sep 17 00:00:00 2001 From: zxv Date: Wed, 28 Oct 2026 00:38:34 -0400 Subject: [PATCH 1/4] Construct complete spectator row stock for global H calls --- research/spectator-row-reservoir/PROOF.md | 167 +++++++++ research/spectator-row-reservoir/README.md | 64 ++++ research/spectator-row-reservoir/RESULT.json | 112 ++++++ research/spectator-row-reservoir/SOURCES.json | 78 ++++ research/spectator-row-reservoir/TASK.json | 124 +++++++ research/spectator-row-reservoir/VERIFY.json | 45 +++ research/spectator-row-reservoir/verify.py | 333 ++++++++++++++++++ 7 files changed, 923 insertions(+) create mode 100644 research/spectator-row-reservoir/PROOF.md create mode 100644 research/spectator-row-reservoir/README.md create mode 100644 research/spectator-row-reservoir/RESULT.json create mode 100644 research/spectator-row-reservoir/SOURCES.json create mode 100644 research/spectator-row-reservoir/TASK.json create mode 100644 research/spectator-row-reservoir/VERIFY.json create mode 100644 research/spectator-row-reservoir/verify.py diff --git a/research/spectator-row-reservoir/PROOF.md b/research/spectator-row-reservoir/PROOF.md new file mode 100644 index 0000000000..0d43389e61 --- /dev/null +++ b/research/spectator-row-reservoir/PROOF.md @@ -0,0 +1,167 @@ +# Complete spectator prefixes for the global Hadamard supplier + +Prepared by [zxv](https://github.com/zxv), with substantial OpenAI Codex assistance. Apache-2.0. This is a constructive conditional interface proof. The completed suppliers, fixed-tape primitives, numerical guarantees and analytic framework remain hypotheses. + +## 1. The opening in the actual caller + +Canonical main `721c03822c421b7f7fcbb2598993b947c4d88419` selects PR6030 at κ=.003125804, priority revision 8. Its outer ledger is the PR4359 `endpoint.py` named in SOURCES.json. The selected five assumptions remain. + +The retained `TENSOR-COMPILER.md` §3 states that its Hadamard schedule is identical across axes and coarse-label blocks; only the diagonal tables differ. `SUPPLIER-SUPPORT-AUDIT.md` §§2–3 and `SUPPORT-ADVERSARIAL-AUDIT.md` §3 explicitly authorize a completed H call on the **complete global binary tensor**, followed by restoration of the original coarse-coordinate order before the next diagonal. A fixed coarse-label microbox is outside that contract. + +The current reservation takes the row prefix and compact controls from the selected neighborhoods themselves. Those selected bits are deferred, so the active call is repeated on the reserved bits later. Under the conservative new-stock envelope in `OUTER-TRANSFER-AUDIT.md` §5, this needs the reserve to be sublinear in the active width. This is a sufficient allocation policy, not a property of the completed kernel. + +The source `notes/compact-control-layout.tex` supplies a stronger endpoint fact than preservation of address labels alone: each completed call is the desired C tensor on active coordinates and **identity on all reserved and spectator coordinates for arbitrary incoming coefficients**. Its row split uses only the leading row region; both front control fields and the back control field remain complete inside every row. This enables a different allocation. + +## 2. A sparse gather with an arbitrarily long spectator prefix + +Let the globally complete stream have binary address set `{0,1}^N`, arbitrary preceding fibers and arbitrary payloads. Let h disjoint complete K-bit neighborhoods occupy an ordered list S of k=hK positions. The selected bit has the same offset in each neighborhood. The input need not be separable, zero, or independent across coordinates. + +Let Q≥1 be the **product** of all simultaneous row divisibility requirements for the complete call, including nested BIT/complex calls. Put + +$$R=K\left\lceil\frac{\lceil\log_2 Q\rceil}{K}\right\rceil.$$ + +Choose front and back capacities + +$$G=4\lceil\log_2p\rceil+6,\quad K=128G,\quad H=hG,$$ + +$$F=K\lceil2H/K\rceil,\qquad B_c=K\lceil H/K\rceil.$$ + +Assume the following fields, plus the retained protected suffix/router workspace, fit inside N: + +$$\underbrace{R}_{\rm row}\ \big|\ \underbrace{F}_{\rm two\ front\ fields}\ \big|\ +\underbrace{hK}_{\rm active\ slots}\ \big|\ \underbrace{B_c}_{\rm back\ field}\ \big|\ \rm spectators.$$ + +Let T be the ordered positions of the active slots in this display. Map S to T in order. Complete the coordinate permutation π by sending `T\S` bijectively to `S\T`, in any fixed order, and fixing everything outside `S∪T`. + +**Lemma 1.** π is a bijection supported on at most 2hK positions. Every preimage of a physical position outside T lies outside S. In particular the new row prefix, front controls and back controls are genuine spectators of the selected kernel. + +**Proof.** The prescribed map S→T is a bijection. The remaining positions in the union are precisely `T\S` in the domain and `S\T` in the image, of equal cardinality. Their matching completes a bijection on the union. The identity completes it on the whole address set. Since all of S maps into T, no position outside T has a preimage in S. ∎ + +The original S may intersect the proposed physical row prefix. This is allowed: exposure moves those selected neighborhoods to T first. At the moment rows are exposed, the row prefix contains only spectator coordinates. No original selected bit is preprocessed or discarded. + +Crucially, this construction does **not** transpose an R-bit field across the address. It changes at most 2hK coordinate positions, even if R≫hK and T starts far from S. The retained support-local router charges by moved support, with arbitrary distance. Therefore exposure and restoration cost + +$$O\!\left(V(h+1)^{1-a_{\rm BIT}}\operatorname{polylog}p+\operatorname{poly}p\right).$$ + +Here a_BIT is the saving of the supplied paid equal-width BIT primitive. It is not free indexed access, and it is not automatically the old .0034 primitive when a stronger target requires a stronger router. The short-record proof reserves its untouched suffix before routing and confines later operations to its complement. The current construction leaves Θ(p) binary coordinates available whenever R+O(h polylog p)=o(p), so the same suffix and reservoir conditions hold. + +## 3. Complete rows, dirty data, one padding and return + +After π, interpret the first R bits as the row label and pad its count once: + +$$2^R\le Z:=Q\left\lceil2^R/Q\right\rceil<2^{R+1}.$$ + +Each added row contains the **entire** within-row range, including all active slots, both front controls, the back control, remaining spectators and the record suffix. Only the extra rows are zero. Every original row remains arbitrary. Existing row coordinates are being reinterpreted; there is no factor `2^R` increase in volume. The only enlargement is Z/2^R<2. + +Call the retained **active core at width h**, with H=hG and its complete stock Q. The spectator blocks are not passed as extra selected axes to the old public preprocessor; that step is replaced by this wrapper. The core proof uses the complete-field capacities, not their origin as selected axes. Run this complete active callee using Q. Its endpoint is + +$$I_{\rm ROW}\otimes I_{\rm controls}\otimes C_T\otimes I_{\rm remaining\ spectators}.$$ + +During this call Z is a possibly nonbinary preceding fiber, with the same binary within-row fields. Exposure routers run only before padding and after restriction, as in the retained source. Q covers the full nested product, so the source splits, chronological child returns and reassemblies require no second exterior padding. Temporary row mixing inside the implementation is permitted; its completed endpoint must be the displayed row-independent operator. + +Under the retained exact/common-grid endpoint contract, every padded zero row returns to zero. A rounded replacement must separately supply its completed-error and padding-disposal guarantee; ideal zero rows do not authorize silently erasing approximate residuals. Delete padded rows **before** running π inverse. Then restore the original coordinate layout. As an operator on the original global tensor, the result is exactly + +$$P_\pi^{-1}(I\otimes C_T)P_\pi=C_S.$$ + +This is equality on arbitrary full arrays, including arbitrary correlations with every borrowed spectator. All h selected kernels are completed in this one top-level active-core invocation, which still performs its retained internal recursion. There is no active-axis deferral caused by row or compact-field reservation. + +For arbitrary intervening diagonal operators D1,D2, the actual schedule is + +$$D_2\,P_\pi^{-1}(I\otimes C_T)P_\pi\,D_1=D_2 C_S D_1.$$ + +There is no claim that a coarse-dependent diagonal commutes with exposure or with intermediate row mixing. The next diagonal is executed only after padding deletion and inverse exposure. This is exactly the source tensor compiler's global-call boundary. + +Three limitations are substantive. A row-preserving but row-dependent endpoint `direct_sum_r C_r` is insufficient. A fixed-label microbox lacks complete spectator ranges. And a native caller needing the sum of simultaneous logarithmic stocks must not replace their product by a maximum. The verifier's controls test each distinction. + +## 4. Uniform capacity and cost without an active-width stock cutoff + +Let N=Θ(p), h≤C p^x, x<1, and suppose the **total** stock satisfies + +$$\log_2Q\le C_0\bigl(1+\log(2h)+h^\nu p^\zeta(\log(2p))^A\bigr),\qquad +0\le\nu<1,\quad\zeta\ge0.$$ + +Here the bound is on binary row bits. A source bound in complete K-bit chunks has the same power exponents because K=Θ(log p). Constants and degrees are fixed and computable before input length varies. + +If + +$$\boxed{\nu x+\zeta<1,}$$ + +then `R=O(p^(νx+ζ) polylog p+log p)=o(p)`, and `hK+F+B_c+router_workspace+protected_suffix=o(p)`. Thus the display in §2 fits eventually. The source long-axis condition also holds for d=Θ(p^ε), ε<1: each original axis has Θ(p^(1−ε)) bits and can contain its K-bit neighborhood. No requirement compares R with h or asks a single original axis to hold the row prefix. + +With explicit constants, an effective threshold follows from the positive power gaps. Below that fixed global threshold one may use the retained elementary algorithm; this is a finite parameter range absorbed in the asymptotic constant. No p-dependent `h≥p^(ζ/(1−ν))` threshold is needed. + +There is also no coefficient-guard charge proportional to R. For any fixed active prefix matrix A and number of rows Z, `||I_Z tensor A||_infinity=||A||_infinity`, and its largest dyadic denominator height is unchanged. The scalar role maps repeat the same bounded blocks at aligned row addresses; address/row permutations have norm one and add no denominators. The retained completed-child guard recurrence therefore has the same per-node constants and selected width h. Unlike the old preprocessor, this wrapper never applies a selected kernel to a prefix/control coordinate. Any prescribed h^rho envelope thus transfers without an extra R term, under the same all-column/primitive precision hypotheses. This is a mathematical coefficient-bound transfer, not an implementation of rounded native children. + +The source stopped recursion and complete stock Q are unchanged. Every internal child keeps the same complete within-row fields; its cost uses its current volume. The unused binary suffix still has Θ(p) positions because R+O(h polylog p)=o(p). Consequently the retained polynomial descriptor work, row arithmetic, parking and head-return charges have the same absorption as in the source. R-bit row parameters have O(p)-bit representations, and their setup is charged polynomial(p). The short-record suffix remains fixed by every operation that uses its length for amortization. + +If the underlying completed supplier has the retained `O(V h^(1−q) polylog p)` recurrence with q0 be completed complex-uniform and admitted ordinary BIT budgets and + +$$M=\min(U,B,1/32).$$ + +For a prescribed global/group precision guard `d^ρ polylog(d)`, ρ≥1, retain `ρε<1` and `ρβ<1`. At the full-width call h=d=Θ(p^ε), Theorem 2 needs `νε+ζ<1`; at grouped calls it needs `νβ+ζ<1`. Since β<ε and ν≥0, the global inequality implies the grouped one. Both include the product of simultaneous nested requirements. + +In the source ledger, replace its two active-width stock predicates by these two ambient stock tests. Retain all 54 strict checks and the other two functional checks, and append the two precision checks: 60 predicates in total. This is an explicitly changed wrapper, so active-width stock fit is not claimed or silently inferred. + +For `0≤ζ<1` put + +$$E=\begin{cases} +\min(1,1/\rho,(1-\zeta)/\nu),&\nu>0,\\ +\min(1,1/\rho),&\nu=0. +\end{cases}$$ + +**Theorem 3.** The 60 strict exponent predicates have rational witnesses exactly when + +$$\boxed{E>1/2,\qquad \mathrm{OLD}<\kappa0 gives ε>1/2. Source ordering gives qOLD. + +**Sufficiency.** Choose + +$$\epsilon=\frac{\max(\kappa/M,1/2)+E}{2},\quad +q=(\kappa/\epsilon+M)/2,\quad a=(2q+M)/3,\quad b=(q+2M)/3.$$ + +Then `1/2<ε0`. + +All remaining source predicates follow directly. The leaf saving is `(a+b)/2>a`, the internal exponent is `1−a`, and `λ=1−(q+a)/2` gives every λ gap. The positive membership/header gaps follow from β<2ε−1. Both group gauge expressions exceed `4(1−ε)+2h0`, while `00,$$ + +so the fused Gaussian and group BIT savings exceed the main saving. The boundary saving is at least 5/64; the sparse-union saving is at least 31/64; the group-scan saving is ε−η≥(3ε−1)/2>1/4, and the polynomial and microbox rows have savings greater than 1/2 and 77. They all exceed κ<1/32. The source constants, halo bounds, semantic group guard and explicit metadata predicate stay positive. This checks every family of the 60 predicates. The verifier additionally evaluates their exact source expressions on 1,920 witnesses, including points 10^-24 below ME. ∎ + +The general unchanged-ledger result `OLD<κζ`, i.e. β>6/5, which cannot hold. The construction escapes that restriction by changing where rows come from. It does not beat an unchanged invoice or declare a new .011 multiplier; the .02 suppliers remain missing. + +Six encoded layout checks at `log2 p=480,960,1920` verify complete prefix/control/active fields, the retained finite K guard, per-axis neighborhoods, router reservoirs and the protected suffix for both widths. They manipulate compressed integer counts; they do not execute astronomical tensors. Small exact reference fixtures separately execute the operator, padding, arbitrary dirty rows and label-dependent diagonal boundaries. The all-size theorem uses the written proof, not extrapolation from either family of checks. diff --git a/research/spectator-row-reservoir/README.md b/research/spectator-row-reservoir/README.md new file mode 100644 index 0000000000..933462337a --- /dev/null +++ b/research/spectator-row-reservoir/README.md @@ -0,0 +1,64 @@ +# Complete spectator rows remove the active-axis stock restriction + +**Constructive conditional interface theorem, with an exact reference. No new κ.** + +A global Hadamard supplier can take its row prefix and compact controls from complete spectator coordinates. It can complete every selected axis in one outer invocation, with one padding by less than two, and restore the original coarse layout before the next diagonal. The prefix may be much larger than the active width. + +The construction maps the h complete K-bit active neighborhoods to their destination slots, then completes that map on their union. Only **2hK coordinate positions** can move, regardless of the row-prefix length or gather distance. The retained paid support router therefore preserves the supplier's exponent. This is a concrete replacement for active-axis reservation and deferred completion, with the full layout and cost proof in [PROOF.md](PROOF.md). + +For total simultaneous stock + +$$\log_2Q=O(h^\nu p^\zeta\operatorname{polylog}p),$$ + +at width h=Θ(p^x), the new fit test is **νx+ζ<1**, using the ambient Θ(p)-bit address. It requires no stock cutoff h≥p^(ζ/(1−ν)) and no individual-axis fallback caused by row reservation. Existing coordinates supply the rows; there is no 2^R volume multiplier. + +## Significance for researchers + +This opens a larger supplier/representation contract than allocating rows inside the active axes. For hypothetical completed U=B=.02 suppliers with guard exponent ρ=3/2 and stock h^(1/2)p^(3/5) polylog(p), active-axis allocation would require β>6/5. The spectator construction instead gives a passing **κ=.011 interface**, with global stock power 217/240<1 and grouped stock power 157/240<1. The stronger finite suppliers remain missing; the example is a sufficient target for their implementation, not a new .011 multiplier. + +More generally, put M=min(U,B,1/32), and + +$$E=\min(1,1/\rho,(1-\zeta)/\nu)$$ + +for ν>0; omit the last term for ν=0 and require ζ<1. The changed wrapper's 60 strict exponent predicates admit rational witnesses exactly when `E>1/2` and `OLD<κ= 1 and K >= 1 and G >= 1 and Q >= 1, 'Positive geometry') + need(len(selected) % K == 0 and len(selected) > 0, 'Whole neighborhoods') + h = len(selected)//K + need(len(set(selected)) == len(selected) and all(0 <= s < n for s in selected), + 'Disjoint complete neighborhoods') + for j in range(h): + block = selected[j*K:(j+1)*K] + need(block == tuple(range(block[0], block[0]+K)), 'Contiguous original neighborhood') + R = K*ceildiv((Q-1).bit_length(), K) + front, back = K*ceildiv(2*h*G, K), K*ceildiv(h*G, K) + start = R+front + target = tuple(range(start, start+h*K)) + need(start+h*K+back <= n, 'Spectator prefix and all complete fields fit') + mapping = dict(zip(selected, target)) + for src, dst in zip(sorted(set(target)-set(selected)), sorted(set(selected)-set(target))): + mapping[src] = dst + # The sparse extension touches only S union T, irrespective of R. + domain = set(selected)|set(target) + need(set(mapping) == domain and set(mapping.values()) == domain, 'Bijective extension') + inverse = {v:k for k,v in mapping.items()} + need(all(inverse.get(i, i) not in selected for i in range(R)), + 'Every physical row bit comes from a genuine spectator') + rows = 1 << R + padded = Q*ceildiv(rows, Q) + need(rows >= Q and rows <= padded < 2*rows and padded % Q == 0, 'One bounded row padding') + return dict(n=n, h=h, K=K, G=G, Q=Q, R=R, front=front, back=back, + target=target, mapping=mapping, inverse=inverse, + rows=rows, padded_rows=padded, selected=selected) + + +def address(x, mapping, n): + y = x + for src, dst in mapping.items(): + bit = (x >> (n-1-src)) & 1 + mask = 1 << (n-1-dst) + y = (y & ~mask) | (bit << (n-1-dst)) + return y + + +def permute(values, mapping, n): + out = [ZERO]*len(values) + for x, value in enumerate(values): + out[address(x, mapping, n)] = value + return out + + +def mul(a, b): + return (a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0]) + + +def c_tensor(values, bits, n): + out = list(values) + for bit in bits: + mask = 1 << (n-1-bit) + for x in range(len(out)): + if x & mask: + continue + ar, ai = out[x] + br, bi = out[x|mask] + out[x] = ((ar-ai+br+bi)/2, (ar+ai-br+bi)/2) + out[x|mask] = ((ar+ai+br-bi)/2, (-ar+ai+br+bi)/2) + return out + + +def diagonal(values, n, salt): + # Deliberately address-dependent: coarse-label tables cannot be commuted. + phases = ((F(1),F(0)), (F(0),F(1)), (F(-1),F(0)), (F(0),F(-1))) + return [mul(v, phases[((x*salt) ^ (x >> 1)).bit_count() % 4]) + for x,v in enumerate(values)] + + +def wrapped(values, p, row_dependent=False, bad_padding=False, + skip_inverse=False, diagonal_too_early=False): + n, R = p['n'], p['R'] + need(len(values) == 1 << n, 'Full global binary rectangle') + data = permute(values, p['mapping'], n) + width = 1 << (n-R) + rows = [data[i*width:(i+1)*width] for i in range(p['rows'])] + rows += [[ZERO]*width for _ in range(p['padded_rows']-p['rows'])] + need(len(rows) % p['Q'] == 0, 'Full product stock, not maximum-only stock') + # A completed-callee fixture may permute arbitrary dirty rows internally. + # It returns I_ROW tensor C, not an implementation of the fast supplier. + rows = rows[1:]+rows[:1] + bits = [s-R for s in p['target'][::p['K']]] + rows = [c_tensor(row, bits, n-R) for row in rows] + rows = rows[-1:]+rows[:-1] + if row_dependent: + rows = [[mul(v, (F(-1),F(0))) if j & 1 else v for v in row] + for j,row in enumerate(rows)] + if bad_padding: + need(len(rows) > p['rows'], 'Control needs a padded row') + rows[-1][0] = (F(1),F(0)) + need(all(v == ZERO for row in rows[p['rows']:] for v in row), 'Padded rows return to zero') + data = [v for row in rows[:p['rows']] for v in row] + if diagonal_too_early: + data = diagonal(data, n, 7) + if not skip_inverse: + data = permute(data, p['inverse'], n) + return data + + +def source_rows(module, p): + out = module.ledger(p) + need(len(out['strict_checks']) == 54 and len(out['functional_checks']) == 3, + 'Exact source inventory') + values = dict(out['strict_checks'], **out['functional_checks']) + # Replace active-width stock fit by the proved ambient spectator fit. + del values['new_BIT_row_stock_sublinear_in_active_group'] + rho, nu, zeta = (p[k] for k in ('rho','nu','zeta')) + values.update(spectator_stock_global=1-nu*p['epsilon']-zeta, + spectator_stock_group=1-nu*p['beta']-zeta, + global_precision_guard=1-rho*p['epsilon'], + group_precision_guard=1-rho*p['beta']) + need(len(values) == 60, '54 strict, four functional and two new precision checks') + return values, out['margins'] + + +def witness(U, B, kappa, rho, nu, zeta): + need(rho >= 1 and 0 <= nu < 1 and 0 <= zeta < 1, 'Growth domain') + M = min(U,B,CAP) + E = min(F(1),1/rho,(1-zeta)/nu) if nu else min(F(1),1/rho) + low = max(kappa/M,F(1,2)) + need(low < E, 'Positive advancing contract') + eps = (low+E)/2 + q = (kappa/eps+M)/2 + a,b = (2*q+M)/3,(q+2*M)/3 + eta = min((2*eps-1)/2,(1-eps)/2) + beta = 2*eps-1-eta + h = min((eps-F(1,2))/2,F(1,64)) + return dict(kappa=kappa,complex_uniform_saving=U,bit_saving=B, + epsilon=eps,beta=beta,q=q,a=a,b=b,stop=(b-a)/(2*b), + r0=(1-rho*eps)/4,layout=F(3,32)-eps*q-h, + rho=rho,nu=nu,zeta=zeta) + + +def encode(value): + if isinstance(value,F): return str(value) + if isinstance(value,dict): return {k:encode(v) for k,v in value.items()} + if isinstance(value,(tuple,list)): return [encode(v) for v in value] + return value + + +def run(): + module,pins = authenticate() + rng = random.Random(6062) + geometry = semantic = basis = 0 + max_prefix_ratio = F(0) + for _ in range(600): + K = rng.randint(1,4) + h = rng.randint(1,6) + Q = rng.choice([1,3,5,6,15,45]) + R = K*ceildiv((Q-1).bit_length(),K) + n = R+K*ceildiv(2*h,K)+h*K+K*ceildiv(h,K)+rng.randint(0,20) + starts = rng.sample(range(0,n-K+1,K),h) + selected = tuple(x+j for x in starts for j in range(K)) + p = plan(n,selected,K,1,Q) + need(len(p['mapping']) <= 2*h*K, 'Support independent of row-prefix length') + for x in range(n): + need(p['inverse'].get(p['mapping'].get(x,x),p['mapping'].get(x,x)) == x, + 'All coordinate positions restored') + geometry += 1 + # Complete basis-column check of every one-bit source location at n=6. + for selected in range(6): + p = plan(6,(selected,),1,1,1) + for column in range(64): + values = [ZERO]*64 + values[column] = (F(1),F(0)) + expected = [ZERO]*64 + expected[column] = (F(1,2),F(1,2)) + expected[column ^ (1 << (5-selected))] = (F(1,2),F(-1,2)) + need(wrapped(values,p) == expected, 'Complete Gaussian operator column') + basis += 1 + fixtures = [] + for n in (7,8,9): + for Q in (3,5): + for s in range(n): + if (Q-1).bit_length()+4 > n: + continue + fixtures.append(plan(n,(s,),1,1,Q)) + for n,Q in ((11,6),(12,15)): + for _ in range(6): + fixtures.append(plan(n,tuple(rng.sample(range(n),2)),1,1,Q)) + for p in fixtures: + n=p['n'] + values=[(F(rng.randint(-4,4)),F(rng.randint(-4,4))) for _ in range(1 << n)] + inputs=diagonal(values,n,3) + expected=diagonal(c_tensor(inputs,p['selected'][::p['K']],n),n,7) + actual=diagonal(wrapped(inputs,p),n,7) + need(actual == expected, 'Arbitrary dirty payload and surrounding label-dependent diagonals') + max_prefix_ratio=max(max_prefix_ratio,F(p['R'],p['h'])) + semantic += 1 + p=plan(12,(0,1),1,1,15) + values=[(F(i%7-3),F(i%5-2)) for i in range(4096)] + inputs=diagonal(values,12,3) + expected=diagonal(c_tensor(inputs,(0,1),12),12,7) + controls={} + for label,kw in [('missing_inverse',dict(skip_inverse=True)), + ('row_dependent_endpoint',dict(row_dependent=True)), + ('coarse_diagonal_before_restoration',dict(diagonal_too_early=True))]: + actual=wrapped(inputs,p,**kw) + if not kw.get('diagonal_too_early'): + actual=diagonal(actual,12,7) + need(actual != expected,'Reject '+label) + controls[label]='rejected by exact Gaussian output' + for label,fn in [('nonzero_padded_return',lambda:wrapped(inputs,p,bad_padding=True)), + ('incomplete_microbox',lambda:wrapped(inputs[:-1],p)), + ('insufficient_ambient_space',lambda:plan(5,(0,),1,1,15))]: + try: fn() + except ValueError: controls[label]='rejected by explicit contract check' + else: raise ValueError('Control accepted: '+label) + # Product 3*5 is required; padding only to max(3,5) does not clear it. + wrong_rows=5*ceildiv(p['rows'],5) + need(wrong_rows % 15 != 0,'Maximum-only stock control') + controls['maximum_instead_of_product']='rejected by product divisibility' + + parameter_count=0 + for U in (F('.004'),F('.012'),F('.02'),F('.05')): + for B in (F('.004'),F('.012'),F('.02'),F('.05')): + for rho in (F(1),F(5,4),F(3,2),F(7,4)): + for nu in (F(0),F(1,250),F(1,2),F(9,10)): + for zeta in (F(0),F('.1'),F('.4'),F('.6')): + M=min(U,B,CAP) + E=min(F(1),1/rho,(1-zeta)/nu) if nu else min(F(1),1/rho) + top=M*E + if E <= F(1,2) or top <= module.OLD_BASELINE: continue + for kappa in ((top+module.OLD_BASELINE)/2,top-F(1,10**24)): + point=witness(U,B,kappa,rho,nu,zeta) + checks,rows=source_rows(module,point) + need(len(rows)==9 and all(v>0 for v in checks.values()),'Full positive outer witness') + parameter_count += 1 + point=witness(F('.02'),F('.02'),F('.011'),F(3,2),F(1,2),F('.6')) + checks,rows=source_rows(module,point) + need(all(v>0 for v in checks.values()),'Target-scale constructive example') + need(point['zeta']/(1-point['nu']) > 1,'Example cannot fit stock inside active width') + encoded=[] + for logp in (480,960,1920): + precision=1 << logp + G=4*logp+6 + K=128*G + for x in (point['epsilon'],point['beta']): + eh=x*logp + er=(point['nu']*x+point['zeta'])*logp + need(eh.denominator==er.denominator==1,'Encoded integral powers') + h=1 << eh.numerator + reserve=100*((1 << er.numerator)*logp**3+logp+1) + R=K*ceildiv(reserve,K) + required=R+K*ceildiv(2*h*G,K)+h*K+K*ceildiv(h*G,K)+logp**2 + need(required < precision//16,'Encoded ambient-prefix capacity') + support=2*h*K + free=precision//16-R + need(free > 9*support*G+2*(support+1)*logp**2,'Router reservoirs and protected suffix fit outside the row prefix') + d=1 << (point['epsilon']*logp).numerator + need(K+64*logp < precision//(12*d),'Complete neighborhoods fit original long axes') + need(K >= G+4*logp+10,'Actual finite compact-control guard') + encoded.append(dict(log2p=logp,width_power=x,stock_power=point['nu']*x+point['zeta'], + row_bits_log2_upper=R.bit_length(),required_bits_log2_upper=required.bit_length(), + address_bits_log2=logp-4)) + return encode(dict(status='PASS_SPECTATOR_ROW_RESERVOIR',source_sha256=pins, + geometry_cases=geometry,complete_gaussian_basis_columns=basis, + arbitrary_payload_fixtures=semantic,max_fixture_row_bits_per_active_bit=max_prefix_ratio, + controls=controls,outer_witnesses=parameter_count,outer_predicates=60, + constructive_example=dict(parameters=point,margins=rows, + minimum_strict_slack=min(checks.values()),old_active_stock_boundary=F(6,5)), + encoded_production_layouts=encoded, + scope='Constructive conditional spectator-prefix theorem and exact indexed reference. Retained router/callee/tape/precision/analytic contracts remain. No new finite supplier, kappa or full multiplier.')) + + +def main(): + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--emit',action='store_true') + args=parser.parse_args() + result=run() + if args.emit: print(json.dumps(result,indent=2,sort_keys=True)) + else: + need(result==json.loads((HERE/'RESULT.json').read_text()),'Receipt mismatch') + print(result['status'],'basis_columns='+str(result['complete_gaussian_basis_columns']), + 'outer_witnesses='+str(result['outer_witnesses']),'RECEIPT_MATCH no_new_kappa') + + +if __name__=='__main__': main() From 6db629b5db882c53fdf63848d3adf2f98d302e17 Mon Sep 17 00:00:00 2001 From: zxv Date: Tue, 27 Oct 2026 23:19:14 -0400 Subject: [PATCH 2/4] Align current CI navigation with selected PR6030 --- docs/ci-verification.md | 19 ++++++++++++++++++- docs/research/current-status.md | 2 +- 2 files changed, 19 insertions(+), 2 deletions(-) diff --git a/docs/ci-verification.md b/docs/ci-verification.md index 006bf5a3d5..63ba3e9aa8 100644 --- a/docs/ci-verification.md +++ b/docs/ci-verification.md @@ -1,6 +1,23 @@ # CI verification -## Current selected-family replay: #5599 +## Current selected-family replay: #6030 + +The [selected record](../certificates/selected-result.json) binds conditional +κ = 0.003125804 to the [proof review](research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md), +[validation receipts](research/pr-intake-evidence/pr6030-audit/VALIDATION.json), +and [explicit source closure](../certificates/frontier6030-source.json). +`make frontier6030-verify` follows that source-bound selected replay. The review +separates retained normal primary macOS/Linux evidence from fresh independent +word/invoice/native, original caller, adapted caller and optimized primary checks. +Consult its receipts for exact commands, source heads and limits; the #5599 +checkpoint below retains its own historical replay details. + +The five inherited framework assumptions remain. Neither the full uniform word +nor a complete rounded multiplier is materialized. A source/metadata check is +not an operator replay or a formal theorem proof. Routine research submissions +do not need to rerun this selected-family replay. + +## Historical selected-family replay: #5599 The [selected record](../certificates/selected-result.json) binds conditional κ = 0.00310045 to the [proof review](research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md) diff --git a/docs/research/current-status.md b/docs/research/current-status.md index a84ac12213..c49a245adc 100644 --- a/docs/research/current-status.md +++ b/docs/research/current-status.md @@ -1,6 +1,6 @@ # Current reviewed status -Selected conditional κ: **0.003125804 = 781451/250000000**, DreamingOfClouds' +Selected conditional κ: **0.003125804** = 781451/250000000, DreamingOfClouds' PR6030 on the cumulative P104 construction. The complete caller counts 13,444 productive fields and 66,834 paid calls. The saving is about 0.81775% above the preceding selected PR5599 claim 0.00310045. From 5a752d346450ca2b3d8088d70ec79aa19cdf9315 Mon Sep 17 00:00:00 2001 From: zxv Date: Wed, 28 Oct 2026 00:41:25 -0400 Subject: [PATCH 3/4] State the charged stock generation and aggregate-prefix contract --- research/spectator-row-reservoir/PROOF.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/research/spectator-row-reservoir/PROOF.md b/research/spectator-row-reservoir/PROOF.md index 0d43389e61..768a043574 100644 --- a/research/spectator-row-reservoir/PROOF.md +++ b/research/spectator-row-reservoir/PROOF.md @@ -80,7 +80,7 @@ Let N=Θ(p), h≤C p^x, x<1, and suppose the **total** stock satisfies $$\log_2Q\le C_0\bigl(1+\log(2h)+h^\nu p^\zeta(\log(2p))^A\bigr),\qquad 0\le\nu<1,\quad\zeta\ge0.$$ -Here the bound is on binary row bits. A source bound in complete K-bit chunks has the same power exponents because K=Θ(log p). Constants and degrees are fixed and computable before input length varies. +Q and the active-core descriptors must be generated within the retained charged polynomial(p) setup budget. A short numeric encoding alone does not prove fast generation. The row prefix is one aggregate field; it does not create R separately parsed descriptors. Here the bound is on binary row bits. A source bound in complete K-bit chunks has the same power exponents because K=Θ(log p). Constants and degrees are fixed and computable before input length varies. If From 1fb9f0604c5a281b6f504f17464f4c70522b3815 Mon Sep 17 00:00:00 2001 From: zxv Date: Wed, 28 Oct 2026 00:43:02 -0400 Subject: [PATCH 4/4] Credit the retained sparse extension separately from its new stock application --- research/spectator-row-reservoir/PROOF.md | 2 +- research/spectator-row-reservoir/README.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/research/spectator-row-reservoir/PROOF.md b/research/spectator-row-reservoir/PROOF.md index 768a043574..000c4e5ddf 100644 --- a/research/spectator-row-reservoir/PROOF.md +++ b/research/spectator-row-reservoir/PROOF.md @@ -31,7 +31,7 @@ Assume the following fields, plus the retained protected suffix/router workspace $$\underbrace{R}_{\rm row}\ \big|\ \underbrace{F}_{\rm two\ front\ fields}\ \big|\ \underbrace{hK}_{\rm active\ slots}\ \big|\ \underbrace{B_c}_{\rm back\ field}\ \big|\ \rm spectators.$$ -Let T be the ordered positions of the active slots in this display. Map S to T in order. Complete the coordinate permutation π by sending `T\S` bijectively to `S\T`, in any fixed order, and fixing everything outside `S∪T`. +Use the exact sparse extension already proved in the retained `SUPPORT-ROUTER.md`; its new application here is the spectator-prefix placement and complete-callee boundary. Let T be the ordered positions of the active slots in this display. Map S to T in order. Complete the coordinate permutation π by sending `T\S` bijectively to `S\T`, in any fixed order, and fixing everything outside `S∪T`. **Lemma 1.** π is a bijection supported on at most 2hK positions. Every preimage of a physical position outside T lies outside S. In particular the new row prefix, front controls and back controls are genuine spectators of the selected kernel. diff --git a/research/spectator-row-reservoir/README.md b/research/spectator-row-reservoir/README.md index 933462337a..5af75bdb7f 100644 --- a/research/spectator-row-reservoir/README.md +++ b/research/spectator-row-reservoir/README.md @@ -4,7 +4,7 @@ A global Hadamard supplier can take its row prefix and compact controls from complete spectator coordinates. It can complete every selected axis in one outer invocation, with one padding by less than two, and restore the original coarse layout before the next diagonal. The prefix may be much larger than the active width. -The construction maps the h complete K-bit active neighborhoods to their destination slots, then completes that map on their union. Only **2hK coordinate positions** can move, regardless of the row-prefix length or gather distance. The retained paid support router therefore preserves the supplier's exponent. This is a concrete replacement for active-axis reservation and deferred completion, with the full layout and cost proof in [PROOF.md](PROOF.md). +Using the retained SUPPORT-ROUTER sparse extension, the construction maps the h complete K-bit active neighborhoods to their destination slots, then completes that map on their union. Only **2hK coordinate positions** can move, regardless of the row-prefix length or gather distance. The retained paid support router therefore preserves the supplier's exponent. This is a concrete replacement for active-axis reservation and deferred completion, with the full layout and cost proof in [PROOF.md](PROOF.md). For total simultaneous stock