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
"""v690 -- E8.QUARTICHALF.01 (review contract E8.QUARTIC.HALF.01): the
quartic invariant restriction -- is G31 the holomorphic mu4 shadow of
the E8 Coxeter compiler?

HYPOTHESIS (external review, theorem candidate): restricting the
W(E8)-invariant root power sums f_d(x) = sum_roots <alpha, x>^d
(d in Deg W(E8) = {2,8,12,14,18,20,24,30}) to the holomorphic
eigenspace V^{1,0} = ker(J - i) (dim 4) kills exactly the half
{2,14,18,30} (degrees = 2 mod 4) and keeps {8,12,20,24} = Deg(G31)
alive -- 'G31 is the holomorphic mu4 shadow of the E8 compiler'.

RADICAL HONESTY -- the review's own Fallstrick, resolved in layers:

  (L1) the mu4-orbit mechanism: for x in V^{1,0} and any root alpha,
       <J alpha, x> = -i <alpha, x> EXACTLY (verified for all 240
       roots as a weight identity), so summing over each J-orbit
       {a, Ja, -a, -Ja} gives the factor 1 + (-i)^d + (-1)^d + i^d
       = 0 for ALL d != 0 mod 4.  The claimed vanishing {2,14,18,30}
       is therefore TRIVIAL and not degree-list-specific: 6, 10, 22,
       26 vanish identically too (checked).  This is a symbolic
       PROOF of the vanishing half, but it carries no G31 content.
  (L2) the isotropy layer: V^{1,0} of ANY orthogonal complex
       structure is q-isotropic (q = <x,x>), and W(E8) has NO basic
       invariant in degrees 4, 6, 10 (f_4 ~ q^2, f_6 ~ q^3, f_10 in
       q-multiples -- f_4, f_6 proportionality verified SYMBOLICALLY
       as 8-variable polynomial identities here).  So F_4| = F_6| =
       F_10| = 0 persists even on non-compiler complex structures.
  (L3) the SUBSTANCE: F_8|, F_12|, F_20|, F_24| are nonzero (exact
       points; a nonzero value at one exact point is a rigorous
       nonvanishing proof), G31-invariant (all 60 reflections + the
       clock generators sigma, J, exact Gaussian arithmetic), and
       ALGEBRAICALLY INDEPENDENT (exact Jacobian != 0).  With
       degrees (8,12,20,24) = the Molien-unique degree quadruple of
       G31 (v634) and 8*12*20*24 = 46080 = |G31|, Chevalley's
       theorem [maths-lit fact, cited not proved] makes them a
       system of BASIC INVARIANTS: the restriction of the W(E8)
       invariant ring to V^{1,0} generates the FULL G31 invariant
       ring.  That -- not the vanishing pattern -- is the theorem
       candidate's load-bearing content.
  (L4) the Jacobian mirror factorization: sum(d_i - 1) = 60 = number
       of G31 mirror lines; the exact Jacobian vanishes at random
       exact points ON each of the 60 mirrors and is nonzero at
       generic points.  The full polynomial identity
       Jac = c * prod(60 linear forms) is the standard basic-
       invariant Jacobian theorem [cited]; the symbolic degree-60
       expansion is NOT performed here (named residual).

Slices:
  II1  the exact number checks (documented, trivial): Exp(E8) =
       (Z/30)^x, chi_-4 split -> Deg(G31), sums 60/60, Deg W(E8)
       mod-4 halves.
  II2  the restriction test with the honesty layers L1/L2 + exact
       nonvanishing {8,12,16,20,24,28} and SYMBOLIC F_4| = 0
       (35/35 coefficients).
  II3  G31 anchoring: invariance under all 60 reflections + sigma +
       J, exact Jacobian != 0, mirror vanishing 60/60 (L3/L4).
  II4  must-fail controls: (0) HONEST NEGATIVE: the naive pair-
       orientation flip S7 J S7 = J o S67 (even sign flip in W(D8))
       PRESERVES the roots -- signed-permutation complex structures
       cannot break compatibility; (a) J' = R J R^T with R the exact
       rational (3,4,5) rotation crossing the mu4 pairs: NOT root-
       preserving, the informative vanishing {14,18,22,26,30} BREAKS
       while the trivial layers {2,4,6,10} persist (documented);
       (b) J'' = S57 J S57 (root-preserving): the pattern survives
       -- the theorem is about root-compatible complex structures,
       not one matrix; (c) a random non-isotropic 4-space: even
       F_2 != 0.

Exact Gaussian-integer / Gaussian-rational arithmetic throughout
(int pairs / Fraction pairs); no floats anywhere.  Verdict enums
(frozen; the EXPECTED verdict of this module is QUARTIC-HALF-ALIVE --
with the honest split: the vanishing half {2,14,18,30} is TRUE but
TRIVIAL (mu4 orbit factor); the load-bearing content is F8/F12/F20/F24
as a system of BASIC G31 invariants): QUARTIC-HALF-ALIVE,
QUARTIC-HALF-PARTIAL, QUARTIC-HALF-KILLED.

FIREWALL: writes nothing; no marker moves; exact arithmetic only;
must-fail controls (II4) adjudicated inline.

PROVENANCE: discovery probe quartic_half_probe.py (2026-08-03, 22/22
PASS, verdict QUARTIC-HALF-ALIVE).
Predecessors (read-only): v634_st31_structure.py (G31, degrees
8/12/20/24 Molien-unique, 60 reflections, sigma = c^4, J = c^9),
v647/v654 (regular clocks, d/4-theorem).
"""

import itertools
import random
import time
from fractions import Fraction as Fr
from math import factorial, gcd

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)


# ------------------------------------------------- Gaussian arithmetic
GZERO = (0, 0)
GONE = (1, 0)
MINUS_I = (0, -1)


def gadd(u, v):
    return (u[0] + v[0], u[1] + v[1])


def gsub(u, v):
    return (u[0] - v[0], u[1] - v[1])


def gmul(u, v):
    return (u[0] * v[0] - u[1] * v[1], u[0] * v[1] + u[1] * v[0])


def gconj(u):
    return (u[0], -u[1])


def gpow_list(t, n):
    out = [GONE]
    for _ in range(n):
        out.append(gmul(out[-1], t))
    return out


# ================================================================== S0
section("S0: roots, J, lines, holomorphic weights (doubled coordinates)")

_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 = sorted(_roots)
RSET = set(RD)
check("S0.1 240 doubled-integer E8 roots reconstructed", len(RD) == 240)


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)

line_of = {}
LINES = []
for r in RD:
    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)
check("S0.2 J preserves the roots, acts freely, 60 lines of size 4",
      all(J_vec(r) in RSET for r in RD) and len(LINES) == 60
      and all(len(o) == 4 for o in LINES))


def weights_J(r):
    """<alpha, b_k> for b_k = e_2k - i e_2k+1 (basis of ker(J - i))."""
    return ((r[0], -r[1]), (r[2], -r[3]), (r[4], -r[5]), (r[6], -r[7]))


WEIGHTS = [weights_J(r) for r in RD]
W_OF = {r: w for r, w in zip(RD, WEIGHTS)}


def t_val(z, Wr):
    acc = GZERO
    for k in range(4):
        acc = gadd(acc, gmul(z[k], Wr[k]))
    return acc


def F_vals(z, ds, weights=None):
    """exact F_d(z) for all d in ds simultaneously."""
    weights = WEIGHTS if weights is None else weights
    dmax = max(ds)
    tot = {d: GZERO for d in ds}
    for Wr in weights:
        pw = gpow_list(t_val(z, Wr), dmax)
        for d in ds:
            tot[d] = gadd(tot[d], pw[d])
    return tot


def grand(rng, m=3):
    return (rng.randint(-m, m), rng.randint(-m, m))


def grand_vec(rng, m=3):
    return tuple(grand(rng, m) for _ in range(4))


# ================================================================== II1
section("II1: the exact number checks (trivial, documented)")

EXP_E8 = {1, 7, 11, 13, 17, 19, 23, 29}
tot30 = {m for m in range(1, 30) if gcd(m, 30) == 1}
check("II1.1 Exp(E8) = {1,7,11,13,17,19,23,29} = (Z/30)^x (h = 30; the "
      "exponent list is the standard E8 datum, the totative identity is "
      "computed)", tot30 == EXP_E8)

chi_minus = {m for m in EXP_E8 if m % 4 == 3}
DEGS_G31 = (8, 12, 20, 24)
check("II1.2 chi_-4 split: {m in Exp(E8): m = 3 mod 4} = %s; shifted by "
      "+1 = %s = Deg(G31) (Molien-unique per v634 S9.3)"
      % (sorted(chi_minus), sorted(m + 1 for m in chi_minus)),
      chi_minus == {7, 11, 19, 23}
      and tuple(sorted(m + 1 for m in chi_minus)) == DEGS_G31)

check("II1.3 sums 60/60: sum{7,11,19,23} = %d = number of G31 mirror "
      "lines (= 60 J-lines computed in S0.2); complement sum "
      "{1,13,17,29} = %d" % (sum(chi_minus), sum(EXP_E8 - chi_minus)),
      sum(chi_minus) == 60 == sum(EXP_E8 - chi_minus)
      and len(LINES) == 60)

DEG_WE8 = tuple(sorted(m + 1 for m in EXP_E8))
half0 = tuple(d for d in DEG_WE8 if d % 4 == 0)
half2 = tuple(d for d in DEG_WE8 if d % 4 == 2)
check("II1.4 Deg W(E8) = %s; the 0-mod-4 half %s = Deg(G31); the "
      "complement %s is all 2 mod 4; product of the G31 half = %d = "
      "|G31| (v634)" % (DEG_WE8, half0, half2,
                        half0[0] * half0[1] * half0[2] * half0[3]),
      DEG_WE8 == (2, 8, 12, 14, 18, 20, 24, 30)
      and half0 == DEGS_G31 and half2 == (2, 14, 18, 30)
      and 8 * 12 * 20 * 24 == 46080)

# ================================================================== II2
section("II2: the restriction test (with honesty layers L1/L2)")

# --- L1: the mu4-orbit weight identity (symbolic proof of vanishing) ---
ok_orbit = all(W_OF[J_vec(r)] == tuple(gmul(MINUS_I, w) for w in W_OF[r])
               for r in RD)
check("II2.1 [L1, PROOF] W(J alpha) = -i W(alpha) for ALL 240 roots -> "
      "each J-orbit contributes t^d (1 + (-i)^d + (-1)^d + i^d) to "
      "F_d| -- IDENTICALLY ZERO for every d != 0 mod 4: the vanishing "
      "half {2,14,18,30} is proven symbolically, and it is TRIVIAL "
      "(mu4), not degree-list-specific", ok_orbit)

rng = random.Random(20260803)
VAN = (2, 6, 10, 14, 18, 22, 26, 30)
pts = [grand_vec(rng) for _ in range(5)]
van_ok = all(all(F_vals(z, VAN)[d] == GZERO for d in VAN) for z in pts)
check("II2.2 [L1 cross-check] F_d| = 0 at 5 exact random points for ALL "
      "d in %s -- including 6, 10, 22, 26 (NOT in the review's list): "
      "the mod-4 mechanism, exactly" % (VAN,), van_ok)

# --- L2: f_4 ~ q^2 and f_6 ~ q^3 as 8-variable polynomial identities ---
def real_powersum_coeffs(d):
    """coefficients of f_d(x) = sum_a <a,x>^d as an 8-var polynomial."""
    out = {}
    powtabs = [[[c ** e for e in range(d + 1)] for c in r] for r in RD]
    fac = factorial(d)
    for m in itertools.product(range(d + 1), repeat=7):
        s7 = sum(m)
        if s7 > d:
            continue
        mm = m + (d - s7,)
        mult = fac
        for e in mm:
            mult //= factorial(e)
        tot = 0
        for pt in powtabs:
            p = 1
            for i in range(8):
                p *= pt[i][mm[i]]
            tot += p
        if tot:
            out[mm] = mult * tot
    return out


def q_power_coeffs(k):
    """coefficients of q(x)^k = (sum x_i^2)^k."""
    out = {}
    fac = factorial(k)
    for m in itertools.product(range(k + 1), repeat=7):
        s7 = sum(m)
        if s7 > k:
            continue
        mm = m + (k - s7,)
        mult = fac
        for e in mm:
            mult //= factorial(e)
        out[tuple(2 * e for e in mm)] = mult
    return out


t_l2 = time.time()
f4 = real_powersum_coeffs(4)
q2 = q_power_coeffs(2)
lam4 = Fr(f4[(4, 0, 0, 0, 0, 0, 0, 0)], q2[(4, 0, 0, 0, 0, 0, 0, 0)])
ok_f4 = (set(f4) == set(q2)
         and all(Fr(f4[m], q2[m]) == lam4 for m in q2))
f6 = real_powersum_coeffs(6)
q3 = q_power_coeffs(3)
lam6 = Fr(f6[(6, 0, 0, 0, 0, 0, 0, 0)], q3[(6, 0, 0, 0, 0, 0, 0, 0)])
ok_f6 = (set(f6) == set(q3)
         and all(Fr(f6[m], q3[m]) == lam6 for m in q3))
check("II2.3 [L2, PROOF] f_4 = %s q^2 and f_6 = %s q^3 as SYMBOLIC "
      "8-variable identities (%.1f s): W(E8) has no basic invariant in "
      "degrees 4, 6 -> their restriction vanishes on ANY q-isotropic "
      "subspace, mu4 or not" % (lam4, lam6, time.time() - t_l2),
      ok_f4 and ok_f6)

# isotropy: q(b_k) = <b_k, b_k> with b_k = e_2k - i e_2k+1
# = 1^2 + (-i)^2 = 0; verified exactly in Gaussian arithmetic:
q_bk = gadd(gmul(GONE, GONE), gmul((0, -1), (0, -1)))
check("II2.4 [L2] V^{1,0} is q-isotropic: q(b_k) = 1 + (-i)^2 = %s = 0 "
      "exactly -> F_4| = F_6| = F_10| = 0 by L2 alone (also forced by "
      "the G31 Molien series: no invariant below degree 8)" % (q_bk,),
      q_bk == GZERO)

# --- symbolic F_4| = 0: all 35 coefficients of the restricted quartic --
t_f4 = time.time()
pw4 = [[gpow_list(w, 4) for w in Wr] for Wr in WEIGHTS]
n_nonzero4 = 0
for m in itertools.product(range(5), repeat=3):
    if sum(m) > 4:
        continue
    mm = m + (4 - sum(m),)
    tot = GZERO
    for pt in pw4:
        p = GONE
        for k in range(4):
            p = gmul(p, pt[k][mm[k]])
        tot = gadd(tot, p)
    if tot != GZERO:
        n_nonzero4 += 1
check("II2.5 SYMBOLIC: F_4|_{V^{1,0}} has ALL 35 monomial coefficients "
      "= 0 exactly (%.1f s): the first G31-consistency point -- mod-4 "
      "alone would allow F_4 != 0, the invariant theory forbids it "
      "(nonzero coefficients: %d)" % (time.time() - t_f4, n_nonzero4),
      n_nonzero4 == 0)

# --- exact nonvanishing on the 0-mod-4 side -----------------------------
NONVAN = (8, 12, 16, 20, 24, 28)
z_nv = grand_vec(rng)
fv = F_vals(z_nv, NONVAN)
nz = {d: fv[d] != GZERO for d in NONVAN}
print("      F_d| at exact point %s: nonzero pattern %s" % (z_nv, nz))
check("II2.6 F_d| != 0 at an exact point for ALL d in %s (a nonzero "
      "exact value proves nonvanishing rigorously); 16 and 28 are "
      "NON-degrees of G31 -- honest: nonvanishing alone is generic "
      "mod-4 behaviour above degree 4, the G31 content is II3"
      % (NONVAN,), all(nz.values()))

# ================================================================== II3
section("II3: G31 anchoring -- invariance, independence, mirrors")

# complex coordinates of roots and lines
def c4(r):
    return ((r[0], r[1]), (r[2], r[3]), (r[4], r[5]), (r[6], r[7]))


ROOTC = [c4(r) for r in RD]
ROOTC_SET = set(ROOTC)
LINE_V = [c4(o[0]) for o in LINES]


def herm(z, V):
    acc = GZERO
    for k in range(4):
        acc = gadd(acc, gmul(z[k], gconj(V[k])))
    return acc


def refl_apply(V, z):
    """R_V(z) = z - (herm(z,V)/4) V; caller guarantees divisibility."""
    h = herm(z, V)
    assert h[0] % 4 == 0 and h[1] % 4 == 0
    s = (h[0] // 4, h[1] // 4)
    return tuple(gsub(z[k], gmul(s, V[k])) for k in range(4))


ok_perm = True
ok_invol = True
for V in LINE_V:
    img = [refl_apply(V, zc) for zc in ROOTC]
    if set(img) != ROOTC_SET:
        ok_perm = False
    if any(refl_apply(V, w) != zc for zc, w in zip(ROOTC, img)):
        ok_invol = False
check("II3.1 all 60 hermitian reflections R_V permute the 240 root "
      "coordinate vectors and are involutions (exact)",
      ok_perm and ok_invol)

DS = (8, 12, 20, 24)
z0 = tuple((4 * a, 4 * b) for (a, b) in grand_vec(rng))
F0 = F_vals(z0, DS)
ok_refl = all(F_vals(refl_apply(V, z0), DS) == F0 for V in LINE_V)


def sig_z(z):
    return (z[2], z[0], z[1], z[3])


def J_z(z):
    return tuple(gmul((0, 1), zk) for zk in z)


ok_gen = True
for _ in range(3):
    zz = grand_vec(rng)
    Fz = F_vals(zz, DS)
    if F_vals(sig_z(zz), DS) != Fz or F_vals(J_z(zz), DS) != Fz:
        ok_gen = False
check("II3.2 G31-INVARIANCE: F_8|, F_12|, F_20|, F_24| invariant under "
      "ALL 60 reflections (exact, one 4Z[i]-point) and under the clock "
      "generators sigma, J (3 exact points each) -- the reflections "
      "generate G31 (v634 S1.3), so the restrictions are G31-invariants",
      ok_refl and ok_gen)


def jac_det(z, weights=None):
    """exact 4x4 Jacobian determinant of (F_8, F_12, F_20, F_24) at z."""
    weights = WEIGHTS if weights is None else weights
    D = [[GZERO] * 4 for _ in range(4)]
    for Wr in weights:
        pw = gpow_list(t_val(z, Wr), 23)
        for i, d in enumerate(DS):
            td = pw[d - 1]
            for j in range(4):
                D[i][j] = gadd(D[i][j], gmul(Wr[j], td))
    for i, d in enumerate(DS):
        D[i] = [gmul((d, 0), x) for x in D[i]]
    tot = GZERO
    for perm in itertools.permutations(range(4)):
        sgn = 1
        for a in range(4):
            for b in range(a + 1, 4):
                if perm[a] > perm[b]:
                    sgn = -sgn
        term = (sgn, 0)
        for r4 in range(4):
            term = gmul(term, D[r4][perm[r4]])
        tot = gadd(tot, term)
    return tot


t_j = time.time()
# small Gaussian-integer points frequently LIE on one of the 60 mirror
# hyperplanes (where the Jacobian must vanish, see II3.5) -- honest
# rejection sampling: test points must avoid all 60 mirrors
jac_pts = []
n_rejected = 0
while len(jac_pts) < 3:
    z = grand_vec(rng)
    if any(herm(z, V) == GZERO for V in LINE_V):
        n_rejected += 1
        continue
    jac_pts.append(z)
jacs = [jac_det(z) for z in jac_pts]
check("II3.3 ALGEBRAIC INDEPENDENCE: exact Jacobian det of (F_8, F_12, "
      "F_20, F_24) nonzero at 3 exact random points OFF all mirrors "
      "(%d small integer points rejected ON mirrors -- where Jac = 0 "
      "is FORCED, see II3.5; %.1f s) -> with degrees (8,12,20,24) "
      "Molien-unique and product 46080 = |G31|, Chevalley [cited] "
      "makes them a system of BASIC INVARIANTS of G31: the holomorphic "
      "restriction of the W(E8) ring generates the FULL G31 invariant "
      "ring" % (n_rejected, time.time() - t_j),
      all(j != GZERO for j in jacs))

check("II3.4 degree bookkeeping: sum(d_i - 1) = %d = number of mirror "
      "lines = deg Jac -- the Jacobian has exactly the degree of the "
      "product of the 60 mirror forms"
      % sum(d - 1 for d in DS), sum(d - 1 for d in DS) == 60)

# mirror vanishing: 2 exact in-hyperplane points per line
t_m = time.time()
ok_mirror = True
n_generic_fail = 0
for li, V in enumerate(LINE_V):
    l0 = next(k for k in range(4) if V[k] != GZERO)
    others = [k for k in range(4) if k != l0]
    us = []
    for k in others:
        u = [GZERO] * 4
        u[k] = gconj(V[l0])
        u[l0] = tuple(-x for x in gconj(V[k]))
        us.append(tuple(u))
    got = 0
    tries = 0
    while got < 2 and tries < 30:
        tries += 1
        cs = [grand(rng, 4) for _ in range(3)]
        z = tuple(gadd(gadd(gmul(cs[0], us[0][k]), gmul(cs[1], us[1][k])),
                       gmul(cs[2], us[2][k])) for k in range(4))
        if all(x == GZERO for x in z) or herm(z, V) != GZERO:
            continue
        if any(herm(z, LINE_V[m]) == GZERO
               for m in range(60) if m != li):
            continue
        got += 1
        if jac_det(z) != GZERO:
            ok_mirror = False
    if got < 2:
        n_generic_fail += 1
check("II3.5 MIRROR FACTORIZATION EVIDENCE: Jac = 0 at 2 exact generic "
      "points ON each of the 60 mirror hyperplanes (off all other "
      "mirrors; %.1f s; lines without 2 generic points: %d) and != 0 "
      "off the mirrors (II3.3); full identity Jac = c prod(60 forms) = "
      "standard basic-invariant theorem [cited], symbolic degree-60 "
      "expansion NOT performed (named residual)"
      % (time.time() - t_m, n_generic_fail),
      ok_mirror and n_generic_fail == 0)

# ================================================================== II4
section("II4: must-fail controls")

# (a) an honest negative first: the review's natural candidate -- flip
# the orientation of one mu4 pair (J' = S7 J S7) -- does NOT fire:
# S7 J S7 = J o S67, and the EVEN sign flip S67 lies in W(D8) < W(E8),
# so this J' preserves the roots.  The same argument covers EVERY
# signed-permutation complex structure: compiler compatibility is
# robust across the whole integral orthogonal class.
def J_s7(x):
    y = list(x)
    y[7] = -y[7]
    z = list(J_vec(tuple(y)))
    z[7] = -z[7]
    return tuple(z)


n_s7 = sum(1 for r in RD if J_s7(r) in RSET)
check("II4.0 HONEST NEGATIVE: the pair-orientation flip J' = S7 J S7 "
      "PRESERVES the root set (%d/240: it equals J o S67 with S67 in "
      "W(D8)) -- signed-permutation complex structures cannot break "
      "compiler compatibility; a genuine must-fail control must leave "
      "the integral orthogonal group" % n_s7, n_s7 == 240)


# the firing control: J' = R J R^T with R the exact rational (3,4,5)
# rotation in the (1,2)-coordinate plane -- R crosses the mu4 pairs
# (0,1) and (2,3), is orthogonal but NOT integral.
def R_apply(x, transpose=False):
    c, s = Fr(3, 5), Fr(4, 5)
    y = [Fr(v) for v in x]
    a, b = y[1], y[2]
    if transpose:
        y[1], y[2] = c * a + s * b, -s * a + c * b
    else:
        y[1], y[2] = c * a - s * b, s * a + c * b
    return tuple(y)


def Jp_vec(x):
    return R_apply(J_vec(R_apply(x, transpose=True)))


EBASIS = [tuple(1 if i == j else 0 for i in range(8)) for j in range(8)]
okJp2 = all(Jp_vec(Jp_vec(e)) == tuple(-Fr(v) for v in e) for e in EBASIS)
okJpO = all(sum(a * b for a, b in zip(Jp_vec(u), Jp_vec(v)))
            == sum(Fr(a) * Fr(b) for a, b in zip(u, v))
            for u in EBASIS for v in EBASIS)
n_kept = 0
for r in RD:
    y = Jp_vec(r)
    if all(v.denominator == 1 for v in y) \
            and tuple(int(v) for v in y) in RSET:
        n_kept += 1
check("II4.1 CONTROL SETUP: J' = R J R^T (exact rational rotation "
      "crossing the mu4 pairs) is an orthogonal complex structure "
      "(J'^2 = -1: %s, orthogonal: %s) that does NOT preserve the "
      "root set (%d/240 root images stay roots)"
      % (okJp2, okJpO, n_kept), okJp2 and okJpO and n_kept < 240)


def weights_Jp(r):
    """<alpha, b'_k> with b'_k = R b_k a basis of ker(J' - i):
    <alpha, R b_k> = <R^T alpha, b_k> (exact Fractions)."""
    rr = R_apply(r, transpose=True)
    return ((rr[0], -rr[1]), (rr[2], -rr[3]),
            (rr[4], -rr[5]), (rr[6], -rr[7]))


WP = [weights_Jp(r) for r in RD]
trivial_persist = True
informative_break = {}
for _ in range(3):
    zz = grand_vec(rng)
    fvp = F_vals(zz, (2, 4, 6, 10, 14, 18, 22, 26, 30), weights=WP)
    if any(fvp[d] != GZERO for d in (2, 4, 6, 10)):
        trivial_persist = False
    for d in (14, 18, 22, 26, 30):
        informative_break[d] = informative_break.get(d, False) or (
            fvp[d] != GZERO)
check("II4.2 CONTROL FIRES (J' = R J R^T): the TRIVIAL layers persist "
      "(F'_2 = F'_4 = F'_6 = F'_10 = 0: isotropy + q-powers, honest) "
      "but the informative mu4 half BREAKS: F'_d != 0 for d in "
      "{14,18,22,26,30}: %s -- the vanishing pattern {14,18,30} is a "
      "property of the COMPILER-compatible (root-preserving) complex "
      "structure, not of orthogonal complex structures per se"
      % ({d: informative_break[d] for d in sorted(informative_break)},),
      trivial_persist and all(informative_break.values()))

# (b) J'' = S57 J S57: root-compatible twin (even sign flip in W(E8))
def Jpp_vec(x):
    y = list(x)
    y[5] = -y[5]
    y[7] = -y[7]
    z = J_vec(tuple(y))
    z = list(z)
    z[5] = -z[5]
    z[7] = -z[7]
    return tuple(z)


n_kept2 = sum(1 for r in RD if Jpp_vec(r) in RSET)


def weights_Jpp(r):
    return ((r[0], -r[1]), (r[2], -r[3]), (r[4], r[5]), (r[6], r[7]))


WPP = [weights_Jpp(r) for r in RD]
ok_twin = True
for _ in range(3):
    zz = grand_vec(rng)
    fvt = F_vals(zz, VAN, weights=WPP)
    if any(fvt[d] != GZERO for d in VAN):
        ok_twin = False
check("II4.3 POSITIVE CONTROL (J'' = S57 J S57, EVEN sign flip, "
      "preserves the roots: %d/240): the full vanishing pattern "
      "SURVIVES on ker(J''- i) -- the theorem candidate is about the "
      "W(E8)-conjugacy class of J (compiler compatibility), not one "
      "matrix" % n_kept2, n_kept2 == 240 and ok_twin)

# (c) random non-isotropic 4-space: even F_2 breaks
rngc = random.Random(4711)
Brand = [[grand(rngc, 2) for _ in range(8)] for _ in range(4)]


def weights_rand(r):
    out = []
    for k in range(4):
        acc = GZERO
        for j in range(8):
            acc = gadd(acc, gmul(Brand[k][j], (r[j], 0)))
        out.append(acc)
    return tuple(out)


WR = [weights_rand(r) for r in RD]
zz = grand_vec(rng)
f2r = F_vals(zz, (2,), weights=WR)[2]
check("II4.4 CONTROL FIRES (random 4-space): F_2 = %s != 0 on a random "
      "non-isotropic subspace -- even the first (isotropy) layer needs "
      "an orthogonal complex structure" % (f2r,), f2r != GZERO)

# ================================================================ 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][:3] in ("II1", "II2", "II3", "S0."))
controls = all(ok for n, ok in CHECKS if n.startswith("II4"))
if core and controls:
    print("VERDICT: QUARTIC-HALF-ALIVE -- with the honest split:")
    print("  * vanishing half {2,14,18,30}: TRUE but TRIVIAL (mu4 orbit")
    print("    factor, proven symbolically; holds for 6,10,22,26 too;")
    print("    degree 2/4/6/10 even hold on non-compiler J' via isotropy);")
    print("  * the load-bearing content: F_8|, F_12|, F_20|, F_24| are")
    print("    G31-invariant, algebraically independent (exact Jacobian),")
    print("    degrees Molien-unique, product = |G31| -> a system of")
    print("    BASIC INVARIANTS: the holomorphic restriction of the W(E8)")
    print("    invariant ring generates the FULL G31 invariant ring;")
    print("  * Jacobian carries the 60 mirror lines (point-verified 60/60,")
    print("    full factorization = cited theorem, named residual).")
elif controls:
    print("VERDICT: QUARTIC-HALF-PARTIAL -- controls fire but a core")
    print("check failed; see FAIL lines.")
else:
    print("VERDICT: QUARTIC-HALF-KILLED -- a must-fail control did not")
    print("fire; the pattern is generic, not compiler-specific.")
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)

489c6c034e8a79cbe281dc09cb17d3d84ffe7e3eb46df4b7b92c46d6ccacb324

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.