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.
v803_e8_jetcode_affine_nsr.py
verification/v803_e8_jetcode_affine_nsr.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"""v803 -- E8.RAMIFIED.JETCODE.01 (+ E8.AFFINE.NSR.01): the jet-code normal form of the Gaussian E8 compiler + the NS/R bit as an affine 8-point geometry, ONE module from two probes (18/18 + 15/15 checks, ~3 s; discovery probes e8_ramified_jetcode_probe.py JETCODE-EXACT and e8_affine_nsr_probe.py AFFINE-NSR-EXACT, both 2026-08-06, FROZEN_SPEC SHA-hashed before any root data). PART 1, THE JET CODE (all [E neu], machine-certified): Z[i]/(2) = F2[eps]/(eps^2) with eps = 1 + i and 2 = -i(1+i)^2 (2 RAMIFIES; the ring iso is UNIQUE -- the only nonzero nilpotent is 1+i -- and the wrong split ring F2 x F2 is NOT isomorphic: all 24 bijections fail, control C1); W = L/2L is FREE of rank 4 over the dual numbers (explicit Z[i]-basis by Hermite reduction over the Euclidean domain Z[i], covolume-certified index 1; the 4^4 = 256 dual-number combinations enumerate W bijectively); 0 -> eps W -> W -> V -> 0 is an exact SELF-extension with V = eps W canonically and ker(eps) = im(eps) -- the self-dual differential code; the deck IS the jet unit J = 1 + eps, whence the certified v782 transition-bus torsor translation rho(Jr) = rho(r) + iota(v) on ALL 240 roots (the full 15-row fiber-translation table re-derived from ring algebra); the extension admits ZERO mu4-equivariant splittings among all 65536 = 16^4 linear sections (-1 = +1 mod 2 makes mu4-equivariance = J-equivariance) -- the no-canonical-origin obstruction IS non-splitness; the 120 root pairs are EXACTLY the q = 1 unit shell of the plus-type quadratic form (census 120/136, Arf 0, polarization b = <x,y>/2 mod 2 with trivial radical), so every root is canonically the triple (address v, admissible error jet in the affine v_perp coset, orientation +-): 240 = 15 x 8 x 2. PART 2, THE AFFINE NS/R GEOMETRY (A1-A6 [E neu], chain reading [H neu]): V \ {0} = (7 NS classes = ker chi_NSR \ 0) u (8 R classes = the affine F2^3-torsor A = chi^{-1}(1)); the 7 NS classes carry EXACTLY the 112 D8 roots and the 8 R classes the 128 Ramond spinor roots -- 248 = (112 + 8) + 128 anchored in v148/v227/v301; Stab_GL(4,2)(chi_NSR) has order 1344 = 20160/15 and EQUALS -- as a permutation group with its natural 8-point action -- AGL(3,2) = Aut(H8) (brute force over all 40320 coordinate permutations; the chart composition is the explicit iso of actions); the evaluation code of affine functions on the 8 points of A is the [8,4,4] code RM(1,3) = H8 with EXACTLY 1344 equivalence permutations; the deployed Sp(4,2) stabilizes chi in an order-48 subgroup acting INSIDE AGL(3,2) (the kill does not fire). HONEST TYPING: the reconstruction chain NS/R bit -> affine 8-point space -> H8 SHARPENS the ARF.BOUNDARY.CODE.01 attack surface but the route to V still passes through Gaussian E8 -- an exact internal reconstruction, NOT a P2 removal. Controls fire in both parts (wrong ring, seeded scrambles, unique parity functional 14/14, flipped code bit). No matter semantics (v775 ROOTCLASS-MIXED cited). No marker move, NO RH claim. Python-only per GATE.WOLFRAM.02.
PROVENANCE: discovery probes e8_ramified_jetcode_probe.py (2026-08-06, 18/18, ~1 s, JETCODE-EXACT; the J2 Hermite-reduction freeness fix documented in its frozen spec) + e8_affine_nsr_probe.py (2026-08-06, 15/15, ~2 s, AFFINE-NSR-EXACT); both re-run identically at promotion (2026-08-06). Promoted verbatim, part 2 wrapped in a function scope (v789/v795 precedent; the wrap indents part 2's two multiline print literals by four spaces -- cosmetic, numbers unchanged); module-level _LAST1/_LAST2 verdict captures inserted (v791 precedent); numbers unchanged; run() encodes both patterns (v757 precedent).
Original e8_ramified_jetcode_probe.py docstring (verbatim):
e8_ramified_jetcode_probe -- E8.RAMIFIED.JETCODE.01: the jet-code
normal form of the Gaussian E8 compiler -- W = L/2L is the free rank-4
module over the DUAL NUMBERS F2[eps]/(eps^2) = Z[i]/(2) (2 ramifies:
2 = -i(1+i)^2), the class space V = L/(1+i)L is the canonical exact
self-extension quotient with ker(eps) = im(eps) (the self-dual
differential code), the deck J = 1 + eps EXPLAINS the certified v782
transition-bus torsor (J-translation = the eps-jet of the address),
the no-canonical-origin obstruction IS the non-splitness of the
extension, and the 120 root pairs are exactly the q = 1 unit shell.
TYPING DISCIPLINE (carried): every J-check below is an [E neu]
candidate -- exact from corpus machinery + elementary algebra,
machine-certified here; no [H] content in this probe.
STANDING CONTEXT (read-only, cited): v752/v689 (deployed rank-4 Z[i]
lattice L = Construction A over C*, class space V = L/(1+i)L = F2^4,
15 x 16 root census), v782 -- E8.TRANSITIONBUS.01 (TRANSITION-BUS-
TORSOR: pair fibers = rho_v + iota(v_perp), q = 1 shell, no
distinguished origin), e8_torsor_fourier_probe.py (TORSOR-FOURIER-
PARTIAL). v775 ROOTCLASS-MIXED is unaffected: no matter semantics
anywhere in this probe.
THE FIVE MODULES (all frozen before running, FROZEN_SPEC hashed):
J1 RING: Z[i]/(2) = F2[eps]/(eps^2) with eps = 1 + i; the iso is
UNIQUE (the only nonzero nilpotent is 1+i); 2 = -i(1+i)^2 exact.
J2 MODULE: W := L/2L is FREE of rank 4 over the dual numbers: an
explicit Z[i]-basis of L is constructed (greedy over roots,
covolume-certified), and the 4^4 = 256 dual-number combinations
enumerate W bijectively.
J3 EXTENSION: 0 -> eps W -> W -> V -> 0 exact; eps-multiplication
induces the canonical iso V = eps W ([x] -> eps x, well-defined,
bijective); ker(eps|W) = im(eps|W) -- the self-dual differential
code (eps^2 = 0, ker = im), censused on all 256 points.
J4 TORSOR EXPLANATION (the payoff): i = 1 + eps on W, so
J w = w + eps w for every w (256/256); on every root, rho(J r) =
rho(r) + iota(v) with iota = the J3 iso image of the class v --
the FULL v782 fiber-translation table re-derived from ring
algebra (15-row table printed). NON-SPLITNESS: the extension
admits ZERO mu4-equivariant linear splittings (census over all
16^4 = 65536 linear sections; -1 = +1 mod 2, so mu4-equivariance
= J-equivariance; a J-fixed section would land in ker eps = eps W,
contradicting complementarity) -- "the product decomposition must
fail" = W is not J-trivially V x V; equivalently J moves exactly
the 240 classes outside eps W.
J5 UNIT SHELL: q(w) = (<x,x>/4 mod 2) (the v782 convention, frozen;
well-definedness re-censused) has exactly 120 + 136 = q^-1(1) +
q^-1(0) points (PLUS type, Arf 0 by count), the 120 root pairs
biject onto q^-1(1), each class fiber is the affine coset
rho_v + iota(v_perp), and every root is exactly the triple
(address v, admissible error jet w in q^-1(1) over v,
orientation +-): 240 = 120 x 2. Polarization census: b(w,w') =
q(w+w')+q(w)+q(w') = <x,y>/2 mod 2 with trivial radical.
KILL (frozen): any module or root action contradicting the jet
structure (a failed census above). CONTROLS (must fire): C1 the
WRONG RING F2 x F2 (split, unramified reading of 2) is NOT isomorphic
to Z[i]/(2) (idempotent/nilpotent census; all 4! bijections fail) --
the extension needs the ramified ring; C2 a seeded scramble of the
root -> W assignment breaks the q = 1 shell.
VERDICT ENUM (frozen): JETCODE-EXACT (all J1-J5 exact + controls
fire) / JETCODE-PARTIAL (controls fire, >= 1 module fails -> name
it) / JETCODE-DEAD (J2 or J3 fails: no jet structure) / TEST-VOID.
FENCES / FIREWALL: experiments/tfpt-discovery probe; ONE new file;
writes nothing; no verification/-, ledger, paper or website surface
touched; no .md. Exact integer / Fraction / F2 arithmetic in every
load-bearing check; RNG only in control C2 (seed frozen 20260806).
No physics, no matter semantics (ROOTCLASS-MIXED cited above).
Run:
python3 experiments/tfpt-discovery/e8_ramified_jetcode_probe.py
Original e8_affine_nsr_probe.py docstring (verbatim):
e8_affine_nsr_probe -- E8.AFFINE.NSR.01: the NS/R character of the
class space V = L/(1+i)L splits V \ {0} into 7 NS classes (= ker chi
minus 0) and an 8-point AFFINE F2^3-torsor A = chi^{-1}(1) (the R
classes); the stabilizer of chi in GL(4,2) is EXACTLY AGL(3,2) of
order 1344 with its natural action on the 8 points -- the SAME group,
with the SAME natural 8-point action, as the corpus Aut(H8) anchor --
and the evaluation code of affine functions on A reconstructs the
[8,4,4] Hamming code RM(1,3) = H8 permutation-equivalently.
TYPING DISCIPLINE (carried): A1-A6 are [E neu] candidates -- exact
from corpus machinery + elementary algebra, machine-certified here.
The RECONSTRUCTION-CHAIN reading (A5b: "NS/R bit -> affine 8-point
space -> [8,4,4]" as a sharpened attack surface for
ARF.BOUNDARY.CODE.01) is typed [H neu]: the chain itself is exact,
but its use as a boundary-code derivation route remains a hypothesis
-- the route to V still passes through Gaussian E8, so NO P2-removal
claim is made.
CORPUS ANCHORS (read-only, cited):
* chi_NSR: v752 P5 (NS/R purity per class, chi = hbar(., y0) linear),
v775 S1.2 (7 NS classes = 112 integer roots, 8 R classes = 128
spinor roots, standard doubled model).
* the 120 + 128 current decomposition: v148 (Fock census: 248
currents = 120 + 128), v227 (248 = adj(D8) + spinor(D8), the D8
branching), v301 (SO(16)_1 contains (E8)_1: dim so(16) = 120
currents + 128 spinor).
* Aut(H8) = AGL(3,2), order 1344: v646 R1a.1 (|AGL(3,2)| = 1344,
all preserving C* in the bits3 position labeling), v776 (30 =
8!/1344 placements of e8-hat).
* ARF.BOUNDARY.CODE.01 state: v776 (verdict BOUNDARY-CODE-UNIQUE),
residual R1 sharpened by v799 (SEAM.CODE.TYPEII.01, TYPEII-FORCED).
* FENCE: v775 ROOTCLASS-MIXED -- this probe reads the NS/R CURRENT
structure (so(16) adjoint vs spinor), NOT a particle table; no
matter semantics anywhere.
THE SIX MODULES (frozen before running, FROZEN_SPEC hashed):
A1 K = ker(chi_NSR) = F2^3 (8 labels incl 0; 7 nonzero = NS classes);
A = chi^{-1}(1) (8 labels = R classes) is an affine K-torsor
(differences in K, action free + transitive); V \ {0} = 7 u 8.
A2 root counts: 7 x 16 = 112 NS roots = EXACTLY the D8 root system
(all +-2e_i +- 2e_j patterns, doubled model); 8 x 16 = 128 R roots
= the Ramond spinor (+-1)^8, sum = 0 mod 4; bookkeeping
248 = (112 + 8) + 128 = adj so(16) + spinor (anchors above).
A3 STABILIZER THEOREM: Stab_{GL(4,2)}(chi) has order 1344 =
20160 / 15 (orbit census), acts AFFINELY on A (a -> g a, affine
over g|_K), FAITHFULLY (kernel of the 8-point action = 1), and
equals -- as a permutation group on the 8 chart points -- the
directly constructed AGL(3,2) = {j -> Mj + t} of order 8 x 168.
A4 Aut(H8) IDENTIFICATION: Aut(C*) (brute force over all 8!
coordinate permutations) has order 1344 and equals the v646
position-AGL(3,2) (bits3 labeling) as a permutation group -- the
SAME natural action on 8 points as A3's; the chart composition is
the explicit isomorphism of actions.
A5 HAMMING RECONSTRUCTION: the evaluation code C_A of all affine
functions a + lambda(x) on the 8 points of A has dim 4, weight
enumerator 1 + 14 x^4 + x^8, doubly even, SELF-DUAL, and is
permutation-equivalent to the deployed C* with EXACTLY 1344
equivalence permutations (= |Aut(H8)|); hence C_A = RM(1,3) = H8.
[H neu] chain reading typed in the docstring above.
A6 COMPATIBILITY (the kill test): the DEPLOYED label symmetry
Sp(4,2) (symplectic group of the hbar Gram, order 720; the label
action of G31, v752) stabilizes chi in a subgroup of order 48 =
720/15 whose 8-point action lies INSIDE the A3 affine group
(census; orbit structure on A reported). KILL: the NS/R label
action incompatible with the affine action = any Stab_Sp(chi)
element acting non-affinely on A.
CONTROLS (must fire, frozen):
X1 WRONG CHARACTER: each of the other 14 nonzero functionals fails
parity purity (its level sets mix NS and R roots) -- chi_NSR is
the UNIQUE parity functional; the wrong-character orbit/stabilizer
structure on roots differs (mixing census > 0).
X2 SCRAMBLED LABELS: a seeded LCG shuffle of the 240 root -> class
assignments destroys NS/R class purity (mixed classes appear).
X3 CORRUPTED CODE: flipping one bit of one nonzero word of C_A
breaks the weight enumerator 1 + 14x^4 + x^8 and self-duality.
VERDICT ENUM (frozen): AFFINE-NSR-EXACT (A1-A6 exact + controls fire)
/ AFFINE-NSR-PARTIAL (controls fire, >= 1 module fails -> name it) /
AFFINE-NSR-DEAD (A3 or A4 or A6 fails: no affine identification) /
TEST-VOID (a control does not fire).
FENCES / FIREWALL: experiments/tfpt-discovery probe; ONE new file;
writes nothing; no verification/-, ledger, paper or website surface
touched; no .md. Exact integer / F2 arithmetic in every load-bearing
check; RNG only in control X2 (seed frozen 20260806).
Run:
python3 experiments/tfpt-discovery/e8_affine_nsr_probe.py
"""
_LAST1 = {}
_LAST2 = {}
import hashlib
import itertools
import random
import time
from collections import Counter
from fractions import Fraction as Fr
T0 = time.time()
CHECKS = []
def check(name, ok, detail=""):
CHECKS.append((name, bool(ok)))
print("[%s] %s%s" % ("PASS" if ok else "FAIL", name,
(" -- " + detail) if detail else ""), flush=True)
return bool(ok)
def section(title):
print("=" * 78)
print(title)
print("=" * 78, flush=True)
FROZEN_SPEC = """\
E8.RAMIFIED.JETCODE.01 FROZEN SPEC (2026-08-06, before any root data).
J1 ring iso Z[i]/(2) = F2[eps]/(eps2), eps = 1+i, unique; 2 = -i(1+i)^2.
J2 W = L/2L free rank 4 over the dual numbers (explicit Z[i]-basis,
covolume-certified; 256 combinations bijective).
J3 0 -> eps W -> W -> V -> 0 exact; V = eps W via [x] -> eps x;
ker(eps) = im(eps) (self-dual differential code).
J4 J = 1 + eps (256/256); rho(Jr) = rho(r) + iota(v) for all 240 roots
(v782 torsor re-derived); ZERO mu4-equivariant splittings among all
65536 linear sections (-1 = +1 mod 2 => mu4-equiv = J-equiv).
J5 q(w) = <x,x>/4 mod 2 (v782 convention frozen): 120 ones / 136 zeros
(plus type, Arf 0), root pairs = q^-1(1) bijectively, fibers = affine
cosets rho_v + iota(v_perp), roots = (address, jet, orientation).
CONTROLS: C1 F2 x F2 not isomorphic (idempotent census 4 vs 2,
nilpotent census 0 vs 1, all 24 bijections fail); C2 LCG scramble
(seed 20260806) of pair images breaks q = 1. VERDICT enum:
JETCODE-EXACT / PARTIAL / DEAD / TEST-VOID as in the docstring.
"""
SPEC_SHA = hashlib.sha256(FROZEN_SPEC.encode("utf-8")).hexdigest()
# ======================================================================
# v752/v689 machinery (verbatim, read-only source)
# ======================================================================
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 = (4, 5, 0, 1, 2, 3, 6, 7)
CSTAR_SUPPORTS_EXPECTED = [
(0, 1, 2, 3), (0, 1, 4, 5), (0, 1, 6, 7), (0, 2, 4, 6), (0, 2, 5, 7),
(0, 3, 4, 7), (0, 3, 5, 6), (1, 2, 4, 7), (1, 2, 5, 6), (1, 3, 4, 6),
(1, 3, 5, 7), (2, 3, 4, 5), (2, 3, 6, 7), (4, 5, 6, 7)]
def apply_perm(c, p):
return tuple(c[p[k]] for k in range(8))
def code_image(code, p):
return frozenset(apply_perm(c, p) for c in code)
def supports_w4(code):
return sorted(tuple(i for i in range(8) if w[i])
for w in code if sum(w) == 4)
def mat_det_inv(rows):
n = len(rows)
A = [[Fr(v) for v in r] for r in rows]
I = [[Fr(1 if i == j else 0) for j in range(n)] for i in range(n)]
det = Fr(1)
for col in range(n):
piv = next((r for r in range(col, n) if A[r][col] != 0), None)
assert piv is not None
if piv != col:
A[col], A[piv] = A[piv], A[col]
I[col], I[piv] = I[piv], I[col]
det = -det
det *= A[col][col]
inv = 1 / A[col][col]
A[col] = [a * inv for a in A[col]]
I[col] = [a * inv for a in I[col]]
for r in range(n):
if r != col and A[r][col] != 0:
f = A[r][col]
A[r] = [a - f * b for a, b in zip(A[r], A[col])]
I[r] = [a - f * b for a, b in zip(I[r], I[col])]
return det, I
def vec_mat(x, M):
n = len(M)
return tuple(sum(x[i] * M[i][j] for i in range(n)) for j in range(n))
def row_hnf(rows):
M = [list(map(int, r)) for r in rows]
m = len(M)
for col in range(m):
piv = next(r for r in range(col, m) if M[r][col] != 0)
M[col], M[piv] = M[piv], M[col]
for r in range(col + 1, m):
while M[r][col] != 0:
q = M[col][col] // M[r][col]
M[col] = [a - q * b for a, b in zip(M[col], M[r])]
M[col], M[r] = M[r], M[col]
if M[col][col] < 0:
M[col] = [-a for a in M[col]]
return M
def hnf_reduce(c, H):
c = list(c)
for i in range(len(H)):
q = c[i] // H[i][i]
if q:
c = [a - q * b for a, b in zip(c, H[i])]
return tuple(c)
def J_vec(x):
out = []
for k in range(0, 8, 2):
out += [-x[k + 1], x[k]]
return tuple(out)
def add_vec(x, y):
return tuple(a + b for a, b in zip(x, y))
def neg_vec(x):
return tuple(-a for a in x)
def ip(x, y):
return sum(a * b for a, b in zip(x, y))
def f2_rref(words):
rows = [list(w) for w in sorted(words, reverse=True) if any(w)]
basis, pivots = [], []
for r in rows:
r = r[:]
for b, pv in zip(basis, pivots):
if r[pv]:
r = [(a + c) % 2 for a, c in zip(r, b)]
if any(r):
basis.append(r)
pivots.append(next(i for i, a in enumerate(r) if a))
return basis, pivots
def make_lattice(in_lat, basis_rows):
det, Binv = mat_det_inv(basis_rows)
lat = {"in": in_lat, "B": basis_rows, "det": det, "Binv": Binv}
def coords(x):
c = vec_mat(x, Binv)
assert all(v.denominator == 1 for v in c), "not a lattice vector"
return tuple(int(v) for v in c)
A = [coords(add_vec(b, J_vec(b))) for b in basis_rows]
H = row_hnf(A)
lat["coords"] = coords
lat["H"] = H
lat["label"] = lambda x: hnf_reduce(coords(x), H)
return lat
def constrA_lattice(code):
cb, pivots = f2_rref(code)
rows = [tuple(r) for r in cb]
rows += [tuple(2 if i == j else 0 for i in range(8))
for j in range(8) if j not in pivots]
return make_lattice(lambda x: tuple(v % 2 for v in x) in code, rows)
def constrA_roots(code):
return [x for x in itertools.product(range(-2, 3), repeat=8)
if sum(v * v for v in x) == 4
and tuple(v % 2 for v in x) in code]
def label_group(lat):
reps = {hnf_reduce((0,) * 8, lat["H"]): (0,) * 8}
frontier = [(0,) * 8]
while frontier:
v = frontier.pop()
for b in lat["B"]:
w = add_vec(v, b)
l = lat["label"](w)
if l not in reps:
reps[l] = w
frontier.append(w)
return reps
def rank_Q(rows):
"""rank over Q of integer rows (Fraction elimination)."""
A = [[Fr(v) for v in r] for r in rows]
rank = 0
ncol = len(A[0]) if A else 0
row = 0
for col in range(ncol):
piv = next((r for r in range(row, len(A)) if A[r][col] != 0),
None)
if piv is None:
continue
A[row], A[piv] = A[piv], A[row]
inv = 1 / A[row][col]
A[row] = [a * inv for a in A[row]]
for r in range(len(A)):
if r != row and A[r][col] != 0:
f = A[r][col]
A[r] = [a - f * b for a, b in zip(A[r], A[row])]
row += 1
rank += 1
return rank
def main():
print("=" * 78)
print("E8.RAMIFIED.JETCODE.01 -- the jet-code normal form "
"(dual numbers, self-extension, unit shell)")
print("=" * 78)
print("FROZEN_SPEC SHA-256 = %s" % SPEC_SHA, flush=True)
# ---------------------------------------------------------------- P0
section("P0: deployed lattice state (v752/v689 recipe, read-only)")
all_placements = set()
for p in itertools.permutations(range(8)):
all_placements.add(code_image(C_NAIVE, p))
both_inv = [c for c in sorted(all_placements, key=lambda c: sorted(c))
if code_image(c, PI_J) == c and code_image(c, PI_SIG) == c]
W0246 = tuple(1 if i in (0, 2, 4, 6) else 0 for i in range(8))
CSTAR = [c for c in both_inv if W0246 in c][0]
ROOTS = sorted(constrA_roots(CSTAR))
LAT = constrA_lattice(CSTAR)
coords = LAT["coords"]
REPS = label_group(LAT)
ZERO = LAT["label"]((0,) * 8)
LBLS = sorted(REPS)
P15 = [lb for lb in LBLS if lb != ZERO]
root_label = {r: LAT["label"](r) for r in ROOTS}
census = Counter(root_label.values())
check("P0.1 C* deterministic, 240 roots, 15 x 16 class census, zero "
"class empty (v752 state)",
supports_w4(CSTAR) == CSTAR_SUPPORTS_EXPECTED
and len(ROOTS) == 240 and len(census) == 15
and sorted(census.values()) == [16] * 15 and ZERO not in census)
# ---------------------------------------------------------------- J1
section("J1 [E neu]: Z[i]/(2) = F2[eps]/(eps^2), eps = 1 + i "
"(2 ramifies)")
check("J1.1 2 = -i (1+i)^2 in Z[i] exact: (0,-1)*(1,1)^2 = (2,0)",
(lambda s: (0 * s[0] - (-1) * s[1],
0 * s[1] + (-1) * s[0]) == (2, 0))
((1 * 1 - 1 * 1, 1 * 1 + 1 * 1)))
# Z[i]/(2): elements (a,b) = a + b i mod 2
ZI2 = [(a, b) for a in (0, 1) for b in (0, 1)]
def zi2_add(x, y):
return ((x[0] + y[0]) % 2, (x[1] + y[1]) % 2)
def zi2_mul(x, y):
return ((x[0] * y[0] - x[1] * y[1]) % 2,
(x[0] * y[1] + x[1] * y[0]) % 2)
# F2[eps]/(eps^2): elements (c,d) = c + d eps
DN = [(c, d) for c in (0, 1) for d in (0, 1)]
def dn_add(x, y):
return ((x[0] + y[0]) % 2, (x[1] + y[1]) % 2)
def dn_mul(x, y):
return ((x[0] * y[0]) % 2, (x[0] * y[1] + x[1] * y[0]) % 2)
def phi(x): # c + d eps -> (c+d) + d i (eps = 1 + i)
return ((x[0] + x[1]) % 2, x[1])
ok_iso = (len({phi(x) for x in DN}) == 4
and all(phi(dn_add(x, y)) == zi2_add(phi(x), phi(y))
for x in DN for y in DN)
and all(phi(dn_mul(x, y)) == zi2_mul(phi(x), phi(y))
for x in DN for y in DN)
and phi((1, 0)) == (1, 0) and phi((0, 1)) == (1, 1))
nilp_zi2 = [x for x in ZI2 if zi2_mul(x, x) == (0, 0) and x != (0, 0)]
idem_zi2 = [x for x in ZI2 if zi2_mul(x, x) == x]
check("J1.2 EXPLICIT RING ISO: phi(c + d eps) = (c+d) + d i is a "
"bijective ring map (16 + 16 products checked); phi(eps) = "
"1 + i; iso UNIQUE (the only nonzero nilpotent of Z[i]/(2) "
"is 1+i: %s); idempotents = {0, 1} (local ring): %s"
% (nilp_zi2, idem_zi2),
ok_iso and nilp_zi2 == [(1, 1)]
and sorted(idem_zi2) == [(0, 0), (1, 0)])
check("J1.3 i = 1 + eps in the quotient: phi(1 + eps) = i "
"(the deck unit IS the jet unit)",
phi(dn_add((1, 0), (0, 1))) == (0, 1))
# ---------------------------------------------------------------- J2
section("J2 [E neu]: W = L/2L is FREE of rank 4 over the dual "
"numbers")
# explicit Z[i]-basis of L via Hermite reduction over the EUCLIDEAN
# domain Z[i]: chart L into Z[i]^4 (z_k = x_2k + i x_2k+1, J = i),
# HNF-reduce the 8 Z-basis generators to 4 pivot rows.
def gadd(a, b):
return (a[0] + b[0], a[1] + b[1])
def gsub(a, b):
return (a[0] - b[0], a[1] - b[1])
def gmul(a, b):
return (a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0])
def gnorm(a):
return a[0] * a[0] + a[1] * a[1]
def gquo(a, b):
"""nearest-integer Gaussian quotient a/b."""
n = gnorm(b)
num = gmul(a, (b[0], -b[1]))
return ((2 * num[0] + n) // (2 * n), (2 * num[1] + n) // (2 * n))
def chart4(x):
return tuple((x[2 * k], x[2 * k + 1]) for k in range(4))
def unchart(z):
out = []
for c in z:
out += [c[0], c[1]]
return tuple(out)
gen = [list(chart4(b)) for b in LAT["B"]]
pivots = []
for col in range(4):
live = [g for g in gen if g[col] != (0, 0)]
rest = [g for g in gen if g[col] == (0, 0)]
while len(live) > 1:
live.sort(key=lambda g: gnorm(g[col]))
a, b = live[0], live[1]
q = gquo(b[col], a[col])
for k in range(4):
b[k] = gsub(b[k], gmul(q, a[k]))
if b[col] == (0, 0):
live.pop(1)
rest.append(b)
elif gnorm(b[col]) == 0:
live.pop(1)
assert live, "rank defect"
pivots.append(live[0])
gen = rest
zbasis = [unchart(p) for p in pivots]
ok_in_L = all(coords(v) is not None for v in zbasis) # asserts
detL = LAT["det"]
rows = []
for v in zbasis:
rows.append(list(v))
rows.append(list(J_vec(v)))
det8 = mat_det_inv(rows)[0]
check("J2.1 explicit Z[i]-basis of L (Hermite over the Euclidean "
"domain Z[i]): 4 lattice vectors %s; (e_k, J e_k) is a "
"Z-basis (covolume |det| = %s = |det L| = %s => index 1, "
"so L is FREE rank 4 over Z[i])"
% (zbasis, abs(det8), abs(detL)),
ok_in_L and len(zbasis) == 4 and abs(det8) == abs(detL))
def rho_of(x):
return tuple(c % 2 for c in coords(x))
def lift2(rho):
w = (0,) * 8
for i, bit in enumerate(rho):
if bit:
w = add_vec(w, LAT["B"][i])
return w
# dual-number combinations: sum (a_k + b_k eps) e_k
combo = {}
for ab in itertools.product((0, 1), repeat=8):
w = (0,) * 8
for k in range(4):
a, b = ab[2 * k], ab[2 * k + 1]
if a:
w = add_vec(w, zbasis[k])
if b:
w = add_vec(w, add_vec(zbasis[k], J_vec(zbasis[k])))
combo[ab] = rho_of(w)
check("J2.2 FREENESS: the 4^4 = 256 dual-number combinations "
"Sum (a_k + b_k eps) e_k enumerate W = L/2L bijectively "
"(%d distinct classes) -- W = (F2[eps]/eps^2)^4 free"
% len(set(combo.values())), len(set(combo.values())) == 256)
RHO_ALL = sorted(itertools.product((0, 1), repeat=8))
LIFT = {rho: lift2(rho) for rho in RHO_ALL}
def eps_w(rho):
x = LIFT[rho]
return rho_of(add_vec(x, J_vec(x))) # (1+i) x = x + J x
EPS = {rho: eps_w(rho) for rho in RHO_ALL}
IW = {rho: rho_of(J_vec(LIFT[rho])) for rho in RHO_ALL}
ok_mod = all(
IW[rho] == tuple((a + b) % 2 for a, b in
zip(rho, EPS[rho])) for rho in RHO_ALL)
check("J2.3 module structure transported: multiplication by i on W "
"equals 1 + eps on all 256 classes (i w = w + eps w)", ok_mod)
# ---------------------------------------------------------------- J3
section("J3 [E neu]: the exact self-extension 0 -> eps W -> W -> "
"V -> 0 and ker(eps) = im(eps)")
EPSW = sorted({EPS[rho] for rho in RHO_ALL})
KER = sorted(rho for rho in RHO_ALL
if EPS[rho] == (0,) * 8)
check("J3.1 SELF-DUAL DIFFERENTIAL CODE: |im(eps)| = %d = |ker(eps)|"
" = %d and ker = im exactly (eps^2 = 0 realized with maximal "
"rank drop 256 -> 16)" % (len(EPSW), len(KER)),
len(EPSW) == 16 and KER == EPSW)
def v_of(rho):
return LAT["label"](LIFT[rho])
ok_seq = (sorted({v_of(rho) for rho in EPSW}) == [ZERO]
and len({v_of(rho) for rho in RHO_ALL}) == 16)
iota = {}
ok_wd = True
for lb in LBLS:
imgs = set()
x = REPS[lb]
for b in [(0,) * 8] + list(LAT["B"]):
xs = add_vec(x, add_vec(b, J_vec(b))) # x + (1+i) b
imgs.add(rho_of(add_vec(xs, J_vec(xs))))
if len(imgs) != 1:
ok_wd = False
iota[lb] = next(iter(imgs))
ok_bij = len(set(iota.values())) == 16 and set(iota.values()) \
== set(EPSW) and iota[ZERO] == (0,) * 8
check("J3.2 EXACTNESS + CANONICAL ISO: eps W maps to 0 in V, "
"W ->> V (16 classes); eps-multiplication induces "
"V = eps W: [x] -> eps x well-defined over all lift shifts "
"(9 lifts per class) and bijective (16 distinct images)",
ok_seq and ok_wd and ok_bij)
# ---------------------------------------------------------------- J4
section("J4 [E neu]: J = 1 + eps explains the v782 torsor; the "
"extension does NOT split mu4-equivariantly")
ok_jw = all(IW[rho]
== tuple((a + b) % 2 for a, b in zip(rho, EPS[rho]))
for rho in RHO_ALL)
ROOT_RHO = {r: rho_of(r) for r in ROOTS}
ok_troot = all(
ROOT_RHO[tuple(J_vec(r))]
== tuple((a + b) % 2
for a, b in zip(ROOT_RHO[r], iota[root_label[r]]))
for r in ROOTS)
check("J4.1 TORSOR EXPLAINED: J w = w + eps w (256/256) and on all "
"240 roots rho(J r) = rho(r) + iota(v) -- the v782 deck "
"translation IS multiplication by the jet unit 1 + eps; "
"translation vector = the J3 iso image of the ADDRESS v",
ok_jw and ok_troot)
print(" fiber-translation table (class v -> iota(v)):")
for lb in P15:
print(" v = %s -> iota(v) = %s" % (lb, iota[lb]))
n_moved = sum(1 for rho in RHO_ALL if IW[rho] != rho)
check("J4.2 J moves exactly 240 of the 256 classes (fixes exactly "
"ker eps = eps W, %d classes): W is NOT a J-trivial product "
"V x V" % (256 - n_moved), n_moved == 240)
# non-splitness census: all 16^4 linear sections
vbasis = []
seen = {ZERO}
for lb in P15:
if lb not in seen:
vbasis.append(lb)
new = set()
for s in seen:
x = add_vec(REPS[s], REPS[lb])
new.add(LAT["label"](x))
seen |= new
if len(vbasis) == 4:
break
cosets = {lb: [rho for rho in RHO_ALL if v_of(rho) == lb]
for lb in vbasis}
ok_cosets = all(len(cosets[lb]) == 16 for lb in vbasis)
n_sections = 0
n_equivariant = 0
for choice in itertools.product(*(cosets[lb] for lb in vbasis)):
n_sections += 1
if all(EPS[rho] == (0,) * 8 for rho in choice):
n_equivariant += 1
n_good_lift = {lb: sum(1 for rho in cosets[lb]
if EPS[rho] == (0,) * 8) for lb in vbasis}
check("J4.3 NON-SPLITNESS (the no-canonical-origin obstruction as "
"ring algebra): of all %d = 16^4 linear sections V -> W, "
"EXACTLY %d are mu4-equivariant (-1 = +1 mod 2, so mu4-equiv "
"= J-equiv = image in ker eps; per-basis good lifts %s): "
"the product decomposition MUST fail -- expected 0"
% (n_sections, n_equivariant,
sorted(n_good_lift.values())),
ok_cosets and n_sections == 65536 and n_equivariant == 0
and all(n == 0 for n in n_good_lift.values()))
# ---------------------------------------------------------------- J5
section("J5 [E neu]: the unit shell -- 120 root pairs = the q = 1 "
"points (plus type), roots = (address, jet, orientation)")
Q2 = {}
ok_qwd = True
for rho in RHO_ALL:
x = LIFT[rho]
n = ip(x, x)
assert n % 4 == 0
Q2[rho] = (n // 4) % 2
for b in LAT["B"]:
x2 = add_vec(x, tuple(2 * a for a in b))
if ((ip(x2, x2) // 4) % 2) != Q2[rho]:
ok_qwd = False
n1 = sum(1 for rho in RHO_ALL if Q2[rho] == 1)
check("J5.1 q(w) = <x,x>/4 mod 2 (v782 convention frozen) "
"well-defined on W; census %d ones / %d zeros = 120 / 136 "
"=> PLUS type (Arf 0 by count)" % (n1, 256 - n1),
ok_qwd and n1 == 120)
pair_imgs = {ROOT_RHO[r] for r in ROOTS}
ok_pairs = (len(pair_imgs) == 120
and all(Q2[rho] == 1 for rho in pair_imgs)
and all(ROOT_RHO[r] == ROOT_RHO[neg_vec(r)]
for r in ROOTS))
check("J5.2 UNIT SHELL: the 240 roots map 2:1 (r ~ -r) onto "
"EXACTLY the 120 q = 1 points -- every admissible unit jet "
"is realized by exactly one root pair", ok_pairs)
VPERP = {v: [t for t in LBLS
if ((ip(REPS[t], REPS[v]) // 2)
+ (ip(REPS[t], J_vec(REPS[v])) // 2)) % 2 == 0]
for v in P15}
ok_fiber = True
for v in P15:
fib = sorted(ROOT_RHO[r] for r in ROOTS if root_label[r] == v)
fib = sorted(set(fib))
base = fib[0]
coset = sorted(tuple((a + b) % 2 for a, b in zip(base, iota[t]))
for t in VPERP[v])
if len(VPERP[v]) != 8 or fib != coset:
ok_fiber = False
check("J5.3 JET READING CERTIFIED: over each address v the 8 root "
"pairs are exactly the affine coset rho_v + iota(v_perp) "
"(the v782 torsor), so every root IS the triple (address v, "
"admissible error jet, orientation +-): 240 = 15 x 8 x 2",
ok_fiber)
ok_pol = True
for rho in RHO_ALL:
for rho2 in RHO_ALL:
b1 = (Q2[tuple((a + b) % 2 for a, b in zip(rho, rho2))]
+ Q2[rho] + Q2[rho2]) % 2
b2 = (ip(LIFT[rho], LIFT[rho2]) // 2) % 2
if b1 != b2:
ok_pol = False
break
if not ok_pol:
break
rad = [rho for rho in RHO_ALL
if all((Q2[tuple((a + b) % 2 for a, b in zip(rho, rho2))]
+ Q2[rho] + Q2[rho2]) % 2 == 0 for rho2 in RHO_ALL)]
check("J5.4 polarization census: b(w,w') = q(w+w')+q(w)+q(w') = "
"<x,y>/2 mod 2 on all 65536 pairs; radical trivial (%d "
"element): (W, q) is a nondegenerate plus-type quadratic "
"space O+(8,2)-style" % len(rad),
ok_pol and rad == [(0,) * 8])
# ---------------------------------------------------------------- C
section("C: must-fail controls")
# C1: the wrong (split/unramified) ring F2 x F2
F22 = [(a, b) for a in (0, 1) for b in (0, 1)]
def f22_mul(x, y):
return ((x[0] * y[0]) % 2, (x[1] * y[1]) % 2)
idem_f22 = [x for x in F22 if f22_mul(x, x) == x]
nilp_f22 = [x for x in F22 if f22_mul(x, x) == (0, 0) and x != (0, 0)]
n_iso = 0
for pm in itertools.permutations(F22):
m = dict(zip(F22, pm))
if m[(0, 0)] != (0, 0):
continue
if all(m[zi2_mul(x, y)] == f22_mul(m[x], m[y])
and m[zi2_add(x, y)] == ((m[x][0] + m[y][0]) % 2,
(m[x][1] + m[y][1]) % 2)
for x in F22 for y in F22):
n_iso += 1
check("C1 CONTROL FIRES: the WRONG RING F2 x F2 (unramified/split "
"reading of 2) is NOT isomorphic to Z[i]/(2): idempotents "
"4 vs 2, nonzero nilpotents %d vs 1, all 24 bijections fail "
"(%d ring isos) -- the extension/jet structure needs the "
"RAMIFIED ring" % (len(nilp_f22), n_iso),
len(idem_f22) == 4 and len(nilp_f22) == 0 and n_iso == 0)
# C2: scrambled lattice assignment breaks q = 1
rng = random.Random(20260806)
targets = rng.sample(RHO_ALL, 120)
n_bad = sum(1 for t in targets if Q2[t] != 1)
check("C2 CONTROL FIRES: a seeded scramble of the 120 pair images "
"(random distinct W-points, seed 20260806) leaves the unit "
"shell: %d/120 scrambled images have q != 1" % n_bad,
n_bad > 0)
# ============================================================ VERDICT
section("SUMMARY / VERDICT")
n_pass = sum(1 for _, ok in CHECKS if ok)
n_all = len(CHECKS)
ctrl_ok = all(ok for nm, ok in CHECKS if nm.startswith("C"))
core = [ok for nm, ok in CHECKS if not nm.startswith("C")]
print("%d/%d checks passed" % (n_pass, n_all))
print("FROZEN_SPEC SHA-256 = %s" % SPEC_SHA)
if not ctrl_ok:
verdict = "TEST-VOID"
elif all(core):
verdict = "JETCODE-EXACT"
elif any(nm.startswith(("J2", "J3")) and not ok
for nm, ok in CHECKS):
verdict = "JETCODE-DEAD"
else:
verdict = "JETCODE-PARTIAL"
_LAST1["verdict"] = verdict
print("VERDICT: %s" % verdict)
if verdict == "JETCODE-EXACT":
print("""
JET-CODE NORMAL FORM (all [E neu], machine-certified above):
Z[i]/(2) = F2[eps]/(eps^2) (2 ramifies, eps = 1+i, unique iso);
W = L/2L = (dual numbers)^4 free; 0 -> eps W -> W -> V -> 0 exact
with V = eps W canonically and ker(eps) = im(eps); the deck is the
jet unit J = 1 + eps, whence the certified v782 torsor translation
rho(Jr) = rho(r) + iota(v); the extension admits ZERO mu4-
equivariant splittings (the no-canonical-origin obstruction IS
non-splitness); the 120 root pairs are exactly the q = 1 unit
shell of the plus-type form, so each root is canonically
(address v, admissible error jet in the affine v_perp coset,
orientation). No matter semantics (v775 ROOTCLASS-MIXED cited).""")
print("runtime: %.1f s" % (time.time() - T0))
print("ALL CHECKS PASSED" if n_pass == n_all else "CHECKS FAILED")
return 0 if n_pass == n_all else 1
_run_part1 = main
def _run_part2():
"""Part 2: e8_affine_nsr_probe.py, promoted verbatim in a function scope (v789/v795 precedent)."""
import hashlib
import itertools
import random
import time
from collections import Counter
from fractions import Fraction as Fr
T0 = time.time()
CHECKS = []
def check(name, ok, detail=""):
CHECKS.append((name, bool(ok)))
print("[%s] %s%s" % ("PASS" if ok else "FAIL", name,
(" -- " + detail) if detail else ""), flush=True)
return bool(ok)
def section(title):
print("=" * 78)
print(title)
print("=" * 78, flush=True)
FROZEN_SPEC = """\
E8.AFFINE.NSR.01 FROZEN SPEC (2026-08-06, before any root data).
A1 K = ker chi_NSR = F2^3, A = chi^-1(1) an affine K-torsor;
V\\{0} = 7 NS u 8 R. A2 112 NS roots = D8 root system, 128 R roots =
Ramond spinor; 248 = (112+8)+128 (v148/v227/v301 anchors).
A3 Stab_GL(4,2)(chi) order 1344 = 20160/15, affine + faithful on A,
= AGL(3,2) (direct construction j -> Mj+t) as permutation group.
A4 Aut(C*) order 1344 = v646 position-AGL(3,2) as permutation group.
A5 evaluation code C_A: dim 4, enumerator 1+14x^4+x^8, doubly even,
self-dual, permutation-equivalent to C* with exactly 1344
equivalences (RM(1,3) = H8). [H neu] chain reading; no P2 removal.
A6 Stab_Sp(4,2)(chi) order 48 acts inside the affine group (kill:
any non-affine action). CONTROLS: X1 all 14 other functionals fail
parity purity; X2 LCG shuffle (seed 20260806) breaks class purity;
X3 one flipped bit breaks the enumerator + self-duality.
VERDICT enum: AFFINE-NSR-EXACT / PARTIAL / DEAD / TEST-VOID.
"""
SPEC_SHA = hashlib.sha256(FROZEN_SPEC.encode("utf-8")).hexdigest()
# ======================================================================
# v752 lattice machinery (verbatim, read-only source)
# ======================================================================
PI_J = (1, 0, 3, 2, 5, 4, 7, 6)
PI_SIG = (4, 5, 0, 1, 2, 3, 6, 7)
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))
CSTAR_SUPPORTS_EXPECTED = [
(0, 1, 2, 3), (0, 1, 4, 5), (0, 1, 6, 7), (0, 2, 4, 6), (0, 2, 5, 7),
(0, 3, 4, 7), (0, 3, 5, 6), (1, 2, 4, 7), (1, 2, 5, 6), (1, 3, 4, 6),
(1, 3, 5, 7), (2, 3, 4, 5), (2, 3, 6, 7), (4, 5, 6, 7)]
def apply_perm(c, p):
return tuple(c[p[k]] for k in range(8))
def code_image(code, p):
return frozenset(apply_perm(c, p) for c in code)
def supports_w4(code):
return sorted(tuple(i for i in range(8) if w[i])
for w in code if sum(w) == 4)
def mat_det_inv(rows):
n = len(rows)
A = [[Fr(v) for v in r] for r in rows]
I = [[Fr(1 if i == j else 0) for j in range(n)] for i in range(n)]
det = Fr(1)
for col in range(n):
piv = next((r for r in range(col, n) if A[r][col] != 0), None)
assert piv is not None
if piv != col:
A[col], A[piv] = A[piv], A[col]
I[col], I[piv] = I[piv], I[col]
det = -det
det *= A[col][col]
inv = 1 / A[col][col]
A[col] = [a * inv for a in A[col]]
I[col] = [a * inv for a in I[col]]
for r in range(n):
if r != col and A[r][col] != 0:
f = A[r][col]
A[r] = [a - f * b for a, b in zip(A[r], A[col])]
I[r] = [a - f * b for a, b in zip(I[r], I[col])]
return det, I
def vec_mat(x, M):
n = len(M)
return tuple(sum(x[i] * M[i][j] for i in range(n)) for j in range(n))
def row_hnf(rows):
M = [list(map(int, r)) for r in rows]
m = len(M)
for col in range(m):
piv = next(r for r in range(col, m) if M[r][col] != 0)
M[col], M[piv] = M[piv], M[col]
for r in range(col + 1, m):
while M[r][col] != 0:
q = M[col][col] // M[r][col]
M[col] = [a - q * b for a, b in zip(M[col], M[r])]
M[col], M[r] = M[r], M[col]
if M[col][col] < 0:
M[col] = [-a for a in M[col]]
return M
def hnf_reduce(c, H):
c = list(c)
for i in range(len(H)):
q = c[i] // H[i][i]
if q:
c = [a - q * b for a, b in zip(c, H[i])]
return tuple(c)
def J_vec(x):
out = []
for k in range(0, 8, 2):
out += [-x[k + 1], x[k]]
return tuple(out)
def add_vec(x, y):
return tuple(a + b for a, b in zip(x, y))
def ip(x, y):
return sum(a * b for a, b in zip(x, y))
def make_lattice(in_lat, basis_rows):
det, Binv = mat_det_inv(basis_rows)
lat = {"in": in_lat, "B": basis_rows, "det": det, "Binv": Binv}
def coords(x):
c = vec_mat(x, Binv)
assert all(v.denominator == 1 for v in c), "not a lattice vector"
return tuple(int(v) for v in c)
A = [coords(add_vec(b, J_vec(b))) for b in basis_rows]
H = row_hnf(A)
lat["coords"] = coords
lat["H"] = H
lat["label"] = lambda x: hnf_reduce(coords(x), H)
return lat
def label_group(lat):
reps = {hnf_reduce((0,) * 8, lat["H"]): (0,) * 8}
frontier = [(0,) * 8]
while frontier:
v = frontier.pop()
for b in lat["B"]:
w = add_vec(v, b)
l = lat["label"](w)
if l not in reps:
reps[l] = w
frontier.append(w)
return reps
def bits3(j):
return ((j >> 2) & 1, (j >> 1) & 1, j & 1)
def main():
print("=" * 78)
print("E8.AFFINE.NSR.01 -- the NS/R bit as an affine 8-point "
"geometry with AGL(3,2) = Aut(H8)")
print("=" * 78)
print("FROZEN_SPEC SHA-256 = %s" % SPEC_SHA, flush=True)
# ---------------------------------------------------------------- A0
section("A0: standard doubled model (v752/v775 machinery, "
"read-only)")
def in_E8_std(x):
par = {v % 2 for v in x}
return len(par) == 1 and sum(x) % 4 == 0
B_STD = [(4, 0, 0, 0, 0, 0, 0, 0), (-2, 2, 0, 0, 0, 0, 0, 0),
(0, -2, 2, 0, 0, 0, 0, 0), (0, 0, -2, 2, 0, 0, 0, 0),
(0, 0, 0, -2, 2, 0, 0, 0), (0, 0, 0, 0, -2, 2, 0, 0),
(0, 0, 0, 0, 0, -2, 2, 0), (1, 1, 1, 1, 1, 1, 1, 1)]
LAT = make_lattice(in_E8_std, list(B_STD))
ROOTS = []
for v in itertools.product(range(-1, 2), repeat=8):
if sum(a * a for a in v) == 2 and sum(v) % 2 == 0:
ROOTS.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:
ROOTS.append(v)
ROOTS = sorted(ROOTS)
REPS = label_group(LAT)
ZERO = LAT["label"]((0,) * 8)
LBLS = sorted(REPS)
root_label = {r: LAT["label"](r) for r in ROOTS}
census = Counter(root_label.values())
ADDV = {(a, b): LAT["label"](add_vec(REPS[a], REPS[b]))
for a in LBLS for b in LBLS}
check("A0.1 240 roots, 15 x 16 census, zero class empty "
"(v752/v775 state)",
len(ROOTS) == 240 and len(census) == 15
and sorted(census.values()) == [16] * 15
and ZERO not in census)
# NS/R character: parity = r[0] mod 2, class-pure, linear
class_par = {}
pure = True
for r, lb in root_label.items():
p = r[0] % 2
if lb in class_par and class_par[lb] != p:
pure = False
class_par[lb] = p
chi = dict(class_par)
chi[ZERO] = 0
ok_lin = all(chi[ADDV[(a, b)]] == (chi[a] + chi[b]) % 2
for a in LBLS for b in LBLS)
check("A0.2 chi_NSR class-pure (v752 P5.1) and LINEAR on V "
"(256/256 additivity; v752 P5.3: chi = hbar(., y0))",
pure and ok_lin)
# ---------------------------------------------------------------- A1
section("A1 [E neu]: K = ker chi = F2^3 and the affine 8-point "
"torsor A")
K = [lb for lb in LBLS if chi[lb] == 0]
A = [lb for lb in LBLS if chi[lb] == 1]
ok_K = (len(K) == 8 and ZERO in K
and all(ADDV[(a, b)] in K for a in K for b in K))
ok_A = (len(A) == 8
and all(ADDV[(a, b)] in K for a in A for b in A)
and all(sorted(ADDV[(k, a)] for a in A) == sorted(A)
for k in K)
and all(len({ADDV[(k, a)] for k in K}) == 8 for a in A))
check("A1.1 K = ker chi is an F2^3 subgroup (8 labels incl 0, "
"closed); A = chi^-1(1) is an affine K-TORSOR: A + A c K, "
"K acts freely and transitively on A; V \\ {0} = "
"(7 NS) u (8 R) exact",
ok_K and ok_A and len(K) - 1 == 7 and len(A) == 8)
# ---------------------------------------------------------------- A2
section("A2 [E neu]: 112 = D8 roots (NS) + 128 = Ramond spinor "
"(R); 248 = (112 + 8) + 128")
ns_roots = [r for r in ROOTS if r[0] % 2 == 0]
r_roots = [r for r in ROOTS if r[0] % 2 == 1]
ok_d8 = (len(ns_roots) == 112
and all(sorted(map(abs, r)) == [0] * 6 + [2, 2]
for r in ns_roots)
and len({root_label[r] for r in ns_roots}) == 7
and {root_label[r] for r in ns_roots} == set(K) - {ZERO})
ok_sp = (len(r_roots) == 128
and all(sorted(map(abs, r)) == [1] * 8 and sum(r) % 4 == 0
for r in r_roots)
and {root_label[r] for r in r_roots} == set(A))
check("A2.1 the 7 NS classes carry EXACTLY the 112 D8 roots "
"(+-2e_i +- 2e_j, doubled model) = 7 x 16; the 8 R classes "
"carry EXACTLY the 128 Ramond spinor roots ((+-1)^8, "
"sum = 0 mod 4) = 8 x 16", ok_d8 and ok_sp)
check("A2.2 current bookkeeping: 248 = (112 + 8) + 128 = "
"adj so(16) + spinor -- the corpus 120 + 128 NS/R current "
"module (v148 Fock census; v227 D8 branching; v301 "
"SO(16)_1 contains (E8)_1)",
112 + 8 + 128 == 248 and 120 + 128 == 248)
# ---------------------------------------------------------------- A3
section("A3 [E neu]: Stab_GL(4,2)(chi) = AGL(3,2), order 1344, "
"natural on the 8 points of A")
# bit coordinates on the label group
vbasis = []
span = {ZERO}
for lb in LBLS:
if lb not in span:
vbasis.append(lb)
span = set()
for m in itertools.product((0, 1), repeat=len(vbasis)):
x = ZERO
for mi, bl in zip(m, vbasis):
if mi:
x = ADDV[(x, bl)]
span.add(x)
if len(vbasis) == 4:
break
bit_of = {}
for m in itertools.product((0, 1), repeat=4):
x = ZERO
for mi, bl in zip(m, vbasis):
if mi:
x = ADDV[(x, bl)]
bit_of[x] = m[0] * 8 + m[1] * 4 + m[2] * 2 + m[3]
lbl_of_bit = {v: k for k, v in bit_of.items()}
chi_bit = [chi[lbl_of_bit[x]] for x in range(16)]
def rank4(rows):
rows = list(rows)
rk = 0
for bit in (8, 4, 2, 1):
piv = next((r for r in rows if r & bit), None)
if piv is None:
continue
rows = [r ^ piv if (r & bit) else r for r in rows
if r != piv]
rk += 1
return rk
def mat_apply(M, x):
y = 0
for i in range(4):
if bin(M[i] & x).count("1") % 2:
y |= (8 >> i)
return y
GL = []
for M in itertools.product(range(16), repeat=4):
if rank4(M) == 4:
GL.append(M)
STAB = [M for M in GL
if all(chi_bit[mat_apply(M, x)] == chi_bit[x]
for x in range(16))]
orbit_chi = {tuple(chi_bit[mat_apply(M, x)] for x in range(16))
for M in GL}
check("A3.1 |GL(4,2)| = %d = 20160; Stab(chi_NSR) order %d = 1344 "
"= 20160 / 15 (chi-orbit census: %d nonzero functionals)"
% (len(GL), len(STAB), len(orbit_chi)),
len(GL) == 20160 and len(STAB) == 1344
and len(orbit_chi) == 15)
A_bits = sorted(x for x in range(16) if chi_bit[x] == 1)
K_bits = sorted(x for x in range(16) if chi_bit[x] == 0)
a0 = A_bits[0]
kbasis = []
kspan = {0}
for x in K_bits:
if x not in kspan and x != 0:
kbasis.append(x)
kspan = {s ^ (x if m else 0) for s in kspan for m in (0, 1)}
if len(kbasis) == 3:
break
idx_of = {}
for m in itertools.product((0, 1), repeat=3):
k = 0
for mi, kb in zip(m, kbasis):
if mi:
k ^= kb
idx_of[k] = m[0] * 4 + m[1] * 2 + m[2]
def chart(a):
return idx_of[a ^ a0]
unchart = {chart(a): a for a in A_bits}
stab_perms = set()
ok_affine = True
for M in STAB:
pm = tuple(chart(mat_apply(M, unchart[j])) for j in range(8))
stab_perms.add(pm)
# affine test: j -> pm[j] ^ pm[0] must be F2^3-linear
t = pm[0]
lin = [pm[j] ^ t for j in range(8)]
if any(lin[j ^ j2] != lin[j] ^ lin[j2]
for j in range(8) for j2 in range(8)):
ok_affine = False
AGL = set()
for M3 in itertools.product(range(8), repeat=3):
rows = list(M3)
rk = 0
rr = rows[:]
for bit in (4, 2, 1):
piv = next((r for r in rr if r & bit), None)
if piv is None:
continue
rr = [r ^ piv if (r & bit) else r for r in rr if r != piv]
rk += 1
if rk != 3:
continue
def app3(x, M3=M3):
y = 0
for i in range(3):
if bin(M3[i] & x).count("1") % 2:
y |= (4 >> i)
return y
for t in range(8):
AGL.add(tuple(app3(j) ^ t for j in range(8)))
check("A3.2 STABILIZER THEOREM: the stabilizer acts AFFINELY and "
"FAITHFULLY on the 8 points of A (%d distinct permutations "
"= 1344, all affine over the chart) and EQUALS the directly "
"constructed AGL(3,2) = {j -> Mj + t} (order %d = 8 x 168) "
"as a permutation group on 8 points"
% (len(stab_perms), len(AGL)),
ok_affine and len(stab_perms) == 1344 and len(AGL) == 1344
and stab_perms == AGL)
# ---------------------------------------------------------------- A4
section("A4 [E neu]: Aut(H8) = the SAME AGL(3,2) action "
"(corpus anchor v646/v776)")
all_placements = set()
for p in itertools.permutations(range(8)):
all_placements.add(code_image(C_NAIVE, p))
both_inv = [c for c in sorted(all_placements, key=lambda c: sorted(c))
if code_image(c, PI_J) == c and code_image(c, PI_SIG) == c]
W0246 = tuple(1 if i in (0, 2, 4, 6) else 0 for i in range(8))
CSTAR = [c for c in both_inv if W0246 in c][0]
check("A4.1 deployed C* rebuilt deterministically (v638 recipe): "
"%d placements of e8-hat = 8!/1344 (v776 census)"
% len(all_placements),
supports_w4(CSTAR) == CSTAR_SUPPORTS_EXPECTED
and len(all_placements) == 30)
AUT = {p for p in itertools.permutations(range(8))
if code_image(CSTAR, p) == CSTAR}
AGL_pos = set()
for M3 in itertools.product(range(8), repeat=3):
rr = list(M3)
rk = 0
for bit in (4, 2, 1):
piv = next((r for r in rr if r & bit), None)
if piv is None:
continue
rr = [r ^ piv if (r & bit) else r for r in rr if r != piv]
rk += 1
if rk != 3:
continue
def app3(x, M3=M3):
y = 0
for i in range(3):
if bin(M3[i] & x).count("1") % 2:
y |= (4 >> i)
return y
for t in range(8):
AGL_pos.add(tuple(app3(j) ^ t for j in range(8)))
check("A4.2 Aut(C*) has order %d = 1344 (brute force over all "
"40320 coordinate permutations) and EQUALS the v646 "
"position-AGL(3,2) (bits3 labeling) as a permutation group "
"-- the SAME natural AGL(3,2)-on-8-points as A3's "
"stabilizer action; the chart composition is the explicit "
"iso of actions" % len(AUT),
len(AUT) == 1344 and AUT == AGL_pos)
# ---------------------------------------------------------------- A5
section("A5: the Hamming reconstruction -- affine functions on A "
"give RM(1,3) = H8")
C_A = set()
for c in (0, 1):
for lam in range(8):
C_A.add(tuple((c ^ (bin(lam & j).count("1") % 2))
for j in range(8)))
wts = Counter(sum(w) for w in C_A)
ok_lin_code = all(tuple(a ^ b for a, b in zip(u, v)) in C_A
for u in C_A for v in C_A)
ok_sd = all(sum(a * b for a, b in zip(u, v)) % 2 == 0
for u in C_A for v in C_A)
check("A5.1 [E neu] evaluation code C_A (all affine functions "
"a + lambda(x) on the 8 chart points of A): dim 4 (16 words,"
" linear), weight enumerator 1 + 14x^4 + x^8 (%s), doubly "
"even, self-dual" % dict(sorted(wts.items())),
len(C_A) == 16 and ok_lin_code
and wts == Counter({4: 14, 0: 1, 8: 1})
and all(w % 4 == 0 for w in wts) and ok_sd)
equivs = [p for p in itertools.permutations(range(8))
if code_image(C_A, p) == CSTAR]
check("A5.2 [E neu] C_A is PERMUTATION-EQUIVALENT to the deployed "
"C*: %d equivalence permutations = |Aut(H8)| = 1344 -- "
"hence C_A = RM(1,3) = H8 exactly" % len(equivs),
len(equivs) == 1344)
print("""
[H neu] RECONSTRUCTION CHAIN (typed, no claim beyond the census):
NS/R bit chi on V -> affine 8-point space A = chi^-1(1) ->
evaluation code of affine functions = [8,4,4] = H8 (exact above).
As an attack on ARF.BOUNDARY.CODE.01 (v776 BOUNDARY-CODE-UNIQUE,
residual sharpened by v799 TYPEII-FORCED) this SHARPENS the
boundary-code story: the Hamming code re-emerges from the NS/R
character alone once V is given. HONEST TYPING: the route to V
itself still passes through Gaussian E8 (Construction A over C*),
so this is NOT a P2 removal and NOT an independent derivation of
the boundary code -- it is an exact internal reconstruction.""")
# ---------------------------------------------------------------- A6
section("A6 [E neu]: compatibility with the DEPLOYED label action "
"(Sp(4,2), the kill test)")
def herm_std(x, y):
re, im = ip(x, y), ip(x, J_vec(y))
assert re % 4 == 0 and im % 4 == 0
return (re // 4, im // 4)
def hb(a, b):
h = herm_std(REPS[a], REPS[b])
return (h[0] + h[1]) % 2
GRAM = [[hb(lbl_of_bit[8 >> i], lbl_of_bit[8 >> j])
for j in range(4)] for i in range(4)]
def form(x, y):
s = 0
for i in range(4):
if not (x & (8 >> i)):
continue
for j in range(4):
if y & (8 >> j):
s ^= GRAM[i][j]
return s
FT = [[form(x, y) for y in range(16)] for x in range(16)]
SP = []
for M in GL:
mp = [mat_apply(M, x) for x in range(16)]
if all(FT[mp[x]][mp[y]] == FT[x][y]
for x in range(16) for y in range(16)):
SP.append(M)
SP_STAB = [M for M in SP
if all(chi_bit[mat_apply(M, x)] == chi_bit[x]
for x in range(16))]
sp_perms = {tuple(chart(mat_apply(M, unchart[j])) for j in range(8))
for M in SP_STAB}
ok_inside = sp_perms <= AGL
orbs = []
seen = set()
for j in range(8):
if j in seen:
continue
orb = {j}
frontier = [j]
while frontier:
x = frontier.pop()
for pm in sp_perms:
if pm[x] not in orb:
orb.add(pm[x])
frontier.append(pm[x])
seen |= orb
orbs.append(len(orb))
check("A6.1 Sp(4,2) of the hbar Gram: order %d = 720; "
"Stab_Sp(chi) order %d = 48 = 720/15; its 8-point action "
"(%d distinct permutations) lies INSIDE the affine group "
"AGL(3,2) -- the NS/R label action IS compatible with the "
"affine action (the kill does NOT fire); orbit structure "
"on A: %s (transitive)"
% (len(SP), len(SP_STAB), len(sp_perms), orbs),
len(SP) == 720 and len(SP_STAB) == 48 and ok_inside
and len(sp_perms) == 48 and orbs == [8])
# ---------------------------------------------------------------- X
section("X: must-fail controls")
n_bad_fun = 0
for cvec in range(1, 16):
chi2 = [bin(cvec & x).count("1") % 2 for x in range(16)]
if chi2 == chi_bit:
continue
mixed = 0
for lb in LBLS:
if lb == ZERO:
continue
pars = {r[0] % 2 for r in ROOTS if root_label[r] == lb}
lvl = chi2[bit_of[lb]]
# a "wrong-NSR" functional: some chi2 = 1 class contains
# NS roots or chi2 = 0 class contains R roots
if (lvl == 1 and 0 in pars) or (lvl == 0 and 1 in pars):
mixed += 1
if mixed > 0:
n_bad_fun += 1
check("X1 CONTROL FIRES: chi_NSR is the UNIQUE nonzero functional "
"whose level sets are parity-pure: all %d/14 other "
"functionals mix NS and R roots in their level sets "
"(different orbit/stabilizer structure on roots)"
% n_bad_fun, n_bad_fun == 14)
rng = random.Random(20260806)
shuffled = list(root_label.values())
rng.shuffle(shuffled)
scr_label = dict(zip(sorted(root_label), shuffled))
n_mixed = 0
for lb in set(scr_label.values()):
pars = {r[0] % 2 for r in ROOTS if scr_label[r] == lb}
if len(pars) > 1:
n_mixed += 1
check("X2 CONTROL FIRES: a seeded LCG shuffle of the 240 root -> "
"class assignments (seed 20260806) destroys NS/R class "
"purity: %d/15 classes now mix NS and R roots" % n_mixed,
n_mixed > 0)
corrupt = set(C_A)
w0 = next(w for w in sorted(corrupt) if sum(w) == 4)
corrupt.remove(w0)
corrupt.add(tuple(b ^ 1 if i == 0 else b for i, b in enumerate(w0)))
wts_c = Counter(sum(w) for w in corrupt)
ok_sd_c = all(sum(a * b for a, b in zip(u, v)) % 2 == 0
for u in corrupt for v in corrupt)
check("X3 CONTROL FIRES: flipping ONE bit of one weight-4 word "
"breaks the enumerator (now %s != 1 + 14x^4 + x^8) and "
"self-duality (%s)"
% (dict(sorted(wts_c.items())), not ok_sd_c),
wts_c != Counter({4: 14, 0: 1, 8: 1}) and not ok_sd_c)
# ============================================================ VERDICT
section("SUMMARY / VERDICT")
n_pass = sum(1 for _, ok in CHECKS if ok)
n_all = len(CHECKS)
ctrl_ok = all(ok for nm, ok in CHECKS if nm.startswith("X"))
core = [ok for nm, ok in CHECKS if not nm.startswith("X")]
dead = any(nm.startswith(("A3", "A4", "A6")) and not ok
for nm, ok in CHECKS)
print("%d/%d checks passed" % (n_pass, n_all))
print("FROZEN_SPEC SHA-256 = %s" % SPEC_SHA)
if not ctrl_ok:
verdict = "TEST-VOID"
elif all(core):
verdict = "AFFINE-NSR-EXACT"
elif dead:
verdict = "AFFINE-NSR-DEAD"
else:
verdict = "AFFINE-NSR-PARTIAL"
_LAST2["verdict"] = verdict
print("VERDICT: %s" % verdict)
if verdict == "AFFINE-NSR-EXACT":
print("""
AFFINE NS/R STRUCTURE (A1-A6 [E neu], chain reading [H neu]):
V \\ {0} = (7 NS = ker chi \\ 0) u (8 R = affine F2^3-torsor A);
112 NS roots = D8, 128 R roots = Ramond spinor (248 = (112+8)+128,
v148/v227/v301); Stab_GL(4,2)(chi_NSR) = AGL(3,2) (1344 = 8 x 168)
acting naturally on the 8 points -- the SAME group + action as
Aut(H8) (v646/v776 anchor, explicit chart iso); affine functions
on A reconstruct RM(1,3) = H8 with exactly 1344 equivalences; the
deployed Sp(4,2) stabilizes chi in an order-48 subgroup acting
inside AGL(3,2) (kill does not fire). No matter semantics
(ROOTCLASS-MIXED cited); no P2-removal claim.""")
print("runtime: %.1f s" % (time.time() - T0))
print("ALL CHECKS PASSED" if n_pass == n_all else "CHECKS FAILED")
return 0 if n_pass == n_all else 1
rc = main()
return rc, list(CHECKS)
def run():
"""run_all entry point (combined adjudication): part 1 must be 18/18
(JETCODE-EXACT), part 2 must be 15/15 (AFFINE-NSR-EXACT)."""
rc1 = _run_part1()
fails1 = [n for (n, ok) in CHECKS if not ok]
v1 = _LAST1.get("verdict", "")
part1_ok = (rc1 == 0 and not fails1 and len(CHECKS) == 18
and v1 == "JETCODE-EXACT")
print("\n[%s] PART-1 PATTERN GATE: expected 18/18 (JETCODE-EXACT) "
"-- got %d checks, fails: %s, verdict: %s"
% ("PASS" if part1_ok else "FAIL", len(CHECKS),
fails1 or "none", v1))
rc2, chks2 = _run_part2()
fails2 = [n for (n, ok) in chks2 if not ok]
v2 = _LAST2.get("verdict", "")
part2_ok = (rc2 == 0 and not fails2 and len(chks2) == 15
and v2 == "AFFINE-NSR-EXACT")
print("\n[%s] PART-2 PATTERN GATE: expected 15/15 "
"(AFFINE-NSR-EXACT) -- got %d checks, fails: %s, verdict: %s"
% ("PASS" if part2_ok else "FAIL", len(chks2),
fails2 or "none", v2))
ok = part1_ok and part2_ok
print("\nCOMBINED ADJUDICATION: %s -- JETCODE-EXACT + "
"AFFINE-NSR-EXACT: W = L/2L is free rank 4 over the dual "
"numbers Z[i]/(2) = F2[eps]/(eps^2) (2 ramifies, unique iso), "
"the deck is the jet unit J = 1 + eps re-deriving the v782 "
"torsor on all 240 roots, the extension admits ZERO "
"mu4-equivariant splittings (0/65536: the no-origin "
"obstruction IS non-splitness), and the 120 root pairs are "
"the q = 1 unit shell (roots = (address, jet, orientation), "
"240 = 15 x 8 x 2); the NS/R character splits V \\ {0} into "
"7 NS + an affine 8-point torsor carrying 112 D8 + 128 spinor "
"roots (248 = (112+8)+128), Stab(chi_NSR) = AGL(3,2) order "
"1344 = Aut(H8) with the SAME natural 8-point action, and "
"affine functions on the torsor reconstruct RM(1,3) = H8 with "
"exactly 1344 equivalences -- typed internal reconstruction, "
"no P2 removal. NO RH claim."
% ("PASS" if ok else "FAIL"))
return 0 if ok else 1
if __name__ == "__main__":
raise SystemExit(run())
Recorded source fingerprint
a89e286c58da50d4ab0d7cb6f39c1b7a410db0aa608c400f9e43c1705076b19f
Paper sections that cite this module
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.