#!/usr/bin/env python3
"""Field-level 2I check on the galpol totally-real degree-120 Galois field
(disc 2^360 · 11^100 · 23^80). Automorphisms from nfgaloisconj (cached);
galoisinit fails because 2I is not weakly supersolvable. The composition
table is computed in F_p[x] (integer composition of the degree-119
automorphisms is too slow). Frobenius is the p-power map on a root in
F_{q^f}; classes of order 5 and 10 are separated by an explicit
isomorphism Gal → 2I ⊂ H^×. Aligned Model A product along I*.
"""
import json, math, time, sys
from pathlib import Path
from collections import Counter, defaultdict
import numpy as np
from cypari2 import Pari

HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE.parent / 'beta1112'))
from groups import group as qgroup, qmul, classes as qclasses

Istar = np.array([0.2893693284547860408290125,
                  -0.9074076844035589414867177,
                  0.3047567653637853675817798])
Istar = Istar / np.linalg.norm(Istar)
BETA_MIN = 0.06976505974012515185075739031050863074773
RAM = (2, 11, 23)
# Primes dividing a denominator of some nfgaloisconj polynomial (power basis is not q-integral).
DENOM_BLOCKED = {2, 3, 5, 11, 151, 277, 809, 1549, 3301, 4153, 4451, 4463, 4643, 5381, 5557, 6827, 9187, 10903, 13649}
# A small unramified prime used only to reduce the automorphism group.
PGRP = 13
X = int(sys.argv[1]) if len(sys.argv) > 1 else 20000
QPATH = HERE / 'sources' / 'galpol-2I-polredbest.txt'
AUTPATH = HERE / 'sources' / 'galpol-2I-auts.json'
CACHE = HERE / 'sources' / 'galpol-2I-groupcache.json'

def primes_upto(n):
    s = bytearray(b'\x01')*(n+1); s[0]=s[1]=0
    for i in range(2, int(n**.5)+1):
        if s[i]:
            s[i*i::i] = b'\x00'*len(s[i*i::i])
    return [i for i in range(n+1) if s[i]]

def nrd_local(g, r, phi, I):
    re = g[0]*r*math.cos(phi) + float(np.dot(g[1:], I))*r*math.sin(phi)
    return 1.0 - 2.0*re + r*r

def qorder(g):
    ident=np.array([1.,0,0,0]); r,n=g,1
    while n<40 and np.linalg.norm(r-ident)>1e-8:
        r=qmul(r,g); n+=1
    return n

def vec_fp(pari, expr='C'):
    v=[int(x) for x in pari(f'Vecrev(lift({expr}))')]
    if len(v)<120:
        v=v+[0]*(120-len(v))
    elif len(v)>120:
        v=v[:120]
    return tuple(v)

def main():
    out=dict(group='2I',
             source='PARI galpol real degree-120 polynomial; nfgaloisconj; Gal = SL(2,5) = [120,5] (binary icosahedral). Group law computed in F_13[x]. LMFDB HTML was recaptcha-blocked; 12 LMFDB 24T201 Artin records confirm the group and the character field Q(sqrt(5)) but are not the field used for the Euler product.',
             ramified=list(RAM), denom_blocked=sorted(DENOM_BLOCKED), disc_factor='2^360 * 11^100 * 23^80',
             Istar=Istar.tolist(), beta_min_predicted=BETA_MIN, X=X)
    Gq=qgroup('2I'); assert len(Gq)==120
    clQ=qclasses(Gq)
    qinfo=[]
    for C in clQ:
        best,bestsc,bestu=None,-1,None
        for h in C:
            an=h[1:]; nn=np.linalg.norm(an)
            if nn<1e-12:
                sc=0.0; u=np.zeros(3)
            else:
                u=an/nn; sc=float(u@Istar)**2
            if sc>bestsc:
                bestsc,best,bestu=sc,h,u
        qinfo.append(dict(size=len(C), order=qorder(C[0]), re=float(C[0][0]),
                          sin2=float(1-C[0][0]**2),
                          aligned=[float(x) for x in best],
                          axis_aligned=bestu.tolist(), align=bestsc,
                          beta_local=float((1-C[0][0]**2)*(1-bestsc))))
    out['quaternion_classes']=qinfo
    print('2I classes:', [(i,inf['size'],inf['order'],round(inf['re'],5),round(inf['beta_local'],5)) for i,inf in enumerate(qinfo)], flush=True)
    beta_aligned=sum(inf['size']/120*inf['beta_local'] for inf in qinfo)
    out['beta_from_aligned_reps']=beta_aligned
    print('β aligned', beta_aligned, 'pred', BETA_MIN, 'diff', beta_aligned-BETA_MIN, flush=True)

    pari=Pari(); pari.allocatemem(4*10**9)
    Q=QPATH.read_text().strip()
    pari(f'Q={Q};')
    auts=json.loads(AUTPATH.read_text())
    assert len(auts)==120
    print('loading AUT...', flush=True)
    tload=time.time()
    pari('AUT=vector(120);')
    for i,a in enumerate(auts,1):
        pari(f'AUT[{i}]={a};')
    print('loaded AUT', time.time()-tload, flush=True)

    pari(f'pgrp={PGRP}; Qp=Q*Mod(1,pgrp); AUTP=vector(120); for(i=1,120, AUTP[i]=AUT[i]*Mod(1,pgrp));')
    nuniq=int(pari('s=Set(vector(120,i,Vec(lift(AUTP[i])))); #s'))
    assert nuniq==120, nuniq
    print('reduced AUT distinct in F_%d[x]'%PGRP, flush=True)

    if CACHE.exists():
        cache=json.loads(CACHE.read_text())
        orders=cache['orders']
        mul_a=cache['mul_a']; mul_b=cache['mul_b']
        a=cache['a']; b=cache['b']
        print('loaded group cache', Counter(orders), 'gens', a,b, flush=True)
    else:
        # orders over F_p
        t0=time.time()
        ords=pari('''
          vector(120,i,
            A=AUTP[i]; n=1;
            while(lift(A)!=x, A=subst(A,x,AUTP[i]) % Qp; n++; if(n>40,break));
            n)
        ''')
        orders=[int(x) for x in ords]
        print('orders', time.time()-t0, Counter(orders), flush=True)
        assert Counter(orders)==Counter({1:1,2:1,3:20,4:30,5:24,6:20,10:24})

        fps=[]
        for i in range(1,121):
            pari(f'C=AUTP[{i}];')
            fps.append(vec_fp(pari,'C'))
        assert len(set(fps))==120
        fp_to_i={fps[i]: i+1 for i in range(120)}

        def compose(i,j):
            pari(f'C=subst(AUTP[{i}],x,AUTP[{j}]) % Qp;')
            return fp_to_i[vec_fp(pari,'C')]

        byord=defaultdict(list)
        for i,o in enumerate(orders, start=1):
            byord[o].append(i)
        ident_idx=byord[1][0]

        def closure(gens_idx):
            S={ident_idx}; fr=[ident_idx]
            while fr:
                nf=[]
                for x in fr:
                    for g in gens_idx:
                        y=compose(g,x)
                        if y not in S:
                            S.add(y); nf.append(y)
                fr=nf
            return S

        a=byord[4][0]
        b=None
        t1=time.time()
        for cand in byord[6]:
            cl=closure([a,cand])
            print('  try b', cand, 'size', len(cl), flush=True)
            if len(cl)==120:
                b=cand; break
        if b is None:
            for cand in byord[10]:
                cl=closure([a,cand])
                print('  try b (ord10)', cand, 'size', len(cl), flush=True)
                if len(cl)==120:
                    b=cand; break
        print('Gal gens a', a, 'ord', orders[a-1], 'b', b, 'ord', orders[b-1] if b else None, 'in', time.time()-t1, flush=True)
        assert b is not None

        # left-multiplication tables by the two generators
        mul_a=[0]*121; mul_b=[0]*121
        for x in range(1,121):
            mul_a[x]=compose(a,x)
            mul_b[x]=compose(b,x)
        CACHE.write_text(json.dumps(dict(orders=orders, a=a, b=b, mul_a=mul_a, mul_b=mul_b)))
        print('wrote group cache', flush=True)

    byord=defaultdict(list)
    for i,o in enumerate(orders, start=1):
        byord[o].append(i)
    ident_idx=byord[1][0]
    out['aut_order_count']={str(o):len(byord[o]) for o in sorted(byord)}
    print('byord', {o:len(byord[o]) for o in sorted(byord)}, 'gens', a,b, flush=True)

    def compose_gen(g_idx, x):
        return (mul_a if g_idx==a else mul_b)[x]

    Qa=[g for g in Gq if qorder(g)==orders[a-1]]
    Qb=[g for g in Gq if qorder(g)==orders[b-1]]
    print('search iso among', len(Qa), 'x', len(Qb), flush=True)
    t3=time.time()

    def try_iso(Ael,Bel, left=False):
        m={ident_idx: np.array([1.,0,0,0])}
        fr=[ident_idx]
        while fr:
            nf=[]
            for x in fr:
                for g_idx, Gqel in ((a,Ael),(b,Bel)):
                    y=compose_gen(g_idx, x)
                    yq=qmul(Gqel, m[x]) if left else qmul(m[x], Gqel)
                    if y in m:
                        if np.linalg.norm(m[y]-yq)>1e-6:
                            return None
                    else:
                        m[y]=yq; nf.append(y)
            fr=nf
        if len(m)!=120: return None
        if len({tuple(np.round(v,6)) for v in m.values()})!=120: return None
        return m

    found=None; conv=None
    for left in (False, True):
        for Ael in Qa:
            for Bel in Qb:
                m=try_iso(Ael,Bel,left=left)
                if m:
                    found=m; conv='left' if left else 'right'
                    print('iso found', conv, 'in', time.time()-t3, flush=True)
                    break
            if found: break
        if found: break
    assert found is not None, 'no isomorphism Gal -> 2I'

    def qidx_of(q):
        for i,C in enumerate(clQ):
            if any(np.linalg.norm(q-h)<1e-6 for h in C):
                return i
        raise RuntimeError('quat not in 2I')
    aut_to_qidx={i: qidx_of(found[i]) for i in found}
    out['iso_check_n']=len(found)
    out['iso_convention']=conv
    print('iso classes of generators', aut_to_qidx[a], aut_to_qidx[b], flush=True)

    unique_ord={1,2,3,4,6}
    ord_to_qidx={}
    for o in unique_ord:
        idxs=set(aut_to_qidx[i] for i in byord[o])
        assert len(idxs)==1, (o,idxs)
        ord_to_qidx[o]=next(iter(idxs))
    print('unique order -> qidx', ord_to_qidx, flush=True)

    def frob_qidx(q):
        f=int(pari(f'poldegree(lift(factor(Mod(Q,{q}))[1,1]))'))
        if f in unique_ord:
            return f, ord_to_qidx[f], None
        cands=byord[f]
        pari(f'''
            w='w;
            F0=factor(Mod(Q,{q}))[1,1];
            Ft=subst(F0,x,w);
            R=ffgen(Ft);
            Rp=R^{q};
        ''')
        hit=None
        for i in cands:
            ok=int(pari(f'subst(AUT[{i}]*Mod(1,{q}),x,R)==Rp'))
            if ok:
                hit=i; break
        if hit is None:
            return f, f'NOHIT f={f}', None
        return f, aut_to_qidx[hit], hit

    pclass={}; freq=Counter(); bad=[]; fords=Counter()
    t4=time.time()
    PR=primes_upto(X)
    for npr,q in enumerate(PR,1):
        if q in RAM or q in DENOM_BLOCKED: continue
        try:
            f, qi, hit=frob_qidx(q)
        except Exception as e:
            bad.append((q,str(e)[:200])); continue
        fords[f]+=1
        if isinstance(qi,str):
            bad.append((q,qi)); continue
        pclass[q]=qi; freq[qi]+=1
        if npr%100==0:
            print(f'  p={q} n={len(pclass)} bad={len(bad)} freq={dict(freq)} {time.time()-t4:.1f}s', flush=True)
    print('Frob done', time.time()-t4, 'n', len(pclass), 'bad', bad[:8], 'orders', dict(fords), flush=True)
    out['nprimes']=len(pclass)
    out['class_freq']={str(k):v for k,v in freq.items()}
    out['order_freq']={str(k):v for k,v in fords.items()}
    out['unrecognized']=bad[:20]
    out['chebotarev_expected']={str(i): qinfo[i]['size']/120*len(pclass) for i in range(len(qinfo))}
    print('freq', dict(freq), 'expected', out['chebotarev_expected'], flush=True)

    ap={int(q): 2.0*qinfo[c]['re'] for q,c in pclass.items()}
    out['ap_sample']={str(q):ap[q] for q in list(sorted(ap))[:30]}

    aligned={i: np.array(qinfo[i]['aligned']) for i in range(len(qinfo))}
    beta_loc={i: qinfo[i]['beta_local'] for i in range(len(qinfo))}

    def log_nrd_completed(sig, t, XX):
        rem=0.0
        direct=0.0
        for q,c in pclass.items():
            if q>XX: continue
            r=q**(-sig); phi=t*math.log(q)
            ln=math.log(nrd_local(aligned[c], r, phi, Istar))
            l2=math.log(1-q**(-2*sig))
            rem += ln + beta_loc[c]*l2
            direct += -ln
        logzeta=math.log(abs(float(pari(f'zeta({2*sig})'))))
        return dict(log_nrd_E_completed=-rem - BETA_MIN*logzeta,
                    log_nrd_E_direct=direct, sum_remainder=rem, log_zeta_2sig=logzeta)

    barrier={}
    for tval in (0.0, 5.0, 11.3, 23.5):
        vals=[]
        for e in (1e-1, 1e-2, 1e-3, 1e-4):
            d=log_nrd_completed(0.5+e, tval, X)
            vals.append(dict(eps=e, **d))
            print(f'  t={tval} ε={e} completed={d["log_nrd_E_completed"]:.6f} direct={d["log_nrd_E_direct"]:.6f}', flush=True)
        sl=[]
        for i in range(len(vals)-1):
            dy=vals[i+1]['log_nrd_E_completed']-vals[i]['log_nrd_E_completed']
            dx=math.log(2*vals[i+1]['eps'])-math.log(2*vals[i]['eps'])
            sl.append(dy/dx)
        barrier[str(tval)]=dict(values=vals, slopes_completed_vs_log_2sig_minus_1=sl,
                                predicted=BETA_MIN)
        print(f'  t={tval} slopes', sl, 'pred', BETA_MIN, flush=True)
    out['barrier']=barrier
    out['pclass']={str(q):int(c) for q,c in pclass.items()}
    out['secs']=time.time()-tload
    HERE.joinpath('measure-2I-results.json').write_text(json.dumps(out, indent=1, default=str))
    print('wrote measure-2I-results.json in', out['secs'], 's')

if __name__=='__main__':
    main()
