Follow the source behind the result.
Search the paper sections, open their original context and follow the checks they actually cite. The knowledge atlas explains the result; this library locates its source.
v857_simplex_fourier_winding.py
verification/v857_simplex_fourier_winding.py
This is a registered verification module. Read its original code and the paper sections that cite it, then follow the linked claim to its present classification.
Read the publication code on this page
The registered Python source is shown as text. Displaying it does not execute the code.
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""v857 -- E8.SIMPLEX.FOURIER.01 + FLAVOR.WINDING.QUADRATIC.01: the E8 audits, part I -- the Gaussian census IS a Fourier law and v817's per-prime measurement is the prime restriction of a CHARACTER THEOREM (mh2(n) = -1/15 as an integer identity at EVERY odd n <= 16500), and the tfpt_2 winding line collapses to ONE rank-one determinant quadratic q_wind = t^2 - g_car t + |Z2| with the triple lock s = 6 and the reality threshold typed, ONE module from two probes (26/26 + 20/20 checks, zero fails, verdicts SIMPLEX-FOURIER-EXACT + INTERTWINER-IDENTIFIED and WINDING-QUADRATIC-EXACT; discovery probes simplex_fourier_probe.py and flavor_winding_quadratic_probe.py, 2026-08-08, re-run identically at promotion, embedded BYTE-EXACT and executed verbatim, exact integer/Fraction/sympy arithmetic, ~2 s). PART A, THE FOURIER LAW (audit package A): the Construction-A rebuild is warded (30 placements, 2 invariant under pi_J and pi_sigma; 240 roots, all norm 4, all in L; the quotient V = L/(1+i)L = F_2^4 with class addition well-defined on all 256 pairs and every class 2-torsion), the census r = (0; 16^15) (zero class EMPTY, v833/v844) has the EXACT Walsh transform rhat = (240; -16 x15) with the inversion sum rule, i.e. the normalized spectrum {1, (-1/15)^15}: the uniform-nonzero channel P = (J - I)/15 entrywise in Fractions (doubly stochastic; eigenaction exact on all 16 characters; two-step P^2 = (I + 14J)/225 with contraction 1/225); THE FIVE-LINE THEOREM measured at every level: (i) RAMIFICATION -- Theta_0(n) = 0 for EVERY odd n <= 16 with the one-line proof (x = (1+i)y forces even level) and Theta_0(2m) = 240 sigma_3(m); (ii) EQUIDISTRIBUTION -- Theta_v(n) is ONE value over the 15 nonzero classes at every level n <= 16 (the Sp(4,2) footprint); (iii) hence Thetahat_u(odd n) = -Theta_L(n)/15; (iv) THE INTERTWINER IDENTITY -- the v817 packet numerator (Th0-Th1+Th2-Th3)(n) EQUALS the code Walsh transform Thetahat_u(n) for every nonzero u at EVERY level n <= 16, odd AND even (both ladders read [-16, 112, -448, 1136, -2016, 3136, -5504, 9328] at n = 1..8; the Eisenstein normal form 15 Theta_D8 = 7 Theta_L + 8 Theta_0 across machineries); (v) THE VALUE THEOREM -- 15 (Th0-Th1+Th2-Th3)(n) = -240 sigma_3(n) for EVERY odd n <= 16500, hence mh2(odd n) = -1/15 IDENTICALLY, covering all 1911 odd primes <= 16500: v817's per-prime measurement is a character theorem of the code, one Walsh transform away from the deployed census with NO new input. THE HONEST TYPE (measured, kept): the identification is SPECTRAL (numerator q-series equal) -- the packet 5|3-parity grading (52, 60, 128) and the code grading (15 x 16) do NOT refine each other (the S6.3 cross table: 4 + 3 + 8 mixed classes); the spinor halving Th1 = Th3 stays numerical fiat (typed); 52 = 40 + 12 = |R(D5)| + |R(A3)| is the seam reading. Controls fire (occupied zero class, one class at 15, wrong quotient dim F_2^3 -- each breaks the law at a stated integer), invariances hold (24 explicit isometries of (L, J) preserve census and spectrum; the OTHER invariant placement C** gives the identical law). PART B, THE WINDING QUADRATIC (audit package for tfpt_2, section I.5): against the deployed residue matrix (det R = 8 = h(D5), tr R = 9, PrinMin2 = (5,3,2), SNF (1,1,8), anchor R e1 = (1,1,2), cofactor seam normal adj(R) row 1 = (5,-9,6) with n.1 = 2 = |Z2|), THE MINI-THEOREM: chi_{R_s} - chi_R = -s q_wind with q_wind = e1^T adj(tI - R) 1 = t^2 - 5t + 2 = t^2 - g_car t + |Z2| EXACT in sympy -- the whole winding line is one rank-one matrix-determinant lemma; the keybox coefficients (9+s, 10+5s, 8+2s), the per-winding det increment d(det R_s)/ds = q_wind(0) = 2 = |Z2| and the minor law PrinMin2(R_s) = (5, 3(s+1), 2(s+1)) (carrier minor 5 s-INVARIANT) are all readouts of the single quadratic; q_wind is irreducible over Q (disc 17 nonsquare) and the two base points are s-invariant (rem(chi_{R_s}, q_wind) = -12t, s-free); THE TRIPLE LOCK: trace (tr R_s = 15), determinant (det R_s = 20) and Coxeter lift ((R_s^T a)_1 = 30) each solve to s = 6 ALONE, intersection {6} = {|R+(A3)|}, and at s = 6: chi_L = t^3 - 15t^2 + 40t - 20 with (15, 40, 20) = (dim A3, |R(D5)|, |R(A4)|), 3 real positive roots; THE LOCUS (exact Sturm/resultant): Delta(s) = disc_t chi_{R_s} = 17s^4 - 18s^3 + 709s^2 + 588s - 7996 (irreducible), Delta(6) = 39200 = 2^5 5^2 7^2 = 2 x 140^2 > 0 -- s = 6 is NOT a collision point; the reality threshold is the unique Delta-root in (2, 3), s* ~ 2.8250 (matching the deployed ~2.83; Sturm real-eigenvalue counts jump 1 -> 3 between s = 2 and s = 3); the integer-window census types s = 6 as the ONLY 2xsquare hit in s = -2..12 (measured, typed -- and q_wind(6) = 8 = det R reported as a measured coincidence). Controls fire: the sibling directions 1 e2^T and 1 e3^T change the quadratic AND break the lock (intersections EMPTY; 1 e3^T even reducible), the sibling ROW transport e1 1^T keeps -g_car t but LOSES |Z2| (locks pairwise disjoint 6/12/24), and the sibling minor branch {1,3,4} is unreachable on the whole winding line (integer scan s = -100..100 empty; the carrier minor 5 invariant) -- the triple (1, -5, 2) is direction-specific. Both parts are exact-arithmetic corpus compressions and audits of DEPLOYED claims (v817, v833, v844, v4/v94 keyboxes) -- normal forms and identities, no new physical claim, no marker moves. NO RH claim. Python-only per GATE.WOLFRAM.02.
PROVENANCE: discovery probes simplex_fourier_probe.py (26/26,
verdict SIMPLEX-FOURIER-EXACT + INTERTWINER-IDENTIFIED) and
flavor_winding_quadratic_probe.py (20/20, verdict
WINDING-QUADRATIC-EXACT), both 2026-08-08, re-run identically at
promotion. ROUND-31 EMBEDDING CONVENTION: both frozen sources are
embedded BYTE-EXACT (raw strings below) and executed verbatim in
isolated module namespaces registered under their canonical import
names -- the printed FROZEN_SPEC SHA-256 values reproduce exactly,
and when the original files are present the harness verifies
byte-equality (provenance ward inside the pattern gate). The
original probe files live verbatim in experiments/tfpt-discovery/.
FIREWALL: exact integer / Fraction / sympy arithmetic throughout;
own sieves (sigma_3, theta series by residue DP); no zeros, no
prime tables, no floats in any load-bearing identity. NO RH claim.
"""
import contextlib
import io
import os
import re
import sys
import time
import types
_HERE = os.path.dirname(os.path.abspath(__file__))
if _HERE not in sys.path:
sys.path.insert(0, _HERE)
# ------------- frozen probe sources (embedded BYTE-EXACT, raw strings)
_SRC_FOURIER = r'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""simplex_fourier_probe -- E8.SIMPLEX.FOURIER.01 (audit package A of the
2026-08-08 morning analysis): the Fourier law of the Gaussian census and
the intertwiner check against the prime-packet m2 channel.
FROZEN CLAIMS (2026-08-08, frozen + SHA-hashed before first run):
PART (a) -- THE FOURIER LAW on V = L/(1+i)L = F_2^4:
S1 REBUILD (read-only machinery, v833/v844 S2-S3 rebuilt inline):
Construction-A Gaussian E8 over the unique mu4/sigma-invariant
placement C* (2 of 30, the W0246 pick); 240 roots, all norm 4;
the quotient Q = L/(1+i)L has EXACTLY 16 classes, every class is
2-torsion (2x = -i(1+i)^2 x in (1+i)L, typed + verified), the
class addition closes and coordinatizes as F_2^4 (4 independent
generators, 16 sums bijective); the root multiplicity function is
r(0) = 0 (zero class EMPTY), r(v) = 16 for ALL 15 nonzero v
(the census 240 = 15 x 16, v844 S3.1 rebuilt).
S2 WALSH TRANSFORM (exact integers): rhat(u) = sum_v (-1)^{u.v} r(v):
rhat(0) = 240; rhat(u) = -16 for ALL 15 nonzero u; inversion sum
rule sum_u rhat(u) = 16 r(0) = 0; normalized spectrum
rhat(u)/rhat(0) = {1, (-1/15)^15} with -16/240 = -1/15 exact.
S3 THE CHANNEL (exact Fractions): the transition matrix of "add a
uniformly random NONZERO class", P[x][y] = r(y-x)/240, equals
(J - I)/15 ENTRYWISE on all 256 cells (J = all-ones, 16 x 16);
doubly stochastic; eigenaction EXACT on all 16 characters:
P chi_0 = chi_0 and P chi_u = (-1/15) chi_u for all 15 nonzero u
(spec {1, (-1/15)^15}); two-step contraction: P^2 = (I + 14J)/225
with nonzero-character eigenvalue exactly 1/225.
PART (b) -- THE INTERTWINER CHECK (the five-line theorem, measured):
S4 CODE SIDE AT ALL LEVELS (exact python-int DP over the 4096 mod-4
residues of L; class label from x mod 4 since 4Z^8 in 2L in
(1+i)L): the 16 class thetas Theta_v(n) = #{x in L : |x|^2 = 4n,
x = v mod (1+i)L} for 1 <= n <= NCAP = 16, gated by the
independent sigma_3 sieve (sum_v Theta_v(n) = 240 sigma_3(n)) and
by the level-1 census (= r); residue fibers all 256.
S4.2 RAMIFICATION: Theta_0(n) = 0 for EVERY odd n (typed one-line
proof: x = (1+i)y => |x|^2 = 2|y|^2 with |y|^2 in 4Z => level
even) and Theta_0(2m) = 240 sigma_3(m) (the (1+i)-scaling
Theta_0 = Theta_L(q^2)).
S4.3 EQUIDISTRIBUTION AT EVERY LEVEL: Theta_v(n) equal over the
15 nonzero v for all n <= NCAP (the Sp(4,2)-transitivity
footprint, MEASURED not cited).
S4.4 THE CHARACTER THEOREM: hence Thetahat_u(n) is one value for
all 15 nonzero u, = (16 Theta_0(n) - Theta_L(n))/15; at odd n
(ramification) Thetahat_u(n) = -Theta_L(n)/15, i.e. the
normalized Walsh coefficient is EXACTLY -1/15 at every odd level.
S5 PACKET SIDE (v817 packet machinery rebuilt read-only, VERBATIM
semantics; numpy int64 with v817's own exactness certificates --
the divisibility gates and the glue identity; N_THETA = 16500):
S5.1 re-gate v817 C1: theta heads (Th_0..Th_3)(1) = (52,64,60,64);
glue identity Th_0+Th_1+Th_2+Th_3 = 240 sigma_3(n) for ALL
n <= 16500; Th_1 = Th_3; Th_0 - Th_2 = -8 f8 on ALL odd n.
S5.2 THE m2 CHANNEL TYPED: in v817 event_profile the j = 2 sector
multiplier is mh[2](n) = (Th_0 - Th_1 + Th_2 - Th_3)(n) /
(240 sigma_3(n)) -- the order-2 character of the Z4 factor of the
register G = C2 x F_2^4 x Z4; the packet's level-1 classes are
the 5|3 PARITY classes of the standard model: (52, 60, 128) =
(D8-even, D8-odd, spinor), re-derived HERE from the actual 240
standard-model roots, with 52 = 40 + 12 = |R(D5)| + |R(A3)| (the
seam reading) and 128 = 2 x 64 (the spinor halving Th_1 = Th_3 is
numerical fiat in v817, not a set partition -- typed).
S5.3 THE VALUE THEOREM (exact integer identity, ALL odd levels):
15 (Th_0 - Th_1 + Th_2 - Th_3)(n) = -240 sigma_3(n) for EVERY odd
n <= 16500, hence mh2(n) = -1/15 identically on odd levels; the
v817 statement "mh2(p) = -1/15 for every odd prime" is the prime
restriction (count of odd primes covered reported).
S6 THE IDENTIFICATION (cross-machinery, the decision):
S6.1 THE INTERTWINER IDENTITY: the packet numerator EQUALS the
code Walsh transform, (Th_0 - Th_1 + Th_2 - Th_3)(n) =
Thetahat_u(n) for EVERY nonzero u and EVERY level 1 <= n <= NCAP
(odd AND even); equivalently the Eisenstein normal form
15 Theta_D8(n) = 7 Theta_L(n) + 8 Theta_0(n) with Theta_D8 =
Th_0 + Th_2 taken from the PACKET machinery and Theta_L, Theta_0
from the CODE machinery. Level 1 is the census law -16 = rhat(u).
S6.2 hence the packet's m2 multiplier at odd events IS the
nontrivial eigenvalue of the Walsh channel P: mh2(odd) = -1/15 =
spec(P)|_{u != 0}, a CHARACTER THEOREM of the code (ramification
S4.2 + equidistribution S4.3), not a per-prime computation; the
two-odd-event contraction is the two-step 1/225 of S3.
S6.3 TYPED TRANSVERSALITY (measured, no narrative): on the SAME
240 standard-model roots the code census (15 x 16, zero empty --
model-independence witnessed) and the packet parity partition
(52, 60, 128) do NOT refine each other (52 and 60 are not
multiples of 16; contingency table printed) -- the identification
is SPECTRAL (equality of numerator q-series), not a quotient-map
intertwiner. This is a report line, not a kill, either way.
C MUST-BREAK CONTROLS (each must fire):
C1 OCCUPIED ZERO CLASS: r'(0) = 16 (keep 15 x 16): Walsh becomes
(256; 0 x15), normalized {1, 0^15} != {1, (-1/15)^15}; the
two-step contraction becomes 0 != 1/225.
C2 PERTURBED MULTIPLICITY: one nonzero class at 15: Walsh multiset
on u != 0 becomes {-17 x7, -15 x8} (u.x0 = 0 seven times) --
NOT uniform, and no value equals -16; the -1/15 law breaks.
C3 WRONG QUOTIENT DIM (F_2^3): 240/7 is NOT an integer (uniform
integer multiplicity impossible); the uniform nonzero channel
on F_2^3 has eigenvalue -1/7 != -1/15 and two-step 1/49 !=
1/225.
I MUST-BE-INVARIANT:
I1 SYMPLECTIC/ISOMETRY RELABELING: explicit isometries of (L, J)
-- sigma (PI_SIG), the C*-preserving pair permutations (of the
24 order-preserving pair perms), the C*-preserving single-pair
quarter turns (measured which); global J and -1 induce the
IDENTITY on V (verified); each accepted isometry induces a
WELL-DEFINED F_2-linear map on V (verified on all 240 roots),
preserves the census, and preserves the Walsh spectrum as a
multiset. (Full Sp(4,2)-orbit transitivity is DELEGATED to
the measured per-level equidistribution S4.3.)
I2 EQUIVALENT CONSTRUCTION-A REPRESENTATIVE: the OTHER
mu4/sigma-invariant placement C** (the second of the 2): full
rebuild gives the SAME census (15 x 16, zero empty) and the
SAME Walsh spectrum (240; -16 x15).
KILLS (any one fires => typed failure):
K1 rebuild / quotient / census breaks -> FOURIER-CENSUS
K2 Walsh law (S2) breaks -> FOURIER-LAW
K3 channel identity / spectrum (S3) breaks -> FOURIER-CHANNEL
K4 a control does not fire -> CONTROL-DEAD
K5 an invariance breaks -> INVARIANCE-BROKEN
K6 code-side law (S4) breaks -> INTERTWINER-GAP-CODE
K7 packet re-gate (S5.1/S5.2) breaks -> INTERTWINER-GAP-PACKET
K8 value theorem (S5.3) breaks -> INTERTWINER-GAP-VALUE
K9 bridge identity (S6.1) breaks -> INTERTWINER-GAP-BRIDGE
VERDICT (frozen enum): "SIMPLEX-FOURIER-EXACT + INTERTWINER-IDENTIFIED"
/ "SIMPLEX-FOURIER-EXACT + INTERTWINER-GAP-<TYPE>" / typed failure
(FOURIER-MISMATCH-<K>, CONTROL-DEAD, INVARIANCE-BROKEN).
FIREWALL: experiments/ probe; EXPLORATION ONLY -- writes nothing but
stdout; no verification/, paper, ledger, changelog or website surface;
no .md, no commits. Exact integer/Fraction arithmetic; the packet
layer uses numpy int64 with v817's own exact-equality certificates; no
floats in any decision, no RNG, no fits. NO physics claim, NO RH
claim. Runtime cap: minutes.
Sources (read-only, machinery rebuilt inline): verification/
v833_gaussian_ramification_ladder.py + v844_message_doily_rank.py
(Construction A, census, class machinery), v817_positive_descent_
master.py (packet thetas, event_profile m2 channel), v634_st31_
structure.py (standard-model roots + J), v800_e8_torsor_fourier.py
(Fourier precedent), tfpt_2/tfpt_1 budget lines (240 = 15 x 16).
Run:
experiments/tfpt-discovery/.venv/bin/python \
experiments/tfpt-discovery/simplex_fourier_probe.py
"""
import hashlib
import itertools
import math
import time
from collections import Counter
from fractions import Fraction as Fr
import numpy as np
T0 = time.time()
CHECKS = []
KILLS = []
NCAP = 16 # code-side theta levels (exact python ints)
N_THETA = 16500 # packet-side reach (v817 value)
def check(name, ok, detail="", kill=None):
CHECKS.append((name, bool(ok)))
if kill and not ok:
KILLS.append(kill)
print(" [%s] %s%s" % ("PASS" if ok else "FAIL", name,
(" -- " + detail) if detail else ""), flush=True)
return bool(ok)
def section(title):
print("\n== %s == (t=%.1fs)" % (title, time.time() - T0), flush=True)
print("=" * 74)
print("E8.SIMPLEX.FOURIER.01 -- the Fourier law of the Gaussian census and")
print("the prime-packet m2 intertwiner (audit package A)")
print("=" * 74)
print("FROZEN_SPEC SHA-256: %s"
% hashlib.sha256(__doc__.encode("utf-8")).hexdigest())
# ======================================================================
section("S1: Construction-A rebuild + the quotient V = L/(1+i)L (v833/v844)")
# ======================================================================
G_NAIVE = ((1, 0, 0, 0, 0, 1, 1, 1), (0, 1, 0, 0, 1, 0, 1, 1),
(0, 0, 1, 0, 1, 1, 0, 1), (0, 0, 0, 1, 1, 1, 1, 0))
C_NAIVE = frozenset(
tuple(sum(m[k] * G_NAIVE[k][j] for k in range(4)) % 2 for j in range(8))
for m in itertools.product((0, 1), repeat=4))
PI_J = (1, 0, 3, 2, 5, 4, 7, 6)
PI_SIG = (2, 3, 4, 5, 0, 1, 6, 7)
W0246 = (1, 0, 1, 0, 1, 0, 1, 0)
def code_image(code, perm):
return frozenset(tuple(c[perm[k]] for k in range(8)) for c in code)
placements = set()
for perm in itertools.permutations(range(8)):
placements.add(code_image(C_NAIVE, perm))
BOTH = [c for c in placements
if code_image(c, PI_J) == c and code_image(c, PI_SIG) == c]
check("S1.1 placement census: %d placements, %d invariant under pi_J and "
"pi_sigma (v833 R1.3); C* = the W0246 pick"
% (len(placements), len(BOTH)),
len(placements) == 30 and len(BOTH) == 2
and sum(1 for c in BOTH if W0246 in c) == 1, kill="K1")
CSTAR = next(c for c in BOTH if W0246 in c)
CSTAR2 = next(c for c in BOTH if W0246 not in c)
def build_roots(code):
roots = []
for k in range(8):
for s in (2, -2):
v = [0] * 8
v[k] = s
roots.append(tuple(v))
for c in (c for c in code if sum(c) == 4):
sup = [k for k in range(8) if c[k]]
for signs in itertools.product((1, -1), repeat=4):
v = [0] * 8
for k, s in zip(sup, signs):
v[k] = s
roots.append(tuple(v))
return roots
def J_vec(v):
out = [0] * 8
for k in range(4):
out[2 * k] = -v[2 * k + 1]
out[2 * k + 1] = v[2 * k]
return tuple(out)
def make_tests(code):
def in_L(v):
return tuple(x % 2 for x in v) in code
def in_pi2L(v):
# x in (1+i)L <=> (1-J)x/2 in L (v844 S3 machinery)
w = [0] * 8
for k in range(4):
w[2 * k] = v[2 * k] + v[2 * k + 1]
w[2 * k + 1] = v[2 * k + 1] - v[2 * k]
if any(x % 2 for x in w):
return False
return in_L([x // 2 for x in w])
return in_L, in_pi2L
in_L, in_pi2L = make_tests(CSTAR)
ROOTS = build_roots(CSTAR)
check("S1.2 root census: %d roots, distinct, all norm 4, all in L"
% len(ROOTS),
len(ROOTS) == 240 and len(set(ROOTS)) == 240
and all(sum(x * x for x in r) == 4 for r in ROOTS)
and all(in_L(r) for r in ROOTS), kill="K1")
def class_reps(roots, test):
reps = []
label = {}
for r in roots:
for li, rep in enumerate(reps):
if test(tuple(x - y for x, y in zip(r, rep))):
label[r] = li
break
else:
label[r] = len(reps)
reps.append(r)
return reps, label
reps15, label = class_reps(ROOTS, in_pi2L)
ZERO = (0,) * 8
REPS16 = [ZERO] + list(reps15)
def cls16(v):
hits = [k for k in range(16)
if in_pi2L(tuple(a - b for a, b in zip(v, REPS16[k])))]
return hits
# group law on the 16 classes (verify uniqueness of the sum class)
ADD = [[None] * 16 for _ in range(16)]
add_unique = True
for a in range(16):
for b in range(16):
s = tuple(x + y for x, y in zip(REPS16[a], REPS16[b]))
hits = cls16(s)
if len(hits) != 1:
add_unique = False
else:
ADD[a][b] = hits[0]
two_torsion = all(ADD[a][a] == 0 for a in range(16))
check("S1.3 quotient: 1 + %d = 16 classes; class addition well-defined "
"(unique sum class on all 256 pairs); EVERY class 2-torsion "
"(2x = -i(1+i)^2 x in (1+i)L)" % len(reps15),
len(reps15) == 15 and add_unique and two_torsion, kill="K1")
# coordinatize as F_2^4
basis = []
span = {0}
for k in range(1, 16):
if k not in span:
basis.append(k)
span = {ADD[x][y] for x in span for y in span | {k}} | span | {k}
closure = {0}
frontier = [0]
gens = list(basis)
seen = {0}
while frontier:
x = frontier.pop()
for g in gens:
y = ADD[x][g]
if y not in seen:
seen.add(y)
frontier.append(y)
span = seen
COORD = {}
ok_coord = (len(basis) == 4)
if ok_coord:
for bits in itertools.product((0, 1), repeat=4):
c = 0
for i, b in enumerate(bits):
if b:
c = ADD[c][basis[i]]
if c in COORD:
ok_coord = False
COORD[c] = bits
check("S1.4 coordinatization: %d independent generators; the 16 subset "
"sums biject onto the 16 classes (V = F_2^4)" % len(basis),
ok_coord and len(COORD) == 16, kill="K1")
r_census = [0] * 16
for r in ROOTS:
hits = cls16(r)
r_census[hits[0]] += 1
check("S1.5 multiplicity function: r(0) = %d (zero class EMPTY); "
"r(v) = 16 for all 15 nonzero v (census 240 = 15 x 16, v844 S3.1)"
% r_census[0],
r_census[0] == 0 and sorted(r_census[1:]) == [16] * 15, kill="K1")
# ======================================================================
section("S2: the Walsh transform of the census (exact integers)")
# ======================================================================
def walsh(census):
out = {}
for u in itertools.product((0, 1), repeat=4):
acc = 0
for k in range(16):
v = COORD[k]
dot = sum(a * b for a, b in zip(u, v)) % 2
acc += (-1) ** dot * census[k]
out[u] = acc
return out
RHAT = walsh(r_census)
U0 = (0, 0, 0, 0)
nonzero_vals = [RHAT[u] for u in RHAT if u != U0]
check("S2.1 rhat(0) = %d == 240; inversion sum rule sum_u rhat(u) = %d "
"== 16 r(0) = 0" % (RHAT[U0], sum(RHAT.values())),
RHAT[U0] == 240 and sum(RHAT.values()) == 0, kill="K2")
check("S2.2 rhat(u) = -16 for ALL 15 nonzero u (values %s)"
% sorted(set(nonzero_vals)),
nonzero_vals == [-16] * 15, kill="K2")
check("S2.3 normalized spectrum {1, (-1/15)^15}: -16/240 = %s == -1/15"
% Fr(-16, 240),
Fr(-16, 240) == Fr(-1, 15)
and sorted(Fr(RHAT[u], RHAT[U0]) for u in RHAT)
== [Fr(-1, 15)] * 15 + [Fr(1)], kill="K2")
# ======================================================================
section("S3: the channel P = (J - I)/15 (exact Fractions)")
# ======================================================================
P = [[Fr(r_census[ADD[x][y]], 240) for x in range(16)] for y in range(16)]
ok_P = all(P[y][x] == (Fr(0) if x == y else Fr(1, 15))
for x in range(16) for y in range(16))
ok_stoch = (all(sum(P[y][x] for y in range(16)) == 1 for x in range(16))
and all(sum(P[y][x] for x in range(16)) == 1 for y in range(16)))
check("S3.1 P[x][y] = r(y-x)/240 == (J - I)/15 ENTRYWISE (256 cells); "
"doubly stochastic", ok_P and ok_stoch, kill="K3")
ok_eig = True
for u in itertools.product((0, 1), repeat=4):
chi = [Fr((-1) ** (sum(a * b for a, b in zip(u, COORD[k])) % 2))
for k in range(16)]
Pchi = [sum(P[y][x] * chi[x] for x in range(16)) for y in range(16)]
lam = Fr(1) if u == U0 else Fr(-1, 15)
if Pchi != [lam * c for c in chi]:
ok_eig = False
check("S3.2 eigenaction exact on all 16 characters: P chi_0 = chi_0, "
"P chi_u = (-1/15) chi_u (spec {1, (-1/15)^15})", ok_eig, kill="K3")
P2 = [[sum(P[y][z] * P[z][x] for z in range(16)) for x in range(16)]
for y in range(16)]
ok_P2 = all(P2[y][x] == (Fr(15, 225) if x == y else Fr(14, 225))
for x in range(16) for y in range(16))
check("S3.3 two-step: P^2 = (I + 14J)/225 entrywise; nonzero-character "
"eigenvalue (-1/15)^2 = %s == 1/225" % (Fr(-1, 15) ** 2,),
ok_P2 and Fr(-1, 15) ** 2 == Fr(1, 225), kill="K3")
# ======================================================================
section("S4: code side at all levels -- class thetas by mod-4 residue DP")
# ======================================================================
EMAX = 4 * NCAP
DIGIT_THETA = {}
for d in range(4):
poly = {}
for z in range(-8, 9):
e = (d + 4 * z) ** 2
if e <= EMAX:
poly[e] = poly.get(e, 0) + 1
DIGIT_THETA[d] = poly
def poly_mul(a, b):
out = {}
for ea, ca in a.items():
for eb, cb in b.items():
e = ea + eb
if e <= EMAX:
out[e] = out.get(e, 0) + ca * cb
return out
THETA = [[0] * (NCAP + 1) for _ in range(16)]
fibers = [0] * 16
for c in CSTAR:
for sbits in itertools.product((0, 1), repeat=8):
rvec = tuple(c[i] + 2 * sbits[i] for i in range(8))
hits = cls16(rvec)
assert len(hits) == 1
k = hits[0]
fibers[k] += 1
poly = {0: 1}
for i in range(8):
poly = poly_mul(poly, DIGIT_THETA[rvec[i]])
for n in range(NCAP + 1):
THETA[k][n] += poly.get(4 * n, 0)
sigma3 = [0] * (2 * N_THETA + 1)
for d in range(1, 2 * N_THETA + 1):
for m in range(d, 2 * N_THETA + 1, d):
sigma3[m] += d ** 3
tot_ok = all(sum(THETA[k][n] for k in range(16)) == 240 * sigma3[n]
for n in range(1, NCAP + 1))
lvl1 = [THETA[k][1] for k in range(16)]
check("S4.1 DP gates: residue fibers all 256 (%s); sum_v Theta_v(n) = "
"240 sigma_3(n) for 1 <= n <= %d (independent sieve); level-1 "
"census == r" % (sorted(set(fibers)), NCAP),
sorted(set(fibers)) == [256] and tot_ok and lvl1 == r_census,
kill="K6")
odd_zero = all(THETA[0][n] == 0 for n in range(1, NCAP + 1, 2))
even_scale = all(THETA[0][2 * m] == 240 * sigma3[m]
for m in range(1, NCAP // 2 + 1))
check("S4.2 RAMIFICATION: Theta_0(n) = 0 for EVERY odd n <= %d (proof: "
"x = (1+i)y => |x|^2 = 2|y|^2 in 8Z => level even); Theta_0(2m) = "
"240 sigma_3(m) (the (1+i)-scaling)" % NCAP,
odd_zero and even_scale, kill="K6")
equi = all(len(set(THETA[k][n] for k in range(1, 16))) == 1
for n in range(1, NCAP + 1))
check("S4.3 EQUIDISTRIBUTION at EVERY level n <= %d: Theta_v(n) is one "
"value over the 15 nonzero classes (Sp(4,2) footprint, measured)"
% NCAP, equi, kill="K6")
THAT = {}
for u in itertools.product((0, 1), repeat=4):
THAT[u] = [sum((-1) ** (sum(a * b for a, b in zip(u, COORD[k])) % 2)
* THETA[k][n] for k in range(16))
for n in range(NCAP + 1)]
one_val = all(len(set(THAT[u][n] for u in THAT if u != U0)) == 1
for n in range(1, NCAP + 1))
uref = next(u for u in THAT if u != U0)
law_all = all(15 * THAT[uref][n] == 16 * THETA[0][n] - 240 * sigma3[n]
for n in range(1, NCAP + 1))
law_odd = all(15 * THAT[uref][n] == -240 * sigma3[n]
for n in range(1, NCAP + 1, 2))
check("S4.4 CHARACTER THEOREM: Thetahat_u(n) is ONE value for all 15 "
"nonzero u, = (16 Theta_0 - Theta_L)/15; at odd n it is "
"-Theta_L(n)/15, i.e. normalized ratio -1/15 at every odd level",
one_val and law_all and law_odd, kill="K6")
print(" levels 1..8 of Thetahat_u (u != 0): %s"
% [THAT[uref][n] for n in range(1, 9)])
# ======================================================================
section("S5: packet side -- v817 machinery rebuilt read-only (int64 + "
"certificates)")
# ======================================================================
def sparse_theta_terms(kind, cap):
out = []
if kind in ("th3", "th4"):
out.append((0, 1))
n = 1
while n * n <= cap:
out.append((n * n, 2 if kind == "th3" else 2 * ((-1) ** n)))
n += 1
else: # th2-type: odd squares
o = 1
while o * o <= cap:
out.append((o * o, 2))
o += 2
return out
def sparse_mul(dense, terms):
out = np.zeros_like(dense)
for e, c in terms:
if e == 0:
out += c * dense
else:
out[e:] += c * dense[:-e]
return out
def build_thetas():
"""exact class thetas Th_j, sigma3, f8 coefficients to N_THETA
(v817 build_thetas, rebuilt verbatim)."""
sig3 = np.zeros(N_THETA + 1, dtype=np.int64)
for d in range(1, N_THETA + 1):
sig3[d::d] += d ** 3
scap = 2 * N_THETA
t3 = sparse_theta_terms("th3", scap)
t4 = sparse_theta_terms("th4", scap)
one = np.zeros(scap + 1, dtype=np.int64)
one[0] = 1
p3 = one.copy()
p4 = one.copy()
for _ in range(8):
p3 = sparse_mul(p3, t3)
p4 = sparse_mul(p4, t4)
m53 = one.copy()
for _ in range(5):
m53 = sparse_mul(m53, t3)
for _ in range(3):
m53 = sparse_mul(m53, t4)
m35 = one.copy()
for _ in range(5):
m35 = sparse_mul(m35, t4)
for _ in range(3):
m35 = sparse_mul(m35, t3)
num0 = p3 + m53 + m35 + p4
num2 = p3 - m53 - m35 + p4
ok_div = bool(np.all(num0 % 4 == 0) and np.all(num2 % 4 == 0))
Th0 = (num0 // 4)[::2][:N_THETA + 1].copy()
Th2 = (num2 // 4)[::2][:N_THETA + 1].copy()
tcap = 8 * N_THETA
t2 = sparse_theta_terms("th2", tcap)
acc = np.zeros(tcap + 1, dtype=np.int64)
acc[0] = 1
for _ in range(8):
acc = sparse_mul(acc, t2)
ok_div &= bool(np.all(acc[::8][:N_THETA + 1] % 4 == 0))
Th1 = (acc[::8][:N_THETA + 1] // 4).copy()
tk = np.zeros(N_THETA + 1, dtype=np.int64)
for d in range(2, N_THETA + 1, 2):
tk[d::d] += d * (4 + (4 if d % 4 == 0 else 0))
g = np.zeros(N_THETA, dtype=np.int64)
g[0] = 1
for n in range(1, N_THETA):
s = int(np.dot(tk[1:n + 1], g[n - 1::-1]))
q, rr = divmod(-s, n)
if rr != 0:
return None
g[n] = q
a = np.zeros(N_THETA + 1, dtype=np.int64)
a[1:] = g
return dict(sig3=sig3, Th_real=(Th0, Th1, Th2, Th1), a=a,
ok_div=ok_div)
TH = build_thetas()
Th0, Th1, Th2, Th3 = TH["Th_real"]
sig3p = TH["sig3"]
heads = (int(Th0[1]), int(Th1[1]), int(Th2[1]), int(Th3[1]))
glue = bool(np.all((Th0 + Th1 + Th2 + Th3)[1:] == 240 * sig3p[1:]))
f8ok = bool(np.all((Th0 - Th2 + 8 * TH["a"])[1:N_THETA:2] == 0))
sig_agree = all(int(sig3p[n]) == sigma3[n] for n in range(1, NCAP + 1))
check("S5.1 v817 C1 re-gated: heads %s == (52,64,60,64); glue identity "
"ALL n <= %d; Th1 == Th3; Th0 - Th2 = -8 f8 on ALL odd n; "
"divisibility gates; sieve agreement" % (str(heads), N_THETA),
TH["ok_div"] and heads == (52, 64, 60, 64) and glue and f8ok
and bool(np.all(Th1 == Th3)) and sig_agree, kill="K7")
# the packet parity classes re-derived from the actual standard model
STD = []
for v in itertools.product(range(-1, 2), repeat=8):
if sum(a * a for a in v) == 2 and sum(v) % 2 == 0:
STD.append(tuple(2 * a for a in v))
for y in itertools.product((0, -1), repeat=8):
v = tuple(2 * a + 1 for a in y)
if sum(a * a for a in v) == 8 and sum(v) % 4 == 0:
STD.append(v)
STD = sorted(STD)
j0 = j2 = spin = 0
j0_d5 = j0_a3 = 0
for x in STD:
if all(t % 2 == 0 for t in x):
a = [t // 2 for t in x]
A, B = sum(a[:5]) % 2, sum(a[5:]) % 2
if A == 0 and B == 0:
j0 += 1
sup = [i for i in range(8) if a[i]]
if all(i < 5 for i in sup):
j0_d5 += 1
elif all(i >= 5 for i in sup):
j0_a3 += 1
elif A == 1 and B == 1:
j2 += 1
else:
spin += 1
check("S5.2 m2 CHANNEL TYPED: mh[2] = (Th0-Th1+Th2-Th3)/(240 sigma_3) = "
"the order-2 Z4 character of the register (v817 event_profile); "
"packet level-1 classes from the ACTUAL 240 std roots: "
"(j0, j2, spin) = (%d, %d, %d) == (52, 60, 128); 52 = %d + %d = "
"|R(D5)| + |R(A3)| (seam reading); spinor halving Th1 = Th3 is "
"numerical fiat (typed)" % (j0, j2, spin, j0_d5, j0_a3),
len(STD) == 240 and (j0, j2, spin) == (52, 60, 128)
and (j0_d5, j0_a3) == (40, 12), kill="K7")
num2c = Th0 - Th1 + Th2 - Th3
odd_idx = np.arange(1, N_THETA + 1, 2)
value_thm = bool(np.all(15 * num2c[odd_idx] == -240 * sig3p[odd_idx]))
primes = []
s = np.ones(N_THETA + 1, bool)
s[:2] = False
for i in range(2, int(N_THETA ** 0.5) + 1):
if s[i]:
s[i * i::i] = False
odd_primes = [int(p) for p in np.nonzero(s)[0] if p % 2 == 1]
check("S5.3 VALUE THEOREM: 15 (Th0-Th1+Th2-Th3)(n) = -240 sigma_3(n) "
"for EVERY odd n <= %d => mh2(odd n) = -1/15 identically; covers "
"all %d odd primes <= %d (v817's measured claim = the prime "
"restriction)" % (N_THETA, len(odd_primes), N_THETA),
value_thm and Fr(int(num2c[3]), int(240 * sig3p[3])) == Fr(-1, 15)
and Fr(int(num2c[odd_primes[-1]]),
int(240 * sig3p[odd_primes[-1]])) == Fr(-1, 15), kill="K8")
# ======================================================================
section("S6: the identification (cross-machinery)")
# ======================================================================
bridge = all(int(num2c[n]) == THAT[u][n]
for u in THAT if u != U0 for n in range(1, NCAP + 1))
eisen = all(15 * int((Th0 + Th2)[n]) == 7 * (240 * sigma3[n])
+ 8 * THETA[0][n] for n in range(1, NCAP + 1))
check("S6.1 INTERTWINER IDENTITY: packet numerator == code Walsh "
"transform, (Th0-Th1+Th2-Th3)(n) == Thetahat_u(n) for EVERY "
"nonzero u and EVERY level n <= %d (odd AND even); Eisenstein "
"normal form 15 Theta_D8 = 7 Theta_L + 8 Theta_0 across "
"machineries; level 1 = the census law (-16)" % NCAP,
bridge and eisen and int(num2c[1]) == -16 == RHAT[uref],
kill="K9")
print(" packet numerator n=1..8: %s"
% [int(num2c[n]) for n in range(1, 9)])
print(" code Walsh n=1..8: %s"
% [THAT[uref][n] for n in range(1, 9)])
check("S6.2 m2 = P-eigenvalue: mh2(odd) = -1/15 == spec(P)|_{u!=0} "
"(character theorem: ramification S4.2 + equidistribution S4.3); "
"two-odd-event contraction = two-step 1/225 (S3.3)",
value_thm and law_odd and Fr(-1, 15) ** 2 == Fr(1, 225),
kill="K9")
# transversality (typed report, no kill): code census on the SAME std model
def in_L_std(v):
if all(t % 2 == 0 for t in v):
return sum(t // 2 for t in v) % 2 == 0
if all(t % 2 == 1 for t in v):
return sum(v) % 4 == 0
return False
def in_pi2L_std(v):
w = [0] * 8
for k in range(4):
w[2 * k] = v[2 * k] + v[2 * k + 1]
w[2 * k + 1] = v[2 * k + 1] - v[2 * k]
if any(x % 2 for x in w):
return False
return in_L_std([x // 2 for x in w])
reps_std, label_std = class_reps(STD, in_pi2L_std)
std_census = Counter(label_std.values())
std_ok = (len(reps_std) == 15
and sorted(std_census.values()) == [16] * 15
and not any(in_pi2L_std(x) for x in STD))
cont = {}
for x in STD:
if all(t % 2 == 0 for t in x):
a = [t // 2 for t in x]
pj = "j0" if sum(a[:5]) % 2 == 0 else "j2"
else:
pj = "spin"
cont[(label_std[x], pj)] = cont.get((label_std[x], pj), 0) + 1
code_ref = all(len({pj for (li, pj) in cont if li == l}) == 1
for l in range(15))
packet_ref = (52 % 16 == 0 and 60 % 16 == 0)
row_profile = Counter(
tuple(sorted((pj, n) for (li, pj), n in cont.items() if li == l))
for l in range(15))
check("S6.3 TYPED TRANSVERSALITY (report, no kill): std-model code census "
"15 x 16 zero-empty (model independence: %s); code refines packet: "
"%s; packet refines code: %s (52,60 not multiples of 16) -- the "
"identification is SPECTRAL, not a quotient-map intertwiner"
% (std_ok, code_ref, packet_ref), std_ok, kill=None)
for prof, cnt in sorted(row_profile.items()):
print(" %2d code classes with packet profile %s" % (cnt, prof))
# ======================================================================
section("C: must-break controls")
# ======================================================================
r1 = list(r_census)
r1[0] = 16
W1 = walsh(r1)
vals1 = sorted(W1[u] for u in W1 if u != U0)
check("C1 FIRES: occupied zero class r(0)=16: Walsh (%d; %s), normalized "
"{1, 0^15} != law; two-step 0 != 1/225"
% (W1[U0], sorted(set(vals1))),
W1[U0] == 256 and vals1 == [0] * 15
and Fr(0, 256) ** 2 != Fr(1, 225), kill="K4")
r2 = list(r_census)
r2[1] -= 1 # one nonzero class at 15
W2 = walsh(r2)
mult2 = Counter(W2[u] for u in W2 if u != U0)
check("C2 FIRES: one class at 15: Walsh multiset on u != 0 = %s == "
"{-17: 7, -15: 8}; NOT uniform, no value -16, ratios != -1/15"
% dict(sorted(mult2.items())),
dict(mult2) == {-17: 7, -15: 8}
and all(Fr(v, W2[U0]) != Fr(-1, 15) for v in mult2), kill="K4")
check("C3 FIRES: wrong quotient dim F_2^3: 240 %% 7 = %d != 0 (uniform "
"integer multiplicity impossible); uniform channel eigenvalue "
"-1/7 != -1/15; two-step 1/49 != 1/225" % (240 % 7),
240 % 7 != 0 and Fr(-1, 7) != Fr(-1, 15)
and Fr(1, 49) != Fr(1, 225), kill="K4")
# ======================================================================
section("I: must-be-invariant")
# ======================================================================
ISOS = [("sigma", lambda v: tuple(v[PI_SIG[k]] for k in range(8)))]
PAIRS = [(0, 1), (2, 3), (4, 5), (6, 7)]
for pp in itertools.permutations(range(4)):
if pp == (0, 1, 2, 3):
continue
perm = [0] * 8
for k in range(4):
perm[2 * k], perm[2 * k + 1] = PAIRS[pp[k]]
if code_image(CSTAR, tuple(perm)) == CSTAR:
ISOS.append(("pairperm%s" % (pp,),
(lambda pm: lambda v: tuple(v[pm[k]]
for k in range(8)))(perm)))
for k in range(4):
swap = list(range(8))
swap[2 * k], swap[2 * k + 1] = swap[2 * k + 1], swap[2 * k]
if code_image(CSTAR, tuple(swap)) == CSTAR:
def U_k(v, kk=k):
out = list(v)
out[2 * kk], out[2 * kk + 1] = -v[2 * kk + 1], v[2 * kk]
return tuple(out)
ISOS.append(("unit%d" % k, U_k))
j_triv = all(label[r] == label.get(J_vec(r), label[r])
and cls16(J_vec(r))[0] == cls16(r)[0] for r in ROOTS)
neg_triv = all(cls16(tuple(-t for t in r))[0] == cls16(r)[0] for r in ROOTS)
ok_iso = True
nontriv = 0
maps_seen = set()
for name, f in ISOS:
imgs = [f(r) for r in ROOTS]
if sorted(imgs) != sorted(ROOTS):
ok_iso = False
continue
gbar = {}
well = True
for r in ROOTS:
a, b = cls16(r)[0], cls16(f(r))[0]
if a in gbar and gbar[a] != b:
well = False
gbar[a] = b
gbar[0] = cls16(f(ZERO))[0]
lin = all(gbar[ADD[a][b]] == ADD[gbar[a]][gbar[b]]
for a in gbar for b in gbar)
censusg = [0] * 16
for r in ROOTS:
censusg[gbar[cls16(r)[0]]] += 1
Wg = walsh(censusg)
spec_ok = (sorted(Wg.values()) == sorted(RHAT.values()))
if not (well and lin and censusg == r_census and spec_ok):
ok_iso = False
key = tuple(gbar[k] for k in range(16))
if key != tuple(range(16)):
nontriv += 1
maps_seen.add(key)
check("I1 INVARIANT: %d explicit isometries of (L, J) (sigma, %d "
"pair-perms, %d unit turns): each induces a well-defined F_2-"
"linear map on V, preserves the census and the Walsh spectrum; "
"%d nontrivial induced maps; J and -1 induce the identity on V "
"(%s, %s)" % (len(ISOS), sum(1 for n, _ in ISOS if "pairperm" in n),
sum(1 for n, _ in ISOS if "unit" in n), nontriv,
j_triv, neg_triv),
ok_iso and nontriv >= 1 and j_triv and neg_triv, kill="K5")
in_L2, in_pi2L2 = make_tests(CSTAR2)
ROOTS2 = build_roots(CSTAR2)
reps2, label2 = class_reps(ROOTS2, in_pi2L2)
ZERO2 = (0,) * 8
REPS16_2 = [ZERO2] + list(reps2)
cens2 = [0] * 16
ok2 = len(reps2) == 15
for r in ROOTS2:
hits = [k for k in range(16)
if in_pi2L2(tuple(a - b for a, b in zip(r, REPS16_2[k])))]
if len(hits) != 1:
ok2 = False
break
cens2[hits[0]] += 1
# Walsh spectrum of the second placement: uniform census => same multiset
w2_0 = sum(cens2)
w2_vals_ok = (cens2[0] == 0 and sorted(cens2[1:]) == [16] * 15)
check("I2 INVARIANT: the OTHER mu4/sigma-invariant placement C**: %d "
"roots, census (zero; nonzero) = (%d; %s) => identical Walsh "
"spectrum (240; -16 x15) by the same uniform law"
% (len(ROOTS2), cens2[0], sorted(set(cens2[1:]))),
len(ROOTS2) == 240 and ok2 and w2_vals_ok and w2_0 == 240,
kill="K5")
# ======================================================================
section("VERDICT")
# ======================================================================
n_pass = sum(1 for _, ok in CHECKS if ok)
n_tot = len(CHECKS)
kills_a = [k for k in KILLS if k in ("K1", "K2", "K3", "K4", "K5")]
kills_b = [k for k in KILLS if k in ("K6", "K7", "K8", "K9")]
if kills_a:
va = {"K1": "FOURIER-MISMATCH-CENSUS", "K2": "FOURIER-MISMATCH-LAW",
"K3": "FOURIER-MISMATCH-CHANNEL", "K4": "CONTROL-DEAD",
"K5": "INVARIANCE-BROKEN"}[kills_a[0]]
else:
va = "SIMPLEX-FOURIER-EXACT"
if kills_b:
vb = {"K6": "INTERTWINER-GAP-CODE", "K7": "INTERTWINER-GAP-PACKET",
"K8": "INTERTWINER-GAP-VALUE",
"K9": "INTERTWINER-GAP-BRIDGE"}[kills_b[0]]
else:
vb = "INTERTWINER-IDENTIFIED"
VERDICT = "%s + %s" % (va, vb)
print("%d/%d checks passed" % (n_pass, n_tot))
print("VERDICT: %s" % VERDICT)
print("\nCORPUS COMPRESSION NOTES (report only -- no promotion, no edits):")
print(" * THE FOURIER LAW: the v833/v844 census 240 = 15 x 16 (zero class")
print(" empty) IS the spectral statement rhat = (240; -16 x15), i.e. the")
print(" uniform-nonzero channel P = (J-I)/15 with spec {1, (-1/15)^15}")
print(" and two-step contraction 1/225 -- one Walsh transform away from")
print(" the deployed census, no new input.")
print(" * THE FIVE-LINE THEOREM (measured here): (i) zero class empty at")
print(" ALL odd levels (ramification, one-line proof), (ii) nonzero")
print(" classes equidistribute at every level (Sp(4,2) footprint),")
print(" (iii) hence Thetahat_u(odd n) = -Theta_L(n)/15, (iv) the packet")
print(" numerator Th0-Th1+Th2-Th3 EQUALS Thetahat_u at every computed")
print(" level (15 Theta_D8 = 7 Theta_L + 8 Theta_0), (v) hence")
print(" mh2(odd) = -1/15 = spec(P)|_{u!=0}: v817's per-prime measurement")
print(" is a CHARACTER THEOREM of the code.")
print(" * HONEST TYPE: the identification is spectral (numerator q-series")
print(" equal); the packet 5|3-parity grading (52,60,128) and the code")
print(" grading (15 x 16) do NOT refine each other (S6.3 table).")
print("Runtime: %.1f s" % (time.time() - T0))
print("ALL CHECKS PASSED" if n_pass == n_tot
else "CHECKS FAILED: %d" % (n_tot - n_pass))
raise SystemExit(0 if (n_pass == n_tot) else 1)
'''
_SRC_WINDING = r'''
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r"""flavor_winding_quadratic_probe -- FLAVOR.WINDING.QUADRATIC.01 (the
I.5 mini-theorem of the 2026-08-08 morning analysis): the winding
deformation of the flavor residue matrix is controlled by ONE quadratic
q_wind(t) = t^2 - g_car t + |Z2|, exactly.
FROZEN CLAIMS (2026-08-08, frozen + SHA-hashed before first run):
S1 THE RESIDUE MATRIX re-verified against the deployed invariants
(v4_flavor_matrix.py + tfpt_2 winding boxes, read-only):
R = [[1,3,0],[1,5,2],[2,5,3]]; det R = 8 = h(D5); tr R = 9;
chi_R = t^3 - 9t^2 + 10t - 8; principal 2x2 minors (5,3,2)
(deletion order), sorted {2,3,5}; SNF (1,1,8); ||R||_F^2 = 78;
anchor column R e1 = a = (1,1,2); column sums (4,13,5);
R^T a = (6,18,8); the cofactor seam normal n = (5,-9,6) = the
common first adjugate row of R AND L, with n.1 = 2 = |Z2| and
n^T R = (8,0,0) (tfpt_2 Winding Line box).
S2 THE MINI-THEOREM (sympy, exact, symbols s and t): for
R_s = R + s 1 e1^T:
chi_{R_s}(t) = det(tI - R_s)
= t^3 - (9+s) t^2 + (10+5s) t - (8+2s)
identically; equivalently chi_{R_s} - chi_R = -s q_wind(t) with
q_wind(t) = t^2 - 5t + 2 = t^2 - g_car t + |Z2|
(coefficient triple (1, -g_car, |Z2|), magnitudes (1,5,2)).
SIGN CONVENTION typed: in the det(R_s - tI) convention (odd
dimension) the deformation term is +s q_wind(t) -- the morning
note's "+" form -- BOTH computed exactly. The structural origin:
the matrix determinant lemma gives q_wind(t) = e1^T adj(tI-R) 1
(verified symbolically), so d(det R_s)/ds = q_wind(0) = 2 = |Z2|
(the per-winding determinant increment of the deployed Winding
Line box). q_wind is irreducible over Q (disc = 17, nonsquare);
the pencil has two s-INVARIANT base points: rem(chi_{R_s},
q_wind, t) is s-free and equals rem(chi_R, q_wind, t).
MEASURED COINCIDENCE (report): q_wind(6) = 8 = det R.
S3 THE TRIPLE LOCK (three independent fixings, each solved exactly):
tr R_s = 15 = dim A3 => s = 6;
det R_s = 8 + 2s = 20 = 2 A_Lambda = |R(A4)| => s = 6;
Coxeter lift (R_s^T a)_1 = 6 + 4s = 30 = h(E8) => s = 6
(the 4 is 1^T a = |mu4|); intersection = {6} = {|R+(A3)|}.
At s = 6: chi_L = t^3 - 15t^2 + 40t - 20 with (15,40,20) =
(dim A3, |R(D5)|, |R(A4)|); PrinMin2(R_s) = (5, 3(s+1), 2(s+1))
symbolically, hence PrinMin2(L) = (5,21,14) = (g_car, 3x7, 2x7)
(carrier minor 5 is s-INVARIANT); R_s^{-1} 1 = (1,1,-1)/(4+s);
L = R + 6W rows = word lengths (7,3,0),(7,5,2),(8,5,3) (v4).
S4 THE ROOT LOCUS (measure, don't narrate; exact Sturm/resultant):
Delta(s) = disc_t(chi_{R_s}) computed exactly as a polynomial in
s; FROZEN VALUES: Delta(0) = -7996 = -2^2 x 1999 (complex pair at
s = 0, deployed) and Delta(6) = 39200 = 2^5 5^2 7^2 = 2 x 140^2
> 0 (three real eigenvalues, deployed); s = 6 is NOT on the
discriminant locus (Delta(6) != 0); the reality threshold s* lies
in (2,3) (deployed ~2.83): exactly one real root of Delta in
(2,3), and the real-eigenvalue count of chi_{R_s} jumps 1 -> 3
between s = 2 and s = 3 (Sturm counts); at s = 6 the spectrum is
3 real POSITIVE roots. MEASURED AND TYPED (no frozen
prediction): the full real-root census of Delta (count, factor
decomposition over Q, rational isolations, minimal polynomial of
s*), whether any collision point exists at s > 6, and the integer
window s = -2..12 of Delta values with square / 2 x square
typing (is 6 distinguished in the window? -- reported either
way).
C CONTROLS (each must fire; exact):
C1 direction 1 e2^T: the deformation quadratic is
e2^T adj(tI-R) 1 = t^2 - t + 2 != q_wind (middle coefficient
1 != g_car); the triple lock BREAKS: trace-fix {6}, det-fix
{6} (constant term coincides -- typed honestly), Coxeter-fix
EMPTY ((R_s^T a)_1 = 6 s-free) => intersection EMPTY.
C2 direction 1 e3^T: quadratic t^2 + t - 2 = (t+2)(t-1) !=
q_wind AND reducible (typed); det-fix {-6}, trace-fix {6},
Coxeter-fix EMPTY => intersection EMPTY.
C3 THE SIBLING ROW TRANSPORT e1 1^T (row instead of column):
quadratic 1^T adj(tI-R) e1 = t^2 - 5t + 1: keeps the g_car
coefficient, LOSES the |Z2| constant; fixings {6}, {12}, {24}
pairwise disjoint (the measured doubling chain) =>
intersection EMPTY.
C4 THE SIBLING MINOR BRANCH (v4's control transported): the
sibling triple {1,3,4} is unreachable on the whole winding
line: 5 in PrinMin2(R_s) for EVERY s (the invariant carrier
minor), 5 not in {1,3,4}; ratio 3:2 of the moving minors is
s-invariant.
KILLS (any one fires => typed failure):
K1 deployed residue invariants break -> RESIDUE-MISMATCH
K2 the quadratic law (S2) breaks -> QUADRATIC-MISMATCH
K3 the triple lock (S3) breaks -> LOCK-BROKEN
K4 the frozen locus values/counts break -> LOCUS-BROKEN
K5 a control does not fire -> CONTROL-DEAD
VERDICT (frozen enum): WINDING-QUADRATIC-EXACT / RESIDUE-MISMATCH /
QUADRATIC-MISMATCH / LOCK-BROKEN / LOCUS-BROKEN / CONTROL-DEAD.
FIREWALL: experiments/ probe; EXPLORATION ONLY -- writes nothing but
stdout; no verification/, paper, ledger, changelog or website surface;
no .md, no commits. Exact sympy/integer arithmetic in every decision;
floats only in report-line prints of algebraic numbers; no RNG, no
fits. NO physics claim. Runtime cap: minutes.
Sources (read-only): verification/v4_flavor_matrix.py (R, sibling
branch), v10_projection_involution.py (6W forcing), v134_dual_anchor.py
(dual anchor), tfpt_2_standard_model.tex (winding-deformation keybox +
Winding Line box: chi_{R_s}, triple lock, disc values, s* ~ 2.83).
Run:
experiments/tfpt-discovery/.venv/bin/python \
experiments/tfpt-discovery/flavor_winding_quadratic_probe.py
"""
import hashlib
import math
import time
import sympy as sp
T0 = time.time()
CHECKS = []
KILLS = []
G_CAR = 5
Z2 = 2
N_FAM = 3
MU4 = 4
H_E8 = 30
DIM_A3 = 15
R_D5 = 40
R_A4 = 20
A_LAMBDA = 10
RP_A3 = 6
def check(name, ok, detail="", kill=None):
CHECKS.append((name, bool(ok)))
if kill and not ok:
KILLS.append(kill)
print(" [%s] %s%s" % ("PASS" if ok else "FAIL", name,
(" -- " + detail) if detail else ""), flush=True)
return bool(ok)
def section(title):
print("\n== %s == (t=%.1fs)" % (title, time.time() - T0), flush=True)
print("=" * 74)
print("FLAVOR.WINDING.QUADRATIC.01 -- chi_{R_s} = chi_R - s q_wind,")
print("q_wind = t^2 - g_car t + |Z2|; triple lock s = 6; root locus")
print("=" * 74)
print("FROZEN_SPEC SHA-256: %s"
% hashlib.sha256(__doc__.encode("utf-8")).hexdigest())
t, s = sp.symbols("t s")
R = sp.Matrix([[1, 3, 0], [1, 5, 2], [2, 5, 3]])
ONES = sp.Matrix([1, 1, 1])
E1 = sp.Matrix([[1, 0, 0]])
A = sp.Matrix([1, 1, 2])
L = R + 6 * sp.Matrix([[1, 0, 0], [1, 0, 0], [1, 0, 0]])
# ======================================================================
section("S1: the residue matrix against the deployed invariants (v4)")
# ======================================================================
chiR = sp.expand(R.charpoly(t).as_expr())
minors = [sp.det(R.minor_submatrix(k, k)) for k in range(3)]
from sympy.matrices.normalforms import smith_normal_form
snf = sorted(abs(int(x)) for x in smith_normal_form(R, domain=sp.ZZ)
.diagonal())
check("S1.1 det R = %d == 8 = h(D5); tr R = %d == 9; chi_R = %s"
% (R.det(), R.trace(), chiR),
R.det() == 8 and R.trace() == 9
and chiR == t ** 3 - 9 * t ** 2 + 10 * t - 8, kill="K1")
check("S1.2 PrinMin2(R) = %s == (5,3,2); sorted {2,3,5}; SNF %s == "
"(1,1,8); ||R||_F^2 = %d == 78"
% (tuple(minors), tuple(snf), sum(x ** 2 for x in R)),
tuple(minors) == (5, 3, 2) and snf == [1, 1, 8]
and sum(x ** 2 for x in R) == 78, kill="K1")
n_vec = R.adjugate().row(0)
check("S1.3 anchor R e1 = %s == (1,1,2); column sums %s == (4,13,5); "
"R^T a = %s == (6,18,8)"
% (tuple(R.col(0)), tuple(ONES.T * R), tuple(R.T * A)),
tuple(R.col(0)) == (1, 1, 2)
and tuple(ONES.T * R) == (4, 13, 5)
and tuple(R.T * A) == (6, 18, 8), kill="K1")
check("S1.4 cofactor seam normal: adj(R) row 1 = %s == (5,-9,6) == "
"adj(L) row 1; n.1 = %s == 2 = |Z2|; n^T R = %s == (8,0,0)"
% (tuple(n_vec), (n_vec * ONES)[0], tuple(n_vec * R)),
tuple(n_vec) == (5, -9, 6)
and tuple(L.adjugate().row(0)) == (5, -9, 6)
and (n_vec * ONES)[0] == 2 and tuple(n_vec * R) == (8, 0, 0),
kill="K1")
# ======================================================================
section("S2: the mini-theorem -- one quadratic controls the deformation")
# ======================================================================
Rs = R + s * ONES * E1
chiS = sp.expand(Rs.charpoly(t).as_expr())
target = sp.expand(t ** 3 - (9 + s) * t ** 2 + (10 + 5 * s) * t
- (8 + 2 * s))
q_wind = t ** 2 - G_CAR * t + Z2
check("S2.1 chi_{R_s}(t) = det(tI - R_s) = t^3 - (9+s)t^2 + (10+5s)t "
"- (8+2s) EXACT (sympy expand)",
sp.expand(chiS - target) == 0, kill="K2")
check("S2.2 chi_{R_s} - chi_R = -s q_wind with q_wind = t^2 - 5t + 2 = "
"t^2 - g_car t + |Z2| (triple (1,-5,2))",
sp.expand(chiS - chiR + s * q_wind) == 0, kill="K2")
det_conv = sp.expand(sp.det(Rs - t * sp.eye(3)))
check("S2.3 SIGN CONVENTION typed: det(R_s - tI) = (-t^3 + 9t^2 - 10t "
"+ 8) + s (t^2 - 5t + 2) -- the '+' reading, computed",
sp.expand(det_conv - (-chiR + s * q_wind)) == 0, kill="K2")
adjP = (t * sp.eye(3) - R).adjugate()
lemma = sp.expand((E1 * adjP * ONES)[0])
check("S2.4 matrix determinant lemma: e1^T adj(tI-R) 1 = %s == q_wind; "
"d(det R_s)/ds = q_wind(0) = %d == |Z2| (per-winding det "
"increment)" % (lemma, lemma.subs(t, 0)),
sp.expand(lemma - q_wind) == 0 and lemma.subs(t, 0) == Z2,
kill="K2")
rem_s = sp.rem(chiS, q_wind, t)
check("S2.5 q_wind irreducible over Q (disc = %s, nonsquare); the two "
"base points are s-INVARIANT: rem(chi_{R_s}, q_wind, t) = %s is "
"s-free and = rem(chi_R, q_wind, t)"
% (sp.discriminant(q_wind, t), sp.expand(rem_s)),
sp.discriminant(q_wind, t) == 17
and not sp.expand(rem_s).has(s)
and sp.expand(rem_s - sp.rem(chiR, q_wind, t)) == 0, kill="K2")
print(" MEASURED COINCIDENCE (report): q_wind(6) = %s (= det R = 8)"
% q_wind.subs(t, 6))
# ======================================================================
section("S3: the triple lock s = 6 (three independent exact fixings)")
# ======================================================================
fix_tr = sp.solve(sp.Eq(Rs.trace(), DIM_A3), s)
fix_det = sp.solve(sp.Eq(Rs.det(), R_A4), s)
cox = sp.expand((Rs.T * A)[0])
fix_cox = sp.solve(sp.Eq(cox, H_E8), s)
check("S3.1 tr R_s = 15 => s = %s; det R_s = 8+2s = 20 => s = %s; "
"(R_s^T a)_1 = %s = 30 => s = %s; intersection {6} = {|R+(A3)|}"
% (fix_tr, fix_det, cox, fix_cox),
fix_tr == [6] and fix_det == [6] and fix_cox == [6]
and sp.expand(cox - (6 + 4 * s)) == 0
and int((ONES.T * A)[0]) == MU4, kill="K3")
chiL = sp.expand(L.charpoly(t).as_expr())
minorsS = [sp.factor(sp.det(Rs.minor_submatrix(k, k))) for k in range(3)]
check("S3.2 at s = 6: chi_L = %s == t^3 - 15t^2 + 40t - 20 with "
"(15,40,20) = (dim A3, |R(D5)|, |R(A4)|)" % chiL,
chiL == t ** 3 - DIM_A3 * t ** 2 + R_D5 * t - R_A4
and sp.expand(chiS.subs(s, 6) - chiL) == 0, kill="K3")
check("S3.3 PrinMin2(R_s) = %s == (5, 3(s+1), 2(s+1)); at s = 6: "
"(5,21,14) = (g_car, 3x7, 2x7); carrier minor 5 s-INVARIANT"
% (tuple(minorsS),),
sp.expand(minorsS[0] - 5) == 0
and sp.expand(minorsS[1] - 3 * (s + 1)) == 0
and sp.expand(minorsS[2] - 2 * (s + 1)) == 0
and [m.subs(s, 6) for m in minorsS] == [5, 21, 14], kill="K3")
rsinv1 = sp.simplify(Rs.inv() * ONES)
check("S3.4 R_s^{-1} 1 = (1,1,-1)/(4+s) (keybox); L rows = word "
"lengths (7,3,0),(7,5,2),(8,5,3) (v4)",
sp.simplify(rsinv1 - sp.Matrix([1, 1, -1]) / (4 + s))
== sp.zeros(3, 1)
and [tuple(L.row(i)) for i in range(3)]
== [(7, 3, 0), (7, 5, 2), (8, 5, 3)], kill="K3")
# ======================================================================
section("S4: the root locus (exact Sturm / resultant measurements)")
# ======================================================================
Delta = sp.expand(sp.discriminant(chiS, t))
D0 = int(Delta.subs(s, 0))
D6 = int(Delta.subs(s, 6))
check("S4.1 Delta(s) = disc_t chi_{R_s} = %s; Delta(0) = %d == -7996 = "
"-2^2 x 1999; Delta(6) = %d == 39200 = 2^5 5^2 7^2 = 2 x 140^2; "
"s = 6 NOT on the locus" % (Delta, D0, D6),
D0 == -7996 and D6 == 39200 and D6 == 2 * 140 ** 2 and D6 != 0,
kill="K4")
Dpoly = sp.Poly(Delta, s)
n_real = Dpoly.count_roots()
n_23 = Dpoly.count_roots(2, 3)
n_after6 = Dpoly.count_roots(6, 10 ** 9)
rr = sp.real_roots(Dpoly)
facs = sp.factor_list(Delta, s)
check("S4.2 FROZEN: exactly one real root of Delta in (2,3) (the "
"reality threshold s*, deployed ~2.83): count = %d; Sturm real-"
"eigenvalue counts of chi jump 1 -> 3 between s = 2 and s = 3: "
"(%d, %d)"
% (n_23, sp.Poly(chiS.subs(s, 2), t).count_roots(),
sp.Poly(chiS.subs(s, 3), t).count_roots()),
n_23 == 1
and sp.Poly(chiS.subs(s, 2), t).count_roots() == 1
and sp.Poly(chiS.subs(s, 3), t).count_roots() == 3, kill="K4")
check("S4.3 at s = 6: chi_L has 3 real POSITIVE roots (count all = %d, "
"count in (0, inf) = %d)"
% (sp.Poly(chiL, t).count_roots(),
sp.Poly(chiL, t).count_roots(0, 10 ** 9)),
sp.Poly(chiL, t).count_roots() == 3
and sp.Poly(chiL, t).count_roots(0, 10 ** 9) == 3, kill="K4")
print(" MEASURED (typed): Delta real-root census: %d real roots; "
"collision points at s > 6: %d" % (n_real, n_after6))
print(" factor_list(Delta) = %s" % (facs,))
for r_ in rr:
print(" real root s* ~ %s (minpoly %s)"
% (sp.N(r_, 8), sp.minimal_polynomial(r_, s)))
print(" integer window s = -2..12 (value, square?, 2 x square?):")
for si in range(-2, 13):
v = int(Delta.subs(s, si))
sq = v >= 0 and math.isqrt(v) ** 2 == v
tsq = v >= 0 and v % 2 == 0 and math.isqrt(v // 2) ** 2 == v // 2
print(" s=%3d Delta=%10d square=%s 2xsquare=%s"
% (si, v, sq, tsq))
window_flags = [si for si in range(-2, 13)
if (lambda v: v >= 0 and v % 2 == 0
and math.isqrt(v // 2) ** 2 == v // 2)
(int(Delta.subs(s, si)))]
print(" 2 x square hits in window: %s (measured, typed)"
% window_flags)
# ======================================================================
section("C: controls (each must fire)")
# ======================================================================
E2 = sp.Matrix([[0, 1, 0]])
E3 = sp.Matrix([[0, 0, 1]])
def lockset(D):
"""solution sets of the three fixings for deformation matrix D."""
Ms = R + s * D
f1 = set(sp.solve(sp.Eq(Ms.trace(), DIM_A3), s))
f2 = set(sp.solve(sp.Eq(Ms.det(), R_A4), s))
f3 = set(sp.solve(sp.Eq(sp.expand((Ms.T * A)[0]), H_E8), s))
return f1, f2, f3
q2 = sp.expand((E2 * adjP * ONES)[0])
l2 = lockset(ONES * E2)
check("C1 FIRES: direction 1 e2^T: quadratic %s != q_wind (triple "
"(1,-1,2)); locks (tr, det, Cox) = (%s, %s, %s): intersection "
"EMPTY (det coincides -- typed; Coxeter kills)"
% (q2, sorted(l2[0]), sorted(l2[1]), sorted(l2[2])),
sp.expand(q2 - q_wind) != 0
and q2 == t ** 2 - t + 2
and l2[0] == {6} and l2[1] == {6} and l2[2] == set()
and (l2[0] & l2[1] & l2[2]) == set(), kill="K5")
q3 = sp.expand((E3 * adjP * ONES)[0])
l3 = lockset(ONES * E3)
check("C2 FIRES: direction 1 e3^T: quadratic %s = %s != q_wind, "
"REDUCIBLE (typed); locks (%s, %s, %s): intersection EMPTY"
% (q3, sp.factor(q3), sorted(l3[0]), sorted(l3[1]), sorted(l3[2])),
sp.expand(q3 - q_wind) != 0 and q3 == t ** 2 + t - 2
and sp.factor(q3) == (t + 2) * (t - 1)
and l3[0] == {6} and l3[1] == {-6} and l3[2] == set()
and (l3[0] & l3[1] & l3[2]) == set(), kill="K5")
q_row = sp.expand((ONES.T * adjP * E1.T)[0])
lrow = lockset(E1.T * ONES.T)
check("C3 FIRES: sibling ROW transport e1 1^T: quadratic %s: keeps "
"-g_car t, LOSES |Z2| (constant 1); locks (%s, %s, %s) pairwise "
"disjoint (measured doubling chain 6/12/24): intersection EMPTY"
% (q_row, sorted(lrow[0]), sorted(lrow[1]), sorted(lrow[2])),
q_row == t ** 2 - 5 * t + 1
and lrow[0] == {6} and lrow[1] == {12} and lrow[2] == {24}
and (lrow[0] & lrow[1] & lrow[2]) == set(), kill="K5")
sib = sp.solve([sp.Eq(minorsS[1], 3), sp.Eq(minorsS[2], 4)], s)
sib_hit = any(set(int(m.subs(s, sv)) for m in minorsS) == {1, 3, 4}
for sv in range(-100, 101))
check("C4 FIRES: sibling minor branch {1,3,4} unreachable on the whole "
"winding line: 5 in PrinMin2(R_s) for EVERY s (invariant carrier "
"minor), moving minors locked at ratio 3:2 (integer scan "
"s = -100..100 finds no hit: %s)" % sib_hit,
minorsS[0] == 5 and not sib_hit
and sp.simplify(minorsS[1] / minorsS[2] - sp.Rational(3, 2)) == 0,
kill="K5")
# ======================================================================
section("VERDICT")
# ======================================================================
n_pass = sum(1 for _, ok in CHECKS if ok)
n_tot = len(CHECKS)
if KILLS:
VERDICT = {"K1": "RESIDUE-MISMATCH", "K2": "QUADRATIC-MISMATCH",
"K3": "LOCK-BROKEN", "K4": "LOCUS-BROKEN",
"K5": "CONTROL-DEAD"}[KILLS[0]]
else:
VERDICT = "WINDING-QUADRATIC-EXACT"
print("%d/%d checks passed" % (n_pass, n_tot))
print("VERDICT: %s" % VERDICT)
print("\nCORPUS COMPRESSION NOTES (report only -- no promotion, no edits):")
print(" * THE I.5 MINI-THEOREM: the whole winding line chi_{R_s} =")
print(" chi_R - s (t^2 - g_car t + |Z2|) is one rank-one determinant")
print(" lemma; the tfpt_2 keybox coefficients (9+s, 10+5s, 8+2s), the")
print(" det increment 2 = |Z2| and the minor law (5, 3(s+1), 2(s+1))")
print(" are all readouts of the single quadratic e1^T adj(tI-R) 1.")
print(" * THE LOCK: trace/det/Coxeter each solve to s = 6 alone; every")
print(" sibling direction (1e2^T, 1e3^T, e1 1^T) breaks the lock AND")
print(" changes the quadratic -- (1, -5, 2) is direction-specific.")
print(" * THE LOCUS: s = 6 is NOT a collision point (Delta(6) = 39200 =")
print(" 2 x 140^2 > 0); the reality threshold is the Delta-root in")
print(" (2,3) (~2.83, deployed); the integer-window 2xsquare census is")
print(" typed above (measured, not narrated).")
print("Runtime: %.1f s" % (time.time() - T0))
print("ALL CHECKS PASSED" if n_pass == n_tot
else "CHECKS FAILED: %d" % (n_tot - n_pass))
raise SystemExit(0 if (n_pass == n_tot) else 1)
'''
# --------------------------------------------------------------- harness
_PF_RE = re.compile(r"^\s*\[(PASS|FAIL)\]\s+(\S+)", re.M)
_VD_RE = re.compile(r"VERDICT[:\]]")
def _probe_file(name):
cand = os.path.abspath(os.path.join(
_HERE, os.pardir, "experiments", "tfpt-discovery", name + ".py"))
return cand if os.path.isfile(cand) else None
def _census(out):
marks = _PF_RE.findall(out)
fails = sorted({tok for st, tok in marks if st == "FAIL"})
verdict = ""
for line in out.splitlines():
if _VD_RE.search(line):
verdict = line.strip()
return len(marks), fails, verdict
def _exec_probe(name, src, run_entry=True):
"""Execute one embedded frozen probe source BYTE-EXACT in its own
module namespace, registered in sys.modules under the probe's
canonical import name; capture and re-emit stdout; return
(stdout, exit_code, byte_equal_to_source_file_or_None)."""
if src[:1] == "\n":
src = src[1:]
path = _probe_file(name)
same = None
if path is not None:
with open(path, encoding="utf-8") as fh:
same = (fh.read() == src)
fname = path or os.path.abspath(__file__)
mod = types.ModuleType(name)
mod.__file__ = fname
sys.modules[name] = mod
buf = io.StringIO()
code = 0
with contextlib.redirect_stdout(buf):
try:
exec(compile(src, fname, "exec"), mod.__dict__)
entry = mod.__dict__.get("main") or mod.__dict__.get("run")
if run_entry and callable(entry):
rc = entry()
code = 0 if rc is None else int(rc)
except SystemExit as exc:
code = 0 if exc.code is None else int(exc.code)
except Exception: # regression guard
import traceback
traceback.print_exc(file=sys.stdout)
code = 99
out = buf.getvalue()
sys.stdout.write(out)
sys.stdout.flush()
return out, code, same
def _gate(name, out, code, same, exp_n, exp_fails, exp_verdict,
exp_code, gates):
n, fails, verdict = _census(out)
ok = (n == exp_n and fails == list(exp_fails)
and exp_verdict in verdict and code == exp_code
and same is not False)
gates.append(ok)
prov = ("byte-exact vs experiments source" if same is True else
"embedded copy (source file not present)" if same is None
else "SOURCE MISMATCH")
print("\n[%s] PATTERN GATE %s: %d checks (exp %d) | FAILs %s "
"(exp %s) | exit %d (exp %d) | %s\n verdict line: %s"
% ("PASS" if ok else "FAIL", name, n, exp_n,
",".join(fails) if fails else "none",
",".join(exp_fails) if exp_fails else "none",
code, exp_code, prov, verdict), flush=True)
return ok
_PLAN = (
("simplex_fourier_probe", _SRC_FOURIER, 26, (),
"SIMPLEX-FOURIER-EXACT + INTERTWINER-IDENTIFIED", 0),
("flavor_winding_quadratic_probe", _SRC_WINDING, 20, (),
"WINDING-QUADRATIC-EXACT", 0),
)
def run():
t0 = time.time()
print("=" * 74)
print("v857 -- E8.SIMPLEX.FOURIER.01 + FLAVOR.WINDING.QUADRATIC.01")
print("(the census as a Fourier law: mh2(odd) = -1/15 a character "
"theorem to 16500;")
print("the winding line as ONE quadratic q_wind = t^2 - g_car t + "
"|Z2| with the")
print("triple lock s = 6 and the reality threshold typed; "
"NO RH claim)")
print("=" * 74, flush=True)
gates = []
for name, src, exp_n, exp_fails, exp_verdict, exp_code in _PLAN:
print("\n" + "-" * 74)
print("EMBEDDED FROZEN PROBE: %s" % name)
print("-" * 74, flush=True)
out, code, same = _exec_probe(name, src)
_gate(name, out, code, same, exp_n, exp_fails, exp_verdict,
exp_code, gates)
ok = all(gates)
print("\n" + "=" * 74)
print("v857: %d/%d probe pattern gates passed | runtime %.1f s"
% (sum(gates), len(gates), time.time() - t0))
print("Both parts are exact corpus compressions of deployed "
"claims (v817/v833/v844,")
print("tfpt_2 I.5 keyboxes) -- identifications typed honestly "
"(spectral-only; the")
print("gradings do not refine each other); no new physical claim; "
"no marker moves.")
print("[%s] v857 VERDICT GATE: SIMPLEX-FOURIER-EXACT + "
"INTERTWINER-IDENTIFIED + WINDING-QUADRATIC-EXACT"
% ("PASS" if ok else "FAIL"))
return 0 if ok else 1
if __name__ == "__main__":
raise SystemExit(run())
Recorded source fingerprint
e812ff8e539e2cc4894194b135f4bdd260d270b621a2598d2ddf800cf90e07c6
Paper sections that cite this module
The module’s catalogue entry retains all 13 section references.
What this source index covers
The public registry includes 116 document views, 6,693 section records and 985 physical LaTeX sources. Active publication documents, research material and archives retain their recorded roles. This is source navigation, not a new semantic review or proof run.