#!/usr/bin/env python3
"""Quaternion-valued ordered Euler products built from ACTUAL Q8 Frobenius elements.

For the two sign -1 Q8 Artin bases, the faithful 2-dim representation is the action of
Q8={±1,±i,±j,±k} on H. At an unramified prime p, Frob_p is an element of Q8 defined only
up to conjugacy (choice of prime above p). We form the ORDERED quaternion product
E_P(s)=prod_{p<=P} (1 - g_p p^{-s})^{-1} for REAL s>1 and test:
  (a) exact: nrd(E_P) = prod det(1-rho(g_p)p^{-s})^{-1} = L_P(rho,s) for every choice/order;
  (b) numerics: |E_P|^2 -> L(rho,s) (PARI lfunartin, floating point);
  (c) the quaternion E_P itself (direction, even real part) depends on choices and order.
Run with /workspace/tools/pari-venv/bin/python3.
"""
from fractions import Fraction as F
from datetime import datetime
from zoneinfo import ZoneInfo
import json, math, random
from cypari2 import Pari
p = Pari(); p.allocatemem(512*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)}
def neg(a): return tuple(-x for x in a)

FIELDS = [
  dict(label='2.2304.8t5.b.a', pol='x^8+12*x^6+36*x^4+36*x^2+9', bad=[2,3]),
  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', bad=[5,41]),
]
results = dict(generated=datetime.now(ZoneInfo('America/Los_Angeles')).isoformat(),
               labels='[project] exact rational identity checks; floating point (not interval) numerics',
               fields=[])
for fd in FIELDS:
    p.set_real_precision(40)
    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], f"{fd['label']} Galois group 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]);")
    cond = int(p('lfunparams(L)')[0])
    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'))
    fd['quadratic_subfield_discs'] = qdisc
    nfd = int(p('N.disc'))
    primes = [int(q) for q in p('primes([2,20000])') if nfd % int(q) != 0]
    frob = {}
    for q in primes:
        dec = p(f'idealprimedec(N,{q})')
        f = int(dec[0][3]); e = int(dec[0][2]); check(e == 1, 'unramified')
        trace = int(p(f'lfunan(L,{q})[{q}]')) if q < 3000 else None
        if f == 1: g = '1'; tr = 2
        elif f == 2: g = '-1'; tr = -2
        else:
            spl = [d for d in qdisc if int(p.kronecker(d, q)) == 1]
            check(len(spl) == 1, f'f=4 prime {q} splits in exactly one quadratic subfield')
            g = letters[spl[0]]; tr = 0
        if trace is not None: check(trace == tr, f'{fd["label"]} p={q} trace {tr} matches PARI a_p')
        frob[q] = g
    # (a) exact rational identity, s=2, primes < 200, several orderings and sign choices
    small = [q for q in primes if q < 200]
    def euler(order, signs, s, exact=True):
        E = (F(1),F(0),F(0),F(0)) if exact else (1.0,0.0,0.0,0.0)
        for q in order:
            u = UNIT[frob[q]]
            if frob[q] in 'ijk' and signs.get(q, 1) < 0: u = neg(u)  # conjugacy class {±i} etc.
            x = F(1, q**s) if exact else q**(-s)
            fac = (1 - u[0]*x, -u[1]*x, -u[2]*x, -u[3]*x)
            E = qmul(E, qinv(fac))
        return E
    local = F(1)
    for q in small:
        a = {'1':2,'-1':-2}.get(frob[q],0); x = F(1,q*q)
        local *= 1/(1 - a*x + x*x)
    rng = random.Random(20261110)
    exact_variants = []
    for trial in range(6):
        order = small[:] if trial == 0 else (small[::-1] if trial == 1 else rng.sample(small, len(small)))
        signs = {} if trial < 2 else {q: rng.choice([1,-1]) for q in small}
        E = euler(order, signs, 2)
        check(nrd(E) == local, f'{fd["label"]} exact nrd identity trial {trial}')
        exact_variants.append([float(c) for c in E])
    check(len({tuple(round(c,15) for c in v) for v in exact_variants}) == 6, 'all six quaternions distinct')
    # (b) float, s=2 and 3/2, primes < 20000, vs PARI L(rho,s)
    out = dict(label=fd['label'], conductor=cond, primes_used=len(primes), P_max=20000,
               frob_counts={g: sum(1 for v in frob.values() if v == g) for g in ['1','-1','i','j','k']},
               exact_rational_trials=6, exact_P=200, exact_variants_s2=exact_variants)
    for s in (2.0, 1.5):
        Lval = float(p(f'lfun(L,{s})'))
        canon = euler(primes, {}, s, False)
        rev = euler(primes[::-1], {}, s, False)
        rand = []
        for t in range(200):
            order = rng.sample(primes, len(primes)); signs = {q: rng.choice([1,-1]) for q in primes}
            rand.append(euler(order, signs, s, False))
        norms = [nrd(v) for v in [canon, rev] + rand]
        unit = lambda v: [c/math.sqrt(nrd(v)) for c in v]
        def ang(a, b): return math.degrees(math.acos(max(-1,min(1,sum(x*y for x,y in zip(unit(a),unit(b)))))))
        angs = [ang(canon, v) for v in rand]
        re_over = [v[0]/math.sqrt(nrd(v)) for v in rand]
        out[f's={s}'] = dict(L_pari=Lval, nrd_canonical=nrd(canon),
             rel_gap_to_L=abs(nrd(canon)-Lval)/Lval,
             nrd_spread=max(norms)-min(norms),
             canonical=canon, reversed=rev, angle_canon_vs_reversed_deg=ang(canon, rev),
             angle_canon_vs_random_deg=dict(min=min(angs), median=sorted(angs)[100], max=max(angs)),
             real_part_ratio_random=dict(min=min(re_over), max=max(re_over)),
             real_part_ratio_canonical=canon[0]/math.sqrt(nrd(canon)), random_variants=rand, random_norms=norms[2:])
        check(max(norms)-min(norms) < 1e-12*Lval, f'{fd["label"]} s={s} norm choice-independent (float)')
        tol = 1e-3 if s == 1.5 else 1e-6
        check(abs(nrd(canon)-Lval)/Lval < tol, f'{fd["label"]} s={s} |E|^2 close to PARI L (tail)')
    results['fields'].append(out)
results['checks'] = len(CHECKS)
json.dump(results, open('q8-frobenius-quaternions-results.json','w'), indent=1)
for f in results['fields']:
    print(f['label'], f['frob_counts'])
    for s in ('s=2.0','s=1.5'):
        d = f[s]; print(' ', s, 'L', d['L_pari'], 'nrd', d['nrd_canonical'], 'gap', d['rel_gap_to_L'],
              'rev angle', round(d['angle_canon_vs_reversed_deg'],4), 'rand', {k: round(v,3) for k,v in d['angle_canon_vs_random_deg'].items()},
              'Re/|E|', d['real_part_ratio_random'], 'canon', d['canonical'])
print('checks', len(CHECKS))
