"""Edge of the Model A correction factor H for finite G in H^x and an axis I.
f_k(g) = psi(cl g)^k if cl g meets the slice A = G ∩ C_I, else 0.
Ghost layers Phi_d(g) = (1/d) sum_{e|d} mu(e) f_{d/e}(g^e);  log F_p = sum_d sum_m Phi_d(g^m) x^{dm}/m.
Model A peels d=1,2 into L(chi,s), L(chi,2s); H = remainder; r_k = sum_{d|k,d>=3} d Phi_d(g^{k/d}).
k0 = min{d>=3: Phi_d != 0 on some class};  sigma_abs = 1/k0;  c1 = <Phi_k0, 1>.
"""
import numpy as np, itertools, json, sys, math, cmath
TOL=1e-9
def qmul(a,b):
    a0,a1,a2,a3=a; b0,b1,b2,b3=b
    return (a0*b0-a1*b1-a2*b2-a3*b3, a0*b1+a1*b0+a2*b3-a3*b2, a0*b2-a1*b3+a2*b0+a3*b1, a0*b3+a1*b2-a2*b1+a3*b0)
def key(q): return tuple(round(x,7)+0.0 for x in q)
def closure(gens):
    els={key((1,0,0,0)):(1.0,0.0,0.0,0.0)}
    frontier=list(els.values())
    while frontier:
        new=[]
        for x in frontier:
            for g in gens:
                y=qmul(x,g); k=key(y)
                if k not in els: els[k]=y; new.append(y)
        frontier=new
    return list(els.values())
phi=(1+5**.5)/2
def dic(n):
    a=(math.cos(math.pi/n),math.sin(math.pi/n),0,0); return closure([a,(0,0,1,0)])
def cyc(m): return closure([(math.cos(2*math.pi/m),math.sin(2*math.pi/m),0,0)])
T=closure([(0,1,0,0),(.5,.5,.5,.5)])
O=closure([(0,1,0,0),(.5,.5,.5,.5),(2**-.5,2**-.5,0,0)])
I=closure([(.5,.5,.5,.5),(phi/2,1/(2*phi),.5,0)])
assert len(T)==24 and len(O)==48 and len(I)==120, (len(T),len(O),len(I))

class Grp:
    def __init__(s,els):
        s.els=els; s.idx={key(g):i for i,g in enumerate(els)}; N=len(els)
        s.inv=[s.idx[key((g[0],-g[1],-g[2],-g[3]))] for g in els]
        M=[[s.idx[key(qmul(els[i],els[j]))] for j in range(N)] for i in range(N)]
        s.M=M; s.mul=lambda i,j: M[i][j]
        s.e=s.idx[key((1,0,0,0))]
        s.ordc={}
        cl=[-1]*N; s.classes=[]
        for i in range(N):
            if cl[i]<0:
                c=set(s.mul(s.mul(h,i),s.inv[h]) for h in range(N))
                for x in c: cl[x]=len(s.classes)
                s.classes.append(sorted(c))
        s.cl=cl
        s.powtab={}
    def power(s,i,e):
        r=s.idx[key((1,0,0,0))]
        for _ in range(e% s.order(i) if True else e): r=s.mul(r,i)
        return r
    def order(s,i):
        if i in s.ordc: return s.ordc[i]
        r=i;k=1
        while r!=s.e: r=s.M[r][i];k+=1
        s.ordc[i]=k; return k
def axes(G):
    out=[]
    for g in G.els:
        v=np.array(g[1:]); n=np.linalg.norm(v)
        if n<1e-9: continue
        v=v/n
        if not any(abs(abs(v@w)-1)<1e-7 for w in out): out.append(v)
    return out
def analyse(G, Iax, dmax=60):
    N=len(G.els); Iax=np.array(Iax)/np.linalg.norm(Iax)
    # slice A and complex image
    z={}
    for i,g in enumerate(G.els):
        v=np.array(g[1:]); 
        if np.linalg.norm(np.cross(v,Iax))<1e-7: z[i]=complex(g[0], v@Iax)
    psi={}
    for c,C in enumerate(G.classes):
        pts=[z[i] for i in C if i in z]
        if pts:
            pts=sorted(set((round(p.real,9),round(p.imag,9)) for p in pts), key=lambda t:-t[1])
            psi[c]=complex(*pts[0])  # Im>=0 if available
    fold={c: sum(1 for i in G.classes[c] if i in z) for c in psi}
    reps=[C[0] for C in G.classes]; ords=[G.order(r) for r in reps]
    def f(k,i):
        c=G.cl[i]; return psi[c]**k if c in psi else 0
    def gp(i,e):
        o=G.order(i); r=G.e
        for _ in range(e%o): r=G.M[r][i]
        return r
    mu=lambda e: 0 if any(e%(p*p)==0 for p in range(2,int(e**.5)+1)) else (-1)**sum(1 for p in range(2,e+1) if e%p==0 and all(p%q for q in range(2,int(p**.5)+1)))
    def Phi(d,i): return sum(mu(e)*f(d//e,gp(i,e)) for e in range(1,d+1) if d%e==0)/d
    k0=None; c1=None; phivals=None
    for d in range(3,dmax+1):
        vals=[Phi(d,r) for r in reps]
        if max(abs(v) for v in vals)>TOL:
            k0=d; c1=sum(len(C)*v for C,v in zip(G.classes,vals))/N; phivals=vals; break
    return dict(order=N, slice=len(z), nclasses=len(G.classes), k0=k0, c1=c1,
                classes=[dict(size=len(C),order=o,inslice=(c in psi),psi=(None if c not in psi else [round(psi[c].real,12),round(psi[c].imag,12)]),
                     Phi_k0=(None if phivals is None else [round(phivals[c].real,12),round(phivals[c].imag,12)])) for c,(C,o) in enumerate(zip(G.classes,ords))],
                rk=lambda k,c: (f(k,reps[c]) - f(1,gp(reps[c],k)) - ((f(2,gp(reps[c],k//2))-f(1,gp(reps[c],k))) if k%2==0 else 0)))
