#!/usr/bin/env python3 """v689 -- E8.GAUSSCODE.01 (review contract E8.GAUSSIAN.CODE.01): the Gaussian code bridge -- is E8(Z[i])/(1+i) the information space of RM(1,3)? HYPOTHESIS (external review, theorem candidate): the mu4 complex structure J on E8 makes E8 a rank-4 Z[i]-lattice L; reduction modulo the ramified Gaussian prime (1+i) gives L/(1+i)L = F2^4, and this 16-element quotient IS the information space (message space) of the equivariant Hamming placement C* = RM(1,3) (v638): the 240 roots fall 15 x 16 over the nontrivial classes, each class is a union of 4 of the 60 G31 lines (v634), and sigma = c^4 acts on the quotient as the RM(1,3) family permutation (3-cycle on 3 family bits, anchor fixed). Slices (following the review's 6-step census verbatim): I1 the Z[i]-module: L = Construction A(C*), J = in-pair rotation; Z-basis, index [L : (1+i)L] = 16 = N(1+i)^4, Smith normal form (1,1,1,1,2,2,2,2) -> L/(1+i)L = F2^4; canonical class map via Hermite normal form, cross-validated against the direct membership test x ~ y <=> (1-J)(x-y)/2 in L. I2 the 6-step census: (1) reduce all 240 roots mod (1+i)L; (2) zero class empty (PROOF-GRADE: |(1+J)x|^2 = 2|x|^2 and min(L) = 4, so min((1+i)L) = 8 > 4); (3) 15 classes x 16 roots (240 = 15 x 16)? (4) classes mu4-stable (root ~ i root; PROOF-GRADE: (i-1) = i(1+i)); (5) exactly 4 of the 60 G31 lines per class (60 = 15 x 4)? (6) sigma = c^4 acts on F2^4 as the RM(1,3) family permutation (3-cycle + fixed anchor): explicit family/anchor bit basis, bit-semantics table, count of residual equivariant identifications. I3 the coordinate block: 240 = 14 x 16 + 16; do the 16 coordinate roots +-2e_i form EXACTLY one class (the 'fifteenth message label')? Canonical assignment documented. I4 must-fail controls: (a) naive v626 placement: piJ-invariant (Z[i]-structure exists) but NOT pisig-invariant -> the sigma-semantics of step (6) is UNDEFINED (control fires); steps (1)-(5) re-run honestly (generic-or-not documented, no silent claim); (b) a placement that is not even piJ-invariant: J does not preserve the lattice -> no Z[i]-module at all (fires); (c) Z[i]^4 (standard unimodular Gaussian lattice): minimal vectors occupy 4/15 classes with 4 each, 11 classes empty -> the census trivializes (fires). I5 standard-model cross-check: the same census in the v634 standard-coordinate E8 model (doubled coordinates, same J, sigma = coordinate pair 3-cycle) -- presentation independence. Exact integer / Fraction arithmetic throughout; sympy only for the Smith normal form. Verdict enums (frozen; the EXPECTED verdict of this module is GAUSSIAN-CODE-BRIDGE-EXACT): GAUSSIAN-CODE-BRIDGE-EXACT, BRIDGE-PARTIAL, BRIDGE-KILLED. FIREWALL: writes nothing; no marker moves; exact arithmetic only; must-fail controls (I4) adjudicated inline. PROVENANCE: discovery probe gaussian_code_bridge_probe.py (2026-08-03, 26/26 PASS, verdict GAUSSIAN-CODE-BRIDGE-EXACT). Predecessors (read-only): v626_e8_code.py (Construction A), v638_code_semantics.py (C* = RM(1,3), anchor pair {6,7}), v634_st31_structure.py (G31, sigma = c^4, J = c^9, 60 lines). """ 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) def section(title): print("=" * 78) print(title) print("=" * 78, flush=True) # ---------------------------------------------------------------- codes 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) # in-pair swap PI_SIG = (4, 5, 0, 1, 2, 3, 6, 7) # new[k] = old[PI_SIG[k]] PAIRS = ((0, 1), (2, 3), (4, 5), (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) # ------------------------------------------------------- linear algebra def mat_det_inv(rows): """exact determinant + inverse of a square matrix (Fractions).""" 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, "singular matrix" 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): """row vector times matrix (exact).""" 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): """row-style Hermite normal form of a full-rank square integer matrix: upper triangular, positive diagonal (off-diagonal not canonicalized -- residues are canonical wrt THIS fixed H).""" 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): """canonical residue of integer vector c modulo the row lattice H (H upper triangular, positive diagonal).""" 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) # --------------------------------------------------------- J and sigma def J_vec(x): out = [] for k in range(0, 8, 2): out += [-x[k + 1], x[k]] return tuple(out) def sig_vec(x): return (x[4], x[5], x[0], x[1], x[2], x[3], x[6], x[7]) def add_vec(x, y): return tuple(a + b for a, b in zip(x, y)) def sub_vec(x, y): return tuple(a - b for a, b in zip(x, y)) # --------------------------------------------------- lattice machinery 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): """package a lattice: membership fn + Z-basis -> coords, labels.""" 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["A"] = A 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 equivalent(lat, x, y): """x ~ y mod (1+i)L <=> (1-J)(x-y)/2 in L (exact).""" u = sub_vec(x, y) w = sub_vec(u, J_vec(u)) if any(v % 2 for v in w): return False return lat["in"](tuple(v // 2 for v in w)) def label_group(lat): """all labels + representative vectors + F2 addition on labels.""" 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 # ====================================================================== I0 section("I0: the equivariant placement C* (deterministic v638 recipe)") all_placements = set() for p in itertools.permutations(range(8)): all_placements.add(code_image(C_NAIVE, p)) all_placements = sorted(all_placements, key=lambda c: sorted(c)) both_inv = [c for c in all_placements 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("I0.1 30 placements, exactly 2 both-invariant, C* pick matches the " "v638 weight-4 supports verbatim", len(all_placements) == 30 and len(both_inv) == 2 and supports_w4(CSTAR) == CSTAR_SUPPORTS_EXPECTED) ROOTS = constrA_roots(CSTAR) RSET = set(ROOTS) ok_J = all(J_vec(r) in RSET for r in ROOTS) ok_S = all(sig_vec(r) in RSET for r in ROOTS) ok_comm = all(J_vec(sig_vec(r)) == sig_vec(J_vec(r)) for r in ROOTS[:40]) ok_J2 = all(J_vec(J_vec(r)) == tuple(-v for v in r) for r in ROOTS[:40]) check("I0.2 240 Construction-A roots of C*; J and sigma preserve the root " "set, [J, sigma] = 0, J^2 = -1", len(ROOTS) == 240 and ok_J and ok_S and ok_comm and ok_J2) # J orthogonal + skew pairing (norm-doubling ingredient, exact on basis) E8B = [tuple(1 if i == j else 0 for i in range(8)) for j in range(8)] dotJ = all(sum(a * b for a, b in zip(J_vec(u), J_vec(v))) == sum(a * b for a, b in zip(u, v)) for u in E8B for v in E8B) skewJ = all(sum(a * b for a, b in zip(u, J_vec(u))) == 0 for u in ROOTS) check("I0.3 J is orthogonal and x.Jx = 0 (skew pairing) -> " "|(1+J)x|^2 = 2|x|^2 exactly", dotJ and skewJ) # ====================================================================== I1 section("I1: the Z[i]-module L and L/(1+i)L = F2^4") LAT = constrA_lattice(CSTAR) ok_rows = all(LAT["in"](b) for b in LAT["B"]) check("I1.1 Z-basis of L = Construction A(C*): all 8 rows in L, " "|det| = 16 = [Z^8 : L] (covolume match => spanning)", ok_rows and abs(LAT["det"]) == 16) detA, _ = mat_det_inv(LAT["A"]) check("I1.2 (1+J)b_i in L for all basis rows (integral coordinate matrix " "A) and index [L : (1+i)L] = |det A| = %d = N(1+i)^4 = 2^4" % abs(int(detA)), abs(int(detA)) == 16) from sympy import Matrix, ZZ # noqa: E402 from sympy.matrices.normalforms import smith_normal_form # noqa: E402 D = smith_normal_form(Matrix(LAT["A"]), domain=ZZ) snf_diag = [abs(int(D[i, i])) for i in range(8)] check("I1.3 Smith normal form of A = %s -> L/(1+i)L = (Z/2)^4 = F2^4 " "(elementary abelian, rank 4)" % (snf_diag,), sorted(snf_diag) == [1, 1, 1, 1, 2, 2, 2, 2]) REPS = label_group(LAT) ok_16 = len(REPS) == 16 # 2L subset (1+i)L: label of 2*b_i is zero for all basis rows zero_label = LAT["label"]((0,) * 8) ok_2L = all(LAT["label"](tuple(2 * v for v in b)) == zero_label for b in LAT["B"]) check("I1.4 exactly 16 classes generated by the basis rows; 2L subset " "(1+i)L (every doubled vector reduces to the zero class)", ok_16 and ok_2L) rng = random.Random(20260803) ok_cross = True rep_list = list(REPS.values()) for _ in range(300): x = rep_list[rng.randrange(16)] y = rep_list[rng.randrange(16)] coef = [rng.randint(-2, 2) for _ in range(8)] dx = tuple(sum(cf * b[i] for cf, b in zip(coef, LAT["B"])) for i in range(8)) # x + (1+i)*(random lattice vector) must stay in x's class sh = add_vec(dx, J_vec(dx)) same = (LAT["label"](add_vec(x, sh)) == LAT["label"](x)) agree = ((LAT["label"](x) == LAT["label"](y)) == equivalent(LAT, x, y)) if not (same and agree): ok_cross = False check("I1.5 class map cross-validated: HNF labels invariant under adding " "(1+J)*(lattice vector), and label equality == direct membership " "test (1-J)(x-y)/2 in L (300 random cases)", ok_cross) # ====================================================================== I2 section("I2: the 6-step census (review wording, verbatim)") root_label = {r: LAT["label"](r) for r in ROOTS} census = Counter(root_label.values()) check("I2.1 all 240 roots reduced modulo (1+i)L: %d distinct classes hit" % len(census), len(census) >= 1) n_zero = census.get(zero_label, 0) min_norms = [x for x in itertools.product(range(-1, 2), repeat=8) if 0 < sum(v * v for v in x) < 4 and LAT["in"](x)] check("I2.2 the zero class is EMPTY on roots (%d roots there); " "proof-grade: min(L) = 4 (no nonzero vector of norm < 4: %d found) " "and |(1+J)x|^2 = 2|x|^2 => min((1+i)L) = 8 > 4" % (n_zero, len(min_norms)), n_zero == 0 and not min_norms) sizes = sorted(census.values()) check("I2.3 EQUIDISTRIBUTION: each of the 15 nontrivial classes contains " "exactly 16 roots (240 = 15 x 16): census %s" % dict(Counter(sizes)), len(census) == 15 and sizes == [16] * 15 and zero_label not in census) ok_mu4 = all(root_label[J_vec(r)] == root_label[r] for r in ROOTS) check("I2.4 classes are mu4-stable (root ~ i root) for all 240 roots; " "proof-grade: (i-1) = i(1+i), so (J-1)r in (1+i)L always", ok_mu4) # the 60 lines (J-orbits) and lines per class line_of = {} lines = [] for r in ROOTS: if r in line_of: continue orb = [r] y = J_vec(r) while y != r: orb.append(y) y = J_vec(y) for x in orb: line_of[x] = len(lines) lines.append(orb) lines_per_class = Counter() for k, orb in enumerate(lines): lines_per_class[root_label[orb[0]]] += 1 check("I2.5 60 J-lines total; each nontrivial class is a union of " "EXACTLY 4 of the 60 G31 lines (60 = 15 x 4): %s" % dict(Counter(sorted(lines_per_class.values()))), len(lines) == 60 and sorted(lines_per_class.values()) == [4] * 15) # ---- step (6): the sigma action on F2^4 ------------------------------- def build_bits(basis_labels, reps, lat): """map each of the 16 labels to F2^4 coords in the given basis.""" out = {} for bits in itertools.product((0, 1), repeat=4): v = (0,) * 8 for bit, lb in zip(bits, basis_labels): if bit: v = add_vec(v, reps[lb]) out[lat["label"](v)] = bits return out # pick 4 independent basis classes greedily basis_labels = [] span = {zero_label} for lb in REPS: if lb in span: continue basis_labels.append(lb) span = set() for bits in itertools.product((0, 1), repeat=len(basis_labels)): w = (0,) * 8 for bit, l2 in zip(bits, basis_labels): if bit: w = add_vec(w, REPS[l2]) span.add(LAT["label"](w)) if len(basis_labels) == 4: break BITS = build_bits(basis_labels, REPS, LAT) check("I2.6a F2-basis of the quotient found: 4 classes span all 16 labels", len(BITS) == 16 and len(basis_labels) == 4) def sig_label(lb): return LAT["label"](sig_vec(REPS[lb])) def m_apply(Mcols, bits): out = (0, 0, 0, 0) for bit, col in zip(bits, Mcols): if bit: out = tuple((a + b) % 2 for a, b in zip(out, col)) return out M_cols = [BITS[sig_label(lb)] for lb in basis_labels] # sanity: sigma is linear on the quotient (it is a lattice automorphism # commuting with J) -- verify on all 16 labels ok_lin = all(m_apply(M_cols, BITS[lb]) == BITS[sig_label(lb)] for lb in REPS) M2_map = {lb: sig_label(sig_label(lb)) for lb in REPS} M3_map = {lb: sig_label(M2_map[lb]) for lb in REPS} fixed_labels = [lb for lb in REPS if sig_label(lb) == lb] check("I2.6b sigma acts linearly on F2^4, sigma^3 = id, sigma != id, " "and EXACTLY 4 fixed labels (dim ker(sigma - 1) = 2): %d fixed" % len(fixed_labels), ok_lin and all(M3_map[lb] == lb for lb in REPS) and any(sig_label(lb) != lb for lb in REPS) and len(fixed_labels) == 4) # sigma orbit census on the 15 nontrivial classes seen = set() orb_census = Counter() for lb in REPS: if lb == zero_label or lb in seen: continue orb = {lb, sig_label(lb), M2_map[lb]} seen |= orb orb_census[len(orb)] += 1 check("I2.6c sigma orbit census on the 15 classes: %s = 3 fixed + 4 " "three-cycles (the (1,1,2)+cycles anchor pattern)" % dict(sorted(orb_census.items())), dict(orb_census) == {1: 3, 3: 4}) # explicit family/anchor basis: v, Mv, M^2v independent + fixed anchor w fam_basis = None for lb in REPS: if lb == zero_label or sig_label(lb) == lb: continue o1, o2, o3 = lb, sig_label(lb), M2_map[lb] s = LAT["label"](add_vec(add_vec(REPS[o1], REPS[o2]), REPS[o3])) if s == zero_label: continue span3 = set() for bits in itertools.product((0, 1), repeat=3): w = (0,) * 8 for bit, l2 in zip(bits, (o1, o2, o3)): if bit: w = add_vec(w, REPS[l2]) span3.add(LAT["label"](w)) if len(span3) != 8: continue anchor = next(l2 for l2 in fixed_labels if l2 != zero_label and l2 not in span3) fam_basis = (o1, o2, o3, anchor, s) break check("I2.6d EXPLICIT family/anchor basis exists: classes (F1, F2, F3) " "with sigma: F1 -> F2 -> F3 -> F1 and an independent sigma-FIXED " "anchor class A: in this basis sigma IS the RM(1,3) family " "permutation matrix (3-cycle + fixed point), exactly the v638 " "info-bit action (positions 0 -> 2 -> 4 -> 0, position 7 fixed)", fam_basis is not None) F1, F2, F3, ANC, FSUM = fam_basis FAM_BITS = build_bits([F1, F2, F3, ANC], REPS, LAT) # count of equivariant identifications (residual gauge): centralizer of # the 3-cycle + fix matrix inside GL(4, F2) P_cols = [(0, 1, 0, 0), (0, 0, 1, 0), (1, 0, 0, 0), (0, 0, 0, 1)] def mmul(A, B): """columns representation: (A o B) column j = A applied to B[j].""" return [m_apply(A, B[j]) for j in range(4)] def invertible(A): span_v = {(0, 0, 0, 0)} for c in A: span_v |= {tuple((a + b) % 2 for a, b in zip(c, v)) for v in span_v} return len(span_v) == 16 n_comm = 0 for colbits in itertools.product(range(16), repeat=4): A = [tuple((c >> k) & 1 for k in range(4)) for c in colbits] if mmul(A, P_cols) == mmul(P_cols, A) and invertible(A): n_comm += 1 check("I2.6e residual gauge of the identification: |centralizer of the " "family 3-cycle in GL(4,F2)| = %d (= |GL(2,2)| x |F4^x| = 6 x 3 " "= 18 equivariant isomorphisms to the RM(1,3) message space)" % n_comm, n_comm == 18) # ====================================================================== I3 section("I3: the coordinate block (240 = 14 x 16 + 16)") coord_roots = [r for r in ROOTS if sorted(map(abs, r)) == [0] * 7 + [2]] coord_labels = {root_label[r] for r in coord_roots} cl = next(iter(coord_labels)) class_of_cl = [r for r in ROOTS if root_label[r] == cl] check("I3.1 the 16 coordinate roots +-2e_i all lie in ONE class, and " "that class contains NOTHING else (|class| = %d): the fifteenth " "message label is the coordinate block, exactly" % len(class_of_cl), len(coord_roots) == 16 and len(coord_labels) == 1 and sorted(class_of_cl) == sorted(coord_roots)) check("I3.2 the coordinate class is sigma-FIXED and equals F1 + F2 + F3 " "(the sum of the three family classes): the 'anchor = sum of " "families' law of the v638 syndrome semantics reappears in the " "Gaussian quotient: %s" % (cl == FSUM,), sig_label(cl) == cl and cl == FSUM) # ---- the bit-semantics table ------------------------------------------ FAM_FAM = {frozenset(PAIRS[a] + PAIRS[b]) for a in range(3) for b in range(a + 1, 3)} FAM_ANC = {frozenset(PAIRS[a] + PAIRS[3]) for a in range(3)} def transversal_digits(supp): dig = [] for (i, j) in PAIRS: if (i in supp) == (j in supp): return None dig.append(int(j in supp)) return tuple(dig) def cw_type(c): if sum(c) == 0: return "zero" supp = frozenset(i for i in range(8) if c[i]) if supp in FAM_FAM: return "fam+fam" if supp in FAM_ANC: return "fam+anchor" d = transversal_digits(supp) return "transversal%s" % (d,) print(" bit-semantics table (basis F1,F2,F3,ANC; sigma: F1->F2->F3->F1,") print(" ANC fixed; coordinate class = F1+F2+F3):") table = {} for lb in sorted(REPS, key=lambda l: FAM_BITS[l]): if lb == zero_label: continue rs = [r for r in ROOTS if root_label[r] == lb] tc = Counter(cw_type(tuple(v % 2 for v in r)) for r in rs) table[FAM_BITS[lb]] = tc print(" bits %s: %2d roots, sigma-> %s, codewords: %s" % (FAM_BITS[lb], len(rs), FAM_BITS[sig_label(lb)], dict(sorted(tc.items())))) fixed_nonzero = [lb for lb in fixed_labels if lb != zero_label] anc_class_roots = [r for r in ROOTS if root_label[r] == ANC] check("I3.3 [observation] the 3 sigma-fixed classes are: the coordinate " "class (= F1+F2+F3), the anchor class ANC and ANC + coordinate " "class; every class mixes codeword fibers (the bridge is NOT the " "mod-2 reduction: classes cut ACROSS Construction-A fibers)", len(fixed_nonzero) == 3 and cl in fixed_nonzero and ANC in fixed_nonzero) # ====================================================================== I4 section("I4: must-fail controls") # (a) the naive v626 placement: piJ-invariant but NOT pisig-invariant naive_piJ = code_image(C_NAIVE, PI_J) == C_NAIVE naive_piS = code_image(C_NAIVE, PI_SIG) == C_NAIVE LATN = constrA_lattice(C_NAIVE) bad_vec = None for c in sorted(C_NAIVE): if not LATN["in"](sig_vec(c)): bad_vec = c break check("I4.1 CONTROL FIRES (naive placement): piJ-invariant %s (the " "Z[i]-structure exists), pisig-invariant %s -> sigma does NOT " "preserve L_naive (witness codeword lift %s with sigma-image off " "the lattice): the step-(6) RM(1,3) family semantics is UNDEFINED " "for the non-equivariant placement" % (naive_piJ, naive_piS, bad_vec), naive_piJ and not naive_piS and bad_vec is not None) ROOTS_N = constrA_roots(C_NAIVE) zeroN = LATN["label"]((0,) * 8) censusN = Counter(LATN["label"](r) for r in ROOTS_N) sizesN = sorted(censusN.values()) check("I4.2 HONESTY (naive placement, steps 1-5 re-run): 240 roots, " "census %s -- the 15 x 16 equidistribution and the 4-lines-per-" "class structure are properties of the Z[i]-lattice (E8, J) alone " "and survive ANY piJ-invariant placement; what dies without " "equivariance is exactly the sigma-bit-semantics (I4.1)" % dict(Counter(sizesN)), len(ROOTS_N) == 240 and len(censusN) == 15 and zeroN not in censusN) # (b) a placement that is not even piJ-invariant C_BAD = None for c in all_placements: if code_image(c, PI_J) != c: C_BAD = c break LATB_in = lambda x: tuple(v % 2 for v in x) in C_BAD # noqa: E731 bad_root = next(r for r in constrA_roots(C_BAD) if not LATB_in(J_vec(r))) check("I4.3 CONTROL FIRES (non-piJ placement): %d/30 placements are not " "piJ-invariant; for such a placement J does not even preserve the " "lattice (witness root %s with J-image off the lattice): NO " "Z[i]-module, the bridge is not defined" % (sum(1 for c in all_placements if code_image(c, PI_J) != c), bad_root), C_BAD is not None and bad_root is not None) # (c) Z[i]^4 standard (unimodular hermitian, WRONG lattice) LATZ = make_lattice(lambda x: True, [tuple(1 if i == j else 0 for i in range(8)) for j in range(8)]) minz = [x for x in itertools.product((-1, 0, 1), repeat=8) if sum(v * v for v in x) == 1] zcen = Counter(LATZ["label"](x) for x in minz) zeroZ = LATZ["label"]((0,) * 8) check("I4.4 CONTROL FIRES (Z[i]^4 standard): only %d minimal vectors, " "occupying %d/15 nontrivial classes with %s each, 11 classes " "EMPTY -- no 240, no 15 x 16, no RM(1,3): the census trivializes " "on the wrong unimodular Z[i]-lattice" % (len(minz), len(zcen), sorted(set(zcen.values()))), len(minz) == 16 and len(zcen) == 4 and sorted(zcen.values()) == [4] * 4 and zeroZ not in zcen) # ====================================================================== I5 section("I5: standard-model cross-check (v634 doubled coordinates)") 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)] LATS = make_lattice(in_E8_std, list(B_STD)) roots_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: roots_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: roots_std.append(v) detS = abs(LATS["det"]) DS = smith_normal_form(Matrix(LATS["A"]), domain=ZZ) snfS = sorted(abs(int(DS[i, i])) for i in range(8)) censusS = Counter(LATS["label"](r) for r in roots_std) zeroS = LATS["label"]((0,) * 8) ok_muS = all(LATS["label"](J_vec(r)) == LATS["label"](r) for r in roots_std) fixS = 0 repsS = label_group(LATS) for lb in repsS: if LATS["label"](sig_vec(repsS[lb])) == lb: fixS += 1 sig3S = all(LATS["label"](sig_vec(sig_vec(sig_vec(repsS[lb])))) == lb for lb in repsS) check("I5.1 the SAME census in the standard E8 model: basis |det| = %d " "= 2^8 (doubled coords), SNF %s, 240 roots -> 15 x 16 equi-" "distribution %s, mu4-stable %s, sigma^3 = id with %d fixed " "labels: the bridge is presentation-independent" % (int(detS), snfS, sorted(censusS.values()) == [16] * 15, ok_muS, fixS), int(detS) == 256 and snfS == [1, 1, 1, 1, 2, 2, 2, 2] and len(censusS) == 15 and zeroS not in censusS and sorted(censusS.values()) == [16] * 15 and ok_muS and sig3S and fixS == 4) # ================================================================ summary section("SUMMARY") n_pass = sum(1 for _, ok in CHECKS if ok) print("%d/%d checks passed" % (n_pass, len(CHECKS))) core = all(ok for n, ok in CHECKS if n.split()[0][:2] in ("I0", "I1", "I2", "I3", "I5")) controls = all(ok for n, ok in CHECKS if n.startswith("I4")) if core and controls: print("VERDICT: GAUSSIAN-CODE-BRIDGE-EXACT -- E8(Z[i])/(1+i) = F2^4") print("carries the RM(1,3) information-space semantics: 240 roots =") print("15 messages x 16 roots (= 4 G31 lines), sigma = family") print("3-cycle + fixed anchor, coordinate block = the sum-of-families") print("label, and every control (non-equivariant placement, non-piJ") print("placement, Z[i]^4) kills or trivializes exactly as demanded.") elif controls: print("VERDICT: BRIDGE-PARTIAL -- controls fire but part of the") print("census/semantics failed; see FAIL lines.") else: print("VERDICT: BRIDGE-KILLED -- a must-fail control did not fire;") print("the claimed structure is generic, not equivariant.") print("elapsed: %.1f s" % (time.time() - T0)) print("ALL CHECKS PASSED" if n_pass == len(CHECKS) else "SOME CHECKS FAILED") def run(): """run_all entry point: the checks execute at import (exact arithmetic, module-level); report the failure count.""" return len(CHECKS) - n_pass if __name__ == "__main__": raise SystemExit(0 if n_pass == len(CHECKS) else 1)