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
"""v629 -- E8.INCIDENCE.01: the root incidence census -- the naive 48 x 5
incidence map to the E8 roots is KILLED for the compiler-canonical
order-12 element, and the positive residue is sharp: the mu4 clock acts
FREELY on the 240 roots with EXACTLY 60 orbits (60 = D_start), and the
family 3-cycle fixes exactly 12 roots (the lifted-mark count).

The external review proposed the kill test: can the 240 E8 roots be
built canonically as (48 cover modes) x (5 carrier slots) INCLUDING the
Gram structure?  First hurdle executed:

  (R1) THE SETUP [E]: the 240 roots in the D8+spinor model (112
       integer + 128 half-integer), and the compiler-canonical
       order-12 element g = J o sigma (J = the mu4 quarter-turn on all
       four coordinate pairs; sigma = the 3-cycle of pairs 1..3 -- the
       clock times the family cycle) preserves the root set.

  (R2) THE KILL [E, honest]: g does NOT act freely: the orbit census
       is 19 x 12 + 3 x 4 (= 240) -- NOT the 20 free zeta_12 orbits
       the naive 48 x 5 = 240 incidence would need: the naive
       construction FAILS at the first hurdle for the canonical
       element; 48 x 5 = 240 stays an audit fingerprint (as the
       review's kill branch anticipated).

  (R3) THE POSITIVE RESIDUE [E]: the mu4 clock J alone acts FREELY
       with EXACTLY 60 orbits of size 4 -- 60 = D_start (the cascade
       start): 240 = |mu4| x D_start realized as free clock orbits on
       the roots; and sigma fixes EXACTLY 12 roots (the pair-4 +
       diagonal support) -- 12 = the lifted-mark count of v623.

  (R4) CONTROLS [E]: J^2 (the deck square, order 2) has 120 orbits of
       size 2 (free); the fixed roots of sigma form 3 J-orbits (the
       12 = 3 x 4 structure closes).

  (R5) THE READING [C]: the review's kill branch fires for the naive
       canonical element -- a Gram-compatible 48 x 5 incidence, if it
       exists, needs a NON-obvious element or a genuinely different
       construction; the sharp positive: 60 = D_start is now a free
       ORBIT COUNT on the roots (a new home for the cascade constant);
       typed observation, no derivation claimed.

Verdict enums (frozen): INCIDENCE-CENSUS-DECIDED (all pass),
CENSUS-FAILS, MIXED.

FIREWALL: no marker changes; typed observations, no derivation claims.

PROVENANCE: discovery probe root_incidence_probe.py (2026-08-02, 6/6,
verdict INCIDENCE-CENSUS-DECIDED).

Python-only (exact Fraction combinatorics), counted per
GATE.WOLFRAM.02.
"""

import itertools
from collections import Counter
from fractions import Fraction as Fr

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


# ================================================================== R1
print("=" * 72)
print("R1: the roots and the canonical order-12 element")
print("=" * 72)

roots = []
for x in itertools.product(range(-1, 2), repeat=8):
    if sum(v * v for v in x) == 2 and sum(x) % 2 == 0:
        roots.append(tuple(Fr(v) for v in x))
n_int = len(roots)
half = Fr(1, 2)
for y in itertools.product((0, -1), repeat=8):
    x = tuple(Fr(v) + half for v in y)
    if sum(v * v for v in x) == 2 and sum(x) % 2 == 0:
        roots.append(x)
n_half = len(roots) - n_int
RS = set(roots)


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


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


def g(x):
    return J_all(sigma(x))


check("R1.1 240 roots (112 integer + 128 half-integer) and the "
      "compiler-canonical order-12 element g = J o sigma preserves the "
      "root set",
      len(roots) == 240 and n_int == 112 and n_half == 128
      and all(g(x) in RS for x in roots))


def census(f):
    seen = set()
    cnt = Counter()
    for x in roots:
        if x in seen:
            continue
        orb = [x]
        y = f(x)
        while y != x:
            orb.append(y)
            y = f(y)
        for z in orb:
            seen.add(z)
        cnt[len(orb)] += 1
    return dict(cnt)


# ================================================================== R2
print("=" * 72)
print("R2: the kill (no free zeta_12 structure)")
print("=" * 72)

cg = census(g)
check("R2.1 [KILL, honest] g does NOT act freely: orbit census "
      "19 x 12 + 3 x 4 (not the 20 free 12-orbits the naive "
      "48 x 5 = 240 incidence needs): the naive construction FAILS at "
      "the first hurdle; 48 x 5 stays an audit fingerprint",
      cg == {12: 19, 4: 3}, str(cg))

# ================================================================== R3
print("=" * 72)
print("R3: the positive residue (60 = D_start as a free orbit count)")
print("=" * 72)

cJ = census(J_all)
check("R3.1 the mu4 clock alone acts FREELY with EXACTLY 60 orbits of "
      "size 4: 240 = |mu4| x 60 with 60 = D_start -- the cascade start "
      "appears as the free clock-orbit count on the roots", cJ == {4: 60})

cs = census(sigma)
fixed = [x for x in roots if sigma(x) == x]
check("R3.2 the family 3-cycle fixes EXACTLY 12 roots (76 free "
      "3-orbits + 12 fixed) -- 12 = the lifted-mark count of v623",
      cs == {3: 76, 1: 12} and len(fixed) == 12)

# ================================================================== R4
print("=" * 72)
print("R4: controls")
print("=" * 72)


def J2(x):
    return J_all(J_all(x))


cJ2 = census(J2)
fixed_orbJ = set()
for x in fixed:
    orb = frozenset([x, J_all(x), J2(x), J_all(J2(x))])
    fixed_orbJ.add(orb)
check("R4.1 J^2 (the deck square) acts freely with 120 2-orbits, and "
      "the 12 sigma-fixed roots form exactly 3 free J-orbits "
      "(12 = 3 x 4 closes)",
      cJ2 == {2: 120} and len(fixed_orbJ) == 3
      and all(len(o) == 4 for o in fixed_orbJ))

# ================================================================== R5
print("=" * 72)
print("R5: the reading")
print("=" * 72)

check("R5.1 [C] the review's kill branch fires for the naive canonical "
      "element: a Gram-compatible 48 x 5 incidence, if it exists, needs "
      "a non-obvious element or a different construction; the sharp "
      "positive residue: 60 = D_start is a free ORBIT COUNT on the "
      "roots and 12 (the lifted marks) is the sigma-fixed count -- "
      "typed observations, no derivation claimed; no marker moves", True)

# ================================================================== summary
print("=" * 72)
n_pass = sum(1 for _, ok in CHECKS if ok)
print("%d/%d checks passed" % (n_pass, len(CHECKS)))
if n_pass == len(CHECKS):
    print("ALL CHECKS PASSED")
    print("VERDICT: INCIDENCE-CENSUS-DECIDED -- the naive 48 x 5 incidence is")
    print("killed (19 x 12 + 3 x 4), and the positive residue is sharp:")
    print("60 = D_start free clock orbits, 12 sigma-fixed roots.")
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)

a483a61f791b5eeaf90198d3c546ed07da22ec6afdc1e5d999de2ad91a56820b

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.