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
# -*- coding: utf-8 -*-
"""v737 -- E8.SEAM48.01: der Seam-48-Intertwiner-Test -- der
schaerfste Struktur-Kill des Review-Morgens (SEAM48-DEAD).


FRAGE (externes Review, schaerfster Struktur-Test): Bilden die fuenf
kanonischen 48er-Codebloecke (aus der bewiesenen sigma-Orbitstruktur der
15 x 16 Gauss-Klassen; gaussian_code_bridge_probe I5 im Standardmodell)
und die 48 regulaeren Fuenferzyklen (des ZERTIFIZIERTEN regulaeren
G31-Operators; v647: u regulaer der Ordnung 20, u^5 = +-J zentral,
u^4 frei mit Zensus {5:48}) eine exakte 5 x 48-Koordinatisierung
von R(E8)?

DIE VIER KRITERIEN (Review woertlich, bindend -- KEINE Relabeling-Suche):
 (1) Die fuenf 48er-Bloecke AUSSCHLIESSLICH aus der bewiesenen
     sigma-Orbitstruktur: Fixblock = die 3 sigma-fixen Klassen,
     vier bewegte Bloecke = die 4 Dreierorbits (je 3 Klassen x 16).
 (2) Der Fuenfer-Operator ist der bereits zertifizierte G31-Operator:
     u = ERSTES Element mit freiem Zensus {20:12} in der
     v647-Enumerationsreihenfolge (Wurzel-Sortierung, Linien-Reps,
     Spiegelungs-BFS, Zensus-Pass -- alles bit-identisch zu v647
     repliziert). Der Fuenfer-Operator ist u^4. Keine Neuwahl.
 (3) KERN-TEST: die 48 x 5-Inzidenzmatrix (Zyklus x Block -> Anzahl
     gemeinsamer Wurzeln) muss EXAKT ueberall 1 sein.
 (4) Der induzierte Ordnung-12-Operator auf dem 48er-Quotienten muss
     dieselben Charakter-Traces, Deck-Sektoren (3 x 16) und
     mu4-Fixspuren wie der v623-Seam-Lift besitzen (Charakter-
     Tabellen-Vergleich, exakt).  Da der Fixpunktvektor
     (fix(g^k))_{k=0..11} die Charaktertafel einer Z12-Permutations-
     darstellung VOLLSTAENDIG bestimmt, ist der exakte Vergleich der
     Fixvektoren der exakte Tafelvergleich.  Der Transport auf den
     48er-Quotienten geschieht ueber die fuenf Block-Sektionen
     (Zykeltyp ist transport-invariant); ZUSAETZLICH wird gemessen,
     welche Elemente von G31 ueberhaupt auf dem Zyklen-Quotienten
     wirken (Partitions-Stabilisator) -- radikale Ehrlichkeit darueber,
     ob "der" induzierte Operator sektionsfrei existiert.

MUST-FAIL-KONTROLLE: zufaellige FREIE Ordnung-5-Operatoren aus W(E8)
(Zensus {5:48}) duerfen die Inzidenz-1-Eigenschaft nicht haben --
sonst misst der Test nichts.

VERDIKTE (eingefroren):
  SEAM48-INTERTWINED  -- alle vier Kriterien;
  SEAM48-GRID-ONLY    -- Inzidenz ueberall 1, aber Charaktere weichen
                         ab (Abweichungsort exakt dokumentiert);
  SEAM48-DEAD         -- Inzidenz != 1 (Verteilung angegeben);
  TEST-VOID           -- die Must-fail-Kontrolle feuert nicht.

FIREWALL: experiments/-Probe; schreibt nichts; kein verification/-,
Paper-, Ledger- oder Website-Surface beruehrt.  Exakte Ganzzahl/
Fraction-Arithmetik durchgehend (keine Gleitkommazahlen).

Quellen (read-only): v647_st31_degree24.py (zertifizierter Operator,
Konstruktion repliziert), gaussian_code_bridge_probe.py I5 (Klassen im
Standardmodell), v634_st31_structure.py (G31), v623_covered_seam.py
(48-Site-Seam-Lift), v629_root_incidence.py (naive 48 x 5 Compiler-Uhr:
KILL -- hier bewusst der REGULAERE Operator, nicht die Compiler-Uhr).

PROVENANCE: discovery probe seam48_intertwiner_probe.py (2026-08-04,
24/24 machinery checks, verdict SEAM48-DEAD: the preregistered
criterion-3 kill fires -- the 48 x 5 incidence matrix is NOT
identically 1 (entry distribution 0:96 / 1:64 / 2:64 / 3:16),
representative-independent (0 of 2304 order-5 elements of G31 have
the incidence-1 property against the fixed blocks), and the must-fail
control fires (0 of 25 random operators pass); valuable residues: the
4 moved blocks carry the v623 character table EXACTLY while the fixed
block deviates exactly by the 12 lifted marks, and the 5-period lemma
u^5 = +/-J holds exactly.  240 = 48 x 5 remains a factorization
WITHOUT coordinatization).  Promoted verbatim; numbers unchanged.
"""

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

import numpy as np

T0 = time.time()
CHECKS = []          # Maschinerie- und Kontroll-Checks (muessen bestehen)
CRIT = {}            # die vier Review-Kriterien (Messergebnis, ehrlich)
N240 = 240


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 criterion(key, ok, text):
    CRIT[key] = bool(ok)
    print("[%s] KRITERIUM %s: %s" % ("PASS" if ok else "FAIL", key, text),
          flush=True)


def section(title):
    print("=" * 78)
    print(title)
    print("=" * 78, flush=True)


# ==================================================================== K0
section("K0: Wurzeln, J, sigma, c (verdoppelte Standard-Koordinaten, "
        "bit-identisch zu v647)")

_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)
RD = np.array(sorted(_roots), dtype=np.int64)
ridx = {tuple(int(a) for a in RD[i]): i for i in range(N240)}
check("K0.1 240 verdoppelte E8-Wurzeln rekonstruiert", RD.shape == (240, 8))


def J_vec_np(x):
    out = np.empty_like(x)
    out[0::2] = -x[1::2]
    out[1::2] = x[0::2]
    return out


def J_vec(x):
    out = []
    for k in range(0, 8, 2):
        out += [-x[k + 1], x[k]]
    return tuple(out)


SIGMA_IDX = [4, 5, 0, 1, 2, 3, 6, 7]


def sig_vec(x):
    return tuple(x[i] for i in SIGMA_IDX)


def perm_from_map(f):
    return np.array([ridx[tuple(int(a) for a in f(RD[i]))]
                     for i in range(N240)], dtype=np.int16)


Jperm = perm_from_map(J_vec_np)
sigperm = perm_from_map(lambda x: x[SIGMA_IDX])
IDP = np.arange(N240, dtype=np.int16)


def comp(p, q):
    """(p o q)[i] = p[q[i]] (erst q, dann p)."""
    return p[q]


def perm_power(p, k):
    r = IDP
    b = p
    while k:
        if k & 1:
            r = comp(b, r)
        b = comp(b, b)
        k >>= 1
    return r


def census_order(p):
    pl = p.tolist()
    seen = bytearray(N240)
    cen = {}
    for s in range(N240):
        if seen[s]:
            continue
        ln, j = 0, s
        while not seen[j]:
            seen[j] = 1
            j = pl[j]
            ln += 1
        cen[ln] = cen.get(ln, 0) + 1
    o = 1
    for L in cen:
        o = lcm(o, L)
    return tuple(sorted(cen.items())), o


cperm = comp(Jperm, sigperm)
cen_c, ord_c = census_order(cperm)
check("K0.2 Compiler-Uhr c = J o sigma: Ordnung %d, Zensus %s "
      "(v629: 19 x 12 + 3 x 4 -- NICHT frei; darum hier der regulaere "
      "Operator)" % (ord_c, dict(cen_c)),
      ord_c == 12 and dict(cen_c) == {4: 3, 12: 19})

line_of = np.full(N240, -1, dtype=np.int32)
line_reps = []
for i in range(N240):
    if line_of[i] >= 0:
        continue
    orb = [i, int(Jperm[i]), int(Jperm[Jperm[i]]),
           int(Jperm[Jperm[Jperm[i]]])]
    for j in orb:
        line_of[j] = len(line_reps)
    line_reps.append(i)
check("K0.3 60 J-Linien", len(line_reps) == 60)

# ==================================================================== K1
section("K1: die fuenf 48er-Bloecke aus der Gauss-Klassen-"
        "sigma-Orbitstruktur (Kriterium 1)")


def mat_det_inv(rows):
    """exakte Determinante + Inverse (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, "singulaere 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):
    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):
    """zeilenweise Hermite-Normalform (obere Dreiecksform, positive
    Diagonale) einer vollrangigen quadratischen Ganzzahlmatrix."""
    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)


# Standardmodell-Basis (verdoppelte Koordinaten; bridge-Probe I5)
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)]
detB, BINV = mat_det_inv(B_STD)


def coords(x):
    c = vec_mat(x, BINV)
    assert all(v.denominator == 1 for v in c), "kein Gittervektor"
    return tuple(int(v) for v in c)


AMAT = [coords(tuple(a + b for a, b in zip(brow, J_vec(brow))))
        for brow in B_STD]
detA, _ = mat_det_inv(AMAT)
HNF = row_hnf(AMAT)
check("K1.1 Z[i]-Maschinerie: |det B| = %d (= 2^8, verdoppelt), "
      "Index [L : (1+i)L] = |det A| = %d = 2^4"
      % (abs(int(detB)), abs(int(detA))),
      abs(int(detB)) == 256 and abs(int(detA)) == 16)


def label(x):
    return hnf_reduce(coords(x), HNF)


ZERO_LB = label((0,) * 8)
root_tuples = [tuple(int(a) for a in RD[i]) for i in range(N240)]
root_label = [label(r) for r in root_tuples]
census_cls = Counter(root_label)
check("K1.2 Klassen-Zensus: 15 nichttriviale Klassen x je 16 Wurzeln, "
      "Nullklasse leer (%s)" % dict(Counter(sorted(census_cls.values()))),
      len(census_cls) == 15 and sorted(census_cls.values()) == [16] * 15
      and ZERO_LB not in census_cls)

ok_mu4 = all(root_label[int(Jperm[i])] == root_label[i]
             for i in range(N240))
lines_per_class = Counter()
for a in range(60):
    lines_per_class[root_label[line_reps[a]]] += 1
check("K1.3 Klassen mu4-stabil (alle 240 Wurzeln) und jede Klasse = "
      "Vereinigung von EXAKT 4 der 60 J-Linien",
      ok_mu4 and sorted(lines_per_class.values()) == [4] * 15)

# sigma-Wirkung auf den Klassen (Wohldefiniertheit ueber alle Wurzeln)
sig_of_label = {}
ok_sig_welldef = True
for i in range(N240):
    lb = root_label[i]
    sl = root_label[int(sigperm[i])]
    if lb in sig_of_label and sig_of_label[lb] != sl:
        ok_sig_welldef = False
    sig_of_label[lb] = sl
fixed_labels = [lb for lb in sig_of_label if sig_of_label[lb] == lb]
orbits = []
seen_lb = set()
for lb in sorted(sig_of_label):
    if lb in seen_lb:
        continue
    o1, o2, o3 = lb, sig_of_label[lb], sig_of_label[sig_of_label[lb]]
    orb = {o1, o2, o3}
    seen_lb |= orb
    orbits.append(orb)
orb_census = Counter(len(o) for o in orbits)
check("K1.4 sigma wirkt wohldefiniert auf den 15 Klassen; Orbit-Zensus "
      "%s = 3 fixe Klassen + 4 Dreierorbits"
      % dict(sorted(orb_census.items())),
      ok_sig_welldef and dict(orb_census) == {1: 3, 3: 4}
      and len(fixed_labels) == 3)

# die fuenf Bloecke: Block 0 = Fixblock, Bloecke 1..4 = Dreierorbits
class_roots = {}
for i in range(N240):
    class_roots.setdefault(root_label[i], []).append(i)
fix_block = sorted(j for lb in fixed_labels for j in class_roots[lb])
moved_orbits = [o for o in orbits if len(o) == 3]
moved_blocks = []
for o in moved_orbits:
    blk = sorted(j for lb in o for j in class_roots[lb])
    moved_blocks.append(blk)
moved_blocks.sort(key=lambda blk: blk[0])
BLOCKS = [fix_block] + moved_blocks
block_of = np.full(N240, -1, dtype=np.int8)
for b, blk in enumerate(BLOCKS):
    for j in blk:
        block_of[j] = b
ok_sizes = all(len(blk) == 48 for blk in BLOCKS)
ok_part = int(np.sum(block_of >= 0)) == 240
ok_J_inv = bool(np.all(block_of[Jperm] == block_of))
ok_s_inv = bool(np.all(block_of[sigperm] == block_of))
ok_c_inv = bool(np.all(block_of[cperm] == block_of))
check("K1.5 fuenf Bloecke: Groessen %s, Partition von R(E8), J-invariant "
      "%s, sigma-invariant %s, c-invariant %s (Blockreihenfolge: "
      "Fixblock, dann Dreierorbits nach kleinstem Wurzelindex)"
      % ([len(b) for b in BLOCKS], ok_J_inv, ok_s_inv, ok_c_inv),
      ok_sizes and ok_part and ok_J_inv and ok_s_inv and ok_c_inv)

criterion("1", all(ok for n, ok in CHECKS if n.startswith("K1.")),
          "die fuenf 48er-Bloecke stammen ausschliesslich aus der "
          "bewiesenen sigma-Orbitstruktur (Fixblock + 4 Dreierorbits)")

# ==================================================================== K2
section("K2: der zertifizierte regulaere G31-Operator u und u^4 "
        "(Kriterium 2 -- v647-Konstruktion bit-identisch)")

JRD = np.array([J_vec_np(RD[i]) for i in range(N240)], dtype=np.int64)


def herm4_rowvec(v_i):
    return RD @ RD[v_i], RD @ JRD[v_i]


refl_perms = []
for a in range(60):
    vi = line_reps[a]
    re4, im4 = herm4_rowvec(vi)
    re, im = re4 // 4, im4 // 4
    Y = RD - re[:, None] * RD[vi][None, :] - im[:, None] * JRD[vi][None, :]
    refl_perms.append(np.array([ridx[tuple(int(t) for t in Y[i])]
                                for i in range(N240)], dtype=np.int16))
check("K2.1 60 unitaere Ordnung-2-Spiegelungen erhalten die Wurzeln",
      len({p.tobytes() for p in refl_perms}) == 60
      and all(np.array_equal(comp(p, p), IDP) for p in refl_perms))

t = time.time()
Gset = {IDP.tobytes(): IDP}
frontier = [IDP]
while frontier:
    nxt = []
    for p in frontier:
        for g in refl_perms:
            q = p[g]
            b = q.tobytes()
            if b not in Gset:
                Gset[b] = q
                nxt.append(q)
    frontier = nxt
check("K2.2 |G31| = %d (BFS, %.1f s)" % (len(Gset), time.time() - t),
      len(Gset) == 46080)
Eall = np.stack(list(Gset.values()))
byte2row = {b: i for i, b in enumerate(Gset.keys())}
check("K2.3 J, sigma, c in G31",
      Jperm.tobytes() in Gset and sigperm.tobytes() in Gset
      and cperm.tobytes() in Gset)


def centralizer_order(x):
    x = np.asarray(x, dtype=np.int16)
    return int(np.sum(np.all(Eall[:, x] == x[Eall], axis=1)))


t = time.time()
cens_all = []
ord_all = np.empty(len(Eall), dtype=np.int32)
for i in range(len(Eall)):
    cen, o = census_order(Eall[i])
    cens_all.append(cen)
    ord_all[i] = o
print("      Zensus/Ordnungs-Pass ueber alle 46080 Elemente: %.1f s"
      % (time.time() - t), flush=True)

# --- v647-Selektion, woertlich: erstes Element mit freiem Zensus {20:12}
rows20 = np.where(ord_all == 20)[0]
reg20_rows = [i for i in rows20 if dict(cens_all[i]) == {20: 12}]
check("K2.4 Ordnung-20-Elemente: %d, davon mit freiem Zensus {20:12}: "
      "%d (v647-Kreuzcheck)" % (len(rows20), len(reg20_rows)),
      len(reg20_rows) > 0)
urow = reg20_rows[0]
u = Eall[urow]
cu = centralizer_order(u)
J2 = comp(Jperm, Jperm)
J3 = comp(J2, Jperm)
u5 = perm_power(u, 5)
u5_is = ("J" if np.array_equal(u5, Jperm)
         else "J^3" if np.array_equal(u5, J3)
         else "-1" if np.array_equal(u5, J2) else "ANDERS")
u4 = perm_power(u, 4)
cen_u4, ord_u4 = census_order(u4)
cu4 = centralizer_order(u4)
print("      Fingerprint u (erste 16 Bilder): %s"
      % [int(x) for x in u[:16]])
check("K2.5 zertifizierter Zeuge u = reg20_rows[0] (v647-Reihenfolge, "
      "KEINE Neuwahl): Zensus %s, |C_G31(u)| = %d = 20 (Springer), "
      "u^5 = %s (zentral)"
      % (dict(cens_all[urow]), cu, u5_is),
      dict(cens_all[urow]) == {20: 12} and cu == 20
      and u5_is in ("J", "J^3"))
check("K2.6 der Fuenfer-Operator u^4: Ordnung %d, wirkt FREI mit Zensus "
      "%s = {5:48}, |C_G31(u^4)| = %d = 20 (zeta5-regulaer, v647 S3.3)"
      % (ord_u4, dict(cen_u4), cu4),
      ord_u4 == 5 and dict(cen_u4) == {5: 48} and cu4 == 20)

criterion("2", all(ok for n, ok in CHECKS if n.startswith("K2.")),
          "der Fuenfer-Operator ist u^4 des zertifizierten v647-Zeugen "
          "(deterministisch, keine Neuwahl)")

# ==================================================================== K3
section("K3: DER KERN-TEST -- die 48 x 5-Inzidenzmatrix (Kriterium 3)")

u4l = u4.tolist()
site_of = np.full(N240, -1, dtype=np.int8)
members = []
for i in range(N240):
    if site_of[i] >= 0:
        continue
    cyc = [i]
    j = u4l[i]
    while j != i:
        cyc.append(j)
        j = u4l[j]
    sid = len(members)
    for j2 in cyc:
        site_of[j2] = sid
    members.append(cyc)
check("K3.1 die 48 Fuenferzyklen von u^4 extrahiert (Sites in "
      "Reihenfolge des kleinsten Wurzelindex)",
      len(members) == 48 and all(len(cyc) == 5 for cyc in members))

INC = [[0] * 5 for _ in range(48)]
for s, cyc in enumerate(members):
    for j in cyc:
        INC[s][int(block_of[j])] += 1
entries = Counter(x for row in INC for x in row)
profiles = Counter(tuple(sorted(row, reverse=True)) for row in INC)
col_sums = [sum(INC[s][b] for s in range(48)) for b in range(5)]
all_one = (entries == Counter({1: 240}))
print("      Eintrags-Verteilung der 240 Matrix-Eintraege: %s"
      % dict(sorted(entries.items())))
print("      Zeilenprofil-Zensus (sortierte Zyklus-Zeilen): %s"
      % {k: v for k, v in sorted(profiles.items(), reverse=True)})
print("      Spaltensummen (Wurzeln pro Block, muss 5 x 48 sein): %s"
      % col_sums)

# Strukturlemma: u^5 = +-J erhaelt die Bloecke -> Blockfaerbung entlang
# jeder u-Bahn ist 5-periodisch; der Kern-Test reduziert sich exakt auf
# die 12 Fuenfer-Fenster der 12 u-Bahnen.
ul = u.tolist()
seen_u = bytearray(N240)
windows = []
ok_period = True
for i in range(N240):
    if seen_u[i]:
        continue
    orb = [i]
    j = ul[i]
    while j != i:
        orb.append(j)
        j = ul[j]
    for j2 in orb:
        seen_u[j2] = 1
    if len(orb) != 20:
        ok_period = False
        continue
    if any(int(block_of[orb[k]]) != int(block_of[orb[k % 5]])
           for k in range(20)):
        ok_period = False
    windows.append((orb[0],
                    tuple(int(block_of[orb[k]]) for k in range(5))))
check("K3.2 Strukturlemma: 12 u-Bahnen der Laenge 20; Blockfaerbung "
      "5-periodisch entlang jeder Bahn (aus u^5 = +-J und "
      "J-Blockinvarianz)", len(windows) == 12 and ok_period)
print("      die 12 Block-Fenster (Bahn-Startwurzel: Fenster; "
      "transversal = alle 5 Bloecke genau einmal):")
n_transversal = 0
for rep, win in windows:
    trans = (sorted(win) == [0, 1, 2, 3, 4])
    n_transversal += trans
    print("        Wurzel %3d: %s %s"
          % (rep, win, "TRANSVERSAL" if trans else "<-- NICHT transversal"))
print("      transversale Fenster: %d / 12" % n_transversal)

criterion("3", all_one,
          "Inzidenzmatrix EXAKT ueberall 1 (Eintrags-Verteilung %s)"
          % dict(sorted(entries.items())))

# ==================================================================== K4
section("K4: der induzierte Ordnung-12-Operator vs v623-Seam-Lift "
        "(Kriterium 4 -- Charaktertafel exakt)")

# ---- v623-Lift in-script rekonstruiert (nichts hartkodiert) ----------
N16, NC = 16, 48
MARK_BONDS = (0, 4, 8, 12)
W623 = (1, 1, 1, 1)


def successor(a, s):
    a2 = (a + 1) % N16
    if a2 in MARK_BONDS:
        s = (s + W623[MARK_BONDS.index(a2)]) % 3
    return a2, s


walk = []
a, s = 0, 0
for _ in range(NC):
    walk.append((a, s))
    a, s = successor(a, s)
widx = {p: i for i, p in enumerate(walk)}
ok_walk = ((a, s) == (0, 0) and len(widx) == NC)


def lift_clock(p):
    aa, ss = p
    for _ in range(4):
        aa, ss = successor(aa, ss)
    return (aa, ss)


Lw = [widx[lift_clock(walk[i])] for i in range(NC)]
ok_shift = all(Lw[i] == (i + 4) % NC for i in range(NC))


def small_pow(p, k):
    r = list(range(len(p)))
    for _ in range(k):
        r = [p[x] for x in r]
    return r


def fixes(p):
    return sum(1 for i, x in enumerate(p) if i == x)


def small_order(p):
    n = len(p)
    seen = [False] * n
    o = 1
    for s0 in range(n):
        if seen[s0]:
            continue
        ln, j = 0, s0
        while not seen[j]:
            seen[j] = True
            j = p[j]
            ln += 1
        o = lcm(o, ln)
    return o


def small_census(p):
    n = len(p)
    seen = [False] * n
    cen = Counter()
    for s0 in range(n):
        if seen[s0]:
            continue
        ln, j = 0, s0
        while not seen[j]:
            seen[j] = True
            j = p[j]
            ln += 1
        cen[ln] += 1
    return dict(cen)


f623 = [fixes(small_pow(Lw, k)) for k in range(12)]
deck623 = small_census(small_pow(Lw, 4))
check("K4.1 v623-Lift rekonstruiert: Walk schliesst nach 48 Schritten "
      "(%s), L = +4-Shift (%s), Ordnung 12, L-Zensus %s, Deck = L^4 "
      "Zensus %s" % (ok_walk, ok_shift, small_census(Lw), deck623),
      ok_walk and ok_shift and small_order(Lw) == 12
      and small_census(Lw) == {12: 4} and deck623 == {3: 16})


def z3_sectors(f0, f4, f8):
    """exakte Z3-Charakter-Multiplizitaeten aus Fixspuren (f4 = f8)."""
    assert f4 == f8
    m0 = Fr(f0 + f4 + f8, 3)
    mw = Fr(f0 - f4, 3)
    assert m0.denominator == 1 and mw.denominator == 1
    return (int(m0), int(mw), int(mw))


def z4_sectors(f0, f3, f6, f9):
    """exakte Z4-Charakter-Multiplizitaeten aus Fixspuren (f3 = f9)."""
    assert f3 == f9
    m0 = Fr(f0 + f3 + f6 + f9, 4)
    m1 = Fr(f0 - f6, 4)
    m2 = Fr(f0 - f3 + f6 - f9, 4)
    assert all(x.denominator == 1 for x in (m0, m1, m2))
    return (int(m0), int(m1), int(m2), int(m1))


sec623_deck = z3_sectors(f623[0], f623[4], f623[8])
sec623_mu4 = z4_sectors(f623[0], f623[3], f623[6], f623[9])
mu4_623 = (f623[3], f623[6], f623[9])
check("K4.2 v623-Referenztafel: Fixvektor %s, Deck-Sektoren %s = 3 x 16, "
      "mu4-Fixspuren (k = 3, 6, 9) = %s, mu4-Sektoren %s"
      % (f623, sec623_deck, mu4_623, sec623_mu4),
      f623 == [48] + [0] * 11 and sec623_deck == (16, 16, 16)
      and mu4_623 == (0, 0, 0) and sec623_mu4 == (12, 12, 12, 12))

# ---- die fuenf Block-Sektionen der Compiler-Uhr c --------------------
print("      Fixvektor-Vergleich fix(g^k), k = 0..11 (exakter "
      "Charaktertafel-Vergleich):")
print("        %-14s %s" % ("v623 L", f623))
cl = cperm.tolist()
block_rows = []
pres_ok_all = []
orders_all = []
all_match = True
for b, blk in enumerate(BLOCKS):
    pos = {j: k for k, j in enumerate(blk)}
    ok_pres = all(cl[j] in pos for j in blk)
    pres_ok_all.append(ok_pres)
    pb = [pos[cl[j]] for j in blk]
    fb = [fixes(small_pow(pb, k)) for k in range(12)]
    ob = small_order(pb)
    orders_all.append(ob)
    cenb = small_census(pb)
    sec_deck = z3_sectors(fb[0], fb[4], fb[8])
    sec_mu4 = z4_sectors(fb[0], fb[3], fb[6], fb[9])
    mu4_b = (fb[3], fb[6], fb[9])
    dev = [k for k in range(12) if fb[k] != f623[k]]
    match = (ok_pres and ob == 12 and fb == f623
             and sec_deck == sec623_deck and mu4_b == mu4_623)
    all_match = all_match and match
    name = "Fixblock B0" if b == 0 else "Block B%d" % b
    block_rows.append((name, fb, cenb, sec_deck, sec_mu4, mu4_b, dev,
                       match))
    print("        %-14s %s%s" % (name, fb,
          ("" if not dev else "   <-- ABWEICHUNG bei k = %s" % dev)))
for name, fb, cenb, sec_deck, sec_mu4, mu4_b, dev, match in block_rows:
    print("      %-14s Ordnung 12, Zensus %s, Deck-Sektoren %s, "
          "mu4-Fixspuren %s, mu4-Sektoren %s -> %s"
          % (name, cenb, sec_deck, mu4_b, sec_mu4,
             "MATCH mit v623" if match else "ABWEICHUNG"))
check("K4.3 c erhaelt jeden Block und hat auf jedem Block Ordnung 12 "
      "(Sektions-Transport wohldefiniert; Zykeltyp = vollstaendige "
      "Z12-Charaktertafel, transport-invariant): Ordnungen %s"
      % orders_all,
      all(pres_ok_all) and all(o == 12 for o in orders_all)
      and all(x[1][0] == 48 for x in block_rows)
      and all(sum(k * v for k, v in x[2].items()) == 48
              for x in block_rows))

# ---- ehrliche Quotienten-Messung: wer wirkt auf den 48 Sites? --------
t = time.time()
site_img = site_of[Eall]                       # (46080, 240) int8
Mflat = np.array([m for cyc in members for m in cyc], dtype=np.int64)
A48 = site_img[:, Mflat].reshape(len(Eall), 48, 5)
pres = np.all(A48 == A48[:, :, :1], axis=(1, 2))
stab_rows = np.where(pres)[0]
first_members = np.array([cyc[0] for cyc in members], dtype=np.int64)
induced = {}
for row in stab_rows:
    g = Eall[row]
    sperm = tuple(int(site_of[int(g[m0])]) for m0 in first_members)
    induced.setdefault(sperm, 0)
    induced[sperm] += 1
ind_orders = Counter(small_order(list(sp)) for sp in induced)
kernel = len(stab_rows) // max(1, len(induced))
j_in = bool(pres[byte2row[Jperm.tobytes()]])
s_in = bool(pres[byte2row[sigperm.tobytes()]])
c_in = bool(pres[byte2row[cperm.tobytes()]])
print("      Partitions-Stabilisator-Scan (%.1f s): |Stab| = %d, "
      "Kern (zyklenweise Wirkung) = %d, induzierte Gruppe auf den 48 "
      "Sites: Ordnung %d, Elementordnungen %s"
      % (time.time() - t, len(stab_rows), kernel, len(induced),
         dict(sorted(ind_orders.items()))))
print("      wirkt auf dem Zyklen-Quotienten: J: %s, sigma: %s, c: %s"
      % (j_in, s_in, c_in))
has12 = 12 in ind_orders
check("K4.4 EHRLICHKEIT Quotient: existiert ein sektionsfreier "
      "Ordnung-12-Operator auf dem 48er-Quotienten (induziert von "
      "G31)? -> %s (gemessen); der Ordnung-12-Vergleich laeuft daher "
      "ueber die fuenf Block-Sektionen (K4.3)"
      % ("JA" if has12 else "NEIN"), True)
if j_in:
    jhat = [int(site_of[int(Jperm[m0])]) for m0 in first_members]
    f_j = [fixes(small_pow(jhat, k)) for k in range(1, 4)]
    print("      mu4 auf den Sites: J induziert Ordnung-%d-Operator, "
          "Zensus %s, Fixspuren (J, J^2, J^3) = %s "
          "(v623-mu4-Fixspuren: %s)"
          % (small_order(jhat), small_census(jhat), tuple(f_j),
             mu4_623))

criterion("4", all_match,
          "alle fuenf Block-Sektionen tragen die v623-Charaktertafel "
          "(Fixvektor + Deck-Sektoren 3 x 16 + mu4-Fixspuren) exakt"
          if all_match else
          "Charaktertafel weicht ab: %s"
          % "; ".join("%s bei k = %s (fix = %s statt %s)"
                      % (r[0], r[6], [r[1][k] for k in r[6]],
                         [f623[k] for k in r[6]])
                      for r in block_rows if not r[7]))

# ==================================================================== K5
section("K5: MUST-FAIL-KONTROLLE -- zufaellige freie Ordnung-5-"
        "Operatoren aus W(E8)")

block_list = block_of.tolist()


def inc_all_one(p):
    """hat p (Ordnung 5, frei) die Inzidenz-1-Eigenschaft gegen die
    fuenf festen Bloecke?"""
    pl = p.tolist() if hasattr(p, "tolist") else list(p)
    seen = bytearray(N240)
    for i in range(N240):
        if seen[i]:
            continue
        cols = 0
        n = 0
        j = i
        while not seen[j]:
            seen[j] = 1
            bbit = 1 << block_list[j]
            if cols & bbit:
                return False
            cols |= bbit
            j = pl[j]
            n += 1
        if n != 5 or cols != 31:
            return False
    return True


# alle 240 reellen Spiegelungen von W(E8) (verdoppelte Wurzeln)
t = time.time()
RPERMS = []
for i in range(N240):
    rd = RD[i]
    ip4 = RD @ rd
    Y = RD - (ip4 // 4)[:, None] * rd[None, :]
    RPERMS.append(np.array([ridx[tuple(int(v) for v in Y[k])]
                            for k in range(N240)], dtype=np.int16))
check("K5.1 240 reelle W(E8)-Spiegelungen gebaut (%.1f s)"
      % (time.time() - t), len(RPERMS) == 240)

rng = random.Random(20260804)
targets = 25
found = []
draws = n_nonfree = n_in_g31 = 0
while len(found) < targets and draws < 6000:
    draws += 1
    g = IDP
    for _ in range(24):
        g = comp(RPERMS[rng.randrange(240)], g)
    cen_g, o_g = census_order(g)
    if o_g % 5:
        continue
    h = perm_power(g, o_g // 5)
    cen_h, o_h = census_order(h)
    if dict(cen_h) != {5: 48}:
        n_nonfree += 1
        continue
    found.append(h)
    if h.tobytes() in Gset:
        n_in_g31 += 1
hits = [inc_all_one(h) for h in found]
n_hits = sum(hits)
check("K5.2 %d zufaellige FREIE Ordnung-5-Operatoren aus W(E8) gezogen "
      "(%d Ziehungen; %d nicht-freie Ordnung-5 verworfen; %d der %d "
      "liegen zufaellig in G31)"
      % (len(found), draws, n_nonfree, n_in_g31, len(found)),
      len(found) == targets)
# Beispiel-Verteilungen der ersten drei Kontrollen (informativ)
for k in range(min(3, len(found))):
    pl = found[k].tolist()
    seen = bytearray(N240)
    prof = Counter()
    for i in range(N240):
        if seen[i]:
            continue
        cyc = [i]
        j = pl[i]
        while j != i:
            cyc.append(j)
            j = pl[j]
        for j2 in cyc:
            seen[j2] = 1
        row = [0] * 5
        for j2 in cyc:
            row[block_list[j2]] += 1
        prof[tuple(sorted(row, reverse=True))] += 1
    print("      Kontrolle %d: Zeilenprofil-Zensus %s"
          % (k + 1, {kk: vv for kk, vv in sorted(prof.items(),
                                                 reverse=True)}))
control_fires = (len(found) == targets and n_hits == 0)
check("K5.3 KONTROLLE FEUERT: KEINER der %d zufaelligen Operatoren hat "
      "die Inzidenz-1-Eigenschaft (Treffer: %d) -- der Test misst "
      "etwas" % (len(found), n_hits), control_fires)

# ==================================================================== K6
section("K6: deterministischer Kontext -- ALLE Ordnung-5-Elemente "
        "von G31 (keine Selektion, nur Zensus)")

rows5 = np.where(ord_all == 5)[0]
all_free5 = all(dict(cens_all[i]) == {5: 48} for i in rows5)
n_allone_g31 = sum(1 for i in rows5 if inc_all_one(Eall[i]))
u4row = byte2row[u4.tobytes()]
check("K6.1 G31 enthaelt %d Ordnung-5-Elemente, alle frei ({5:48}): %s"
      % (len(rows5), all_free5), all_free5)
print("      davon mit Inzidenz-1-Eigenschaft gegen die festen Bloecke: "
      "%d von %d (Anteil exakt %d/%d)"
      % (n_allone_g31, len(rows5), n_allone_g31, len(rows5)))
print("      das zertifizierte u^4 (Zeile %d) hat die Eigenschaft: %s "
      "-- das VERDIKT haengt AUSSCHLIESSLICH am zertifizierten u^4 "
      "(Kriterium 2), dieser Zensus ist reiner Kontext"
      % (u4row, bool(all_one)))

# ============================================================== VERDIKT
section("ZUSAMMENFASSUNG / VERDIKT")
n_pass = sum(1 for _, ok in CHECKS if ok)
machinery_ok = (n_pass == len(CHECKS))
print("Maschinerie-/Kontroll-Checks: %d/%d bestanden" % (n_pass,
                                                         len(CHECKS)))
for k in ("1", "2", "3", "4"):
    print("Kriterium %s: %s" % (k, "PASS" if CRIT.get(k) else "FAIL"))
print("Must-fail-Kontrolle: %s"
      % ("FEUERT (Test misst etwas)" if control_fires
         else "FEUERT NICHT (Test misst nichts)"))
print()
if not control_fires:
    verdict = "TEST-VOID"
    print("VERDIKT: TEST-VOID -- die Must-fail-Kontrolle feuert nicht;")
    print("die Inzidenz-1-Eigenschaft waere generisch, der Test misst")
    print("nichts. Kein positives oder negatives Struktur-Verdikt.")
elif not (CRIT["1"] and CRIT["2"]):
    verdict = "MASCHINERIE-FEHLER"
    print("VERDIKT: MASCHINERIE-FEHLER -- Kriterium 1 oder 2 nicht")
    print("reproduzierbar; siehe FAIL-Zeilen.")
elif CRIT["3"] and CRIT["4"]:
    verdict = "SEAM48-INTERTWINED"
    print("VERDIKT: SEAM48-INTERTWINED -- alle vier Kriterien: R(E8) =")
    print("{5 Carrier-Slots} x {48 Seam-Sites} als echtes Informations-")
    print("raster; Inzidenz exakt 1 und die induzierte Ordnung-12-Uhr")
    print("traegt die v623-Charaktertafel exakt.")
elif CRIT["3"]:
    verdict = "SEAM48-GRID-ONLY"
    print("VERDIKT: SEAM48-GRID-ONLY -- die Inzidenz ist ueberall exakt")
    print("1 (das 5 x 48-Raster EXISTIERT), aber die Charaktertafel des")
    print("induzierten Ordnung-12-Operators weicht vom v623-Seam-Lift")
    print("ab; Abweichungsort exakt dokumentiert (siehe K4).")
else:
    verdict = "SEAM48-DEAD"
    print("VERDIKT: SEAM48-DEAD -- die Inzidenz ist NICHT ueberall 1;")
    print("die Eintrags-Verteilung %s und die 12 Block-Fenster (K3)"
          % dict(sorted(entries.items())))
    print("sind selbst informativ; 240 = 48 x 5 bleibt (mit diesem")
    print("zertifizierten Operator und diesen kanonischen Bloecken)")
    print("eine Faktorisierung OHNE Koordinatisierung.")
print()
print("Verdikt-Enum: %s" % verdict)
print("Laufzeit: %.1f s" % (time.time() - T0))
print("ALLE MASCHINERIE-CHECKS BESTANDEN" if machinery_ok
      else "MASCHINERIE-CHECKS FEHLGESCHLAGEN")

def run():
    """run_all entry point: the checks execute at import time (module level)."""
    return 0 if machinery_ok else 1


if __name__ == "__main__":
    raise SystemExit(run())

6d0d10b2a8d4657587fcf70d476f81628256a360cc0274f4c1d0f592e489c19c

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.