"""Validation: run the same consistency machinery on the Brauer category
(crossing only), which HAS a genuine non-gauge first-order deformation (BMW)."""
import sys, time, flint
from collections import defaultdict, deque
import evalmap, system, rewrite, gauge
from deligne import canon, set_partitions
from pmap import from_word
p=1000003; t=flint.nmod(123457,p)   # here t = loop value delta

# --- Brauer evaluation: perfect matchings basis ---
_PM={}
def pm(k):
    if k not in _PM:
        _PM[k]=sorted(canon(q) for q in set_partitions(list(range(k))) if all(len(b)==2 for b in q))
    return _PM[k]
def evaluate_brauer(nodes, alpha, k, t, loops=0):
    # nodes: list of (darts, externals) where merge nodes are all 2-valent (strands) or boundary
    owner={}
    for i,(ds,ex) in enumerate(nodes):
        for d in ds: owner[d]=i
    # build graph on nodes, each node has <=2 darts; components are paths/cycles
    seen=set(); blocks=[]; cyc=0
    adj=defaultdict(list)
    for i,(ds,ex) in enumerate(nodes):
        for d in ds:
            adj[i].append(owner[alpha[d]])
    for i in range(len(nodes)):
        if i in seen: continue
        comp=[]; st=[i]; seen.add(i)
        while st:
            x=st.pop(); comp.append(x)
            for y in adj[x]:
                if y not in seen: seen.add(y); st.append(y)
        ex=[e[1] for x in comp for e in nodes[x][1]]
        if ex: blocks.append(ex)
        else: cyc+=1
    for b in blocks:
        if len(b)==1 or len(b)>2:
            # a T would be needed; in pure Brauer maps never happens except via inserted blocks
            pass
    return {canon(blocks): t**(cyc+loops)}
def coords_b(res,k,zero):
    return [res.get(q,zero) for q in pm(k)]
# monkeypatch sfp / evaluate / coords
evalmap.sfp=pm
def sfidx(k):
    return {q:i for i,q in enumerate(pm(k))}
evalmap.sfidx=sfidx
evalmap.evaluate=evaluate_brauer
evalmap.coords=coords_b
for mod in (system, rewrite, gauge):
    for name in ("sfp","evaluate","coords","sfidx"):
        if hasattr(mod,name): setattr(mod,name,getattr(evalmap,name))
def eval_map(M,t):
    nodes=evalmap._merge_nodes(M)
    return coords_b(evaluate_brauer(nodes,M.alpha,M.k,t,M.loops),M.k,0*t)
evalmap.eval_map=eval_map; system.eval_map=eval_map; gauge.eval_map=eval_map
# rot_perm uses sfp/sfidx via module globals
def rot_perm(k,r):
    idx=sfidx(k); return [idx[canon([[(i+r)%k for i in b] for b in q])] for q in pm(k)]
evalmap.rot_perm=rot_perm; system.rot_perm=rot_perm
def rotate_vec(v,k,r):
    perm=rot_perm(k,r); w=[None]*len(v)
    for i,j in enumerate(perm): w[j]=v[i]
    return w
evalmap.rotate_vec=rotate_vec; system.rotate_vec=rotate_vec; gauge.rotate_vec=rotate_vec
# relations
def W(m,l): return from_word(m,l)[0]
one=t**0
rels=[dict(name="R1",L=W(1,[("cup",1),("X",0),("cap",1)]),rhs=[(one,W(1,[]))],err="a"),
      dict(name="R2",L=W(2,[("X",0),("X",0)]),rhs=[(one,W(2,[]))],err="E2"),
      dict(name="R3",L=W(3,[("X",0),("X",1),("X",0)]),rhs=[(one,W(3,[("X",1),("X",0),("X",1)]))],err="E3")]
system.ERRDIMS.update({"a":1,"b":0,"E2":3,"E25":0,"E3":15})
from run_common import words
seeds=[]
for m in range(0,5):
    for mm,layers in words(m,int(sys.argv[1]) if len(sys.argv)>1 else 4,4):
        if any(g in ("T","Ts") for g,_ in layers): continue
        M,n=from_word(mm,layers)
        if 1<=M.k<=6: seeds.append(M)
S=system.System(t,rels=rels,verbose=False); S.run(seeds)
print("maps",len(S.reps),"rows",len(S.rows))
from analyze import analyze
import analyze as A
A.gauge_errors=gauge.gauge_errors
A.plus_eigen_basis=gauge.plus_eigen_basis
res,gr,bad,*_=analyze(S,p,t,blocks_order=("E3","E2","a"))
for k in res: print("projection onto",k,":",res[k]," gauge rank:",gr[k])
print("gauge violations",bad)