Follow the source behind the result.

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

"""v514 -- CELEST.WP5E.EPS1.01: WP5e-epsilon-1 of the research contract
CELEST.SEAM.01 -- "the O(-2) bulk-axion slot", executed (verdict B).
Question: build the tower field in the s = 0 slot explicitly (v505 E3: the
BSS axion eta in Omega^{0,1}(Omega^2_cl) is, via Omega-contraction, the
O(-2) slot; H^1(PT, O(-2)) = massless scalar; a0 does NOT fill it), pin
lambda~ = 6 (v495: lambda~^2_{e8} = 36 = h_vee + 6) as a residue with
explicit factor bookkeeping on PT/Z4, and take the first honest
back-reaction step (the Gibbons-Hawking A3 form of the CPS Omega_N
mechanism).  References: Costello arXiv:2111.08879 (box anomaly, GS axion
coupling lambda_g/(8 pi sqrt 3)); Bittleston-Sharma-Skinner
arXiv:2208.12701 (Poisson-CS tower (+)_s O(2s-2)); Costello-Paquette-
Sharma arXiv:2306.00940 (Omega_N backreaction, K = |u|^2 + N log|u|^2,
eq. 3.5/3.33/3.37; level = flux quantum); Gibbons-Hawking (Phys. Lett.
78B, 1978); Hitchin (A-series twistor family XY = Z^4 + ...).  Exact
sympy/Fraction arithmetic throughout, no floats.

[E] S1. THE EQUIVARIANT O(-2) SLOT, EXACT: on PT' = P^3 minus P^1 =
      tot(O(1)+O(1) -> P^1) the pushforward ledger pi_* O(-2) =
      (+)_{p,q>=0} O(-2-p-q) [mu1^p mu2^q] gives per spacetime degree d
      exactly (d+1)^2 twistor classes = the nullspace dimension of the
      wave operator Box = det(d/dx) on degree-d polynomials (exact
      nullspaces 1, 4, 9, 16, 25, 36 for d = 0..5): the Penrose
      accounting closes degree by degree.
[E] S2. EQUIVARIANT DECOMPOSITION: the v492 action acts on the fibre
      coordinates as (mu1, mu2) -> (i mu1, i^-1 mu2); the incidence
      relation forces column weights (+1, +1, -1, -1) on x, and the
      equivariant bookkeeping closes BLOCK BY BLOCK (all d <= 6, all 4
      characters).  Character series P_0 = 1 + 3t^2 + 15t^4 + 21t^6 +
      45t^8 + ..., P_1 = P_3 = 2t + 8t^3 + 18t^5 + ..., P_2 = 6t^2 +
      10t^4 + 28t^6 + ...; the d = 0 slot has multiplicity (1, 0, 0, 0)
      -- THE BULK AXION SURVIVES THE PROJECTION (density 1/|Z4|).
      Molien invariant ring = (1 - t^8)/((1 - t^4)^2 (1 - t^2)):
      Z in O(2), X, Y in O(4), one relation in degree 8 = the a0 weight
      (the v492/v493 bridge).  E3 BIJECTION SHARPENED: the twisted
      characters {i, -1, -i} appear with minimal content (2t, 6t^2, 2t)
      and NO degree-0 mode = the Coxeter eigenvalues on H^2(ALE),
      det(A - 1) = -4.  GRAVITON CONTROL: the O(+2) slot starts
      invariant only at fibre degree 4 with multiplicity 3 = {X, Z^2, Y}
      (the cohomological form of v505 X = -2 != +2 = Y).
[E] S3. LAMBDA~ = 6 TRIPLY PINNED: (1) OKUBO: Tr_adj X^4 = 36 <x,x>^2 =
      (6 <x,x>)^2 on the 240 glue roots, 36 = h_vee + 6, lambda~ = 6 =
      |Z2| N_fam; (2) MEASURE CANCELLATION: mu = 1/4 enters three times
      (vertex^2 mu^2, propagator 1/mu, anomaly mu) and cancels EXACTLY
      -- lambda~_eff^2 = 36 for ARBITRARY mu; wrong bookings quantified
      and excluded: anomaly-only => lambda~ = 3, missing propagator
      renormalisation => lambda~ = 12; (3) FLUX: minimal CPS quantum
      N = 1, a single exchange channel exactly at k = 1 (#primaries),
      (kappa/c3)^2 = 36/3 = 12 exact.
[E] S4. GH/A3 BACK-REACTION BUILDING BLOCK: invariant four-centre
      configurations = exactly 2 branches (axis^4 or ONE free mu4
      orbit); free orbit => prod(Z - i^p z0) = Z^4 - z0^4 => XY = Z^4 +
      a0 with a0 = -z0^4 (the v493 family RE-DERIVED from the
      geometry); monodromy a0 -> e^{2 pi i} a0 = one clock step; the
      charge-k GH point is EXACTLY R^4/Z_k (k = 4 => seam boundary
      S^3/Z4); periods int omega = 4 pi (x_q - x_p), free orbit:
      Pi_j = 4 pi t0 (i-1)(1, i, i^2), |Pi_j| equal (LOCKSTEP,
      counter-check of v509); the Coxeter clock FROM THE GEOMETRY
      (A^4 = 1, det(A - 1) = -4, Pi . A = i Pi); the CPS "N log"
      analogue = source charge 4 = |mu4| (flux -4 pi per centre);
      HONEST SHARPENING: for the Ricci-flat ALE the asymptotic log
      coefficient is exactly 0 (EH: u K' = sqrt(u^2 + a^4), det g = 1)
      -- the log lives at the exceptional locus; Burns contrast
      (K = u + N log u => det g != 1, only scalar-flat); bonus:
      multipole selection rule m = 0 mod 4, the first symmetry-breaking
      multipole (4, +-4) carries -a0 with amplitude (35/16) sin^4 th.
[E] S5. NEGATIVE CONTROLS: so8 (lambda~^2 = 12 irrational; perfect
      squares in the Deligne series only {9, 36} = {sl3, e8});
      diag(i, i) (Veronese, 5 generators, no hypersurface, the
      bijection collapses); k = 2 (three channels; honest: lambda~^2 =
      36 is k-independent, the kill is the closure dial).
[C] Conditional on Costello's flat-PT matching lambda_g^2 E = A (the
      measure chain is CLASSICAL bookkeeping).
[O] O-FENCE: the quantised BCOV one-loop coefficient on PT/Z4; the
      twisted channels (32 T3) are not covered by the bulk axion.
      M1-M3 preregistered VERBATIM:
      M1 [THE A3 OMEGA_N] compute the A3 analogue of CPS eq. 3.5 on
      PT/Z4: the Beltrami/Kodaira-Spencer deformation sourced by the
      glue currents wrapping the three lockstep spheres.  SUCCESS: a
      closed-form Omega-deformation whose S^3/Z4 periods are
      (2 pi i)^2 x (integer flux vector) reproducing the lockstep phase
      structure (i-1)(1, i, i^2).  KILL: if the sourced deformation
      forces UNEQUAL sphere fluxes or a non-integer period, the CPS
      transplant (and the eps2 level dial v509) dies.
      M2 [TWISTED KS MEASURE] quantise the O(-2) tower on PT/Z4 using
      the eps1 mode ledger (P_m series) and compute the one-loop box
      coefficient PER SECTOR.  SUCCESS: the bulk sector reproduces
      lambda~^2 = 36 with the eps1 measure bookkeeping AND the twisted
      sectors pair with the three sphere axions cancelling the rigid
      32 T3 residual (v505 S3.7).  KILL: a leftover independent quartic
      (T3-type) in ANY sector after all four axions are included.
      M3 [THE a0 UPLIFT] uplift the (l, m) = (4, +-4) GH multipole
      (= the a0 direction) to the Beltrami differential on PT/Z4 and
      compute the induced Kahler-potential correction.  SUCCESS: a
      log-type correction whose coefficient is tied to the source
      charge 4 = |mu4| (matching the V-ledger).  KILL: coefficient
      decoupled from the centre count.

Status: [E] exact slot/residue/GH arithmetic (sympy + Fraction); [C]
Costello's flat-PT matching; [O] the quantised BCOV coefficient on
PT/Z4 and the twisted channels (M1-M3).  Python; Wolfram-mirrored
(Penrose ledger blocks, character series, Molien hypersurface, triple
lambda~ pinning incl. exclusions 3/12, GH centre dichotomy, period
lockstep, multipole selection rule), counted per GATE.WOLFRAM.02.
Discovery provenance: experiments/tfpt-discovery/
celestial_seam_wp5e_eps1_o2_bulk_axion_probe.py (2026-07-22, 20/20) +
celestial_seam_wp5e_eps1_gh_a3_backreaction_probe.py (2026-07-22,
14/14).
"""
from collections import Counter
from fractions import Fraction as F
from itertools import combinations, combinations_with_replacement, product
from math import factorial

import sympy as sp

from tfpt_constants import check, summary, reset, g_car, N_fam, rankE8

MU4 = N_fam + 1             # 4 = |mu4|, the seam clock order
RANK = rankE8               # 8
H_VEE = 2 * N_fam * g_car   # 30 = |Z2| N_fam g_car (v495 anchor decomposition)
HALF = F(1, 2)


def fmt(xs):
    return "(" + ", ".join(str(x) for x in xs) + ")"


# ---------------------------------------------------------------------------
# combinatorial helpers (equivariant Penrose ledger)
# ---------------------------------------------------------------------------
def exp_tuples(nv, d):
    if nv == 1:
        return [(d,)]
    out = []
    for k in range(d + 1):
        for rest in exp_tuples(nv - 1, d - k):
            out.append((k,) + rest)
    return out


def tw_block_count(d, m):
    """# of fibre blocks (p, q), p+q = d, with Z4 character p - q = m mod 4
    for the SU(2) action (mu1, mu2) -> (i mu1, i^-1 mu2)."""
    return len([p for p in range(d + 1) if (2 * p - d) % 4 == m])


def box_kernel_by_char(d):
    """kernel of Box = d_a d_e - d_b d_c on degree-d polynomials in
    (a, b, c, e) = the columns of x^{alpha alphadot}, split by Z4 character
    (n_a + n_b - n_c - n_e mod 4); returns {m: dim}."""
    srcs = exp_tuples(4, d)

    def char(ex):
        return (ex[0] + ex[1] - ex[2] - ex[3]) % 4

    out = {}
    for m in range(4):
        cols = [ex for ex in srcs if char(ex) == m]
        if d < 2:
            out[m] = len(cols)
            continue
        tgts = [ex for ex in exp_tuples(4, d - 2) if char(ex) == m]
        tix = {ex: i for i, ex in enumerate(tgts)}
        M = sp.zeros(len(tgts), len(cols))
        for j, ex in enumerate(cols):
            na, nb, nc, ne = ex
            if na >= 1 and ne >= 1:
                M[tix[(na - 1, nb, nc, ne - 1)], j] += na * ne
            if nb >= 1 and nc >= 1:
                M[tix[(na, nb - 1, nc - 1, ne)], j] -= nb * nc
        out[m] = len(cols) - (M.rank() if tgts else 0)
    return out


# ---------------------------------------------------------------------------
# exact multivariate polynomial machinery (v495/v509 style: dict of Fractions)
# ---------------------------------------------------------------------------
def dot(u, v):
    return sum(x * y for x, y in zip(u, v))


def multinom(combo, p):
    c = Counter(combo)
    r = factorial(p)
    for v in c.values():
        r //= factorial(v)
    return r


def add_pow(out, a, p):
    idxs = [j for j in range(len(a)) if a[j] != 0]
    for combo in combinations_with_replacement(idxs, p):
        coef = F(multinom(combo, p))
        for j in combo:
            coef *= a[j]
        out[combo] = out.get(combo, F(0)) + coef


def poly_square(K):
    out = {}
    items = list(K.items())
    for i in range(len(items)):
        k1, c1 = items[i]
        key = tuple(sorted(k1 + k1))
        out[key] = out.get(key, F(0)) + c1 * c1
        for j in range(i + 1, len(items)):
            k2, c2 = items[j]
            key = tuple(sorted(k1 + k2))
            out[key] = out.get(key, F(0)) + 2 * c1 * c2
    return out


def poly_eq_scaled(P, Q, num, den):
    keys = set(P) | set(Q)
    return all(den * P.get(k, F(0)) == num * Q.get(k, F(0)) for k in keys)


def power_sums(vectors, basis):
    K, Q = {}, {}
    for v in vectors:
        a = [F(dot(v, b)) for b in basis]
        add_pow(K, a, 2)
        add_pow(Q, a, 4)
    return K, Q


def gram_quad(basis):
    out = {}
    m = len(basis)
    for j in range(m):
        for k in range(j, m):
            g = F(dot(basis[j], basis[k]))
            if g:
                out[(j, k)] = out.get((j, k), F(0)) + g * (1 if j == k else 2)
    return out


# ---------------------------------------------------------------------------
# E8 roots in D5 (+) A3 glue coordinates (v128/v492/v495/v505 construction)
# ---------------------------------------------------------------------------
def build_glue_roots():
    d5_roots, d5_v = [], []
    for i, j in combinations(range(5), 2):
        for si in (1, -1):
            for sj in (1, -1):
                v = [F(0)] * 5
                v[i], v[j] = F(si), F(sj)
                d5_roots.append(tuple(v))
    for i in range(5):
        for s in (1, -1):
            v = [F(0)] * 5
            v[i] = F(s)
            d5_v.append(tuple(v))
    d5_s, d5_c = [], []
    for signs in product((1, -1), repeat=5):
        v = tuple(HALF * s for s in signs)
        (d5_s if signs.count(-1) % 2 == 0 else d5_c).append(v)
    a3_roots = []
    for i in range(4):
        for j in range(4):
            if i != j:
                v = [F(0)] * 4
                v[i], v[j] = F(1), F(-1)
                a3_roots.append(tuple(v))

    def wclass(k):
        out = []
        for sub in combinations(range(4), k):
            v = [F(-k, 4)] * 4
            for i in sub:
                v[i] += 1
            out.append(tuple(v))
        return out

    z5, z4 = tuple([F(0)] * 5), tuple([F(0)] * 4)
    roots = {}
    for r in d5_roots:
        roots[r + z4] = 0
    for r in a3_roots:
        roots[z5 + r] = 0
    for d in d5_s:
        for w in wclass(1):
            roots[d + w] = 1
    for d in d5_v:
        for w in wclass(2):
            roots[d + w] = 2
    for d in d5_c:
        for w in wclass(3):
            roots[d + w] = 3
    return roots


def e8_basis():
    basis = []
    for i in range(5):
        v = [F(0)] * 9
        v[i] = F(1)
        basis.append(tuple(v))
    for i in range(3):
        v = [F(0)] * 9
        v[5 + i], v[6 + i] = F(1), F(-1)
        basis.append(tuple(v))
    return basis


def roots_so8():
    out = []
    for i, j in combinations(range(4), 2):
        for si in (1, -1):
            for sj in (1, -1):
                v = [0] * 4
                v[i], v[j] = si, sj
                out.append(tuple(v))
    return out


# ---------------------------------------------------------------------------
# S1 -- the slot on PT': pushforward ledger + Penrose accounting
# ---------------------------------------------------------------------------
def section1():
    print("  -- S1: the O(-2) slot on PT' = tot(O(1)+O(1) -> P^1), exact")

    cech = {n: [(a, n - a) for a in range(1, n)] for n in range(2, 9)}
    check("S1.1 [CECH BASIS] H^1(P^1, O(-n)) has basis la0^-a la1^-b, "
          "a, b >= 1, a + b = n: dims %s = n - 1 for n = 2..8; the "
          "pushforward ledger pi_* O(-2) = (+)_{p,q>=0} O(-2-p-q) "
          "[mu1^p mu2^q] gives block dims p + q + 1"
          % fmt(len(cech[n]) for n in range(2, 9)),
          all(len(cech[n]) == n - 1 for n in range(2, 9)))

    ok_sq = all(sum(d + 1 for p in range(d + 1)) == (d + 1) ** 2
                for d in range(11))
    check("S1.2 [UNTWISTED PENROSE COUNT] per spacetime degree d: "
          "sum_{p+q=d} dim H^1(P^1, O(-2-d)) = (d+1)*(d+1) = (d+1)^2 for "
          "d = 0..10 -- the massless-scalar mode count, degree by degree",
          ok_sq)

    dims_box = {d: sum(box_kernel_by_char(d).values()) for d in range(6)}
    check("S1.3 [SPACETIME SIDE] ker(Box = d_a d_e - d_b d_c) on degree-d "
          "polynomials in the four matrix entries of x: dims %s = (d+1)^2 "
          "for d = 0..5 (exact nullspaces): H^1(PT', O(-2)) = massless "
          "scalar, the Penrose accounting closes EXACTLY"
          % str(dims_box),
          all(dims_box[d] == (d + 1) ** 2 for d in range(6)))


# ---------------------------------------------------------------------------
# S2 -- the equivariant decomposition under the v492 Z4 action
# ---------------------------------------------------------------------------
def section2():
    print("  -- S2: equivariant H^1(O(-2)) under (mu1, mu2) -> "
          "(i mu1, i^-1 mu2)")
    I = sp.I
    t = sp.symbols('t')

    Hdef = {j: sp.cancel(sp.expand(
        (1 - t ** 2) / ((1 - I ** j * t) ** 2 * (1 - I ** (-j) * t) ** 2)))
        for j in range(4)}
    Hclosed = {0: (1 + t) / (1 - t) ** 3,
               1: (1 - t ** 2) / (1 + t ** 2) ** 2,
               2: (1 - t) / (1 + t) ** 3,
               3: (1 - t ** 2) / (1 + t ** 2) ** 2}
    ok_closed = all(sp.cancel(Hdef[j] - Hclosed[j]) == 0 for j in range(4))
    chis = {}
    ok_series = True
    for j in range(4):
        ser = sp.series(Hclosed[j], t, 0, 9).removeO()
        for d in range(9):
            chi = sp.expand(sum(I ** (j * (2 * p - d)) * (d + 1)
                                for p in range(d + 1)))
            chis[(d, j)] = chi
            ok_series &= sp.expand(ser.coeff(t, d) - chi) == 0
    check("S2.1 [CHARACTER SERIES, TWO ROUTES] H(t, g_j) = (1 - t^2)/"
          "((1 - i^j t)^2 (1 - i^-j t)^2) = closed forms ((1+t)/(1-t)^3, "
          "(1-t^2)/(1+t^2)^2, (1-t)/(1+t)^3, (1-t^2)/(1+t^2)^2) and the "
          "brute-force block sums agree to O(t^8); e.g. chi_2(g_1) = %s, "
          "chi_4(g_1) = %s" % (chis[(2, 1)], chis[(4, 1)]),
          ok_closed and ok_series
          and chis[(2, 1)] == -3 and chis[(4, 1)] == 5)

    ok_equiv = True
    tab = {}
    for d in range(7):
        ker = box_kernel_by_char(d)
        for m in range(4):
            twp = (d + 1) * tw_block_count(d, m)
            tab[(d, m)] = (twp, ker[m])
            ok_equiv &= twp == ker[m]
    print("     equivariant ledger (d, m) -> (twistor, spacetime): "
          + str({k: tab[k] for k in tab if tab[k][0] != 0}))
    check("S2.2 [EQUIVARIANT PENROSE LEDGER] the incidence mu^ad = "
          "x^{a ad} la_a forces column weights (+1, +1, -1, -1) on x; "
          "the per-character wave-operator kernels EQUAL the twistor "
          "block counts (d+1) * #{(p,q): p+q = d, p-q = m mod 4} for "
          "ALL d = 0..6 and ALL m: the equivariant Penrose accounting "
          "closes block by block", ok_equiv)

    P = {m: sp.cancel(sp.Rational(1, 4) * sum(
        I ** (-j * m) * Hclosed[j] for j in range(4))) for m in range(4)}
    ser = {m: sp.series(P[m], t, 0, 9).removeO() for m in range(4)}
    exp_ser = {0: {0: 1, 2: 3, 4: 15, 6: 21, 8: 45},
               1: {1: 2, 3: 8, 5: 18, 7: 32},
               2: {2: 6, 4: 10, 6: 28, 8: 36},
               3: {1: 2, 3: 8, 5: 18, 7: 32}}
    ok_P = all(sp.expand(ser[m].coeff(t, d)
                         - exp_ser[m].get(d, 0)) == 0
               for m in range(4) for d in range(9))
    print("     P_0 = 1 + 3t^2 + 15t^4 + 21t^6 + 45t^8 + ...")
    print("     P_1 = P_3 = 2t + 8t^3 + 18t^5 + 32t^7 + ...")
    print("     P_2 = 6t^2 + 10t^4 + 28t^6 + 36t^8 + ...")
    dens0 = sp.limit((1 - t) ** 3 * P[0], t, 1)
    densH = sp.limit((1 - t) ** 3 * Hclosed[0], t, 1)
    check("S2.3 [THE BULK AXION SURVIVES] per-character series P_m(t) as "
          "printed (all coefficients verified to t^8); the d = 0 slot has "
          "multiplicity (1, 0, 0, 0): the unique constant mode of the "
          "s = 0 tower field is CLOCK-INVARIANT and survives the Z4 "
          "projection = the bulk axion; invariant mode density "
          "lim (1-t)^3 P_0 = %s = (1/|Z4|) lim (1-t)^3 H_0 = %s/4"
          % (dens0, densH),
          ok_P and ser[0].coeff(t, 0) == 1
          and all(ser[m].coeff(t, 0) == 0 for m in (1, 2, 3))
          and dens0 == sp.Rational(1, 2) and densH == 2)

    Mol = sp.cancel(sp.Rational(1, 4) * sum(
        1 / ((1 - I ** j * t) * (1 - I ** (-j) * t)) for j in range(4)))
    hyp = (1 - t ** 8) / ((1 - t ** 4) ** 2 * (1 - t ** 2))
    inv_counts = {d: len([p for p in range(d + 1) if (2 * p - d) % 4 == 0])
                  for d in (2, 4)}
    check("S2.4 [INVARIANT RING = v492 HYPERSURFACE] Molien series "
          "(1/4) sum_j 1/((1-i^j t)(1-i^-j t)) = (1 - t^8)/((1 - t^4)^2 "
          "(1 - t^2)) EXACTLY: generators Z = mu1 mu2 (degree 2, O(2)), "
          "X = mu1^4, Y = mu2^4 (degree 4, O(4)), one relation XY = Z^4 in "
          "degree 8 = the a0 weight O(8) (v492/v493/v505 bridge); slice "
          "counts: degree 2: %d invariant (Z), degree 4: %d (X, Z^2, Y)"
          % (inv_counts[2], inv_counts[4]),
          sp.cancel(Mol - hyp) == 0
          and inv_counts == {2: 1, 4: 3})

    A = sp.Matrix([[0, 0, -1], [1, 0, -1], [0, 1, -1]])
    eigs = set(A.eigenvals().keys())
    minimal = (ser[1].coeff(t, 1), ser[2].coeff(t, 2), ser[3].coeff(t, 1))
    check("S2.5 [E3 BIJECTION SHARPENED] the twisted characters i, -1, -i "
          "(m = 1, 2, 3) all appear in H^1(O(-2)) with minimal content "
          "(2t, 6t^2, 2t) (modes mu1, {mu1^2, mu2^2}, mu2) and NO degree-0 "
          "mode; the Coxeter clock A on H^2(ALE) has eigenvalues %s = "
          "exactly these characters and det(A - 1) = %s = -4 (no invariant "
          "sphere class): the three sphere 2-forms fill the three TWISTED "
          "slots, the invariant tower is the bulk axion -- slot count "
          "1 + 3 = 4 = |mu4| now per-character (v505 S5.8/S5.9 sharpened)"
          % (sorted(eigs, key=str), (A - sp.eye(3)).det()),
          eigs == {sp.I, -1, -sp.I} and (A - sp.eye(3)).det() == -4
          and minimal == (2, 6, 2)
          and all(ser[m].coeff(t, 0) == 0 for m in (1, 2, 3)))

    grav = {}
    for d in range(7):
        for m in range(4):
            grav[(d, m)] = (d - 3) * tw_block_count(d, m) if d >= 4 else 0
    inv_start = min(d for d in range(7) if grav[(d, 0)] > 0)
    check("S2.6 [GRAVITON CONTROL O(+2)] H^1(PT', O(2)) = (+) H^1(P^1, "
          "O(2-p-q)): invariant part starts at fibre degree %d with "
          "multiplicity %d = the three blocks mu1^4, mu1^2 mu2^2, mu2^4 = "
          "the X, Z^2, Y directions (the a0 deformation family), while the "
          "axion slot O(-2) starts at degree 0: the cohomological form of "
          "the v505 weight verdict X = -2 != +2 = Y (a0 is the graviton "
          "modulus, the s = 0 slot is a DIFFERENT field)"
          % (inv_start, grav[(4, 0)]),
          inv_start == 4 and grav[(4, 0)] == 3 and grav[(4, 2)] == 2
          and all(grav[(d, m)] == 0 for d in range(4) for m in range(4)))
    return ser


# ---------------------------------------------------------------------------
# S3 -- lambda~ = 6 as a residue: Okubo / measure / flux bookkeeping
# ---------------------------------------------------------------------------
def section3():
    print("  -- S3: lambda~ = 6 as a residue -- explicit factor bookkeeping")

    roots = build_glue_roots()
    counts = [sum(1 for c in roots.values() if c == m) for m in range(4)]
    norm_ok = all(sum(x * x for x in r) == 2 for r in roots)
    check("S3.1 [GLUE ROOTS] 240 roots, all norm 2, class split %s = "
          "(52, 64, 60, 64) (v492/v505 replication)" % counts,
          len(roots) == 240 and norm_ok and counts == [52, 64, 60, 64])

    basis = e8_basis()
    G = gram_quad(basis)
    K, Q = power_sums(list(roots.keys()), basis)
    check("S3.2 [KILLING ANCHOR] Tr_adj X^2 = sum_roots <alpha,x>^2 = "
          "60 <x,x> = 2 h_vee <x,x> as an exact polynomial identity: the "
          "unit-trace normalisation tr~ X^2 = <x,x> is pinned "
          "(theta^2 = 2)",
          poly_eq_scaled(K, G, 60, 1))

    G2 = poly_square(G)
    lam2_conv = F(10 * H_VEE * H_VEE, 248 + 2)
    check("S3.3 [OKUBO RESIDUE] Tr_adj X^4 = 36 <x,x>^2 = (6 <x,x>)^2 as "
          "an exact polynomial identity on the 240 glue roots: the box "
          "anomaly is the PERFECT SQUARE of 6 <x,x> -- the residue on the "
          "single axion channel is lambda~ = 6 = |Z2| N_fam; conventions: "
          "lambda~^2 = 10 h_vee^2/(dim+2) = %s = h_vee + 6 = 36 (v495)"
          % lam2_conv,
          poly_eq_scaled(Q, G2, 36, 1)
          and lam2_conv == 36 and lam2_conv == H_VEE + 6
          and 6 == 2 * N_fam)

    mu, le2, Gp, vv = sp.symbols('mu lam_eff2 G v', positive=True)
    LAM2 = 36
    sol_ok = sp.solve(sp.Eq(le2 * (mu * vv) ** 2 * (Gp / mu),
                            mu * LAM2 * vv ** 2 * Gp), le2)
    sol_anom = sp.solve(sp.Eq(le2 * vv ** 2 * Gp,
                              mu * LAM2 * vv ** 2 * Gp), le2)
    sol_prop = sp.solve(sp.Eq(le2 * (mu * vv) ** 2 * Gp,
                              mu * LAM2 * vv ** 2 * Gp), le2)
    v_anom = sol_anom[0].subs(mu, sp.Rational(1, 4))
    v_prop = sol_prop[0].subs(mu, sp.Rational(1, 4))
    print("     factor table (mu = 1/|Z4| = 1/4): vertex measure mu (each "
          "of 2), invariant-mode propagator 1/mu, anomaly measure mu")
    check("S3.4 [MEASURE BOOKKEEPING EXACT] GS matching on the quotient: "
          "lam_eff^2 (mu v)^2 (G/mu) = mu 36 v^2 G  =>  lam_eff^2 = %s "
          "for ARBITRARY mu: the three 1/4 factors (vertex^2 = mu^2, "
          "propagator = 1/mu, anomaly = mu) cancel EXACTLY and "
          "lambda~_eff(PT/Z4) = 6; WRONG bookings quantified: anomaly-only "
          "reduction gives lam_eff^2 = %s = 9 (lambda~ = 3 = N_fam), "
          "missing propagator renormalisation gives lam_eff^2 = %s = 144 "
          "(lambda~ = 12 = |mu4| N_fam) -- both EXCLUDED by the ledger"
          % (sol_ok[0], v_anom, v_prop),
          sol_ok == [36] and v_anom == 9 and v_prop == 144
          and sp.sqrt(v_anom) == N_fam
          and sp.sqrt(v_prop) == MU4 * N_fam)

    marks = (2, 3, 4, 6, 5, 4, 3, 2)
    nprim = {}
    for k in range(1, 5):
        cnt = 0
        for a in product(*[range(k // m + 1) for m in marks]):
            if sum(x * m for x, m in zip(a, marks)) <= k:
                cnt += 1
        nprim[k] = cnt
    ratio2 = F(36, 3)
    check("S3.5 [FLUX NORMALISATION] minimal CPS quantum N = 1 (v509); "
          "#primaries((E8)_k) = %s: a SINGLE exchange channel iff k = 1 "
          "(the residue lands on one axion); (kappa/c3)^2 = 36/3 = %s = "
          "|mu4| N_fam exact, kappa/c3 = 2 sqrt 3 irrational (v495); the "
          "sqrt 3 is the anomaly's own: sqrt 48 = 4 sqrt 3 with 48 = 2*4! "
          "(box symmetry factor); the 8 pi = 1/c3 stays convention-typed "
          "[C]" % (str(nprim), ratio2),
          nprim == {1: 1, 2: 3, 3: 5, 4: 10}
          and ratio2 == 12 and 12 == MU4 * N_fam
          and sp.sqrt(12).is_rational is False
          and 48 == 2 * factorial(4)
          and sp.sqrt(48) == 4 * sp.sqrt(3))

    check("S3.6 [HONEST GAPS -- what eps1 does NOT close] (a) the BCOV "
          "one-loop coefficient on PT/Z4 (the quantum kinetic term of the "
          "O(-2) tower field, 4th-order operator + twisted KS measure) is "
          "NOT computed: the measure chain is CLASSICAL bookkeeping, "
          "conditional on Costello's flat-PT matching lambda_g^2 E = A; "
          "(b) the twisted channels are NOT covered: the AB ledger leaves "
          "the rigid 32 T3 residual (v505 S3.7) and the graded exchange is "
          "rank-obstructed (v505 S3.9) -- the three sphere axions must "
          "carry it (M1-M3 territory); (c) 'invariant H^1 tower = "
          "dynamical axion' is a slot + measure statement, not yet a "
          "quantised field", True)


# ---------------------------------------------------------------------------
# S4 -- GH/A3: clock-invariant centre configurations
# ---------------------------------------------------------------------------
def section4():
    print("  -- S4: clock-invariant four-centre configurations on C x R "
          "(GH/A3)")
    I = sp.I
    z = sp.symbols('z')

    fixed_ok = all(sp.solve(sp.Eq(I ** j * z, z), z) == [0]
                   for j in (1, 2, 3))
    # orbit-size partitions of 4 with parts in {1, 4}: (n1, n4)
    parts = []
    for n4 in range(2):
        n1 = 4 - 4 * n4
        if n1 >= 0:
            parts.append((n1, n4))
    check("S4.1 [ORBIT CLASSIFICATION] i^j z = z forces z = 0 (j = 1, 2, "
          "3): mu4 orbit sizes on C x R are {1 (axis), 4 (free)}; a "
          "clock-invariant 4-centre set is 4 = 1+1+1+1 (four AXIS points, "
          "pointwise fixed: pure RESOLUTION branch) or 4 = 4 (ONE free "
          "orbit at a common height: pure DEFORMATION branch) -- exactly "
          "%d branches; heights are untouched by (z, h) -> (iz, h), so a "
          "free orbit has ONE common height (translate to 0)"
          % len(parts),
          fixed_ok and parts == [(4, 0), (0, 1)])

    z0, Z = sp.symbols('z0 Z')
    prod4 = sp.expand(sp.prod([Z - I ** p * z0 for p in range(4)]))
    a0 = -z0 ** 4
    Zs, b0, b1, b2, b3 = sp.symbols('Zs b0 b1 b2 b3')
    Pgen = Zs ** 4 + b3 * Zs ** 3 + b2 * Zs ** 2 + b1 * Zs + b0
    diff = sp.expand(Pgen.subs(Zs, I * Zs) - Pgen)
    sol = sp.solve([diff.coeff(Zs, n) for n in range(4)], [b3, b2, b1],
                   dict=True)
    check("S4.2 [v493 FAMILY FROM CENTRES] prod_p (Z - i^p z0) = %s = "
          "Z^4 - z0^4 EXACTLY (e1 = e2 = e3 = 0): the deformation branch "
          "is XY = Z^4 + a0 with a0 = -z0^4 -- the v493 clock-invariant "
          "family; independent route: P(iZ) = P(Z) forces b3 = b2 = b1 = "
          "0 (unique solution %s, v493 S1 replicated)"
          % (prod4, sol),
          sp.expand(prod4 - (Z ** 4 - z0 ** 4)) == 0
          and sol == [{b3: 0, b2: 0, b1: 0}])

    s = sp.symbols('s', real=True)
    z0s = z0 * sp.exp(I * sp.pi * s / 2)
    a0s = sp.simplify(-z0s ** 4)
    shifted = {sp.simplify(I ** (p + 1) * z0) for p in range(4)}
    orbit = {sp.simplify(I ** p * z0) for p in range(4)}
    check("S4.3 [MONODROMY = ONE CLOCK STEP] along a0(s) = e^{2 pi i s} "
          "a0 the orbit parameter moves as z0(s) = e^{i pi s/2} z0 "
          "(check: -z0(s)^4 = e^{2 pi i s} a0: %s); at s = 1: z0 -> i z0 "
          "and the centre SET is invariant under the cyclic shift "
          "(i * orbit = orbit: %s) -- the a0 monodromy is one mu4 clock "
          "step permuting the four centres (v509 S4.3 in GH clothes)"
          % (sp.simplify(a0s - sp.exp(2 * sp.pi * I * s) * a0) == 0,
             shifted == orbit),
          sp.simplify(a0s - sp.exp(2 * sp.pi * I * s) * a0) == 0
          and shifted == orbit)


# ---------------------------------------------------------------------------
# S5 -- GH form, periods, and the Coxeter clock
# ---------------------------------------------------------------------------
def section5():
    print("  -- S5: Gibbons-Hawking form -- boundary, periods, Coxeter "
          "clock")
    I = sp.I
    r, R, th, ph, tau, k = sp.symbols('r R theta phi tau k', positive=True)

    # charge-k GH point: V = k/r, A = -k cos(th) dphi, tau period 4 pi
    V = k / r
    rsub = R ** 2 / (4 * k)
    drdR = sp.diff(rsub, R)
    g_RR = sp.simplify((V * drdR ** 2).subs(r, rsub))
    g_ang = sp.simplify((V * r ** 2).subs(r, rsub))
    g_fib = sp.simplify((1 / V).subs(r, rsub))
    # monopole equation dA = -*dV in flat spherical coords
    dA_coeff = sp.diff(-k * sp.cos(th), th)              # dA = k sin dth^dph
    star_dV = sp.simplify(-r ** 2 * sp.diff(V, r) * sp.sin(th))
    check("S5.1 [GH POINT = FLAT CONE, EXACT] V = k/r with r = R^2/(4k): "
          "V dr^2 = %s dR^2, V r^2 = %s = R^2/4, V^-1 (dtau - k cos th "
          "dph)^2 = (R^2/4)(dpsi - cos th dph)^2 with psi = tau/k of "
          "period 4 pi / k: the charge-k GH point is EXACTLY the cone "
          "R^4/Z_k (k = 1: flat R^4, Hopf S^3); k = 4: seam boundary "
          "S^3/Z4, deck order 4 = |mu4|; monopole equation dA = -*dV: "
          "k sin th = %s exact"
          % (g_RR, sp.simplify(g_ang / R ** 2 * 4), star_dV),
          g_RR == 1 and sp.simplify(g_ang - R ** 2 / 4) == 0
          and sp.simplify(g_fib - R ** 2 / (4 * k ** 2)) == 0
          and sp.simplify(dA_coeff - star_dV) == 0
          and sp.simplify(star_dV - k * sp.sin(th)) == 0)

    # period pullback on the fibred segment, generic A, V, convention cV
    sv = sp.symbols('s', real=True)
    d1, d2, d3, cV = sp.symbols('Delta1 Delta2 Delta3 c_V')
    A1, A2, A3f, Vf = (sp.Function(n)(sv) for n in ('A1', 'A2', 'A3', 'V'))
    dx = (d1, d2, d3)                      # dx_i = Delta_i ds on the segment

    def one_form(coef_ds, coef_dtau):
        return (coef_ds, coef_dtau)

    def wedge(u, v):
        # coefficient of ds ^ dtau
        return sp.expand(u[0] * v[1] - u[1] * v[0])

    dtauA = one_form(A1 * dx[0] + A2 * dx[1] + A3f * dx[2], 1)
    periods = []
    for i in range(3):
        w_conn = wedge(dtauA, one_form(dx[i], 0))          # (dtau+A)^dx_i
        j, l = [(1, 2), (2, 0), (0, 1)][i]
        w_V = cV * Vf * wedge(one_form(dx[j], 0), one_form(dx[l], 0))
        coeff = sp.simplify(-(w_conn + w_V))               # dtau ^ ds orient.
        periods.append(sp.integrate(sp.integrate(coeff, (sv, 0, 1)),
                                    (tau, 0, 4 * sp.pi)) / (4 * sp.pi))
    check("S5.2 [PERIOD FORMULA, GENERIC] pullback of omega_i = (dtau + "
          "A) ^ dx_i - c_V V eps_ijk dx_j ^ dx_k to the fibred segment: "
          "the V-term and ALL A-terms vanish IDENTICALLY (1-dim base "
          "path), leaving int_{Sigma_pq} omega_vec = 4 pi (x_q - x_p): "
          "periods/4pi = %s = (Delta1, Delta2, Delta3) for GENERIC "
          "functions A_k(s), V(s) and ANY convention factor c_V"
          % fmt(periods),
          periods == [d1, d2, d3])

    t0 = sp.symbols('t0', positive=True)
    centres = [I ** p * t0 for p in range(4)]
    Pi = [sp.simplify(4 * sp.pi * (centres[j + 1] - centres[j]))
          for j in range(3)]
    Pi_target = [sp.simplify(4 * sp.pi * t0 * (I - 1) * I ** j)
                 for j in range(3)]
    mods = [sp.simplify(sp.Abs(p)) for p in Pi]
    check("S5.3 [LOCKSTEP FROM GEOMETRY] free-orbit config (centres i^p "
          "t0, heights 0): holomorphic periods Pi_j = 4 pi t0 (i-1)(1, i, "
          "i^2) (exact match %s), |Pi_j| = %s = 4 sqrt(2) pi t0 EQUAL on "
          "all three spheres (v509 S4.2 counter-check from GH geometry); "
          "omega_I (Kahler) periods = 4 pi * (height differences) = "
          "(0, 0, 0): the invariant free-orbit branch is the PURE "
          "DEFORMATION; the axis branch has holomorphic periods 0 and "
          "free Kahler periods 4 pi Delta h: the exact dichotomy"
          % (all(sp.simplify(Pi[j] - Pi_target[j]) == 0 for j in range(3)),
             fmt(mods)),
          all(sp.simplify(Pi[j] - Pi_target[j]) == 0 for j in range(3))
          and all(sp.simplify(m - 4 * sp.sqrt(2) * sp.pi * t0) == 0
                  for m in mods))

    closure = sp.simplify(sum(centres[(p + 1) % 4] - centres[p]
                              for p in range(4)))
    A = sp.Matrix([[0, 0, -1], [1, 0, -1], [0, 1, -1]])
    lam = sp.symbols('lambda')
    eigs = set(A.eigenvals().keys())
    PiRow = sp.Matrix([[Pi_target[0], Pi_target[1], Pi_target[2]]])
    transf = sp.simplify(PiRow * A - I * PiRow)
    check("S5.4 [COXETER CLOCK FROM GH] rotation maps segment (p, p+1) -> "
          "(p+1, p+2); closure sum_p (x_{p+1} - x_p) = %s = 0 makes "
          "[Sigma_30] = -(e1 + e2 + e3), so the induced map on H_2 is "
          "A = [[0,0,-1],[1,0,-1],[0,1,-1]]: A^4 = 1 (%s), char poly %s, "
          "det(A - 1) = %s = -4 (no invariant flux vector), eigenvalues "
          "%s = {i, -1, -i} = the twisted sector characters (E3 "
          "bijection counter-check); period covector: Pi . A = i Pi "
          "(pure phase, %s) -- v505 S4.10 / v509 S4.3 re-derived from "
          "centre geometry"
          % (closure, A ** 4 == sp.eye(3),
             sp.factor(A.charpoly(lam).as_expr()),
             (A - sp.eye(3)).det(), sorted(eigs, key=str),
             transf == sp.zeros(1, 3)),
          closure == 0 and A ** 4 == sp.eye(3)
          and (A - sp.eye(3)).det() == -4
          and eigs == {sp.I, -1, -sp.I}
          and sp.expand(A.charpoly(lam).as_expr()
                        - (lam ** 3 + lam ** 2 + lam + 1)) == 0
          and transf == sp.zeros(1, 3))


# ---------------------------------------------------------------------------
# S6 -- the "N log|u|^2" ledger: kernel, multipoles, EH log
# ---------------------------------------------------------------------------
def section6():
    print("  -- S6: the CPS 'N log|u|^2' analogue -- exact ledger")
    x, y, zc = sp.symbols('x y zc', real=True)
    r, th, ph, phi0 = sp.symbols('r theta phi phi0', positive=True)

    lap = sum(sp.diff(1 / sp.sqrt(x ** 2 + y ** 2 + zc ** 2), v, 2)
              for v in (x, y, zc))
    flux1 = sp.integrate(sp.integrate(
        (sp.diff(1 / r, r) * r ** 2 * sp.sin(th)), (th, 0, sp.pi)),
        (ph, 0, 2 * sp.pi))
    check("S6.1 [THE KERNEL AND ITS CHARGE] Delta(1/|x|) = %s away from "
          "the centre (exact) and the flux integral through S^2 is %s = "
          "-4 pi per centre: V = sum_{p=0}^{3} 1/|x - x_p| is the 3d "
          "Green kernel with TOTAL SOURCE CHARGE 4 = |mu4| = centre count "
          "= total flux (Gauss); this is the A3 analogue of the CPS "
          "backreaction kernel (their N log|u|^2 with N branes): the "
          "coefficient is the centre count 4"
          % (sp.simplify(lap), flux1),
          sp.simplify(lap) == 0 and flux1 == -4 * sp.pi
          and 4 == MU4)

    # Legendre generating identity (l <= 4), then the exact multipoles
    h, xg = sp.symbols('h xg')
    gen = sp.series(1 / sp.sqrt(1 - 2 * xg * h + h ** 2), h, 0, 5).removeO()
    ok_gen = all(sp.expand(gen.coeff(h, l) - sp.legendre(l, xg)) == 0
                 for l in range(5))

    cosg = [sp.sin(th) * sp.cos(ph - phi0 - p * sp.pi / 2)
            for p in range(4)]
    Vl = {l: sp.simplify(sp.expand_trig(sp.expand(
        sum(sp.legendre(l, cg) for cg in cosg)))) for l in range(1, 5)}
    four = {(l, m): sp.integrate(Vl[l] * sp.cos(m * (ph - phi0)),
                                 (ph, 0, 2 * sp.pi)) / sp.pi
            for l in range(1, 5) for m in range(1, 5)}
    amp44 = sp.simplify(four[(4, 4)])
    ok_sel = all(sp.simplify(four[(l, m)]) == 0
                 for l in range(1, 5) for m in range(1, 4))
    shift_ok = sp.simplify(sum(
        sp.legendre(2, sp.sin(th) * sp.cos(ph + sp.pi / 2 - phi0
                                           - p * sp.pi / 2))
        for p in range(4)) - Vl[2]) == 0
    check("S6.2 [MULTIPOLE LEDGER, EXACT] generating identity 1/sqrt(1 - "
          "2xh + h^2) = sum P_l(x) h^l verified to l = 4 (%s); free-orbit "
          "V = 4/r + sum_l t0^l/r^{l+1} S_l: DIPOLE S_1 = %s and OCTUPOLE "
          "S_3 = %s vanish; quadrupole S_2 = %s (m = 0, clock-invariant); "
          "the FIRST symmetry-breaking multipole is (l, m) = (4, +-4): "
          "cos-4(ph - phi0) amplitude = %s = (35/16) sin^4 th != 0, "
          "carried by t0^4 e^{4 i phi0} = -a0 (v493 bridge: the GH "
          "potential stores the O(8) modulus in the l = 4 clock "
          "harmonic); selection rule m = 0 mod 4 exact (all m = 1, 2, 3 "
          "Fourier integrals vanish; V(ph + pi/2) = V(ph): %s)"
          % (ok_gen, Vl[1], Vl[3], Vl[2], amp44, shift_ok),
          ok_gen and Vl[1] == 0 and Vl[3] == 0
          and sp.simplify(Vl[2] - (3 * sp.sin(th) ** 2 - 2)) == 0
          and sp.simplify(amp44 - sp.Rational(35, 16) * sp.sin(th) ** 4)
          == 0
          and ok_sel and shift_ok)

    # EH (A1) exact log ledger
    u, a = sp.symbols('u a', positive=True)
    Kp = sp.sqrt(u ** 2 + a ** 4) / u
    detg = sp.simplify(Kp ** 2 + u * Kp * sp.diff(Kp, u))
    ser_inf = sp.series(Kp, u, sp.oo, 4)
    c_inf = ser_inf.coeff(1 / u, 1)
    ser_0 = sp.series(Kp, u, 0, 2)
    c_0 = ser_0.coeff(1 / u, 1)
    zc2, zb = sp.symbols('zeta zetabar', positive=True)
    g_log = sp.simplify(sp.diff(a ** 2 * sp.log(1 + zc2 * zb), zc2, zb))
    rr = sp.symbols('rr', positive=True)
    flux_exc = sp.integrate(2 * g_log.subs({zc2: rr, zb: rr}) * rr,
                            (rr, 0, sp.oo)) * 2 * sp.pi
    KB = u + sp.symbols('N', positive=True) * sp.log(u)
    detB = sp.simplify(sp.diff(KB, u) ** 2
                       + u * sp.diff(KB, u) * sp.diff(KB, u, 2))
    check("S6.3 [EH LOG LEDGER, EXACT] radial Ricci-flat Monge-Ampere: "
          "u K' = sqrt(u^2 + a^4) gives det g = K'^2 + u K' K'' = %s = 1 "
          "exactly; at infinity K' = 1 + a^4/(2u^2) + ... with 1/u "
          "coefficient %s = 0: NO asymptotic log -- the naive CPS-log "
          "transplant to the Ricci-flat ALE FAILS at infinity (honest "
          "sharpening); at u -> 0: K' ~ %s/u: log coefficient a^2, and "
          "the exceptional-sphere flux is %s = 2 pi a^2 (v509 S1.2 with "
          "N -> a^2: CPS eq. 3.37 is an EXCEPTIONAL-LOCUS statement); "
          "Burns contrast: K = u + N log u gives det g = %s != 1 "
          "(scalar-flat, SOURCED: the CPS log is brane backreaction, not "
          "a Ricci-flat feature)"
          % (detg, c_inf, c_0, flux_exc, detB),
          detg == 1 and c_inf == 0 and c_0 == a ** 2
          and sp.simplify(flux_exc - 2 * sp.pi * a ** 2) == 0
          and sp.simplify(detB - (1 + sp.symbols('N', positive=True) / u))
          == 0)

    check("S6.4 [THE ANALOGUE, TYPED HONESTLY] CPS Burns: kernel N "
          "log|u|^2 (2d/4d log Green kernel), source N branes, "
          "exceptional flux 2 pi N.  A3 seam in GH form: kernel V (3d "
          "Green kernel), source charge 4 = |mu4| (exact), boundary "
          "fibration S^3/Z4 (S5.1), per-sphere flux = period/2pi with "
          "the LOCKSTEP vector 4 pi t0 (i-1)(1, i, i^2) (S5.3).  The "
          "expectation 'coefficient = total flux / centre count 4 = "
          "|mu4|' is CONFIRMED for the source ledger of V; the honest "
          "refinement: for the RICCI-FLAT ALE the asymptotic log "
          "coefficient is EXACTLY ZERO (S6.3) -- the CPS-style "
          "asymptotic log belongs to the scalar-flat brane-backreacted "
          "geometry, whose PT/Z4 analogue is precisely the open "
          "backreaction milestone M1 [C dictionary, O construction]",
          True)


# ---------------------------------------------------------------------------
# S7 -- negative controls
# ---------------------------------------------------------------------------
def section7(ser):
    print("  -- S7: negative controls")
    I = sp.I
    t = sp.symbols('t')

    Ver = sp.cancel(sp.Rational(1, 4) * sum(
        1 / (1 - I ** j * t) ** 2 for j in range(4)))
    ver_closed = (1 + 3 * t ** 4) / (1 - t ** 4) ** 2
    Hf = {j: sp.cancel((1 - I ** (2 * j) * t ** 2)
                       / (1 - I ** j * t) ** 4) for j in range(4)}
    P0f = sp.cancel(sp.Rational(1, 4) * sum(Hf[j] for j in range(4)))
    ser0f = sp.series(P0f, t, 0, 9).removeO()
    ok_lock = all(sp.expand(ser0f.coeff(t, d)
                            - ((d + 1) ** 2 if d % 4 == 0 else 0)) == 0
                  for d in range(9))
    m2_fake = 9      # d = 2: ALL 9 harmonics sit in m = 2 (degree-locked)
    m2_su2 = int(ser[2].coeff(t, 2))     # SU(2) action: 6 of 9 at m = 2
    check("S7.1 [NC-a: diag(i, i)] eigenvalue product i*i = %s != 1: not "
          "SU(2) (the O(2) fibre symplectic form is NOT preserved, no ALE "
          "resolution, no sphere side for the bijection); the character is "
          "DEGREE-LOCKED (i^{p+q}): harmonic invariants = degrees 0 mod 4 "
          "only, series 1 + 25t^4 + 81t^8 (verified); d = 2 ledger: "
          "invariant 0 vs 3, m = 2 carries %d vs %d harmonics; invariant "
          "Molien = (1 + 3t^4)/(1 - t^4)^2 = the quartic VERONESE cone: "
          "degree-4 slice dim 5 => FIVE generators, embedding dim 5, not a "
          "hypersurface (v505 S6.1 quantified)"
          % (sp.expand(I * I), m2_fake, m2_su2),
          sp.expand(I * I) == -1
          and sp.cancel(Ver - ver_closed) == 0
          and ok_lock
          and ser0f.coeff(t, 2) == 0 and ser0f.coeff(t, 4) == 25
          and m2_fake == 9 and m2_su2 == 6)

    r8 = roots_so8()
    b8 = [tuple(F(1) if j == i else F(0) for j in range(4))
          for i in range(4)]
    G8 = gram_quad(b8)
    K8, Q8 = power_sums(r8, b8)
    lam2_so8 = F(10 * 6 * 6, 28 + 2)
    table = [8, 9, 10, 12, 15, 18, 24, 36]
    squares = [x for x in table if sp.sqrt(x).is_rational]
    check("S7.2 [NC-b: so8] Killing 12 <x,x> and Okubo Tr_adj X^4 = "
          "12 <x,x>^2 hold exactly (so8 IS on Costello's list), but "
          "lambda~^2 = h_vee + 6 = %s: lambda~ = 2 sqrt 3 IRRATIONAL -- "
          "the residue is not an anchor integer; perfect squares among "
          "lambda~^2 = (8, 9, 10, 12, 15, 18, 24, 36): %s = {sl3, e8} "
          "only (2/8, v495); and the measure chain is mu-blind (S3.4), so "
          "NO quotient bookkeeping can cure the irrationality"
          % (lam2_so8, squares),
          poly_eq_scaled(K8, G8, 12, 1)
          and poly_eq_scaled(Q8, poly_square(G8), 12, 1)
          and lam2_so8 == 12
          and sp.sqrt(12).is_rational is False
          and squares == [9, 36])

    resid = {k: 47 * k * k + 219 * k - 266 for k in (1, 2)}
    c2 = F(248 * 2, 2 + H_VEE)
    check("S7.3 [NC-c: k = 2] #primaries((E8)_2) = 3 != 1: THREE exchange "
          "channels -- no single-axion GS residue; embedding residual "
          "%s = 360 != 0, c(E8, 2) = %s => prefactor -c/24 = %s != -1/3; "
          "HONEST: the Lie-algebra residue 36 is k-independent -- the "
          "k = 2 kill is the closure/condensation dial (v502/v505/v509), "
          "not the residue chain itself"
          % (resid[2], c2, -c2 / 24),
          resid == {1: 0, 2: 360} and c2 == F(31, 2)
          and -c2 / 24 == F(-31, 48))


# ---------------------------------------------------------------------------
# S8 -- the remaining backreaction roadmap M1-M3, preregistered
# ---------------------------------------------------------------------------
def section8():
    print("  -- S8: the remaining backreaction roadmap M1-M3, "
          "preregistered")
    check("S8.1 [M1: THE A3 OMEGA_N] compute the A3 analogue of CPS eq. "
          "3.5 on PT/Z4: the Beltrami/Kodaira-Spencer deformation sourced "
          "by the glue currents wrapping the three lockstep spheres.  "
          "SUCCESS: a closed-form Omega-deformation whose S^3/Z4 periods "
          "are (2 pi i)^2 x (integer flux vector) reproducing the "
          "lockstep phase structure (i-1)(1, i, i^2).  KILL: if the "
          "sourced deformation forces UNEQUAL sphere fluxes or a "
          "non-integer period, the CPS transplant (and the eps2 level "
          "dial v509) dies", True)
    check("S8.2 [M2: TWISTED KS MEASURE] quantise the O(-2) tower on "
          "PT/Z4 using the eps1 mode ledger (P_m series, S2) and compute "
          "the one-loop box coefficient PER SECTOR.  SUCCESS: the bulk "
          "sector reproduces lambda~^2 = 36 with the eps1 measure "
          "bookkeeping AND the twisted sectors pair with the three "
          "sphere axions cancelling the rigid 32 T3 residual (v505 "
          "S3.7).  KILL: a leftover independent quartic (T3-type) in ANY "
          "sector after all four axions are included", True)
    check("S8.3 [M3: THE a0 UPLIFT] uplift the (l, m) = (4, +-4) GH "
          "multipole (= the a0 direction, S6.2) to the Beltrami "
          "differential on PT/Z4 and compute the induced Kahler-"
          "potential correction.  SUCCESS: a log-type correction whose "
          "coefficient is tied to the source charge 4 = |mu4| (matching "
          "the V-ledger).  KILL: coefficient decoupled from the centre "
          "count", True)


# ---------------------------------------------------------------------------
# S9 -- verdict and honest fences
# ---------------------------------------------------------------------------
def section9():
    print("  -- S9: verdict against the eps1 scope")
    check("S9.1 [WHAT IS EXACT] (a) the O(-2) slot: pushforward ledger, "
          "Penrose accounting (d+1)^2 both sides, equivariant block-by-"
          "block match of twistor and spacetime characters (d <= 6, all "
          "m); (b) the per-character Hilbert series P_m(t) with the "
          "invariant bulk-axion tower (density 1/4, zero mode (1,0,0,0)) "
          "and the twisted minimal content (2t, 6t^2, 2t); (c) Molien = "
          "v492 hypersurface with relation degree 8 = a0 weight; (d) the "
          "lambda~ = 6 residue: Okubo perfect square (6<x,x>)^2, measure "
          "chain mu-exact (3 and 12 excluded), flux side single-channel "
          "iff k = 1; (e) the GH/A3 back-reaction step: centre dichotomy, "
          "v493 family + Coxeter clock re-derived from geometry, period "
          "lockstep, source charge 4 = |mu4|, EH log ledger with the "
          "honest zero at infinity, multipole selection rule m = 0 mod 4",
          True)
    check("S9.2 [VERDICT B] eps1 EXECUTED at the slot + residue + first-"
          "backreaction level: the s = 0 slot is a CONSTRUCTION (explicit "
          "equivariant mode ledger consistent with the v505 E3 bijection, "
          "sharpened to character series) and lambda~ = 6 is pinned as a "
          "residue through three exact ledgers with wrong bookings "
          "quantified; the GH/A3 step re-derives the v493 family and the "
          "Coxeter clock from geometry.  OPEN (the honest fence): the "
          "quantised BCOV kinetic term on PT/Z4 and the twisted-channel "
          "pairing (32 T3) -- M1-M3 preregistered (S8); conditional on "
          "Costello's flat-PT matching [C]; WP5e stays [O]; "
          "SEAM.EQUIV.01 untouched; NO marker moves anywhere", True)


# ---------------------------------------------------------------------------
def run():
    reset()
    print("v514  CELEST.WP5E.EPS1.01: the O(-2) bulk-axion slot "
          "(WP5e-epsilon-1 of CELEST.SEAM.01 -- verdict B)")
    section1()
    ser = section2()
    section3()
    section4()
    section5()
    section6()
    section7(ser)
    section8()
    section9()

    return summary("v514 CELEST.WP5E.EPS1.01: the O(-2) bulk-axion slot -- "
                   "eps1 executed (verdict B): the slot is a CONSTRUCTION "
                   "(equivariant Penrose ledger closes block by block for "
                   "d <= 6, all 4 characters; P_0 = 1 + 3t^2 + 15t^4 + "
                   "..., d = 0 multiplicity (1,0,0,0): the bulk axion "
                   "survives; Molien = v492 hypersurface, relation degree "
                   "8 = a0 weight; twisted minimal content (2t, 6t^2, 2t) "
                   "= Coxeter eigenvalues, det(A-1) = -4; graviton "
                   "control: O(+2) invariant only from fibre degree 4, "
                   "multiplicity 3 = {X, Z^2, Y}); lambda~ = 6 is pinned "
                   "three ways (Okubo (6<x,x>)^2 on the 240 glue roots; "
                   "measure chain mu-exact excluding 3 and 12; flux "
                   "single-channel iff k = 1, (kappa/c3)^2 = 12); the "
                   "GH/A3 back-reaction step re-derives the v493 family "
                   "XY = Z^4 + a0 and the Coxeter clock from centre "
                   "geometry (2 branches, lockstep periods 4 pi t0 (i-1)"
                   "(1, i, i^2), source charge 4 = |mu4|, EH asymptotic "
                   "log exactly 0, multipole rule m = 0 mod 4 with "
                   "(4,+-4) carrying -a0); so8 / diag(i,i) / k = 2 "
                   "controls separate honestly; the quantised BCOV "
                   "coefficient and the twisted channels stay [O] "
                   "(M1-M3 preregistered); no marker moves")


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

58f47b21526af9b9284928b9a7bc27dd67260ede7520e2b0683e0fd1ecb449e2

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.