"""Complex-s extension of the Q8 Frobenius-quaternion Euler product (sprint 11 Nov 2026 PST).
Model A: the complex unit of s is a unit imaginary quaternion I inside H (s = sigma + t*I).
Model B: the complex unit is central (H (x) C = M2(C)); g_p acts by its 2x2 matrix.
Run with /workspace/tools/pari-venv/bin/python3. Floating point (mpmath 30 digits for identity checks), not intervals."""
import json, math, random, cmath
import mpmath as mp
from cypari2 import Pari
mp.mp.dps = 30
p = Pari(); p.allocatemem(800*10**6)
CHECKS = []
def check(c, msg):
    CHECKS.append(msg); assert c, msg
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 nrd(a): return sum(x*x for x in a)
def qinv(a):
    n = nrd(a); return (a[0]/n, -a[1]/n, -a[2]/n, -a[3]/n)
UNIT = {'1':(1,0,0,0),'-1':(-1,0,0,0),'i':(0,1,0,0),'j':(0,0,1,0),'k':(0,0,0,1)}
MAT = {'1':((1,0),(0,1)),'-1':((-1,0),(0,-1)),'i':((1j,0),(0,-1j)),'j':((0,1),(-1,0)),'k':((0,1j),(1j,0))}
def mmul(A,B): return tuple(tuple(sum(A[r][m]*B[m][c] for m in range(2)) for c in range(2)) for r in range(2))
def minv(A):
    d = A[0][0]*A[1][1]-A[0][1]*A[1][0]; return ((A[1][1]/d,-A[0][1]/d),(-A[1][0]/d,A[0][0]/d)), d
def neg(u): return tuple(-x for x in u)
# sanity: matrix rep is Q8 (ij=k, i^2=-1) and matches quaternion product
check(mmul(MAT['i'],MAT['j'])==MAT['k'] and mmul(MAT['i'],MAT['i'])==MAT['-1'], 'matrix rep of Q8')

FIELDS = [dict(label='2.2304.8t5.b.a', pol='x^8+12*x^6+36*x^4+36*x^2+9'),
          dict(label='2.42025.8t5.a.a', pol='x^8-3*x^7-63*x^6+90*x^5+1311*x^4-20*x^3-7702*x^2-5524*x-1009')]
PMAX = 20000
SIGMAS = [2.0, 1.5]
TS = [round(0.25*n,2) for n in range(0, 161)]   # t in [0,40]
out = dict(labels='[project] floating point (not interval) numerics; identity checks at 30 digits', pmax=PMAX, fields=[])
GENERIC_I = tuple(x/math.sqrt(3) for x in (0,1,1,1))  # unit imaginary not aligned with i,j,k... (1,1,1)/sqrt3
for fd in FIELDS:
    p.set_real_precision(38)
    p(f"P={fd['pol']}; N=nfinit(P); G=galoisinit(N); TC=galoischartable(G); T=TC[1];")
    check([int(x) for x in p('galoisidentify(G)')]==[8,4], 'Q8')
    deg = [int(p(f'T[1,{j}]')) for j in range(1,6)]
    p(f"chi=T[,{deg.index(2)+1}]; L=lfunartin(N,G,chi,TC[2]);")
    quad = [p(f'nfsubfields(P,2)[{t}][1]') for t in (1,2,3)]
    qdisc = [int(p.nfdisc(q)) for q in quad]; letters = dict(zip(qdisc,'ijk'))
    nfd = int(p('N.disc'))
    primes = [int(q) for q in p(f'primes([2,{PMAX}])') if nfd % int(q) != 0]
    frob = {}
    for q in primes:
        f = int(p(f'idealprimedec(N,{q})')[0][3])
        if f==1: g='1'
        elif f==2: g='-1'
        else:
            spl=[d for d in qdisc if int(p.kronecker(d,q))==1]; check(len(spl)==1,'one split quad'); g=letters[spl[0]]
        frob[q]=g
    an = [int(x) for x in p(f'lfunan(L,3000)')]
    for q in primes:
        if q<3000: check(an[q-1]=={'1':2,'-1':-2}.get(frob[q],0), 'a_p match')
    rng = random.Random(20261111)
    sign_sets = {'all+':{q:1 for q in primes}, 'all-':{q:-1 for q in primes}}
    for r in range(4): sign_sets[f'rand{r}'] = {q:rng.choice([1,-1]) for q in primes}
    def qpow(q, s, t, I):  # q^{-(sigma + t I)} as quaternion
        r = q**(-s); ph = t*math.log(q); c, sn = math.cos(ph), math.sin(ph)
        return (r*c, -r*sn*I[1], -r*sn*I[2], -r*sn*I[3]) if len(I)==4 else None
    def modelA(sig, t, I, signs, order):
        E=(1.0,0.0,0.0,0.0); lognrd=0.0
        for q in order:
            u = UNIT[frob[q]]
            if frob[q] in 'ijk' and signs[q]<0: u=neg(u)
            x = qpow(q,sig,t,I); gx = qmul(u,x)
            fac = (1-gx[0],-gx[1],-gx[2],-gx[3])
            lognrd -= math.log(nrd(fac)); E = qmul(E, qinv(fac))
        return E, lognrd
    def modelB(sig, t, signs, order):
        E=((1,0),(0,1)); logdet=0j
        for q in order:
            M = MAT[frob[q]]
            if frob[q] in 'ijk' and signs[q]<0: M = tuple(tuple(-x for x in row) for row in M)
            z = complex(q)**(-complex(sig,t))
            fac = ((1-M[0][0]*z, -M[0][1]*z),(-M[1][0]*z, 1-M[1][1]*z))
            inv, d = minv(fac); logdet -= cmath.log(d); E = mmul(E, inv)
        return E, logdet
    def logabsLP(sig,t):
        s=0.0
        for q in primes:
            a={'1':2,'-1':-2}.get(frob[q],0); z=complex(q)**(-complex(sig,t))
            s -= math.log(abs(1-a*z+z*z))
        return s
    # 30-digit identity check of the closed form nrd(1-gx) = 1 - 2r(cos th cos ph + sin th sin ph (u.I)) + r^2
    maxerr=0
    for trial in range(200):
        th=mp.mpf(rng.uniform(0,3.14)); ph=mp.mpf(rng.uniform(-50,50)); rr=mp.mpf(rng.uniform(0,0.9))
        def unitv():
            v=[mp.mpf(rng.gauss(0,1)) for _ in range(3)]; n=mp.sqrt(sum(a*a for a in v)); return [a/n for a in v]
        u=unitv(); I=unitv()
        g=(mp.cos(th),)+tuple(mp.sin(th)*a for a in u); x=(rr*mp.cos(ph),)+tuple(-rr*mp.sin(ph)*a for a in I)
        gx=qmul(g,x); direct=(1-gx[0])**2+gx[1]**2+gx[2]**2+gx[3]**2
        closed=1-2*rr*(mp.cos(th)*mp.cos(ph)+mp.sin(th)*mp.sin(ph)*sum(a*b for a,b in zip(u,I)))+rr**2
        maxerr=max(maxerr,abs(direct-closed))
    check(maxerr<mp.mpf(10)**-25, 'closed form nrd(1-gx)')
    rec = dict(label=fd['label'], quad_discs_ijk=qdisc, n_primes=len(primes),
               class_counts={c:sum(1 for q in primes if frob[q]==c) for c in UNIT}, closed_form_maxerr=float(maxerr), runs={})
    canon = primes[:]; rev = primes[::-1]; shuf = rng.sample(primes,len(primes))
    for sig in SIGMAS:
        rows=[]
        for t in TS:
            LP = logabsLP(sig,t)
            row=dict(t=t, log_absLP=LP)
            for nameI,I in (('i',UNIT['i']),('j',UNIT['j']),('k',UNIT['k']),('generic',GENERIC_I)):
                vals={}
                for sn,signs in sign_sets.items():
                    E,ln = modelA(sig,t,I,signs,canon); vals[sn]=ln
                    # order independence of the norm (Model A): check on two signs sets at a few t
                    if sn in ('all+','rand0') and t in (0.0,7.5,33.25):
                        _,ln2=modelA(sig,t,I,signs,rev); _,ln3=modelA(sig,t,I,signs,shuf)
                        check(abs(ln-ln2)<1e-11 and abs(ln-ln3)<1e-11,'A norm order-free')
                row[f'A_{nameI}']=vals
            # Model B: det choice/order free; trace spread
            dets=[]; trs=[]
            for sn,signs in list(sign_sets.items())[:4]:
                for order in (canon,rev):
                    E,ld = modelB(sig,t,signs,order); dets.append(ld); trs.append(E[0][0]+E[1][1])
            row['B_logdet_spread']=max(abs(d-dets[0]) for d in dets)
            row['B_logabsdet_minus_LP']=dets[0].real-LP
            row['B_trace_values']=[[x.real,x.imag] for x in trs]
            rows.append(row)
        # PARI full L check at a few points
        pari_pts=[]
        for t in (0.0,10.0,25.0,40.0):
            v = complex(p(f'lfun(L,{sig}+{t}*I)'))
            pari_pts.append(dict(t=t, log_abs_L_pari=math.log(abs(v)), log_absLP=logabsLP(sig,t),
                                 B_logdet_real=modelB(sig,t,sign_sets['all+'],canon)[1].real))
        rec['runs'][str(sig)]=dict(rows=rows, pari=pari_pts)
        mx=lambda key,sn: max(abs(r[key][sn]-r['log_absLP']) for r in rows)
        spread=lambda key: max(max(r[key].values())-min(r[key].values()) for r in rows)
        summ=dict(B_det_choice_spread=max(r['B_logdet_spread'] for r in rows),
                  B_det_vs_LP=max(abs(r['B_logabsdet_minus_LP']) for r in rows),
                  B_trace_max_spread=max(max(abs(complex(*a)-complex(*b)) for a in r['B_trace_values'] for b in r['B_trace_values']) for r in rows),
                  A_t0_dev={k:abs(rows[0][f'A_{k}']['all+']-rows[0]['log_absLP']) for k in ('i','j','k','generic')})
        for k in ('i','j','k','generic'):
            summ[f'A_{k}_max_dev_from_LP_all+']=mx(f'A_{k}','all+'); summ[f'A_{k}_max_sign_spread']=spread(f'A_{k}')
        rec['runs'][str(sig)]['summary']=summ
        print(fd['label'], sig, json.dumps(summ, default=float)); print(' pari', pari_pts)
    out['fields'].append(rec)
out['checks']=len(CHECKS)
json.dump(out, open('complex-s-results.json','w'), default=float)
print('checks passed', len(CHECKS))
