#!/usr/bin/env python3
"""2I (binary icosahedral, SL(2,5)) aligned Model A product F10 along a 10-fold axis.

Exact arithmetic in Q(zeta_60) (elements = polynomials in z mod Phi_60 over Q).
Classes are labelled by t with eigenvalues of the quaternion = z^{±t}, z = e^{2 pi i/60}.
  C1 t=0 | C-1 t=30 | C4 t=15 | C3 t=20 | C6 t=10 | C5a t=12 (2pi/5) | C5b t=24 (4pi/5)
  C10a t=6 (pi/5) | C10b t=18 (3pi/5)
Slice: <e^{i pi/5}> = {z^{6m}}; classes meeting it: C1,C-1,C5a,C5b,C10a,C10b; psi = z^t (Im>=0).

k=1 layer  -> exponents a_chi of L(chi,s)
k=2 layer  -> exponents b_chi of L(chi,2s)
k>=3       -> H_p, with dlogH/dx = sum_{k>=1} r_k x^{k-1}, r_k periodic in k.
Run: /workspace/tools/pari-venv/bin/python derive_identity.py
"""
from __future__ import annotations
import json, time
from fractions import Fraction
from pathlib import Path
import sympy as sp

t0 = time.time()
HERE = Path(__file__).resolve().parent
N = 60
x = sp.symbols('x')
PHI = sp.Poly(sp.cyclotomic_poly(N, x), x, domain='QQ')
DEG = PHI.degree()

# ---------- Q(zeta_60) arithmetic: dense lists of Fractions, length DEG ----------
# precompute z^j mod Phi for j=0..N-1
ZP = []
for j in range(N):
    r = sp.Poly(x**j, x, domain='QQ').rem(PHI)
    c = [Fraction(0)] * DEG
    for (e,), v in r.terms():
        c[e] = Fraction(int(v.p), int(v.q))
    ZP.append(c)

def zpow(j):
    return list(ZP[j % N])
def add(a, b): return [u + v for u, v in zip(a, b)]
def sub(a, b): return [u - v for u, v in zip(a, b)]
def scal(c, a): return [c * u for u in a]
ZERO = [Fraction(0)] * DEG
ONE = zpow(0)
def mul(a, b):
    out = [Fraction(0)] * (2 * DEG)
    for i, u in enumerate(a):
        if u:
            for j, v in enumerate(b):
                if v:
                    out[i + j] += u * v
    res = list(ZERO)
    for k, c in enumerate(out):
        if c:
            res = add(res, scal(c, zpow(k)))
    return res
def conj(a):
    res = list(ZERO)
    for k, c in enumerate(a):
        if c:
            res = add(res, scal(c, zpow(-k)))
    return res
def is_zero(a): return all(c == 0 for c in a)
def to_sym(a):
    zz = sp.exp(2 * sp.pi * sp.I / N)
    return sp.nsimplify(sum(sp.Rational(c.numerator, c.denominator) * zz**k for k, c in enumerate(a) if c))
def to_complex(a):
    import cmath
    return sum(float(c) * cmath.exp(2j * cmath.pi * k / N) for k, c in enumerate(a))

# ---------- group data ----------
CL = ['C1', 'Cm1', 'C4', 'C3', 'C6', 'C5a', 'C5b', 'C10a', 'C10b']
T = dict(C1=0, Cm1=30, C4=15, C3=20, C6=10, C5a=12, C5b=24, C10a=6, C10b=18)
SIZE = dict(C1=1, Cm1=1, C4=30, C3=20, C6=20, C5a=12, C5b=12, C10a=12, C10b=12)
ORD = dict(C1=1, Cm1=2, C4=4, C3=3, C6=6, C5a=5, C5b=5, C10a=10, C10b=10)
assert sum(SIZE.values()) == 120
SLICE = {'C1', 'Cm1', 'C5a', 'C5b', 'C10a', 'C10b'}
# qidx used in poly1112 / icosa1113 pclass files
QIDX = {0: 'C1', 1: 'C6', 2: 'C3', 3: 'C10b', 4: 'Cm1', 5: 'C5b', 6: 'C5a', 7: 'C4', 8: 'C10a'}

def tau(t):
    """Galois conjugation sqrt5 -> -sqrt5 on the angle of rho: multiples of pi/5 go to 3x."""
    t %= N
    return (3 * t) % N if (t % 6 == 0) else t

def eig_exps(ir, t):
    """eigenvalue exponents (powers of z) of irrep ir on the class with angle t."""
    tp = tau(t)
    if ir == '1':   return [0]
    if ir == 'rho': return [t, -t]
    if ir == "rho'": return [tp, -tp]
    if ir == '3':   return [2*t, 0, -2*t]
    if ir == "3'":  return [2*tp, 0, -2*tp]
    if ir == '4':   return [t+tp, t-tp, -t+tp, -t-tp]
    if ir == '5':   return [4*t, 2*t, 0, -2*t, -4*t]
    if ir == "4'":  return [3*t, t, -t, -3*t]
    if ir == '6':   return [5*t, 3*t, t, -t, -3*t, -5*t]
    raise KeyError(ir)
IRR = ['1', '3', "3'", '4', '5', 'rho', "rho'", "4'", '6']
FAITHFUL = {'rho', "rho'", "4'", '6'}

def power_sum(ir, cl, k):
    """chi(g^k) for g in class cl, as an element of Q(zeta_60)."""
    acc = list(ZERO)
    for e in eig_exps(ir, T[cl]):
        acc = add(acc, zpow(k * e))
    return acc

# sanity: orthogonality (exact)
for a_ in IRR:
    for b_ in IRR:
        ip = list(ZERO)
        for cl in CL:
            ip = add(ip, scal(Fraction(SIZE[cl]), mul(power_sum(a_, cl, 1), conj(power_sum(b_, cl, 1)))))
        exp = scal(Fraction(120 if a_ == b_ else 0), ONE)
        assert ip == exp, (a_, b_, to_sym(ip))
print('orthogonality of the 9 characters: OK (exact)')
# consistency of tau with powers: rho'(g^k) must be a class function of g^k
chartab = {ir: [to_sym(power_sum(ir, cl, 1)) for cl in CL] for ir in IRR}

def psi(cl):
    return zpow(T[cl]) if cl in SLICE else None

def inner(f, ir):  # <f, chi> = 1/120 sum |C| f(C) conj chi(C)
    acc = list(ZERO)
    for cl in CL:
        if f[cl] is not None and not is_zero(f[cl]):
            acc = add(acc, scal(Fraction(SIZE[cl]), mul(f[cl], conj(power_sum(ir, cl, 1)))))
    return scal(Fraction(1, 120), acc)

# k=1
f1 = {cl: (psi(cl) if cl in SLICE else list(ZERO)) for cl in CL}
A = {ir: inner(f1, ir) for ir in IRR}
# check expansion
for cl in CL:
    s = list(ZERO)
    for ir in IRR: s = add(s, mul(A[ir], power_sum(ir, cl, 1)))
    assert s == f1[cl]
# k=2: f2(g) = psi^2 [slice] - sum a chi(g^2) ; 2 sum b chi(g) = f2
f2 = {}
for cl in CL:
    v = mul(psi(cl), psi(cl)) if cl in SLICE else list(ZERO)
    for ir in IRR: v = sub(v, mul(A[ir], power_sum(ir, cl, 2)))
    f2[cl] = v
B = {ir: scal(Fraction(1, 2), inner(f2, ir)) for ir in IRR}

def r(cl, k):
    v = zpow(k * T[cl]) if cl in SLICE else list(ZERO)
    for ir in IRR: v = sub(v, mul(A[ir], power_sum(ir, cl, k)))
    if k % 2 == 0:
        for ir in IRR: v = sub(v, scal(Fraction(2), mul(B[ir], power_sum(ir, cl, k // 2))))
    return v

KMAX = 120
R = {cl: [r(cl, k) for k in range(1, KMAX + 1)] for cl in CL}
for cl in CL:
    assert is_zero(R[cl][0]) and is_zero(R[cl][1]), cl
print('k=1 and k=2 layers cancel exactly on every class')
# periodicity
PER = {}
for cl in CL:
    Tp = 2 * ORD[cl] if ORD[cl] > 1 else 2
    for k in range(KMAX - Tp):
        assert R[cl][k] == R[cl][k + Tp], (cl, k)
    PER[cl] = Tp
print('r_k periodic with period 2*ord on every class, checked for k <= %d' % KMAX)

# closed form of dlog H
Hrat = {}
roots_ok = {}
for cl in CL:
    Tp = PER[cl]
    num = sum(to_sym(R[cl][k - 1]) * x**(k - 1) for k in range(1, Tp + 1))
    expr = sp.cancel(sp.together(num / (1 - x**Tp)))
    expr = sp.simplify(expr)
    Hrat[cl] = expr
    n_, d_ = sp.fraction(sp.cancel(expr))
    if d_.has(x):
        rts = sp.Poly(d_, x).nroots(n=30)
        roots_ok[cl] = max(abs(abs(complex(z)) - 1) for z in rts)
    else:
        roots_ok[cl] = 0.0
    # verify series of closed form against r_k through KMAX
    ser = sp.series(expr, x, 0, 40).removeO()
    for k in range(1, 40):
        dif = sp.nsimplify(sp.expand(ser.coeff(x, k - 1) - to_sym(R[cl][k - 1])))
        assert abs(complex(sp.N(dif, 30))) < 1e-25, (cl, k, dif)
    print(cl, 'dlogH =', expr, '| max ||root|-1| =', roots_ok[cl], flush=True)

def nice(a):
    v = to_sym(a)
    v = sp.nsimplify(sp.radsimp(sp.expand(sp.simplify(v.rewrite(sp.cos)))))
    return sp.simplify(v)

Aexp = {ir: nice(A[ir]) for ir in IRR}
Bexp = {ir: nice(B[ir]) for ir in IRR}
print('\nL(chi, s) exponents a_chi:')
for ir in IRR: print(f'  {ir:5s}', Aexp[ir], '  ~', complex(sp.N(Aexp[ir])))
print('L(chi, 2s) exponents b_chi:')
for ir in IRR: print(f'  {ir:5s}', Bexp[ir], '  ~', complex(sp.N(Bexp[ir])))

out = dict(
    classes=CL, sizes=SIZE, t=T, slice=sorted(SLICE), qidx=QIDX,
    character_table={ir: [str(v) for v in chartab[ir]] for ir in IRR},
    a={ir: str(Aexp[ir]) for ir in IRR}, b={ir: str(Bexp[ir]) for ir in IRR},
    a_num={ir: [complex(sp.N(Aexp[ir])).real, complex(sp.N(Aexp[ir])).imag] for ir in IRR},
    b_num={ir: [complex(sp.N(Bexp[ir])).real, complex(sp.N(Bexp[ir])).imag] for ir in IRR},
    r_exact={cl: [[float(c) for c in R[cl][k]] for k in range(PER[cl])] for cl in CL},
    r_complex={cl: [[to_complex(R[cl][k]).real, to_complex(R[cl][k]).imag] for k in range(PER[cl])] for cl in CL},
    period=PER, dlogH={cl: str(Hrat[cl]) for cl in CL},
    dlogH_root_modulus_dev=roots_ok, formal_series_checked_through_k=KMAX,
    secs=time.time() - t0)
(HERE / 'derive-identity-results.json').write_text(json.dumps(out, indent=1))
print('done', out['secs'])
