Repository navigation
Prove the scoped 112-call standalone fanout optimum (no new κ) - #5425
Merged
Mister-Meeseeks merged 2 commits intoOct 24, 2026
Merged
Mister-Meeseeks merged 2 commits into
Mister-Meeseeks merged 2 commits into
Conversation
Contributor
|
Independent numerical check of the source-bound constant C = 112 (no new κ; this is corroboration, not review of the written theorem). The module lower bound is a written all-width argument, so no finite computation can test it. Its only numerical input is the class census: C = Σ over LEFT classes {p ~ r iff A_p A_r⁻¹ is monomial}, with A_p = q⁻¹ Kp_p⁻¹, of the rank of the M rows in each class. I recomputed that census without the package's tableau classifier and without any of its code.
So the numerical specialization C = 112, matching the 112-H1 upper program, is independently confirmed. The theorem itself still needs independent reading: the Vandermonde faithfulness over all widths, the history-module bound (N+k)|G|, and the freeness of the class modules. Its grammar hypotheses (fixed finite program, fixed exterior coefficients, one row per paid call, no initial nonordinary observations) are scope conditions, not numbers. classes.py (standard library; reads FANOUT-INPUT-v1.json plus the two main files)"""Independent numerical check of the source-bound part of PR #5425's lower bound.
Mark (Matarener), with Claude Code assistance. Standard library only; uses no code from #5425.
Gate semantics (same in #5415 verify.py and the #5402 audit evaluator): a word is applied in
list order; P rows: y_j = parity(row_j & x); D(Q, alpha): phase += sum alpha_j x_j +
2 sum_j x_j parity(Q_j & x & above_j) (mod 4); X b: x ^= b; phase g: phase += g.
q^-1 = C(mask 1, sign -1): |x> -> (1-i)|x> + (1+i)|x^1> (unnormalised; C_s C_-s = 4 I).
The theorem's constant C = sum over LEFT classes {p ~ r iff A_p A_r^-1 monomial} of the rank of
the class rows of M, with A_p = q^-1 Kp_p^-1. This script decides every pair directly: it builds
L_{p,r} = A_p A_r^-1 (up to the scalar 4) = C_- Kp_p^-1 Kp_r C_+ and evaluates ALL 512 basis
columns exactly over Gaussian integers; L is monomial iff every column has one nonzero entry.
It also checks every A_p is non-monomial, every M row is nonzero, the input binding to the pinned
NORMALIZERS/PROVIDER files on main, and (control) that a known monomial pair is detected.
"""
import json, time, hashlib
from fractions import Fraction
from pathlib import Path
HERE = Path(__file__).resolve().parent
LOG = HERE / 'classes.log'
def log(*a):
s = time.strftime('%H:%M:%S ') + ' '.join(str(x) for x in a)
print(s, flush=True)
with open(LOG, 'a', encoding='utf-8') as f:
f.write(s + '\n')
def need(ok, why):
if not ok:
raise SystemExit('FAIL: ' + why)
def par(x):
return bin(x).count('1') & 1
def table(word):
"""Monomial word -> list of (image, phase mod 4) for the 512 basis states."""
out = []
for x in range(512):
y, ph = x, 0
for g in word:
k = g[0]
if k == 'P':
y = sum(par(r & y) << j for j, r in enumerate(g[1]))
elif k == 'D':
Q, al = g[1], g[2]
ph += sum(al[j] for j in range(9) if y >> j & 1)
ph += 2 * sum(par(Q[j] & y & ~((1 << (j + 1)) - 1)) for j in range(9) if y >> j & 1)
elif k == 'X':
y ^= g[1]
elif k == 'phase':
ph += g[1]
else:
raise SystemExit('unknown gate %r' % (g,))
out.append((y, ph % 4))
need(len({y for y, _ in out}) == 512, 'word is a permutation monomial')
return out
def inverse(t):
o = [None] * 512
for x, (y, p) in enumerate(t):
o[y] = (x, -p % 4)
return o
def compose(first, second): # apply first, then second
return [(second[y][0], (p + second[y][1]) % 4) for y, p in first]
I4 = [(1, 0), (0, 1), (-1, 0), (0, -1)]
def gmul(a, b):
return (a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0])
def apply_C(vec, s):
out = {}
for x, v in vec.items():
for y, c in ((x, (1, s)), (x ^ 1, (1, -s))):
w = gmul(c, v); o = out.get(y, (0, 0)); n = (o[0] + w[0], o[1] + w[1])
if n == (0, 0):
out.pop(y, None)
else:
out[y] = n
return out
def apply_m(vec, t):
return {t[x][0]: gmul(I4[t[x][1]], v) for x, v in vec.items()}
def is_monomial_L(m):
"""L = C_- m C_+ (applied right to left: C_+ first, then m, then C_-)."""
for x in range(512):
v = apply_C({x: (1, 0)}, +1)
v = apply_m(v, m)
v = apply_C(v, -1)
if len(v) != 1:
return False
return True
def main():
t0 = time.time()
inp = json.loads((HERE / 'inputs/FANOUT-INPUT-v1.json').read_text())
norm = json.loads((HERE / 'inputs/NORMALIZERS.json').read_text())
prov = json.loads((HERE / 'inputs/PROVIDER.json').read_text())
# binding: the fanout input equals the pinned files on main
need([z['K_word'] for z in norm['ports']] == inp['Kp_words'], 'Kp words bound to NORMALIZERS')
need([[norm['mode_columns'][k][i] for k in range(8)] for i in range(112)] == inp['M_rows'], 'M rows bound')
km = {z['mode']: z['input_K']['literal_word'] for z in prov['mode_boundaries']}
need([km[k] for k in range(8)] == inp['Km_words'], 'Km words bound to PROVIDER (no factor 2)')
log('inputs bound: 112 Kp, 112x8 M, 8 Km')
Kp = [table(w) for w in inp['Kp_words']]
Kpinv = [inverse(t) for t in Kp]
# every A_p = C_- Kp_p^-1 is non-monomial (one column suffices)
for p in range(112):
v = apply_C(apply_m({0: (1, 0)}, Kpinv[p]), -1)
need(len(v) == 2, 'A_p has two entries in column 0')
need(all(any(r) for r in inp['M_rows']), 'every M row is nonzero')
# control: L_{p,p} is the identity (monomial); and a deliberately monomial pair
need(is_monomial_L(compose(Kp[0], Kpinv[0])), 'control: identity pair is monomial')
zphase = table([['D', [0] * 9, [2, 0, 0, 0, 0, 0, 0, 0, 0]]]) # Z on the central axis
need(is_monomial_L(zphase), 'control: q^-1 Z0 q (a Pauli) is monomial')
s = table([['D', [0] * 9, [1, 0, 0, 0, 0, 0, 0, 0, 0]]]) # S on the central axis: not preserved
need(not is_monomial_L(s), 'control: q^-1 S0 q is not monomial')
log('controls pass')
classes = list(range(112)); pairs = 0; mono = []
for p in range(112):
for r in range(p + 1, 112):
# L_{p,r} = A_p A_r^-1 = q^-1 Kp_p^-1 Kp_r q: apply q (C_+), then Kp_r, then Kp_p^-1, then q^-1 (C_-)
m = compose(Kp[r], Kpinv[p])
pairs += 1
if is_monomial_L(m):
mono.append((p, r))
if p % 16 == 15:
log('rows done', p + 1, 'pairs', pairs, 'monomial pairs', len(mono), '%.0fs' % (time.time() - t0))
# union-find classes
parent = list(range(112))
def f(a):
while parent[a] != a:
parent[a] = parent[parent[a]]; a = parent[a]
return a
for p, r in mono:
parent[f(p)] = f(r)
groups = {}
for p in range(112):
groups.setdefault(f(p), []).append(p)
def rank(rows):
a = [[Fraction(x) for x in row] for row in rows]; rk = 0
for c in range(8):
k = next((k for k in range(rk, len(a)) if a[k][c]), None)
if k is None:
continue
a[rk], a[k] = a[k], a[rk]
for k2 in range(len(a)):
if k2 != rk and a[k2][c]:
fct = a[k2][c] / a[rk][c]; a[k2] = [x - fct * y for x, y in zip(a[k2], a[rk])]
rk += 1
return rk
C = sum(rank([inp['M_rows'][p] for p in g]) for g in groups.values())
res = {'pairs_tested': pairs, 'monomial_pairs': mono, 'classes': len(groups), 'C': C,
'all_A_p_nonmonomial': True, 'controls': ['identity pair monomial', 'q^-1 Z0 q monomial', 'q^-1 S0 q not monomial'],
'seconds': round(time.time() - t0, 1)}
(HERE / 'classes_result.json').write_text(json.dumps(res, indent=1))
log('RESULT classes', len(groups), 'C =', C, 'monomial pairs', len(mono))
need(len(groups) == 112 and C == 112, 'claimed 112 singleton classes and C = 112')
log('PASS_INDEPENDENT_5425_CLASSES')
if __name__ == '__main__':
main()Mark (Matarener), with Claude Code assistance. |
This was referenced Oct 24, 2026
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Change and mathematical scope
Give a matching construction and written lower bound for the standalone interface
The construction uses 112 paid H1 calls, 672 ADDs, 344 monomial maps, 8 COPYs, 249 CLEARs and 249 zero-retags. Seventeen owned fields have arbitrary entry values and return zero. There are no runtime odd divisions and no query reduction. The exact 112-row source classification has 112 singleton classes, each of rational row rank one.
The accompanying written proof establishes 112 TOTAL Gaussian field calls in its declared standalone grammar, matching this upper bound. It allows later paid calls to consume earlier responses. Its hypotheses remain essential: one fixed finite exact program, fixed exterior coefficients, a finite columnwise ordinary group, the same program on every positive width or one consecutive integer-width tail, ordinary initial span only, fixed common field capacity, arbitrary independent original inputs, the retained scalar-row/shared-right-factor structure, and one field-output row per paid call.
This is not 112 additional calls at a global cut. Existing Gaussian/native/cached initial observations, changed capacities or multiple outputs per charge, inter-column operations, width-dependent/growing programs, restricted width subsequences, approximate/nonlinear/antilinear computations and projective-phase identities lie outside the theorem. It supplies no complete caller, physical raw dual, weighted recursive invoice, compiler/precision/stock admission or new κ.
Task and overlap
The explicit donor assignment and coordinated owner request change the pinned
independent-momentcard to this source-bound construction/optimality/verification package;TASK.jsonrecords that scope change. It identifies a precise limit on standalone fanout work so that caller research can investigate genuinely different premises, including actual pre-existing observations, with complete accounting.Canonical provenance is
1a3ced60b2f7a46bc70280a04f2eeb8ca027c700, selected conditional κ.003027288235under the same five assumptions. The upper checker, its six consumed dependencies, original program/result and module proof are retained unchanged with explicit LOCAL provenance and owner publication permission. Canonical metadata/Merkle origins do not turn those generated files into canonical ancestors. The source provider lineage includes #5402; #5423 and #5424 are distinct coordinated component and budget contributions. No new standalone census, competing constructor or reinterpretation of their price allowances is introduced here.Pre-submission all-author coverage through 08:46:47 UTC found no new competing source/fanout/price submission; main, selected record and guidance were unchanged. Discussion-only and unpublished work are not exhaustively covered. Existing ownership coordination is retained, and this result does not reserve another contributor's caller work.
Validation
The original unchanged checker is
b824bf066999887b96fc386678ce44fb2269dc30406b06d65a9aac43a0437ae3. Its complete RESULT isbf29a13f9e7ef9feb87befcc71b6919ed75726e6fef87b139e0c9c6ad244cdb7; complete PROGRAM is5575fc71eb94f1b75b3421d787d3313716ece5e72d3498ce348500f3628291f7(1,282,103 bytes). The written module proof is retained atcfa9f3df855f96a3e73bcb8042a750a3aa41d18ec098d6a34268370f3e84d782.The 57,344 column comparisons check 112 singleton SELF-alias operators on 512 addresses each. They are not a fresh 137-field physical endpoint replay. Forward endpoint correctness is compositional: pinned Kp/Km words and exact phase conventions, integer factorization/recovery certificates, one exterior 1/2, literal ADD segments and source/owned lifetimes. The native factor2 is not counted again in Km, and exterior coefficients are not tensor-powered. Thirteen original controls reject phase, ordering, alias, coefficient, scalar-lift and lifetime mutations.
Independent static review accepts the upper construction under its pinned premises. A separate static proof review accepts the lower argument: all-width Vandermonde faithfulness, finite ordinary-module history dimension even with feedback/overwrites, a CENTRAL scalar right inverse followed only by cancellation of an invertible group element, and disjoint coset supports. No ordinary ring-domain assumption is made; zero divisors are allowed. The consecutive-tail corollary uses shifted Vandermonde powers. This is a written proof and independent mathematical reading, not a formal-kernel or numerical verification of the lower theorem. The wrapper authenticates and scopes the proof; it does not execute it as a theorem checker.
Four authorized fresh upper-checker replays passed in three serial 30-second/256-MiB requests: registered normal/optimized pair 8.757609s, 88,203,264 sampled peak bytes; readonly normal 4.230012s, 57,831,424B; readonly optimized 4.637756s, 62,660,608B. All four complete PROGRAMs and RESULTs match the frozen originals in full raw bytes AND typed JSON, with ZERO exclusions. The wrapper's ten controls also reject forged source/proof evidence, global/incremental or cached-history promotion, unsupported widths/capacity, false physical-replay claims and numeric-type substitutions. These augment the thirteen controls in the original upper checker.
Full fresh PROGRAMs are retained through lossless zlib+base64 transport. Bounded strict decoding checks length, EOF, no unused/unconsumed tails, raw SHA and exact uncompressed bytes. Compression is only transport; no compressed-container hash determines scientific equality. Full small RESULTs remain UTF-8. All eight fresh artifacts are publicly reconstructible from the passive raw capsule.
The 67 actual pinned files comprise 32 working sources, 32 readonly copies, runner, guard and source freeze. Actual peer pre/post custody and independent current readbacks match; the new current readback has its own UTC provenance and is not presented as an independently captured historical post-run snapshot. All 23 readonly directory modes match. Portable sources were 0444/directories 0555 with empty PATH, absolute Python and an explicit Git-discovery ceiling/probe exit 128; ancestor Git metadata was preserved.
Two passive artifacts sit OUTSIDE the 32 executed package sources and source export: the exact peer summary
certificates/research/fanout-optimality-package-validation-v1.json(SHA2567a2f4a2df8b3e26d5fe7a5a158617ad49775507aa86edf367c6ba71168b1c4a9), and the raw logs/custody capsulecertificates/research/fanout-optimality-replay-evidence-v1.json(SHA256dc7568800ae38877a8ef3bdf6608dd7da7f567bd6af63297536698714b974f4d, 441,469 bytes). The latter retains all three actual logs/guards, exact original pre-inventory/post-summary and all four transport events; it was built AFTER execution and is not an executed input. Frozen preparation-status prose is historical; these actual records supersede pending status without changing tested source.Science/evidence commit:
82cd2a2e4d74314d4c03ad57a6d2ce1374731f75, direct parent canonical 1a3. Publication head:00005c8c5e81c7f27b5769f9309ff88758e26f51. The 34 science/evidence paths are 32 source files plus two passive records; the sole extra publication file is the exact previously reviewed #5420/#5423/#5424docs/ci-verification.mdrepair. There are 35 total PR paths. Metadata, committed-byte and declared-source-history checks pass at both commits. The canonical commit graph has 7507 commits; a complete file-corpus checkout or historical mathematical replay is not claimed.Official source export/check passes: SHA256
3193c986695817a2a261dd91c7c41a2cd5ddbab87f702623092d212ae5116e86, 2,385,920 bytes, 33 members comprising 32 payloads plus one transport receipt. All 32 payloads match the tested working/readonly source, both commits and export. Both passive records match separately and are not exported. Working 0644, readonly 0444/directories 0555, Git 100644 and export 0644 are distinct representation modes. The final archive was not separately rerun. Registered package; public raw evidence capsule.Direct portable replay is
/usr/bin/python3 -I -Werror -B verify.py, adding-Ofor optimized mode. The hook runs only the unchanged upper checker and its required phase oracle in a fresh original-path sandbox. It does not overwrite expected artifacts, run an additional classifier/native/provider/price/Lean engine, execute the source-assessor reviews or formally verify the lower proof. First hosted run 40080072002, attempt 1, passed at exact publication head00005c8c5e81c7f27b5769f9309ff88758e26f51(completed 2026-10-24 09:04:13 UTC). Plan job120831602950passed onboarding and package selection; replay job120832351858passed the bounded normal/optimized package replay and unchanged-input check. Both modes matched complete PROGRAM and RESULT in raw bytes and typed JSON with zero exclusions, with thirteen original controls and ten wrapper controls. Hosted CI preserves the stated standalone scope and static lower-proof boundary; it establishes no incremental global bound or new κ.Credit
Credit the coordinated upper-construction and module-lower-proof owners, native provider/normalizer/phase-oracle authors, and retained source lineage: Dillon Amburgey, Ali Romman, Cao Yifan, Cinna Davis, zxv, Jacob Alan Sussman, Dugongue and the native/helper/Clifford/compiler/precision/analytic predecessors. Independent static upper/proof reviews are credited separately. This contribution supplies reproducible custody, scoped presentation and registered/portable verification; it does not claim a new decoder or mechanism priority. Chris R/Clear1nsight with substantial OpenAI Codex assistance; Apache-2.0 and source-specific notices retained. No independent human/kernel acceptance or selected promotion is claimed.
Open next questions