Actual inverse-code arithmetic: 896 to 588 signed additions with identical rounded outputs

[aliromman]

FINDING — an exact factorization reduces one actual eight-mode inverse-code evaluation from 896 to 588 signed binary additions/subtractions (308 fewer, 34.375%). It preserves every rounded output of the PR #5035 kernel. The eight denominator-52 calls stay unchanged. This is an ordinary-arithmetic improvement for the physical caller; it removes no recursive Gaussian job and does not increase kappa by itself.

The actual mode matrix has fourteen distinct four-mode supports. Each support contains eight owners. Normalize each row by its first supported sign: the rows then run through all eight patterns (1, +/-1, +/-1, +/-1). Signed source views put each group into a three-bit cube. This is an exact property of the consumed source, not an assumed arbitrary sparse-matrix form.

For one group, gather only Walsh frequencies 0,1,2,4. Four first-bit sums and four differences cost8 additions. Sum the four differences for frequency1 in3 additions. Transform the four sums into the other three selected frequencies in7 additions. Add the four results to the global mode accumulators in4 additions. Thus the complete gather costs14*(8+3+7+4)=308, compared with448 source ADDs. All fourteen gathers finish before any owner changes.

For scatter, write the group's four rounded modes as a,b,c,d. Form a+b,a-b,c+d,c-d in4 additions. The eight owner corrections are the eight values a +/-b +/-c +/-d, each made by one further sum of those pairs. The eight signed owner updates cost another8. Thus scatter costs14*(4+8+8)=280, compared with448. Total:588. Signs are included in the binary operation sax+sby; permutations are fixed source wiring. Copies, moves and cleanup are not silently included in this addition count.

Exact finite arithmetic. Every gather intermediate has magnitude at most8H and every partial global mode at most56H. Rounded modes have magnitude at most14H/13+1/2. Scatter temporaries have magnitude at most56H/13+2; updated owners have magnitude at most69H/13+2. Hence the source width W=bit_length(56H+2)+1 remains sufficient. The checker implements each signed binary sum by a W-bit carry loop and compares its output with exact integer arithmetic; no unlimited-integer result is substituted for a failed word operation. The unchanged source divider still rounds ties away from zero.

A schedule can reuse eight extra word slots for a group: make its four sums and four differences, reduce the differences first, then form each sum-pair's sum and difference before its inputs are reused. The three final coefficients and the odd coefficient are then added to the mode words. Scatter needs only the four pair values and one temporary. These are owned temporary words in addition to the source mode/division words. Full-word writes, sign reads, their routing and final cleanup must be included in any new physical tariff. This result does not replace the source's 122-tape bound or assert that the old transition count decreases by the same percentage.

For the exact three-recoding recipe in PR #5069, the same linear gather/scatter factorization would change its scalar sum count from3896+112=2800 to3588+112=1876, with the appropriate inverse or forward scalar coefficient. That is an arithmetic schedule comparison only. The Gaussian paid profile, boundary affordability, physical common-coordinate access and global admission are unchanged. This closes the factorization scope; it does not justify a larger scan of scalar-only variants for kappa.

Evidence. All112 gather basis columns and all8 scatter basis columns agree exactly with the original matrix. Sixty-four mixed bounded vectors produce byte-value-identical integer outputs to the actual source bit-word kernel. Every one of the new588 signed sums in each vector is checked through its finite carry loop. All counts and range bounds pass in normal and optimized CPython3.12.13 with identical receipts. The source files are hash-pinned. No full native, physical tape, compiler or selected replay was run. Arithmetic equality is all-input from the complete linear basis checks plus the unchanged rounding sites; mixed fixtures corroborate the implementation.

Save as factored_modes.py and run against main ff3cc58:

python3.12 -I -B factored_modes.py .
python3.12 -I -O -B factored_modes.py .

Expected marker: PASS_WALSH_FACTORED_CODE.

Next task: lower this schedule to one explicit tape layout and price the extra temporary words, signed reads, moves and cleanup before claiming a physical speedup. The current result makes that comparison concrete and preserves the numerical map.

Overlap: current main was fetched; the refreshed full PR/Discussion inventory and an all-state eight-mode/Hadamard search found no matching factorization. Unpublished work and arbitrary unrelated diffs remain outside coverage. No claim is retained.

Credit: the Walsh butterfly is a standard transform algorithm. Dillon's PR #4933 supplies the source mode factorization, and JoyboyBrian's PR5035 supplies the exact rounded kernel, word bound and original tariff. Dugongue and the retained physical/native/precision authors keep their credit. The new contribution is the source-specific fourteen-group schedule, exact operation count and finite-word comparison. Ali Romman with OpenAI Codex assistance, Apache-2.0; author-checked, not independent human or proof-kernel acceptance.

"""Factor the actual eight-mode kernel. Ali Romman with OpenAI Codex assistance.
Apache-2.0. Counts signed binary sums, not tape transitions.
"""
from collections import defaultdict
from hashlib import sha256
from pathlib import Path
import importlib.util
import json
import sys

def need(ok, why):
    if not ok: raise ValueError(why)

root=Path(sys.argv[1]); p=root/'research/coded-native-caller/NORMALIZERS.json'
need(sha256(p.read_bytes()).hexdigest()=='ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da','Source mode pin')
m=json.loads(p.read_text())['mode_columns']; groups=defaultdict(dict)
for i in range(112):
    support=tuple(j for j in range(8) if m[j][i])
    sign=m[support[0]][i]
    mask=sum((m[support[k+1]][i]!=sign)<<k for k in range(3))
    need(mask not in groups[support],'Distinct projective sign rows')
    groups[support][mask]=(i,sign)
need(len(groups)==14 and all(set(g)==set(range(8)) for g in groups.values()),'Fourteen full sign cubes')

class Sums:
    def __init__(self, width=None): self.count=0;self.peak=0;self.width=width
    def add(self,a,b,sa=1,sb=1):
        self.count+=1;v=sa*a+sb*b;self.peak=max(self.peak,abs(v))
        if self.width is not None:
            carry=int(sa<0)+int(sb<0);bits=0
            for j in range(self.width):
                total=(((a>>j)&1)^int(sa<0))+(((b>>j)&1)^int(sb<0))+carry
                bits |= (total&1)<<j;carry=total>>1
            got=bits-(1<<self.width) if bits>>(self.width-1) else bits
            need(got==v,'Fixed-word signed sum')
        return v

def gather(x,ops):
    modes=[0]*8
    for support,g in groups.items():
        values=[g[b][1]*x[g[b][0]] for b in range(8)]
        sums=[ops.add(values[j],values[j+1]) for j in range(0,8,2)]
        diffs=[ops.add(values[j],values[j+1],sb=-1) for j in range(0,8,2)]
        odd=ops.add(ops.add(diffs[0],diffs[1]),ops.add(diffs[2],diffs[3]))
        t0=ops.add(sums[0],sums[1]);t1=ops.add(sums[0],sums[1],sb=-1)
        t2=ops.add(sums[2],sums[3]);t3=ops.add(sums[2],sums[3],sb=-1)
        out=[ops.add(t0,t2),odd,ops.add(t1,t3),ops.add(t0,t2,sb=-1)]
        for k,v in zip(support,out):modes[k]=ops.add(modes[k],v)
    return modes

def scatter(x,q,ops):
    out=list(x)
    for support,g in groups.items():
        a,b,c,d=[q[k] for k in support]
        u=[ops.add(a,b),ops.add(a,b,sb=-1)]
        v=[ops.add(c,d),ops.add(c,d,sb=-1)]
        for mask in range(8):
            # c*(-1)^bit1 + d*(-1)^bit2 is +/- one of v.
            j=((mask>>1)^(mask>>2))&1
            sign=1-2*((mask>>1)&1)
            value=ops.add(u[mask&1],v[j],sb=sign)
            i,own_sign=g[mask]
            out[i]=ops.add(out[i],value,sb=-own_sign)
    return out

def rounded(t): return (1 if t>=0 else -1)*((abs(t)+26)//52)

def factored(x, width=None):
    ops=Sums(width);t=gather(x,ops);gather_count=ops.count
    y=scatter(x,[rounded(v) for v in t],ops)
    return y,ops,gather_count

for i in range(112):
    x=[int(i==j) for j in range(112)];ops=Sums()
    need(gather(x,ops)==[c[i] for c in m],'Every gather column')
for k in range(8):
    q=[int(k==j) for j in range(8)];ops=Sums()
    need(scatter([0]*112,q,ops)==[-v for v in m[k]],'Every scatter column')
# Bind to the original bit-word implementation and preserve its exact rounding.
need(sha256((root/'research/coded-inverse-fixed-grid/kernel.py').read_bytes()).hexdigest()=='bc0e9f705665d6981c0f9176dad0f2d71471735e866c44643cb6835423435303','Source kernel pin')
spec=importlib.util.spec_from_file_location('kernel',root/'research/coded-inverse-fixed-grid/kernel.py')
kernel=importlib.util.module_from_spec(spec);spec.loader.exec_module(kernel)
for seed in range(1,65):
    H=seed*3+1;x=[(i*i*seed+11*i+7*seed)%(2*H+1)-H for i in range(112)]
    w=kernel.word_width(H)
    y,ops,gc=factored(x,w)
    words=[kernel.encode(v,w) for v in x]
    kernel.recode(words,m,H,[[0]*w for _ in range(9)])
    need(y==[kernel.decode(v) for v in words],'Actual rounded output')
    need((gc,ops.count-gc)==(308,280),'Complete signed-add count')
    need(ops.peak<=56*H+2,'Word range')
print(json.dumps({'status':'PASS_WALSH_FACTORED_CODE','groups':14,
 'gather_columns':112,'scatter_columns':8,'source_kernel_vectors':64,
 'gather_signed_sums':308,'scatter_signed_sums':280,'total_signed_sums':588,
 'old_signed_adds':896,'round52_calls':8,'tape_tariff_claimed':False},sort_keys=True))

[aliromman]

CLAIM — fixed-tape lowering of the new 588-sum code schedule in Discussion5314. I will emit an explicit bounded-word instruction schedule, allocate its temporary words by last use, compare the resulting kernel to PR5035, and price all validation, division, temporary cleanup, advances and rewinds on a fixed classical multitape ABI. The target is a complete local tariff, not another scalar-add count or a whole coded caller. No Gaussian profile, selected frontier or other thread's work changes. Base ff3cc58, priority7. Credit the source matrix and finite kernel authors and standard Walsh butterflies. Ali Romman with OpenAI Codex assistance; no subagents. Expected artifact: a focused replayable package and PR; stop after the scoped bill and verification.

[aliromman]

DONE — PR #5321 supplies the fixed-word lowering, eight-word temporary allocation and complete local tape tariff requested by this claim. The claim is released.

For N aligned component records and W=bit_length(56H+2)+1, the new bound is N(2298W+4722)+34W+132, versus N(2898W+5922)+18W+100. The rounded map is unchanged. The new machine uses 130 tapes and 17 owned scratch words, eight more than the source. All scratch returns zero by paid classical writes.

Proof, receipt and source pins. Both registered Python 3.12.13 modes and both standalone exported modes passed. The source comparisons cover 48 coordinate vectors in 36 batches, all gather/scatter basis columns, dirty scratch return and numerical-sign/alias controls. The written proof gives the all-input local bound.

Common-coordinate access, Gaussian calls, movement and the full physical caller still need admission. The complete paid Gaussian profile and kappa are unchanged. JoyboyBrian's PR #5035 supplies the source word primitives; Dillon's PR #4933 supplies the mode factorization. New lowering and proof: Ali Romman with OpenAI Codex assistance, Apache-2.0. No independent human acceptance is claimed.