Follow the source behind the result.

The registered Python source is shown as text. Displaying it does not execute the code.

#!/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)

9d08b59aa5ada89232894762398f54ed690a08d170e619f79cb80fb926b85979

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.