#!/usr/bin/env python3
"""Zero side of the 2O (galpol [48,28]) Model A quaternion prime sum: real part and pure part (axes u, n, m).
Usage: python3 run.py [A|B]   (plain python3 + numpy/scipy/mpmath; data from zeros_export.py -> pari-zeros.json)
Explicit formula, self-dual Artin L (all 2O characters are real) [known: Weil 1952; Iwaniec-Kowalski Thm 5.12]:
   m0 h(0) + 2 sum_{gamma>0} h(gamma) = pole + (1/pi) int_0^inf h(r)[log N + sum_j Re psi((1/2+kap_j+ir)/2) - d log pi] dr
                                         - 2 sum_n Lam(n) w(log n)/sqrt n,     h even, w(x) = (1/2pi) int h(r) e^{-irx} dr.
Quaternion side (Model A, unramified p only, exact prime powers p^k<=NMAX):
   real = -2 sum cos(k th_p) log p w(k log p)/p^{k/2};  axis a in {u,n,m}: same with sin(k th_p), classes on axis a.
k=1 layer = sum_chi c_chi(axis) * [-2 sum Lam_chi w/sqrt n] (coeffs.json, exact); Delta = quaternion - k=1 L-combination
(k>=2 terms and ramified p=2,5,17), computed on the prime side only.
Code A: mpmath 30 digits, closed-form cos/sin.  Code B: numpy/scipy doubles, explicit quaternion multiplication."""
import json, math, sys, time
import numpy as np, mpmath as mp
from scipy import integrate, special
from datetime import datetime
from zoneinfo import ZoneInfo
mp.mp.dps = 30
CONV = 'A'
from pathlib import Path
import glob
sys.path.insert(0, '.')
NMAX = 20000
CH = {}
for nm in ('zeta', 'rho', 'three', 'threep', 'four', 'five'):
    f = Path(f'zeros-{nm}.json')
    if f.exists(): CH[nm] = json.loads(f.read_text())
C = json.load(open('coeffs.json'))['k1']
def ev(s): return float(eval(s.replace('sqrt', 'math.sqrt'), {'math': math}))
COEF = {ax: {k: ev(v) for k, v in C[ax]['coeffs'].items() if v != '0'} for ax in ('v5', 'n3', 'm2', 'real')}
NAMES = list(CH)
def primes_upto(n):
    s = bytearray([1])*(n+1); s[0] = s[1] = 0
    for i in range(2, int(n**.5)+1):
        if s[i]: s[i*i::i] = bytearray(len(s[i*i::i]))
    return [i for i in range(n+1) if s[i]]
PR = primes_upto(NMAX); RAM = {2, 11, 23}
from an_build import load_pclass
_pc, _th, _q = load_pclass()
pi = math.pi
CLN = ['C1', 'C10a', 'C5a', 'C6', 'C4', 'C10b', 'C3', 'C5b', 'C-1']
THN = [0, pi/5, 2*pi/5, pi/3, pi/2, 3*pi/5, 2*pi/3, 4*pi/5, pi]
AXN = ['v5', 'v5', 'v5', 'n3', 'm2', 'v5', 'n3', 'v5', 'v5']
IDX = {i: min(range(9), key=lambda j: abs(THN[j]-_th[i])) for i in range(len(_th))}
assert all(abs(THN[IDX[i]]-_th[i]) < 1e-9 for i in IDX)
PCL = {p: CLN[IDX[_pc[p]]] for p in PR if p not in RAM}
ORD = {'C1': 1, 'C-1': 2, 'C4': 4, 'C6': 6, 'C3': 3, 'C10a': 10, 'C10b': 10, 'C5a': 5, 'C5b': 5}
AUDIT_MISMATCH = 0
REP = {CLN[j]: (AXN[j], THN[j]) for j in range(9)}
AX = {'v5': np.array([1., 0, 0]), 'n3': np.array([1., 1, 1])/math.sqrt(3), 'm2': np.array([0., 1, 1])/math.sqrt(2)}
def quat(c):
    ax, th = REP[c]; v = AX[ax]
    return np.array([math.cos(th), *(math.sin(th)*v)])
def qm(a, b):
    a0, a1, a2, a3 = a; b0, b1, b2, b3 = b
    return np.array([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])
# ---- Lambda from a_n (incl. ramified) ----
def lam_from_an(a):
    Lam = {}
    for p in PR:
        q = p; k = 1; prev = []
        while q <= NMAX:
            s = a[q-1]*k*math.log(p) - sum(prev[j-1]*a[p**(k-j)-1] for j in range(1, k))
            prev.append(s); Lam[q] = (p, k, s); q *= p; k += 1
    return Lam
LAM = {c: lam_from_an(CH[c]['an']) for c in NAMES}
ZP = {c: [z for z in CH[c]['zeros_pos'] if z > 0] for c in NAMES}
M0 = {c: CH[c]['order0'] for c in NAMES}
# ---- test functions ----
def g0m(T, x): return T/(2*mp.sqrt(mp.pi))*mp.exp(-(T*x)**2/4)
def g0f(T, x): return T/(2*math.sqrt(math.pi))*math.exp(-(T*x)**2/4)
class Fam:
    """even: h = exp(-(r/T)^2) cos(x0 r), w = (g0(x-x0)+g0(x+x0))/2"""
    def __init__(s, T, x0=0.0): s.T, s.x0 = T, x0
    def h_m(s, r): return mp.exp(-(r/s.T)**2)*mp.cos(s.x0*r)
    def h_f(s, r): return math.exp(-(r/s.T)**2)*math.cos(s.x0*r)
    def w_m(s, x): return (g0m(s.T, x-s.x0)+g0m(s.T, x+s.x0))/2
    def w_f(s, x): return (g0f(s.T, x-s.x0)+g0f(s.T, x+s.x0))/2
def arch_m(fam, c):
    N = CH[c]['conductor']; kap = CH[c]['Vga']; T = fam.T
    f = lambda r: fam.h_m(r)*(mp.log(N) + mp.fsum(mp.re(mp.digamma((mp.mpf(1)/2+kj+1j*r)/2)) - mp.log(mp.pi) for kj in kap))
    if fam.x0:
        n = int(12*T*fam.x0/mp.pi)+1
        pts = [mp.mpf(j)*12*T/n for j in range(n+1)] + [mp.inf]
    else:
        pts = [0] + [T*m for m in (0.5, 1, 1.5, 2, 3, 4, 6, 8, 12)] + [mp.inf]
    return mp.quad(f, pts)/mp.pi
def arch_f(fam, c):
    N = CH[c]['conductor']; kap = CH[c]['Vga']
    f = lambda r: fam.h_f(r)*(math.log(N) + sum(special.digamma((0.5+kj+1j*r)/2).real - math.log(math.pi) for kj in kap))
    v = 0.0; edges = np.linspace(0, 12*fam.T, int(12*fam.T*max(fam.x0, 1)/2)+2)
    for lo, hi in zip(edges[:-1], edges[1:]):
        v += integrate.quad(f, lo, hi, epsabs=1e-15, epsrel=1e-13, limit=200)[0]
    return v/math.pi
def pole_m(fam, c):
    if c != 'zeta': return mp.mpf(0)
    z = mp.mpc(0, 0.5); return 2*mp.re(mp.exp(-(z/fam.T)**2)*mp.cos(fam.x0*z))
def pole_f(fam, c):
    if c != 'zeta': return 0.0
    return 2*math.exp(1/(4*fam.T**2))*math.cosh(fam.x0/2)
def zero_m(fam, c): return M0[c]*fam.h_m(0) + 2*mp.fsum(fam.h_m(mp.mpf(z)) for z in ZP[c])
def zero_f(fam, c): return M0[c]*fam.h_f(0.0) + 2*sum(fam.h_f(z) for z in ZP[c])
def prime_m(fam, c): return mp.fsum(-2*mp.mpf(s)*fam.w_m(mp.log(n))/mp.sqrt(n) for n, (p, k, s) in LAM[c].items())
def prime_f(fam, c): return sum(-2*s*fam.w_f(math.log(n))/math.sqrt(n) for n, (p, k, s) in LAM[c].items())
def quat_m(fam):
    out = {a: mp.mpf(0) for a in ('real', 'v5', 'n3', 'm2')}
    k1 = {a: mp.mpf(0) for a in out}
    for p, c in PCL.items():
        ax, th = REP[c]; lg = mp.log(p); pk = 1
        for k in range(1, 40):
            pk *= p
            if pk > NMAX: break
            wt = -2*lg*fam.w_m(k*lg)/mp.sqrt(pk)
            out['real'] += wt*mp.cos(k*mp.mpf(th)); out[ax] += wt*mp.sin(k*mp.mpf(th))
            if k == 1: k1['real'] += wt*mp.cos(mp.mpf(th)); k1[ax] += wt*mp.sin(mp.mpf(th))
    return out, k1
def quat_f(fam):
    out = {a: 0.0 for a in ('real', 'v5', 'n3', 'm2')}
    for p, c in PCL.items():
        g = quat(c); ax = REP[c][0]; q = np.array([1., 0, 0, 0]); lg = math.log(p); pk = 1
        for k in range(1, 40):
            q = qm(q, g); pk *= p
            if pk > NMAX: break
            wt = -2*lg*fam.w_f(k*lg)/math.sqrt(pk)
            out['real'] += wt*q[0]; out[ax] += wt*float(q[1:] @ AX[ax])
    return out
def tail_bound(fam, c, E=10.0):
    """[heuristic] zeros above H (both signs): 2*(env(H)*E + int_H^inf env(t) rho(t) dt), rho=(1/2pi)(log N + d log(t/2pi)); E not a proved N(T) bound"""
    N = CH[c]['conductor']; d = CH[c]['dim']; T = fam.T; H = CH[c]['H']
    env = lambda t: mp.exp(-(t/T)**2)
    rho = lambda t: (mp.log(N) + d*mp.log(t/(2*mp.pi)))/(2*mp.pi)
    return float(2*(env(H)*E + mp.quad(lambda t: env(t)*rho(t), [H, H+5*T, mp.inf])))
def prime_tail(fam, d):
    T, x0 = fam.T, fam.x0
    env = lambda x: (g0m(T, x-x0)+g0m(T, x+x0))/2
    return float(2*d*mp.quad(lambda x: x*env(x)*mp.exp(x/2), [mp.log(NMAX), mp.log(NMAX)+2, mp.log(NMAX)+8, mp.inf]))
def main():
    t0 = time.time()
    need = sorted(set(CH))
    need = [c for c in need if c in CH]
    missing = sorted({c for ax in COEF for c in COEF[ax]} - set(CH))
    res = dict(generated=datetime.now(ZoneInfo('America/Los_Angeles')).isoformat(), convention=CONV, nmax=NMAX,
               labels='[project] numerical check of [known] explicit formula; PARI zeros uncertified floats; mpmath(A) vs numpy(B)',
               coeffs=COEF, missing_L=missing, class_audit_mismatch=AUDIT_MISMATCH,
               class_counts={c: sum(1 for v in PCL.values() if v == c) for c in ORD},
               zero_counts={c: dict(pos=len(ZP[c]), m0=M0[c], H=CH[c]['H']) for c in need}, rows=[])
    print('convention', CONV, 'missing', missing, 'audit mismatches', AUDIT_MISMATCH, res['class_counts'], flush=True)
    fams = [Fam(T) for T in (1.0, 1.5, 2.0, 3.0, 5.0, 8.0, 12.0)] + [Fam(8.0, x0) for x0 in (1.0, 1.5, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0)]
    from multiprocessing import Pool
    with Pool(7) as pool:
        rows = pool.map(row_for, fams, chunksize=1)
    for row in rows:
        res['rows'].append(row)
        print(f"T={row['T']} x0={row['x0']}: " + ' '.join(f"{c}:{row['per_L'][c]['resid_A']:+.1e}" for c in need) + ' | ' + ' '.join(f"{ax}: Q={v['quat']:+.6f} res={v.get('resid', float('nan')):+.1e}" for ax, v in row['axes'].items()), flush=True)
    res['elapsed_seconds'] = time.time()-t0
    json.dump(res, open(f'results-{CONV}.json', 'w'), indent=1)

def row_for(fam):
    need = sorted(set(CH))
    if True:
        t1 = time.time()
        row = dict(T=fam.T, x0=fam.x0, per_L={})
        ZA, AA, PA, ZB, AB, PB = {}, {}, {}, {}, {}, {}
        for c in need:
            ZA[c] = zero_m(fam, c); AA[c] = arch_m(fam, c) + pole_m(fam, c); PA[c] = prime_m(fam, c)
            ZB[c] = zero_f(fam, c); AB[c] = arch_f(fam, c) + pole_f(fam, c); PB[c] = prime_f(fam, c)
            row['per_L'][c] = dict(zero=float(ZA[c]), arch_pole=float(AA[c]), prime=float(PA[c]), resid_A=float(ZA[c]-AA[c]-PA[c]),
                                   resid_B=ZB[c]-AB[c]-PB[c], zero_A_minus_B=float(ZA[c])-ZB[c],
                                   budget=tail_bound(fam, c)+prime_tail(fam, CH[c]['dim']))
        QA, K1 = quat_m(fam); QB = quat_f(fam)
        row['axes'] = {}
        for ax in ('real', 'v5', 'n3', 'm2'):
            cf = COEF[ax]
            if any(c not in CH for c in cf):
                row['axes'][ax] = dict(quat=float(QA[ax]), quat_B=QB[ax], note='needs missing L: ' + ','.join(c for c in cf if c not in CH)); continue
            lin_zero = mp.fsum(cf[c]*(ZA[c]-AA[c]) for c in cf)
            lin_prime = mp.fsum(cf[c]*PA[c] for c in cf)
            delta = QA[ax] - lin_prime
            row['axes'][ax] = dict(quat=float(QA[ax]), quat_B=QB[ax], codeA_B=float(QA[ax])-QB[ax], quat_k1=float(K1[ax]),
                                   lin_zero_side=float(lin_zero), lin_prime_side=float(lin_prime), delta=float(delta),
                                   resid=float(QA[ax] - (lin_zero + delta)),
                                   resid_B=QB[ax] - (sum(cf[c]*(ZB[c]-AB[c]) for c in cf) + (QB[ax]-sum(cf[c]*PB[c] for c in cf))),
                                   share={c: float(cf[c]*(ZA[c]-AA[c])) for c in cf},
                                   budget=float(sum(abs(cf[c])*row['per_L'][c]['budget'] for c in cf)))
        r = row['axes']['real']
        if 'rho' in ZA:
            cz = M0['rho']*fam.h_m(0)
            row['rho_central'] = dict(central_share=float(cz/ZA['rho']), resid_without_central=float(ZA['rho']-cz-AA['rho']-PA['rho']))
        row['secs'] = round(time.time()-t1, 1)
        for ax in ('v5','n3','m2'):
            cf = COEF[ax]; av = {c: float(cf[c]*(ZA[c]-AA[c])) for c in cf if c in ZA}
            row['axes'][ax]['avail_share'] = av
        return row
if __name__ == '__main__': main()
