"""Aligned-unit (Model A) Frobenius-quaternion product as a 'half' Hecke L-function. Sprint 11 Nov 2026 ~8:30 PM PST.
Claim tested: with I = u (complex unit of s = the quaternion unit u labelling quadratic subfield F) and the 'all +' choice g_p = +u,
  F(s) := prod_{p unram, Frob in {1,-1,+-u}} (1 - g_p p^-s)^-1   (lies in C_u = C)
       = L(rho,s)^(1/2) * [zeta L_u / (L_v L_w)](s)^(i/4) * [zeta(2s)/L_u(2s)]^(1/4) * G(s),
G holomorphic, nonvanishing, absolutely convergent Euler product on Re s > 1/3 (all L partial: ramified factors removed).
Run: /workspace/tools/pari-venv/bin/python3 half_hecke.py   Floating point, not intervals."""
import json, math, cmath, sys, time
import numpy as np, sympy as sp
from cypari2 import Pari
pari = Pari(); pari.allocatemem(1500*10**6); pari.set_real_precision(30)
CHECKS=[]
def check(c,msg):
    CHECKS.append(msg)
    if not c: raise AssertionError(msg)
out=dict(note='[project] float numerics (not intervals); exact series check in Q(i)', fields=[])
# ---------- 1. exact formal check: local log difference starts at x^3, for every class ----------
x=sp.symbols('x'); I=sp.I
def mlog(poly): return sp.series(-sp.log(poly),x,0,6).removeO()
# classes: '1','-1','u','v','w' ; values of quadratic chars (triv,chi_u,chi_v,chi_w) and det(1-rho x)
CH={'1':(1,1,1,1),'-1':(1,1,1,1),'u':(1,1,-1,-1),'v':(1,-1,1,-1),'w':(1,-1,-1,1)}
DET={'1':(1-x)**2,'-1':(1+x)**2,'u':1+x**2,'v':1+x**2,'w':1+x**2}
LAM={'1':1,'-1':-1,'u':I,'v':None,'w':None}
a=(I/4,I/4,-I/4,-I/4); b=(sp.Rational(1,4),-sp.Rational(1,4),0,0)
ser={}
for c in CH:
    T = 0 if LAM[c] is None else mlog(1-LAM[c]*x)
    R = sp.Rational(1,2)*mlog(DET[c]) + sum(a[m]*mlog(1-CH[c][m]*x) for m in range(4)) + sum(b[m]*mlog(1-CH[c][m]*x**2) for m in range(4))
    d=sp.expand(T-R); ser[c]=str(d)
    check(all(sp.simplify(d.coeff(x,k))==0 for k in (0,1,2)), f'series O(x^3) class {c}')
out['exact_series_difference_to_x5']=ser
# uniqueness: unknown exponents for (rho, 4 chars at s, 4 chars at 2s) -> linear system on x,x^2 coefficients
A_=sp.symbols('A0:5'); B_=sp.symbols('B0:4'); eqs=[]
for c in CH:
    T = 0 if LAM[c] is None else mlog(1-LAM[c]*x)
    R = A_[4]*mlog(DET[c]) + sum(A_[m]*mlog(1-CH[c][m]*x) for m in range(4)) + sum(B_[m]*mlog(1-CH[c][m]*x**2) for m in range(4))
    d=sp.expand(T-R); eqs += [d.coeff(x,1), d.coeff(x,2)]
sol=sp.solve(eqs, list(A_)+list(B_), dict=True)
out['exponent_solution']=str(sol)
# x^2 coefficient only sees B0+B1 (classes 1,-1,u) and B0-B1 (v,w): system determines B0,B1 only up to B2,B3 combos? report
print('solution', sol)

FIELDS=[dict(label='2.2304.8t5.b.a', pol='x^8+12*x^6+36*x^4+36*x^2+9', eps=-1),
        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', eps=-1),
        dict(label='2.2304.8t5.a.a', pol='x^8-12*x^6+36*x^4-36*x^2+9', eps=+1)]
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 qinv(a):
    n=sum(t*t for t in a); return (a[0]/n,-a[1]/n,-a[2]/n,-a[3]/n)
UV={'i':(0,1,0,0),'j':(0,0,1,0),'k':(0,0,0,1)}
XMAX=80000; XS=[5000,20000,80000]
SIG=[2.0,1.5]; TS=np.round(np.arange(0,40.0001,0.05),3)
quick = '--quick' in sys.argv
if quick: XMAX=20000; XS=[5000,20000]; TS=TS[::10]
def lval(name, s): return complex(pari(f'lfun({name},{s.real}+{s.imag}*I)'))
for fd in FIELDS:
    t0=time.time()
    pari(f"P={fd['pol']}; N=nfinit(P); G=galoisinit(N); TC=galoischartable(G); T=TC[1];")
    check([int(v) for v in pari('galoisidentify(G)')]==[8,4],'Q8')
    deg=[int(pari(f'T[1,{j}]')) for j in range(1,6)]
    pari(f"chi=T[,{deg.index(2)+1}]; Lr=lfunartin(N,G,chi,TC[2]);")
    eps=complex(pari('lfunrootres(Lr)[3]')); check(abs(eps-fd['eps'])<1e-8, 'root number')
    qd=[int(pari.nfdisc(pari(f'nfsubfields(P,2)[{t}][1]'))) for t in (1,2,3)]
    nfd=int(pari('N.disc')); ram=[int(q) for q in pari(f'factor({nfd})[,1]')]
    an=[int(v) for v in pari(f'lfunan(Lr,{XMAX})')]
    primes=[int(q) for q in pari(f'primes([2,{XMAX}])') if q not in ram]
    kr={d:np.array([int(pari.kronecker(d,q)) for q in primes]) for d in qd}
    frob=[]
    for n_,q in enumerate(primes):
        ap=an[q-1]
        if ap==2: frob.append('1')
        elif ap==-2: frob.append('-1')
        else:
            spl=[m for m,d in enumerate(qd) if kr[d][n_]==1]; check(len(spl)==1,'one split'); frob.append('ijk'[spl[0]])
    frob=np.array(frob); P_=np.array(primes,dtype=float)
    pari(f"Lz=lfuncreate(1); "+"; ".join(f"Lq{m}=lfuncreate({d})" for m,d in enumerate(qd)))
    rec=dict(label=fd['label'], root_number=fd['eps'], quad_discs_ijk=qd, ramified=ram, n_primes=len(primes), aligned={})
    for ui,u in enumerate('ijk'):
        others=[m for m in range(3) if m!=ui]
        names=dict(z='Lz', u=f'Lq{ui}', v=f'Lq{others[0]}', w=f'Lq{others[1]}')
        dsc=dict(z=1,u=qd[ui],v=qd[others[0]],w=qd[others[1]])
        lam=np.where(frob=='1',1+0j,np.where(frob=='-1',-1+0j,np.where(frob==u,1j,0j)))
        chi={k:(np.ones(len(primes)) if k=='z' else kr[dsc[k]].astype(float)) for k in dsc}
        detc=np.where(frob=='1',2.0,np.where(frob=='-1',-2.0,0.0))  # trace; det(1-rho x)=1-tr x + x^2
        # quaternion cross-check of one product value (all + , I=u): stays in C_u and equals complex product
        s0=complex(1.5,7.3); Eq=(1.0,0,0,0)
        for n_,q in enumerate(primes[:3000]):
            if lam[n_]==0: continue
            r=q**(-s0.real); ph=s0.imag*math.log(q); xq=tuple([r*math.cos(ph)]+[-r*math.sin(ph)*c for c in UV[u][1:]])
            g=(1.0,0,0,0) if frob[n_]=='1' else (-1.0,0,0,0) if frob[n_]=='-1' else UV[u]
            gx=qmul(g,xq); Eq=qmul(Eq,qinv((1-gx[0],-gx[1],-gx[2],-gx[3])))
        Ec=np.prod(1/(1-lam[:3000]*P_[:3000]**(-s0)))
        perp=[Eq[1+m] for m in range(3) if m!=ui]
        check(max(abs(v) for v in perp)<1e-14 and abs(Eq[0]-Ec.real)<1e-12 and abs(Eq[1+ui]-Ec.imag)<1e-12,'quaternion product = complex product in C_u')
        def ramfix(key, s):  # log of partial L = log L - sum_ram log local factor
            tot=0j
            for q in ram:
                if key=='r':
                    continue  # rho has no inertia invariants at ramified primes (faithful, irreducible): local factor 1
                c=1 if key=='z' else int(pari.kronecker(dsc[key],q))
                if c!=0: tot += -cmath.log(1-c*q**(-s))
            return tot
        res={}
        for sig in SIG:
            S=sig+1j*TS
            # PARI values with continuous branch in t (t=0 real positive)
            Lv={}
            for key,nm in [('r','Lr')]+[(k,names[k]) for k in 'zuvw']:
                vals=np.array([lval(nm,s) for s in S]); lg=np.log(np.abs(vals))+1j*np.unwrap(np.angle(vals))
                lg=lg-np.array([ramfix(key,s) for s in S]); Lv[key]=lg
            L2={}
            for key in 'zu':
                vals=np.array([lval(names[key],2*s) for s in S]); lg=np.log(np.abs(vals))+1j*np.unwrap(np.angle(vals))
                L2[key]=lg-np.array([ramfix(key,2*s) for s in S])
            main=0.5*Lv['r']+0.25j*(Lv['z']+Lv['u']-Lv['v']-Lv['w'])+0.25*(L2['z']-L2['u'])
            errs={}
            for X in XS:
                m=P_<=X; pp=P_[m][:,None]; xx=pp**(-S[None,:])
                logF=np.sum(-np.log(1-lam[m][:,None]*xx),axis=0)
                rhs_loc=(0.5*(-np.log(1-detc[m][:,None]*xx+xx**2))
                         +0.25j*sum(sg*(-np.log(1-chi[k][m][:,None]*xx)) for k,sg in zip('zuvw',(1,1,-1,-1)))
                         +0.25*(-np.log(1-chi['z'][m][:,None]*xx**2))-0.25*(-np.log(1-chi['u'][m][:,None]*xx**2)))
                logG=np.sum(-np.log(1-lam[m][:,None]*xx)-rhs_loc,axis=0)
                d=logF-(main+logG)
                # compare modulo 2*pi*i? should be exact branch: report raw
                errs[X]=dict(max_abs=float(np.max(np.abs(d))), max_re=float(np.max(np.abs(d.real))),
                             logG_max=float(np.max(np.abs(logG))))
            res[str(sig)]=dict(errors=errs, max_abs_logF_minus_halflogL=float(np.max(np.abs((logF-0.5*Lv['r'])))))
        rec['aligned'][u]=res
        print(fd['label'],u,json.dumps(res),flush=True)
    rec['seconds']=time.time()-t0
    out['fields'].append(rec)
out['checks']=len(CHECKS)
json.dump(out,open('half-hecke-results.json' if not quick else 'quick.json','w'),indent=1)
print('checks',len(CHECKS))
