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
"""v638 -- E8.CODESEM.01: the code-semantics stage-2 round -- exploit-or-kill
for the UNIQUE equivariant Hamming placement C* found by
code_semantics_kill_probe.py (stage 1, 13/13: the naive v626 placement is
DEAD for pisig, exactly 2/30 placements carry both compiler symmetries,
exchanged by the anchor transposition (67)).

Background (predecessor, verified 13/13):
  * the 30 S8-placements of the extended Hamming [8,4,4] code contain
    EXACTLY 2 that are invariant under BOTH compiler symmetries mod 2
      piJ   = J_all mod 2 = the mu4 in-pair swap (01)(23)(45)(67),
      pisig = the family pair 3-cycle (positions 0->2->4->0, 1->3->5->1,
              6,7 fixed),
    and the two are exchanged by the anchor-pair transposition (67):
    ONE placement up to the residual anchor orientation.  Call it C*.
  * C* reproduces the v629 root censuses verbatim
    (J {4:60}, sigma {3:76,1:12}, g = J o sigma {12:19,4:3}).

Stage-2 slices (sharpen the dictionary or kill it):
  S1  WHAT ARE THE INFORMATION BITS -- position orbits, information
      sets vs the pair structure, weight-4 orbit decomposition under
      Z6 = <piJ, pisig>, and exact bridges to compiler objects
      (lifted-mark shadow, clock-orbit fibration).
  S2  SYNDROME SEMANTICS -- the geometric single-coordinate error
      class x -> x +- e_i on the 240 Construction-A roots of C*:
      where does it land (exact norm census, distance to the lattice),
      and does the syndrome space factor as
        0 < <q> < F2^4   (q = the universal in-pair syndrome)
      with the quotient F2^3 carrying FOUR pair directions on which
      sigma acts as a 3-cycle + fixed point (anchor = sum of the
      three families)?
  S3  DECODE = PROJECTION -- does hard-decision Construction-A
      syndrome decoding commute mod 2 with the exact nearest-lattice-
      point projection?  (a) all 3840 integer single-coordinate
      errors, (b) 100 random sub-half-integer perturbations,
      (c) 100 random boundary perturbations (honest regime), all in
      exact Fraction arithmetic, seeds fixed.
  S4  KILL CONTROL -- repeat the S1(b) measurement for the NAIVE
      (non-equivariant) v626 placement and census all 30 placements:
      if non-equivariant placements carry the same clean structure,
      the equivariance is irrelevant and the semantics dies.

Verdict enums (frozen): DICTIONARY-SHARP (all pass),
DICTIONARY-PARTIAL, SEMANTICS-KILLED.

FIREWALL: no marker changes; the dictionary is a theorem-level structure
of the equivariant placement (RM(1,3) on AG(3,2)), not a physics
derivation; typed observations only.

PROVENANCE: discovery probes code_semantics_kill_probe.py (stage 1,
2026-08-02, 13/13, verdict CODE-SEMANTICS-RELABELLED) and
code_semantics_stage2_probe.py (2026-08-02, 27/27, verdict
DICTIONARY-SHARP).

Exact arithmetic throughout (int / Fraction); Python-only, counted per
GATE.WOLFRAM.02.
"""

import itertools
import random
import time
from collections import Counter
from fractions import Fraction as Fr
from math import floor

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 ""))


# ------------------------------------------------------------- the 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)]


def apply_perm(c, p):
    return tuple(c[p[k]] for k in range(8))


def compose(p, q):
    """r with apply(w, r) == apply(apply(w, q), p)."""
    return tuple(q[p[k]] for k in range(8))


# Z6 = <piJ, pisig> as a closed set of permutations
Z6 = {tuple(range(8))}
frontier = [tuple(range(8))]
while frontier:
    p = frontier.pop()
    for g in (PI_J, PI_SIG):
        r = compose(g, p)
        if r not in Z6:
            Z6.add(r)
            frontier.append(r)
Z6 = sorted(Z6)
assert len(Z6) == 6


def code_image(code, p):
    return frozenset(apply_perm(c, p) for c in code)


# reconstruct the both-invariant placements exactly as the predecessor
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))
assert len(all_placements) == 30
both_inv = [c for c in all_placements
            if code_image(c, PI_J) == c and code_image(c, PI_SIG) == c]
assert len(both_inv) == 2
# deterministic pick: the placement containing the even transversal
# support {0,2,4,6} (this is 'placement 1' of the predecessor output)
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]
COTHER = [c for c in both_inv if c is not CSTAR][0]

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 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 code_basis(code):
    """Gaussian elimination -> 4 basis words."""
    rows = [list(w) for w in sorted(code, reverse=True) if any(w)]
    basis = []
    pivots = []
    for r in rows:
        r = r[:]
        for b, pv in zip(basis, pivots):
            if r[pv]:
                r = [(x + y) % 2 for x, y in zip(r, b)]
        if any(r):
            basis.append(r)
            pivots.append(next(i for i, x in enumerate(r) if x))
    return basis


BASIS = code_basis(CSTAR)
assert len(BASIS) == 4


def synd(v):
    """syndrome in F2^4 wrt the self-dual C* (codeword <=> 0)."""
    return tuple(sum(a * b for a, b in zip(bb, v)) % 2 for bb in BASIS)


SYND = {v: synd(v) for v in itertools.product((0, 1), repeat=8)}
LEADERS = {}
for v, s in SYND.items():
    w = sum(v)
    cur = LEADERS.get(s)
    if cur is None or w < cur[0]:
        LEADERS[s] = (w, [v])
    elif w == cur[0]:
        cur[1].append(v)

# ======================================================================= S1
print("=" * 78)
print("S1: what are the information bits")
print("=" * 78)

check("S1.0 C* reconstructed deterministically: 16 words, weight-4 "
      "supports match the predecessor's placement 1 verbatim",
      supports_w4(CSTAR) == CSTAR_SUPPORTS_EXPECTED
      and len(CSTAR) == 16)

# --- S1(a): position orbits ------------------------------------------------
def subset_image(S, p):
    return frozenset(k for k in range(8) if p[k] in S)


def orbits_subsets(subsets, perms):
    seen = set()
    orbs = []
    for s in sorted(subsets, key=sorted):
        if s in seen:
            continue
        orb = {s}
        fr = [s]
        while fr:
            u = fr.pop()
            for p in perms:
                v = subset_image(u, p)
                if v not in orb:
                    orb.add(v)
                    fr.append(v)
        seen.update(orb)
        orbs.append(orb)
    return orbs


singles = [frozenset([i]) for i in range(8)]
orb_pos_J = [sorted(sorted(s)[0] for s in o)
             for o in orbits_subsets(singles, [PI_J])]
orb_pos_S = [sorted(sorted(s)[0] for s in o)
             for o in orbits_subsets(singles, [PI_SIG])]
orb_pos_Z6 = [sorted(sorted(s)[0] for s in o)
              for o in orbits_subsets(singles, Z6)]
check("S1.1 position orbits: piJ -> the 4 mu4 pairs %s; pisig -> "
      "%s (two 3-cycles + fixed pair {6,7}); Z6 -> sizes %s = 6+2 "
      "(three cycled pairs + the fixed ANCHOR pair {6,7})"
      % (sorted(orb_pos_J), sorted(orb_pos_S),
         sorted(len(o) for o in orbits_subsets(singles, Z6))),
      sorted(sorted(o) for o in orb_pos_J) ==
      [[0, 1], [2, 3], [4, 5], [6, 7]]
      and sorted(len(o) for o in orbits_subsets(singles, Z6)) == [2, 6])

# invariant 4-subsets and information sets
four_subsets = [frozenset(s) for s in itertools.combinations(range(8), 4)]
w4_supports = {frozenset(s) for s in supports_w4(CSTAR)}
info_sets = [s for s in four_subsets if s not in w4_supports]
z6_inv_4 = [s for s in four_subsets
            if all(subset_image(s, p) == s for p in Z6)]
pair_unions = [frozenset(PAIRS[a] + PAIRS[b])
               for a in range(4) for b in range(a + 1, 4)]
pu_in_code = [pu for pu in pair_unions if pu in w4_supports]
piJ_inv_info = [s for s in info_sets if subset_image(s, PI_J) == s]
check("S1.2 information sets: %d of 70 four-subsets (complement of a "
      "weight-4 support is a support since 1^8 in C*); Z6-invariant "
      "4-subsets: %d (position orbits 6+2 admit NO invariant 4-set) "
      "=> NO equivariant block-systematic 4+4 split exists"
      % (len(info_sets), len(z6_inv_4)),
      len(info_sets) == 56 and len(z6_inv_4) == 0)
check("S1.3 ALL %d/6 pair-unions are C* codeword supports => even "
      "piJ-invariant information sets: %d => no information set "
      "respects the mu4-pair block structure; in particular the "
      "standard split {0,1,2,3} info / {4,5,6,7} parity is IMPOSSIBLE "
      "(both are codeword supports)"
      % (len(pu_in_code), len(piJ_inv_info)),
      len(pu_in_code) == 6 and len(piJ_inv_info) == 0
      and frozenset({0, 1, 2, 3}) in w4_supports
      and frozenset({4, 5, 6, 7}) in w4_supports)

info_orbs = orbits_subsets(info_sets, Z6)
info_census = Counter(len(o) for o in info_orbs)
min_orb = min(info_orbs, key=len)
check("S1.4 information-set Z6 orbit census: %s (56 = 2 + 9 x 6); the "
      "UNIQUE minimal orbit (size 2) is %s = the transversal info sets "
      "'one bit per mu4 pair, anchor orientation flipped': the "
      "canonical systematic form takes ONE information bit from each "
      "pair (3 family bits + 1 anchor bit), parity = the complementary "
      "transversal"
      % (dict(sorted(info_census.items())),
         sorted(sorted(s) for s in min_orb)),
      dict(info_census) == {2: 1, 6: 9}
      and sorted(sorted(s) for s in min_orb) ==
      [[0, 2, 4, 7], [1, 3, 5, 6]])


# transversal digit helpers: word one-per-pair <-> digits (a,b,c,d)
def transversal_digits(supp):
    dig = []
    for k, (i, j) in enumerate(PAIRS):
        a = int(j in supp)
        if (i in supp) == (j in supp):
            return None
        dig.append(a)
    return tuple(dig)


transversal_words = {w: transversal_digits({i for i in range(8) if w[i]})
                     for w in CSTAR if sum(w) == 4}
transversal_words = {w: d for w, d in transversal_words.items()
                     if d is not None}
check("S1.5 the 8 non-pair-union weight-4 words are exactly the pair "
      "TRANSVERSALS with EVEN digit parity (codeword supports = even "
      "sheet, information sets = odd sheet): digits %s"
      % sorted(transversal_words.values()),
      len(transversal_words) == 8
      and all(sum(d) % 2 == 0 for d in transversal_words.values()))

# --- S1(b): weight-4 orbit decomposition under Z6 --------------------------
def orbits_words(words, perms):
    seen = set()
    orbs = []
    for w in sorted(words):
        if w in seen:
            continue
        orb = {w}
        fr = [w]
        while fr:
            u = fr.pop()
            for p in perms:
                v = apply_perm(u, p)
                if v not in orb:
                    orb.add(v)
                    fr.append(v)
        seen.update(orb)
        orbs.append(orb)
    return orbs


w4_star = [w for w in CSTAR if sum(w) == 4]
orbs_star = orbits_words(w4_star, Z6)
sizes_star = sorted(len(o) for o in orbs_star)
orb_names = []
for o in orbs_star:
    sup = sorted(tuple(i for i in range(8) if w[i]) for w in o)
    orb_names.append((len(o), sup))
print("    C* weight-4 Z6 orbits:")
for n, sup in sorted(orb_names):
    print("      size %d: %s" % (n, sup))
check("S1.6 the 14 weight-4 words decompose under Z6 as 14 = 2 + 3 + 3 "
      "+ 6: size-2 = the transversal doublet {0000,1111} (even/odd-"
      "diagonal sheet pair), size-3 = the family-family pair-unions, "
      "size-3 = the family-anchor pair-unions, size-6 = the mixed "
      "transversals", sizes_star == [2, 3, 3, 6])

orb2 = [o for o in orbs_star if len(o) == 2][0]
orb3s = [o for o in orbs_star if len(o) == 3]
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)}
orb3_sets = [{frozenset(i for i in range(8) if w[i]) for w in o}
             for o in orb3s]
check("S1.7 the two size-3 orbits are EXACTLY {family+family} and "
      "{family+anchor} pair-unions (the anchor pair {6,7} grades the "
      "decomposition)",
      (fam_fam in orb3_sets) and (fam_anc in orb3_sets))

# --- S1(c): exact bridges to compiler objects ------------------------------
# roots of the Construction-A model of C*
ROOTS = sorted(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 CSTAR)
assert len(ROOTS) == 240
RSET = set(ROOTS)


def J_all(v):
    out = []
    for i in range(0, 8, 2):
        a, b = v[i], v[i + 1]
        out += [-b, a]
    return tuple(out)


def sigma_r(v):
    return (v[4], v[5], v[0], v[1], v[2], v[3], v[6], v[7])


sig_fixed = [x for x in ROOTS if sigma_r(x) == x]
shadow = Counter(tuple(v % 2 for v in x) for x in sig_fixed)
t_even = next(w for w, d in transversal_words.items() if d == (0, 0, 0, 0))
t_odd = next(w for w, d in transversal_words.items() if d == (1, 1, 1, 1))
zero_fibre = [x for x in sig_fixed
              if tuple(v % 2 for v in x) == (0,) * 8]
check("S1.8 the 12 sigma-fixed roots (the lifted-mark count) reduce "
      "mod 2 to EXACTLY three classes with 4 roots each: {0, t_even, "
      "t_odd} where {t_even, t_odd} IS the size-2 Z6 orbit of S1.6, "
      "and the 0-fibre is {+-2e6, +-2e7} = the ANCHOR pair "
      "(12 = 3 x 4 exactly)",
      len(sig_fixed) == 12
      and shadow == Counter({(0,) * 8: 4, t_even: 4, t_odd: 4})
      and sorted(zero_fibre) == sorted(
          [tuple(2 * (i == j) - 4 * (i == j) * (s == 1) for i in range(8))
           for j in (6, 7) for s in (0, 1)])
      and {t_even, t_odd} == orb2)


def orbit_of(x, f):
    orb = [x]
    y = f(x)
    while y != x:
        orb.append(y)
        y = f(y)
    return orb


# the 60 clock orbits and their mod-2 shadow
seen = set()
J_orbits = []
for x in ROOTS:
    if x in seen:
        continue
    orb = orbit_of(x, J_all)
    seen.update(orb)
    J_orbits.append(frozenset(orb))
assert len(J_orbits) == 60

classes_visited = [frozenset(tuple(v % 2 for v in x) for x in o)
                   for o in J_orbits]
fibre = Counter()
for cl in classes_visited:
    fibre[cl] += 1
piJ_class_orbits = {frozenset({c, apply_perm(c, PI_J)}) for c in CSTAR
                    if sum(c) in (0, 4)}
check("S1.9 clock-orbit fibration: each clock orbit projects onto one "
      "piJ-class-orbit of codewords; the 11 bases (1 zero + 6 pair-"
      "unions + 4 transversal doublets) carry %s clock orbits "
      "(60 = 7 x 4 + 4 x 8); D_start = 60 counts 4 clock orbits per "
      "piJ-fixed class and 8 per transversal doublet"
      % sorted(fibre.values()),
      set(fibre.keys()) == piJ_class_orbits
      and sorted(fibre.values()) == [4] * 7 + [8] * 4)

# sigma action on the 60 clock orbits
orb_index = {}
for k, o in enumerate(J_orbits):
    for x in o:
        orb_index[x] = k
sig_on_orbits = {}
for k, o in enumerate(J_orbits):
    sig_on_orbits[k] = orb_index[sigma_r(next(iter(o)))]
seen = set()
cens60 = Counter()
fixed_orbit_classes = []
for k in range(60):
    if k in seen:
        continue
    cyc = [k]
    j = sig_on_orbits[k]
    while j != k:
        cyc.append(j)
        j = sig_on_orbits[j]
    seen.update(cyc)
    cens60[len(cyc)] += 1
    if len(cyc) == 1:
        fixed_orbit_classes.append(classes_visited[k])
check("S1.10 sigma on the 60 clock orbits: census %s = 3 fixed + 19 "
      "free 3-cycles (reproducing the v629 g-census 19 x 12 + 3 x 4 "
      "as the quotient tower 240 -> 60 -> 3+19); the 3 fixed clock "
      "orbits project exactly onto {0} and the size-2 codeword orbit"
      % dict(sorted(cens60.items())),
      dict(cens60) == {1: 3, 3: 19}
      and sorted(map(sorted, fixed_orbit_classes)) ==
      sorted(map(sorted, [frozenset({(0,) * 8}),
                          frozenset({t_even, t_odd}),
                          frozenset({t_even, t_odd})])))

# the WHY: C* = RM(1,3) and the symmetries are affine maps of AG(3,2)
def bits(j):
    return ((j >> 2) & 1, (j >> 1) & 1, j & 1)


RM13 = set()
for a, c2, c1, c0 in itertools.product((0, 1), repeat=4):
    RM13.add(tuple((a + c2 * bits(j)[0] + c1 * bits(j)[1]
                    + c0 * bits(j)[2]) % 2 for j in range(8)))


def posmap(p):
    return tuple(p.index(i) for i in range(8))


def is_affine(m):
    """m affine on AG(3,2) <=> T(u) = bits(m[u]) xor bits(m[0]) linear."""
    b = bits(m[0])

    def T(u):
        return tuple(x ^ y for x, y in zip(bits(m[u]), b))

    for u in range(8):
        for v in range(8):
            uv = ((bits(u)[0] ^ bits(v)[0]) << 2 |
                  (bits(u)[1] ^ bits(v)[1]) << 1 |
                  (bits(u)[2] ^ bits(v)[2]))
            if T(uv) != tuple(x ^ y for x, y in zip(T(u), T(v))):
                return False
    return True


mJ = posmap(PI_J)
mS = posmap(PI_SIG)
planes_ok = all(
    all((u ^ v ^ w) in {a for a in s}
        for u, v, w in itertools.combinations(s, 3))
    for s in ({i for i in sup} for sup in supports_w4(CSTAR)))
check("S1.11 [the WHY, observation] under the binary position labels "
      "j = (b2,b1,b0), C* IS the Reed-Muller code RM(1,3): %s; piJ = "
      "translation by 001: %s; pisig is an AFFINE map of AG(3,2): %s; "
      "the 14 weight-4 supports are the 14 planes of AG(3,2): %s "
      "-- the equivariant placement exists because Aut = AGL(3,2) "
      "contains the Z6, and 30 = |S8|/|AGL(3,2)|"
      % (frozenset(RM13) == CSTAR,
         mJ == tuple(j ^ 1 for j in range(8)),
         is_affine(mS), planes_ok),
      frozenset(RM13) == CSTAR and mJ == tuple(j ^ 1 for j in range(8))
      and is_affine(mS) and planes_ok)

movers67 = code_image(CSTAR, (0, 1, 2, 3, 4, 5, 7, 6)) == COTHER
check("S1.12 [observation] the residual ambiguity of the equivariant "
      "placement is EXACTLY the anchor-pair orientation: the (67) "
      "swap maps C* to the second placement: %s" % movers67, movers67)

# ======================================================================= S2
print("=" * 78)
print("S2: syndrome semantics")
print("=" * 78)

# --- S2(a): the geometric error class --------------------------------------
norm_census = Counter()
for x in ROOTS:
    for i in range(8):
        for e in (1, -1):
            norm_census[4 + 2 * e * x[i] + 1] += 1
check("S2.1 single-coordinate errors x -> x +- e_i on the 240 roots: "
      "exact norm census over all 3840 perturbations %s -- every "
      "perturbed vector has ODD norm, hence lies OFF the (doubly-even) "
      "lattice and OFF every shell"
      % dict(sorted(norm_census.items())),
      dict(norm_census) == {1: 16, 3: 896, 5: 2016, 7: 896, 9: 16}
      and all(n % 2 == 1 for n in norm_census))


def nearest_lattice(y):
    """exact nearest points of the Construction-A lattice of C*.

    Complete by construction: min over the 16 cosets c + 2Z^8, each
    minimized coordinatewise (parity-constrained nearest integers).
    Returns (min squared distance, set of nearest lattice points)."""
    best = None
    packs = []
    for c in CSTAR:
        tot = 0
        opts = []
        for yi, ci in zip(y, c):
            f = floor(yi)
            cands = [k for k in range(f - 2, f + 3) if k % 2 == ci]
            d2 = [(yi - k) ** 2 for k in cands]
            m = min(d2)
            tot += m
            opts.append([k for k, d in zip(cands, d2) if d == m])
        if best is None or tot < best:
            best = tot
            packs = [opts]
        elif tot == best:
            packs.append(opts)
    pts = set()
    for opts in packs:
        pts.update(itertools.product(*opts))
    return best, pts


geo_ok = True
tie_pair_ok = True
class_ok = True
for x in ROOTS:
    c = tuple(v % 2 for v in x)
    for i in range(8):
        for e in (1, -1):
            y = list(x)
            y[i] += e
            y = tuple(y)
            d2, pts = nearest_lattice(y)
            if d2 != 1:
                geo_ok = False
            exp = {x, tuple(v + (2 * e if k == i else 0)
                            for k, v in enumerate(x))}
            if pts != exp:
                tie_pair_ok = False
            if {tuple(v % 2 for v in p) for p in pts} != {c}:
                class_ok = False
check("S2.2 every perturbed vector lies at squared distance EXACTLY 1 "
      "from the lattice (the packing radius) with EXACTLY the tie pair "
      "{x, x +- 2e_i} as nearest points (3840/3840): %s, %s"
      % (geo_ok, tie_pair_ok), geo_ok and tie_pair_ok)
check("S2.3 the geometric 2-fold tie COLLAPSES mod 2: both nearest "
      "points reduce to the original codeword c in every one of the "
      "3840 cases -- mod-2 projection is unambiguous on the whole "
      "single-coordinate error class", class_ok)

# --- S2(b): the syndrome factorization -------------------------------------
s_coord = [SYND[tuple(1 if k == i else 0 for k in range(8))]
           for i in range(8)]
q_list = [tuple((a + b) % 2 for a, b in zip(s_coord[2 * k],
                                            s_coord[2 * k + 1]))
          for k in range(4)]
q = q_list[0]
check("S2.4 the 8 coordinate syndromes are distinct and nonzero "
      "(the code corrects the exact COORDINATE), and the in-pair "
      "syndrome q = s(e_2k)+s(e_2k+1) is UNIVERSAL: all four pairs "
      "give the same q = %s != 0 (this needs all pair-unions in the "
      "code -- exactly the S1.3 fact)"
      % (q,),
      len(set(s_coord)) == 8 and all(s != (0,) * 4 for s in s_coord)
      and len(set(q_list)) == 1 and q != (0,) * 4)

piv = next(i for i, b in enumerate(q) if b)


def qred(s):
    """linear projection F2^4 -> F2^4/<q> (canonical rep)."""
    if s[piv]:
        return tuple((a + b) % 2 for a, b in zip(s, q))
    return s


P = [qred(s_coord[2 * k]) for k in range(4)]
span = {(0,) * 4}
for v in P:
    span |= {tuple((a + b) % 2 for a, b in zip(v, u)) for u in span}
check("S2.5 the four PAIR DIRECTIONS P_k = [s(e_2k)] mod <q>: distinct "
      "and nonzero %s, P0+P1+P2+P3 = 0 (the all-ones word is a "
      "codeword), and P0,P1,P2 span the full quotient F2^3: the "
      "syndrome space factors as the flag 0 < <q> < F2^4 with "
      "quotient = the PAIR POINTER (in-pair bit q localizes the "
      "element WITHIN the pair)"
      % (len(set(P)) == 4,),
      len(set(P)) == 4 and all(p != (0,) * 4 for p in P)
      and qred(tuple(sum(x) % 2 for x in zip(*P))) == (0,) * 4
      and len(span) == 8
      and all(qred(s_coord[i]) == P[i // 2] for i in range(8)))

# induced actions on the syndrome space: well-defined + the sharp test
def induced_action(perm):
    m = {}
    for v in itertools.product((0, 1), repeat=8):
        s = SYND[v]
        t = SYND[apply_perm(v, perm)]
        if s in m and m[s] != t:
            return None
        m[s] = t
    return m


A_sig = induced_action(PI_SIG)
A_J = induced_action(PI_J)
sig_on_P = [P.index(qred(A_sig[s_coord[2 * k]])) for k in range(4)]
check("S2.6 THE SHARP TEST: sigma is well-defined on syndromes "
      "(placement equivariance), fixes <q>, and acts on the four pair "
      "directions as the 3-CYCLE + FIXED POINT %s (P0->P1->P2->P0, "
      "ANCHOR P3 fixed) with P3 = P0+P1+P2: the 4 pairs = 3 families "
      "cycled + 1 fixed anchor -- the (1,1,2)-type anchor structure "
      "on the syndrome quotient, exactly"
      % (sig_on_P,),
      A_sig is not None and A_sig[q] == q
      and sig_on_P == [1, 2, 0, 3]
      and qred(tuple((a + b + c) % 2 for a, b, c
                     in zip(P[0], P[1], P[2]))) == P[3])
check("S2.7 piJ is well-defined on syndromes, fixes q, and acts "
      "TRIVIALLY on the quotient F2^3 (swapping only the in-pair bit): "
      "the pair pointer is exactly the piJ-invariant content of the "
      "syndrome -- the syndrome localizes the mu4 PAIR canonically, "
      "the coordinate only after choosing a pair orientation",
      A_J is not None and A_J[q] == q
      and all(qred(A_J[s]) == qred(s) for s in set(SYND.values())))

# ======================================================================= S3
print("=" * 78)
print("S3: decode = projection (exact, Fraction arithmetic)")
print("=" * 78)


def nearest_int(y):
    f = floor(y)
    r = y - f
    assert r != Fr(1, 2), "half-integer rounding tie -- excluded by design"
    return f if r < Fr(1, 2) else f + 1


def decode_A(y):
    """hard-decision Construction-A syndrome decoder.

    Round to Z^8, syndrome-decode mod 2 (all minimum-weight coset
    leaders), realize each flip toward y, keep the exact-nearest
    candidates.  Returns (set of decoded lattice points, leader wt)."""
    z = tuple(nearest_int(v) for v in y)
    s = SYND[tuple(v % 2 for v in z)]
    if s == (0,) * 4:
        return {z}, 0
    wt, leaders = LEADERS[s]
    cands = set()
    for e in leaders:
        opts = []
        for j in range(8):
            if e[j]:
                two = [z[j] - 1, z[j] + 1]
                d2 = [(y[j] - t) ** 2 for t in two]
                m = min(d2)
                opts.append([t for t, d in zip(two, d2) if d == m])
            else:
                opts.append([z[j]])
        cands.update(itertools.product(*opts))
    scored = sorted((sum((a - b) ** 2 for a, b in zip(y, w)), w)
                    for w in cands)
    m = scored[0][0]
    return {w for d, w in scored if d == m}, wt


def mods(pts):
    return {tuple(v % 2 for v in p) for p in pts}


# --- S3.1: the full integer error class ------------------------------------
ok31 = True
for x in ROOTS:
    for i in range(8):
        for e in (1, -1):
            y = tuple(Fr(v + (e if k == i else 0))
                      for k, v in enumerate(x))
            dec, wt = decode_A(y)
            d2, near = nearest_lattice(y)
            if not (wt == 1 and dec == near and len(mods(dec)) == 1
                    and mods(dec) == mods(near)):
                ok31 = False
check("S3.1 all 3840 integer single-coordinate errors: the syndrome "
      "decoder (unique weight-1 leader) returns EXACTLY the geometric "
      "nearest-point tie pair {x, x+-2e_i}, and both agree mod 2 -- "
      "decode = projection holds VERBATIM (3840/3840) on the "
      "geometric error class", ok31)

# --- S3.2: 100 random sub-half perturbations (provably safe regime) --------
rng = random.Random(20260802)
ok32 = 0
for _ in range(100):
    x = ROOTS[rng.randrange(240)]
    d = tuple(Fr(rng.randint(-7, 7), 16) for _ in range(8))
    y = tuple(Fr(v) + dv for v, dv in zip(x, d))
    dec, wt = decode_A(y)
    d2, near = nearest_lattice(y)
    if dec == near == {x}:
        ok32 += 1
check("S3.2 100 random perturbations with |delta_i| <= 7/16 < 1/2 "
      "(seed 20260802): decoder and exact projection BOTH return "
      "exactly x in %d/100 cases (provable: |delta|_inf < 1/2 keeps "
      "x the unique nearest point and rounding exact)" % ok32,
      ok32 == 100)

# --- S3.3: 100 boundary perturbations (honest regime) ----------------------
rng = random.Random(20260629)
ks = [k for k in range(-9, 10) if abs(k) != 8]
stats = Counter()
mismatch_detail = []
for t in range(100):
    x = ROOTS[rng.randrange(240)]
    d = tuple(Fr(rng.choice(ks), 16) for _ in range(8))
    y = tuple(Fr(v) + dv for v, dv in zip(x, d))
    z = tuple(nearest_int(v) for v in y)
    nerr = sum(1 for zi, xi in zip(z, x) if zi != xi)
    dec, wt = decode_A(y)
    d2, near = nearest_lattice(y)
    dm, nm = mods(dec), mods(near)
    if dm == nm and len(nm) == 1:
        cat = "commute"
    elif dm == nm:
        cat = "commute-multiclass-tie"
    else:
        cat = "MISMATCH"
        mismatch_detail.append((t, nerr, wt, sorted(dm), sorted(nm)))
    stats[(min(nerr, 3), cat)] += 1

by_err = {}
for (nerr, cat), n in stats.items():
    by_err.setdefault(nerr, Counter())[cat] += n
print("    boundary regime |delta_i| <= 9/16 (seed 20260629), by number")
print("    of rounding errors (3 = '>=3'):")
tot_commute = 0
tot = 0
low_err_clean = True
mismatch_low = 0
for nerr in sorted(by_err):
    row = by_err[nerr]
    n_all = sum(row.values())
    n_com = row.get("commute", 0) + row.get("commute-multiclass-tie", 0)
    tot += n_all
    tot_commute += n_com
    if nerr <= 1 and n_com != n_all:
        low_err_clean = False
        mismatch_low += n_all - n_com
    print("      %d rounding errors: %2d samples, %2d commute, %2d "
          "mismatch" % (nerr, n_all, n_com, n_all - n_com))
for t, nerr, wt, dm, nm in mismatch_detail:
    print("      mismatch sample %2d: %d rounding errors, leader "
          "weight %d, decode class %s vs nearest class %s"
          % (t, nerr, wt, dm, nm))
check("S3.3 boundary regime, honest: %d/100 commute mod 2 overall; "
      "CONDITIONAL on <= 1 rounding error the commutation is %s "
      "(every mismatch has >= 2 rounding errors: %s) -- exactly the "
      "d = 4 correction radius: decode = projection ON the "
      "single-error class, and it degrades beyond it as any [8,4,4] "
      "decoder must"
      % (tot_commute, "100%" if low_err_clean else "BROKEN",
         all(m[1] >= 2 for m in mismatch_detail)),
      low_err_clean and all(m[1] >= 2 for m in mismatch_detail))

# ======================================================================= S4
print("=" * 78)
print("S4: kill control -- the naive placement and the 30-census")
print("=" * 78)

w4_all = [w for w in itertools.product((0, 1), repeat=8) if sum(w) == 4]
orbs70 = orbits_words(w4_all, Z6)
check("S4.1 Z6 orbit structure of ALL 70 weight-4 words: census %s "
      "(2 transversal doublets, 2 pair-union triples, 10 sextets)"
      % dict(sorted(Counter(len(o) for o in orbs70).items())),
      dict(Counter(len(o) for o in orbs70)) == {2: 2, 3: 2, 6: 10})


def placement_stats(code):
    w4 = {w for w in code if sum(w) == 4}
    invJ = code_image(code, PI_J) == code
    invS = code_image(code, PI_SIG) == code
    npu = sum(1 for pu in pair_unions
              if tuple(1 if i in pu else 0 for i in range(8)) in code)
    b = code_basis(code)

    def sy(v):
        return tuple(sum(a * c for a, c in zip(bb, v)) % 2 for bb in b)

    qs = {sy(tuple(1 if i in PAIRS[k] else 0 for i in range(8)))
          for k in range(4)}
    quniv = (len(qs) == 1 and (0,) * 4 not in qs)
    frag = sum(1 for o in orbs70 if 0 < len(o & w4) < len(o))
    own = [p for p in (PI_J, PI_SIG) if code_image(code, p) == code]
    sizes = sorted(len(o) for o in orbits_words(w4, own + [tuple(range(8))]))
    return invJ, invS, npu, quniv, frag, sizes


stats30 = [placement_stats(c) for c in all_placements]
naive_stats = placement_stats(C_NAIVE)
star_stats = placement_stats(CSTAR)
print("    naive v626 placement: invJ=%s invS=%s pair-unions=%d/6 "
      "q-universal=%s fragmented-orbits=%d own-group w4 sizes %s"
      % naive_stats)
print("    C* placement:         invJ=%s invS=%s pair-unions=%d/6 "
      "q-universal=%s fragmented-orbits=%d Z6 w4 sizes %s"
      % star_stats)
frag_profile = Counter()
for o in orbs70:
    w4n = {w for w in C_NAIVE if sum(w) == 4}
    k = len(o & w4n)
    if k:
        frag_profile[(len(o), k)] += 1
check("S4.2 S1(b) repeated on the NAIVE placement: the 14 words "
      "fragment across Z6 orbits with intersection profile "
      "{(orbit size, words inside): count} = %s -- only the "
      "transversal doublet survives intact; %d of the meeting orbits "
      "are PROPERLY fragmented (C*: 0 fragmented, 4 full orbits): "
      "the orbit structure measurably degrades without equivariance"
      % (dict(sorted(frag_profile.items())), naive_stats[4]),
      naive_stats[4] > 0 and star_stats[4] == 0
      and naive_stats[5] == [1, 1, 2, 2, 2, 2, 2, 2]
      and star_stats[5] == [2, 3, 3, 6])
check("S4.3 the naive placement has only %d/6 pair-unions, so the "
      "in-pair syndrome is NOT universal (%s): the S2 flag "
      "0 < <q> < F2^4 (pair localization + anchor 3-cycle) DOES NOT "
      "EXIST for the naive placement -- the stage-2 dictionary is "
      "strictly a property of the equivariant placement"
      % (naive_stats[2], naive_stats[3]),
      naive_stats[2] == 2 and naive_stats[3] is False)

n_quniv = sum(1 for s in stats30 if s[3])
n_frag0 = sum(1 for s in stats30 if s[4] == 0)
n_both = sum(1 for s in stats30 if s[0] and s[1])
check("S4.4 the 30-census: %d/30 placements carry the universal "
      "in-pair syndrome (= contain all 6 pair-unions), %d/30 have "
      "zero fragmented Z6 orbits, %d/30 are both-invariant -- and "
      "these three sets COINCIDE (the two C* relabellings): "
      "equivariance <=> pair-syndrome flag <=> clean orbit structure; "
      "the kill control FIRES, the equivariance is load-bearing"
      % (n_quniv, n_frag0, n_both),
      n_quniv == 2 and n_frag0 == 2 and n_both == 2
      and all((s[3] and s[4] == 0) == (s[0] and s[1]) for s in stats30))

# ================================================================== summary
print("=" * 78)
n_pass = sum(1 for _, ok in CHECKS if ok)
print("%d/%d checks passed" % (n_pass, len(CHECKS)))
s1 = all(ok for n, ok in CHECKS if n.startswith("S1"))
s2 = all(ok for n, ok in CHECKS if n.startswith("S2"))
s3 = all(ok for n, ok in CHECKS if n.startswith("S3"))
s4 = all(ok for n, ok in CHECKS if n.startswith("S4"))
print("slice verdicts: S1 %s | S2 %s | S3 %s | S4 %s"
      % tuple("PASS" if s else "FAIL" for s in (s1, s2, s3, s4)))
if s1 and s2 and s3 and s4:
    print("VERDICT: DICTIONARY-SHARP -- the equivariant placement carries")
    print("an exact dictionary: positions = AG(3,2) points, pairs = the")
    print("mu4 digits (3 families cycled + 1 anchor fixed), information")
    print("bits = one per pair (transversal, anchor-flipped), syndrome =")
    print("(in-pair bit) + (pair pointer with anchor = sum of families),")
    print("decode = projection verbatim on the single-error class, and")
    print("all of it dies for every non-equivariant placement.")
elif s4:
    print("VERDICT: DICTIONARY-PARTIAL -- equivariance load-bearing but")
    print("part of the stage-2 dictionary failed; see FAIL lines.")
else:
    print("VERDICT: SEMANTICS-KILLED -- the kill control did not fire;")
    print("equivariance is irrelevant to the observed structure.")
print("elapsed: %.1f s" % (time.time() - T0))
if n_pass == len(CHECKS):
    print("ALL CHECKS PASSED")
else:
    print("SOME CHECKS FAILED")


def run():
    """run_all.py entry point; the checks execute at import time above."""
    return len([1 for _, ok in CHECKS if not ok])


if __name__ == "__main__":
    raise SystemExit(1 if run() else 0)

156908004bcde25cce065c20bd07f4184da35b19bd2ec1c5d557f733e6b115c7

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.