"""Method B for general p (independent of genp.py / method_A.py code): Cayley-Dickson integer octonions,
explicit Zorn frame mod p^6, orders transported, Howell canonical form over Z/p^6, LEFT ideals.
Children: 'hyp' = stable hyperplanes of L/pL found by intersecting eigenspaces of the transposed
generators (valid when all simple modules are 1-dim; the certificate is in genp.py and is re-run there),
'cyc' = minimal submodules of the dual found by iterated batch closure (any module)."""
import itertools, json, sys, time
import numpy as np
P=int(sys.argv[2]) if len(sys.argv)>2 else 5
NMOD=6; MOD=P**NMOD
def cd(x,y):
    if len(x)==1: return (x[0]*y[0],)
    h=len(x)//2; a,b,c,d=x[:h],x[h:],y[:h],y[h:]
    cj=lambda z:(z[0],)+tuple(-t for t in z[1:])
    A=cd(a,c); B=cd(cj(d),b); C=cd(d,a); D=cd(b,cj(c))
    return tuple(s-t for s,t in zip(A,B))+tuple(s+t for s,t in zip(C,D))
def m(x,y): return tuple(t%MOD for t in cd(tuple(x),tuple(y)))
ONE=(1,)+(0,)*7; std=[tuple(int(i==j) for i in range(8)) for j in range(8)]
T=MOD-1; w=None
for x in range(0,int(T**.5)+1):
    for y in range(0,x+1):
        r=T-x*x-y*y
        if r<0: break
        z=int(round(r**.5))
        if z*z==r: w=(0,x,y,z,0,0,0,0);break
    if w: break
assert w and sum(t*t for t in w)%MOD==MOD-1
inv2=pow(2,-1,MOD)
e=tuple((ONE[i]+w[i])*inv2%MOD for i in range(8)); f=tuple((ONE[i]-e[i])%MOD for i in range(8)); assert m(e,e)==e
def rankp(vs):
    R=[]
    for v in vs:
        v=[t%P for t in v]
        for r in R:
            c=next(i for i,t in enumerate(r) if t)
            if v[c]: k=v[c]*pow(r[c],-1,P); v=[(a-k*b)%P for a,b in zip(v,r)]
        if any(v): R.append(v)
    return len(R)
U=[]
for x in [m(m(e,s),f) for s in std]:
    if rankp(U+[x])>len(U): U.append(x)
u1,u2,u3=U; lam=m(u1,m(u2,u3)); k=next(i for i in range(8) if e[i]%P); lc=lam[k]*pow(e[k],-1,MOD)%MOD
assert all((lam[i]-lc*e[i])%MOD==0 for i in range(8)) and lc%P
u3=tuple(t*pow(lc,-1,MOD)%MOD for t in u3); v1,v2,v3=m(u2,u3),m(u3,u1),m(u1,u2)
FR=[e,u1,u2,u3,v1,v2,v3,f]
eps={(1,2):(3,1),(2,3):(1,1),(3,1):(2,1),(2,1):(3,-1),(3,2):(1,-1),(1,3):(2,-1)}
def zp(i,j):
    if i==0: return [(j,1)] if j in (0,1,2,3) else []
    if i==7: return [(j,1)] if j in (4,5,6,7) else []
    if i in (1,2,3):
        if j==7: return [(i,1)]
        if j in (1,2,3): return [(eps[(i,j)][0]+3,eps[(i,j)][1])] if (i,j) in eps else []
        if j in (4,5,6): return [(0,1)] if j-3==i else []
        return []
    if j==0: return [(i,1)]
    if j in (4,5,6): return [(eps[(i-3,j-3)][0],-eps[(i-3,j-3)][1])] if (i-3,j-3) in eps else []
    if j in (1,2,3): return [(7,1)] if j==i-3 else []
    return []
comb=lambda cs:tuple(sum(c*FR[j][i] for j,c in cs)%MOD for i in range(8))
for i in range(8):
    for j in range(8): assert m(FR[i],FR[j])==comb(zp(i,j)),(i,j)
assert rankp(FR)==8
def val(t):
    t%=MOD
    if t==0: return NMOD
    k=0
    while t%P==0: t//=P;k+=1
    return k
def canon(gens):
    rows=[[t%MOD for t in g] for g in gens]; rows=[r for r in rows if any(r)]; out=[]
    for c in range(8):
        best=None
        for r in rows:
            if r[c]%MOD and (best is None or val(r[c])<val(best[c])): best=r
        if best is None: out.append([0]*8); continue
        rows.remove(best); vb=val(best[c]); unit=(best[c]//P**vb)%MOD
        best=[t*pow(unit,-1,MOD)%MOD for t in best]; new=[]
        for r in rows:
            if r[c]%MOD: q=(r[c]//P**vb)%MOD; r=[(a-q*b)%MOD for a,b in zip(r,best)]
            if any(r): new.append(r)
        ex=[(t*P**(NMOD-vb))%MOD for t in best]
        if any(ex): new.append(ex)
        rows=new; out.append(best)
    for c in range(8):
        r=out[c]
        if not any(r): continue
        pv=P**val(r[c])
        for d in range(c):
            q=out[d][c]//pv
            if q: out[d]=[(a-q*b)%MOD for a,b in zip(out[d],r)]
    return tuple(tuple(r) for r in out)
def logidx(H): return sum(val(H[c][c]) if any(H[c]) else NMOD for c in range(8))
def member(H,v):
    v=[t%MOD for t in v]
    for c in range(8):
        if v[c]%MOD==0: continue
        if not any(H[c]): return False
        vb=val(H[c][c])
        if val(v[c])<vb: return False
        q=(v[c]//P**vb)*pow((H[c][c]//P**vb)%MOD,-1,MOD)%MOD; v=[(a-q*b)%MOD for a,b in zip(v,H[c])]
    return not any(v)
ORD={'Q':(0,1,4,7),'U':(0,1,7),'N4':(0,1,5,7),'P5':(0,1,2,6,7),'P6':(0,1,2,4,6,7)}
def order_gens(n): return [FR[i] for i in ORD[n]]+[tuple(P*t for t in s) for s in std]
def acts_of(H,gens):
    B=[list(r) for r in H if any(r)]; assert len(B)==8
    def coords(v):
        v=[t%MOD for t in v]; co=[0]*8
        for idx,r in enumerate(B):
            c=next(i for i in range(8) if r[i]%MOD)
            if v[c]%MOD==0: continue
            vb=val(r[c]); q=(v[c]//P**vb)*pow((r[c]//P**vb)%MOD,-1,MOD)%MOD; co[idx]=q; v=[(a-q*b)%MOD for a,b in zip(v,r)]
        assert not any(v),'unstable'; return co
    # left action x -> y x ; row i = image of basis i  (row-vector convention c -> c A)
    return B,[np.array([[c%P for c in coords(m(y,b))] for b in B],dtype=np.int64) for y in gens]
def kernel_cols(A):
    """basis of column vectors x with A x = 0 mod P (A: k x 8 numpy)."""
    A=[list(map(int,r)) for r in A%P]; piv=[]; R=[]
    for r in A:
        for c0,pr in zip(piv,R):
            if r[c0]: t=r[c0]; r=[(a-t*b)%P for a,b in zip(r,pr)]
        if any(r):
            c0=next(i for i,x in enumerate(r) if x); iv=pow(r[c0],-1,P); r=[x*iv%P for x in r]
            R=[[(a-q[c0]*b)%P for a,b in zip(q,r)] for q in R]; R.append(r); piv.append(c0)
    out=[]
    for fcol in [j for j in range(8) if j not in piv]:
        v=[0]*8; v[fcol]=1
        for c0,r in zip(piv,R): v[c0]=(-r[fcol])%P
        out.append(v)
    return out
def intersect(B1,B2):
    """intersection of column spans B1, B2 (lists of vectors)."""
    if not B1 or not B2: return []
    M=np.array(B1+[[-x%P for x in v] for v in B2]).T   # 8 x (k1+k2)
    ns=[]
    A=[list(map(int,r)) for r in M%P]
    # kernel of M (columns k1+k2)
    n=M.shape[1]; piv=[];R=[]
    for r in A:
        for c0,pr in zip(piv,R):
            if r[c0]: t=r[c0]; r=[(a-t*b)%P for a,b in zip(r,pr)]
        if any(r):
            c0=next(i for i,x in enumerate(r) if x); iv=pow(r[c0],-1,P); r=[x*iv%P for x in r]
            R=[[(a-q[c0]*b)%P for a,b in zip(q,r)] for q in R]; R.append(r); piv.append(c0)
    vecs=[]
    for fcol in [j for j in range(n) if j not in piv]:
        v=[0]*n; v[fcol]=1
        for c0,r in zip(piv,R): v[c0]=(-r[fcol])%P
        vecs.append([sum(v[k]*B1[k][i] for k in range(len(B1)))%P for i in range(8)])
    # reduce to a basis
    out=[]
    for v in vecs:
        if rankp(out+[v])>len(out): out.append(v)
    return out
def children_hyp(H,gens):
    B,X=acts_of(H,gens)
    # phi column with X phi = lam phi for every generator X (so that ker phi is stable under c -> c X)
    cur=[[[int(i==j) for i in range(8)] for j in range(8)]]
    for Xm in X:
        nxt=[]
        for S in cur:
            for lam in range(P):
                E=kernel_cols((Xm-lam*np.eye(8,dtype=np.int64))%P)
                I=intersect(S,E)
                if I: nxt.append(I)
        cur=nxt
    out=[]
    for S in cur:
        for co in itertools.product(range(P),repeat=len(S)):
            if not any(co) or co[next(i for i,x in enumerate(co) if x)]!=1: continue
            phi=[sum(c*S[k][i] for k,c in enumerate(co))%P for i in range(8)]
            ker=kernel_cols(np.array([phi]))
            g=[[sum(c[i]*B[i][j] for i in range(8)) for j in range(8)] for c in ker]+[[P*t for t in b] for b in B]
            out.append(canon(g))
    return out
_PR={}
def projv():
    if P not in _PR: _PR[P]=np.array([v for v in itertools.product(range(P),repeat=8) if any(v) and v[next(i for i,x in enumerate(v) if x)]==1],dtype=np.int64)
    return _PR[P]
def brref(A):
    A=A%P; Bn,mm_,n=A.shape; rank=np.zeros(Bn,int); ar=np.arange(Bn); inv=np.array([0]+[pow(i,-1,P) for i in range(1,P)])
    for c in range(n):
        cand=(A[:,:,c]!=0)&(np.arange(mm_)[None,:]>=rank[:,None]); has=cand.any(1); r=np.argmax(cand,1)
        idx=ar[has]; rr=r[has]; rk=rank[has]; t=A[idx,rr].copy(); A[idx,rr]=A[idx,rk]; A[idx,rk]=t
        A[idx,rk]=(A[idx,rk]*inv[A[idx,rk,c]][:,None])%P; fct=A[idx,:,c].copy(); fct[np.arange(len(idx)),rk]=0
        A[idx]=(A[idx]-fct[:,:,None]*A[idx,rk][:,None,:])%P; rank[idx]+=1
    return A[:,:8,:],rank
def children_cyc(H,gens,chunk=8000):
    B,X=acts_of(H,gens)
    G=[x for x in X]   # column action on functionals: phi -> X phi
    seen={}
    V=projv()
    for s in range(0,len(V),chunk):
        S=V[s:s+chunk][:,None,:].copy()  # (b,1,8) spanning rows
        while True:
            imgs=np.concatenate([np.einsum('ij,bkj->bki',g,S) for g in G],axis=1)%P
            R,rk=brref(np.concatenate([S,imgs],axis=1))
            mx=rk.max(); Snew=R[:,:mx,:]
            if Snew.shape==S.shape and (Snew==S).all(): break
            S=Snew
        for b in range(len(S)):
            key=S[b,:rk[b]].tobytes()
            if key not in seen: seen[key]=(int(rk[b]),S[b,:rk[b]].copy())
    subs=list(seen.values())
    def inside(a,bg):
        _,r=brref(np.vstack([bg,a])[None]); return r[0]==len(bg)
    mins=[s for s in subs if not any(t[0]<s[0] and inside(t[1],s[1]) for t in subs)]
    out=[]
    for d,C in mins:
        ker=kernel_cols(C)
        g=[[sum(c[i]*B[i][j] for i in range(8)) for j in range(8)] for c in ker]+[[P*t for t in b] for b in B]
        out.append(canon(g))
    return out
def run(name,mode):
    g=order_gens(name); O=canon(std+[tuple(MOD*0 for _ in range(8))]); Lam=canon(list(g))
    child=children_hyp if mode=='hyp' else children_cyc
    seen={O:0}; fr=[O]; t=time.time()
    while fr:
        nf=[]
        for H in fr:
            for K in child(H,g):
                if all(x%P==0 for r in K for x in r): continue
                if K not in seen: seen[K]=logidx(K); nf.append(K)
        fr=nf; print(name,P,mode,'frontier',len(fr),'total',len(seen),round(time.time()-t,1),flush=True)
    shift=8-len(ORD[name]); PO={};PL={}
    for K,k in seen.items():
        PO[k]=PO.get(k,0)+1
        if all(member(Lam,r) for r in K if any(r)): PL[k-shift]=PL.get(k-shift,0)+1
    return {'order':name,'p':P,'side':'L','mode':mode,'P_O':{str(k):v for k,v in sorted(PO.items())},'P_Lambda':{str(k):v for k,v in sorted(PL.items())},'n_primitive':len(seen),'frame_w':w}
if __name__=='__main__':
    n=sys.argv[1]; mode=sys.argv[3]
    r=run(n,mode); print(json.dumps(r),flush=True)
    json.dump(r,open(f'results-Bp-{n}-p{P}.json','w'),indent=1)
