#!/usr/bin/env python3
"""v625 -- PRIME.SHADOW.01: the prime-shadow audit -- the checkable core
of the "primes are the shadow of the finished geometry" reading is
EXACT: the
E8 theta function is the weight-4 Eisenstein series, its shell counts
are 240 sigma_3(n) (multiplicative -- the "address space" reading), the
primes act as commuting Hecke channels with the E8 theta as simultaneous
eigenvector (the "independent channels" reading), and the L-function
factorizes as zeta(s) zeta(s-3) -- the primes appear AFTER the lattice,
as its multiplicative decomposition.  The speculative framings beyond
this core are typed, not adopted.

An external note (2026-08-02) proposed five framings for the role of
primes in TFPT and one central claim: "primes appear only after E8 is
built -- as the shadow of the finished geometry, not as input".  The
checkable core is classical modular arithmetic, machine-verified here
on the compiler's own glue chain (mu4 -> D5+A3 -> E8, v1/v47; at theta
level E8 = D8 u (D8+s)):

  (P1) THETA = EISENSTEIN [E]: the E8 theta series, computed from the
       glue decomposition Theta_E8 = (theta2^8 + theta3^8 + theta4^8)/2,
       has shell counts r(2n) = 240 sigma_3(n) for n = 1..12 EXACTLY
       (240 = |R(E8)| is the FIRST shell): Theta_E8 = E_4, the finished
       lattice's counting function is a modular form.

  (P2) THE ADDRESS SPACE IS EXACT [E]: sigma_3 is multiplicative --
       shell counts factor over COPRIME addresses (census m, n < 20);
       must-fail: non-coprime addresses do NOT factor (sigma_3(4) = 73
       != 81 = sigma_3(2)^2): the "primes as elementary addresses"
       reading is unique factorization, exactly -- no more, no less.

  (P3) THE PRIME CHANNELS COMMUTE [E]: the Hecke operators T_p act on
       the shell counts with T_p Theta = (1 + p^3) Theta for
       p = 2, 3, 5, 7 (n <= 40), and [T_2, T_3] = 0 on the coefficient
       array: each prime is an independent commuting channel, and the
       compiler's theta is a SIMULTANEOUS eigenvector of all of them --
       the exact content of the "independent check channels" reading.

  (P4) THE ZETA SHADOW [E-float]: L(E_4, s) = zeta(s) zeta(s-3): the
       Dirichlet series of the shell counts at s = 6 matches
       zeta(6) zeta(3) to 5e-8 (3000 terms): the Riemann zeta appears
       as the FACTORIZED SHADOW of the E8 counting function -- primes
       enter after the geometry, through its Euler decomposition.

  (P5) THE TYPING [C]: the note's chain (mu4 -> D5+A3 -> E8 -> theta ->
       Hecke -> zeta -> primes) is EXACT at every arrow checked here;
       the framings "address space" (P2) and "independent channels"
       (P3) are theorems at the theta level; the framings "compiler
       eigenfrequencies", "synchronization code", "complexity barriers"
       and "RH as maximal coherence" are HYPOTHESES -- typed
       speculation, not adopted, no marker moves, no RH statement.
       Honest scope: these are classical facts (Jacobi/Hecke); the
       audit's content is that the COMPILER'S OWN OBJECTS realize them
       verbatim, fixing the direction of explanation (geometry first,
       primes as readout) within TFPT's narrative.

Verdict enums (frozen): PRIME-SHADOW-EXACT (all pass),
SHADOW-FAILS, MIXED.

FIREWALL: no marker changes; the speculative framings stay typed
hypotheses; no RH statement.

PROVENANCE: discovery probe prime_shadow_probe.py (2026-08-02, 6/6,
verdict PRIME-SHADOW-EXACT); external note 2026-08-02.

Python-only (integer convolution + sympy + mpmath), counted per
GATE.WOLFRAM.02.
"""

import sympy as sp
import mpmath as mp

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


NMAX = 24  # q-coefficients up to q^24 (norm 24 = shell n = 12)


def mul(a, b, nmax=NMAX):
    out = [0] * (nmax + 1)
    for i, ai in enumerate(a):
        if ai == 0 or i > nmax:
            continue
        for j, bj in enumerate(b):
            if i + j > nmax:
                break
            out[i + j] += ai * bj
    return out


def power(a, k, nmax=NMAX):
    r = [1] + [0] * nmax
    for _ in range(k):
        r = mul(r, a, nmax)
    return r


def sigma3(n):
    return sum(d ** 3 for d in sp.divisors(n))


# ================================================================== P1
print("=" * 72)
print("P1: Theta_E8 = E_4 (shell counts 240 sigma_3)")
print("=" * 72)

th3 = [0] * (NMAX + 1)
th3[0] = 1
th4 = [0] * (NMAX + 1)
th4[0] = 1
k = 1
while k * k <= NMAX:
    th3[k * k] = 2
    th4[k * k] = 2 * (-1) ** k
    k += 1
t2o = [0] * (NMAX + 1)
k = 0
while k * (k + 1) <= NMAX:
    t2o[k * (k + 1)] = 1
    k += 1
th2_8 = ([0, 0] + [256 * c for c in power(t2o, 8)])[:NMAX + 1]
TE8 = [(power(th3, 8)[m] + power(th4, 8)[m] + th2_8[m]) // 2
       for m in range(NMAX + 1)]

odd_zero = all(TE8[m] == 0 for m in range(1, NMAX + 1, 2))
shells_ok = all(TE8[2 * n] == 240 * sigma3(n) for n in range(1, NMAX // 2 + 1))
check("P1.1 the E8 theta from the glue decomposition (theta2^8 + theta3^8 "
      "+ theta4^8)/2 has ONLY even norms and shell counts r(2n) = "
      "240 sigma_3(n) for n = 1..12 EXACTLY (first shell = 240 = |R(E8)|): "
      "Theta_E8 = E_4",
      TE8[0] == 1 and odd_zero and shells_ok,
      "first shells: %s" % ([TE8[2 * n] for n in range(1, 5)],))

# ================================================================== P2
print("=" * 72)
print("P2: the address space is exact (multiplicativity)")
print("=" * 72)

cop = all(sigma3(m * n) == sigma3(m) * sigma3(n)
          for m in range(2, 20) for n in range(2, 20) if sp.gcd(m, n) == 1)
check("P2.1 shell counts factor over COPRIME addresses "
      "(sigma_3(mn) = sigma_3(m) sigma_3(n), census m, n < 20); "
      "[must-fail] non-coprime does NOT factor: sigma_3(4) = 73 != 81 "
      "= sigma_3(2)^2 -- the 'address space' reading IS unique "
      "factorization, exactly",
      cop and sigma3(4) == 73 and sigma3(2) ** 2 == 81)

# ================================================================== P3
print("=" * 72)
print("P3: the prime channels commute (Hecke)")
print("=" * 72)

a = {n: (1 if n == 0 else 240 * sigma3(n)) for n in range(0, 400)}


def Tp_arr(arr, p, nmax, k=4):
    out = {}
    for n in range(0, nmax + 1):
        if n == 0:
            out[n] = arr[0] + p ** (k - 1) * arr[0]
        else:
            out[n] = arr[p * n] + (p ** (k - 1) * arr[n // p]
                                   if n % p == 0 else 0)
    return out


eig_ok = True
for p in (2, 3, 5, 7):
    Ta = Tp_arr(a, p, 40)
    eig_ok &= all(Ta[n] == (1 + p ** 3) * a[n] for n in range(0, 41))
check("P3.1 T_p Theta_E8 = (1 + p^3) Theta_E8 for p = 2, 3, 5, 7 "
      "(coefficients n <= 40): every prime channel reads the SAME "
      "eigenvector", eig_ok)

T2 = Tp_arr(a, 2, 120)
T3 = Tp_arr(a, 3, 120)
comm_ok = all(Tp_arr(T2, 3, 30)[n] == Tp_arr(T3, 2, 30)[n]
              for n in range(31))
check("P3.2 [T_2, T_3] = 0 on the coefficient array (n <= 30): the prime "
      "channels are INDEPENDENT commuting operators -- the exact content "
      "of the 'independent check channels' reading", comm_ok)

# ================================================================== P4
print("=" * 72)
print("P4: the zeta shadow (L(E_4, s) = zeta(s) zeta(s-3))")
print("=" * 72)

mp.mp.dps = 25
S = mp.mpf(0)
for n in range(1, 3000):
    S += sigma3(n) / mp.mpf(n) ** 6
target = mp.zeta(6) * mp.zeta(3)
rel = abs(S - target) / target
check("P4.1 the Dirichlet series of the shell counts at s = 6 matches "
      "zeta(6) zeta(3) to < 1e-6 (3000 terms; the tail is O(N^-2)): "
      "the Riemann zeta is the FACTORIZED SHADOW of the E8 counting "
      "function", rel < 1e-6, "rel diff = %s" % mp.nstr(rel, 3))

# ================================================================== P5
print("=" * 72)
print("P5: the typing")
print("=" * 72)

check("P5.1 [C] the note's chain (mu4 -> D5+A3 -> E8 -> theta -> Hecke -> "
      "zeta -> primes) is EXACT at every arrow checked; 'address space' "
      "and 'independent channels' are THEOREMS at the theta level; "
      "'compiler eigenfrequencies', 'synchronization code', 'complexity "
      "barriers' and 'RH as maximal coherence' are HYPOTHESES -- typed "
      "speculation, not adopted; honest scope: classical facts "
      "(Jacobi/Hecke) realized verbatim by the compiler's own objects, "
      "fixing the direction of explanation (geometry first, primes as "
      "readout) within TFPT's narrative; no marker moves, no RH statement",
      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: PRIME-SHADOW-EXACT -- the primes enter AFTER the lattice:")
    print("Theta_E8 = E_4, shell counts 240 sigma_3(n) (multiplicative),")
    print("commuting Hecke channels with the theta as simultaneous eigenvector,")
    print("and the zeta factorization as the arithmetic shadow.")
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)