"""Checks of T764, independent of the truncated-series computation.

    sage -python checks.py
    sage -python checks.py --stored

Requires attached generate.py, newform-reference.json and campaign check.py.
Independent methods: exact PARI weight-four newforms selected by their source
LMFDB coefficient prefixes, and direct BCM Theorem 1.3 Gauss sums in 384-bit
complex balls. The latter works for nonsplit primes too. Integrality follows
from the canonical rational-data geometric trace, not a rounding heuristic.
The script outputs RESULTS_JSON; save that line's JSON as check-results.json.
--stored checks live entries; supplying a key through stdin is supported.
No table edits or review actions are made here.
"""
import os,sys,json,hashlib,time
from pathlib import Path
from functools import lru_cache
from math import gcd
import numberdb.sage as numberdb
from sage.rings.integer_ring import ZZ
from sage.rings.rational_field import QQ
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.rings.complex_arb import ComplexBallField
from sage.rings.finite_rings.finite_field_constructor import GF
from sage.symbolic.ring import SR
from sage.symbolic.function import BuiltinFunction
from sage.libs.pari import pari
from sage.env import SAGE_VERSION
from generate import RigidFrobenius, R, TEMPLATES, PRIMES, CONDUCTORS
from check import exactness,exact_in_disguise,measure,names_its_rings,prose

CB=ComplexBallField(384)
# Source Table 1, independently transcribed. chi_d(p) is the Kronecker symbol.
OBJECTS={'2.2.2.2':(8,1),'2.2.3':(36,3),'2.2.4':(16,2),'2.2.6':(72,1),
         '3.3':(27,1),'3.4':(9,6),'3.6':(108,3),'4.4':(32,1),'4.6':(144,2),
         '6.6':(216,1),'5':(25,5),'8':(128,2),'10':(200,1),'12':(864,1)}

def mobius(n):
    out=1
    for p in range(2,n+1):
        if n%p: continue
        n//=p
        if n%p==0: return 0
        out=-out
    return out

def gamma_vectors(template):
    exponents={1:-4}
    for d in map(int,template.split('.')):
        for e in range(1,d+1):
            if d%e==0: exponents[e]=exponents.get(e,0)+mobius(d//e)
    plus=[e for e,m in exponents.items() for _ in range(max(m,0))]
    minus=[e for e,m in exponents.items() for _ in range(max(-m,0))]
    assert sum(plus)==sum(minus)
    scale=QQ(1)
    for e in plus: scale*=ZZ(e)**e
    for e in minus: scale/=ZZ(e)**e
    # Exact independent cyclotomic quotient identity.
    ring=PolynomialRing(QQ,'X'); X=ring.gen()
    num=ring(1);den=ring(1)
    for d in map(int,template.split('.')): num*=ring.cyclotomic_polynomial(d)
    den=(X-1)**4
    left=ring(1);right=ring(1)
    for e in plus:left*=X**e-1
    for e in minus:right*=X**e-1
    assert num*right==den*left
    return plus,minus,scale

@lru_cache(None)
def gauss_data(p):
    F=GF(p); g=F.multiplicative_generator()
    xs=[g**k for k in range(p-1)]
    assert len(set(xs))==p-1
    logs={x:k for k,x in enumerate(xs)}
    omega=[CB(QQ(2*k)/(p-1)).exppii() for k in range(p-1)]
    psi=[CB(QQ(2*int(x))/p).exppii() for x in xs]
    G=[sum((omega[(m*k)%(p-1)]*psi[k] for k in range(p-1)),CB(0)) for m in range(p-1)]
    for m,h in enumerate(G):
        assert h.real().is_finite() and h.imag().is_finite()
        norm=h*h.conjugate()
        assert (1 if m==0 else p) in norm.real() and 0 in norm.imag()
        assert norm.real().rad()<QQ(1)/10**90
    assert -1 in G[0].real() and 0 in G[0].imag()
    return F,logs,omega,G

def finite_trace(template,p):
    plus,minus,scale=gamma_vectors(template)
    F,logs,omega,G=gauss_data(p)
    arg=F(QQ((-1)**sum(minus))/scale)
    ell=logs[arg]; n=p-1
    s0=min(len(plus),len(minus))
    total=CB(0)
    for m in range(n):
        sm=min(sum((e*m)%n==0 for e in plus),sum((e*m)%n==0 for e in minus))
        term=CB(QQ(p)**(sm-s0))*omega[(ell*m)%n]
        for e in plus:term*=G[(e*m)%n]
        for e in minus:term*=G[(-e*m)%n]
        total+=term
    total*=QQ((-1)**(len(plus)+len(minus)))/QQ(1-p)
    assert total.real().is_finite() and total.imag().is_finite()
    assert 0 in total.imag()
    assert total.real().rad()<QQ(1)/10**80 and total.imag().rad()<QQ(1)/10**80
    h=ZZ(total.real())
    assert h in total.real()
    assert 2*total.real().rad()<1
    chi=ZZ(OBJECTS[template][1]).kronecker(p)
    a=h-chi*p
    assert a*a<=4*ZZ(p)**3
    return a,h,chi,str(total.real().rad()),str(total.imag().rad())

def convolution(p):
    chi=lambda n: ZZ(n%p).kronecker(p)
    # Jacobi(phi,phi)=-phi(-1), three independent Euler convolutions.
    S=sum(chi(x*(1-x)*y*(1-y)*z*(1-z)*(1-x*y*z))
          for x in range(1,p) for y in range(1,p) for z in range(1,p))
    return ZZ((-chi(-1))**3*S)

def equal(actual,expected):
    return actual==expected

def main(stored=False):
    start=time.monotonic()
    root=Path(__file__).resolve().parent
    references=json.loads((root/'newform-reference.json').read_text())
    gen=RigidFrobenius(); params=list(gen.enumerate())
    expected={(p['template'],int(p['p'])) for p in params}
    assert len(expected)==112
    assert set(OBJECTS)==set(TEMPLATES)==set(references)
    assert all(OBJECTS[k][0]==CONDUCTORS[k]==references[k]['level'] for k in OBJECTS)
    if stored:
        from numberdb._generate import _stored_entries
        doc=numberdb.table('T764'); entries=_stored_entries(doc)
        assert set(entries)=={','.join(str(p[k]) for k in gen.parameters) for p in params}
        values={(p['template'],int(p['p'])):R(entries[p['template']+','+str(p['p'])]) for p in params}
    else:
        values={(p['template'],int(p['p'])):gen.value(p,100) for p in params}
    assert not exactness(values) and not exact_in_disguise(values) and not prose(values)
    assert not names_its_rings(str(root/'generate.py'))
    assert all(type(c).__name__=='Integer' for P in values.values() for c in P.list())
    # Published nonzero controls and deliberately incorrect inputs.
    assert equal(values[('5',7)],R([1,-6,343]))
    assert equal(values[('2.2.2.2',7)],R([1,-24,343]))
    assert not equal(R([1,24,343]),R([1,-24,343]))
    assert finite_trace('5',7)[0]==6
    assert finite_trace('2.2.2.2',7)[0]==24
    a,h,chi,*_=finite_trace('5',7)
    assert h!=a and h+chi*7!=a
    details=[]; recognition=[]; holdouts=[]
    for template in TEMPLATES:
        N,d=OBJECTS[template]; reference=references[template]
        coefficients=reference['coefficients']
        assert coefficients[1]==1
        space=pari.mfinit([N,4],0)
        basis=pari.mfeigenbasis(space)
        candidates=[]
        for i,f in enumerate(basis):
            try: prefix=[int(ZZ(x)) for x in pari.mfcoefs(f,16)]
            except (TypeError,ValueError):continue
            if prefix==coefficients[:17]:candidates.append((i,f))
        assert len(candidates)==1,(template,'ambiguous newform prefix',len(candidates))
        index,f=candidates[0]
        coefs=[ZZ(x) for x in pari.mfcoefs(f,99)]
        assert list(map(int,coefs))==coefficients
        recognition.append({'template':template,'source_label':reference['label'],'level':N,
                            'pari_index_zero_based':index,'newform_orbits':len(basis),
                            'selection_indices':'0..16','comparison_indices':'0..99'})
        for p in PRIMES:
            P=values[(template,p)]; a=-P[1]
            assert P.degree()==2 and P[0]==1 and P[2]==p**3
            assert a*a<=4*p**3 and p**6>16*p**3
            assert equal(P,R([1,-coefs[p],ZZ(p)**3])),(template,p,'newform disagreement')
            b,h,chi,rr,ir=finite_trace(template,p)
            assert equal(a,b),(template,p,'finite-sum disagreement',a,b)
            details.append({'template':template,'p':p,'coefficients':list(map(int,P.list())),
                            'newform_ap':int(coefs[p]),'finite_Hp':int(h),'chi':int(chi),
                            'finite_sum_ap':int(b),'real_radius':rr,'imag_radius':ir})
        # Completely unused primes exceed both recognition and stored ranges.
        for p in (37,41):
            b,h,chi,rr,ir=finite_trace(template,p)
            assert b==coefs[p]
            holdouts.append({'template':template,'p':p,'newform_ap':int(coefs[p]),'finite_sum_ap':int(b)})
        print('CHECKED',template,reference['label'],'8 stored factors plus 2 holdout primes',flush=True)
    controls=[]
    for p in PRIMES:
        h=convolution(p)
        assert h==finite_trace('2.2.2.2',p)[1]
        controls.append({'p':p,'all_half_convolution_Hp':int(h)})
    zeros=[{'template':k[0],'p':k[1]} for k,P in values.items() if P[1]==0]
    for k in zeros: assert finite_trace(k['template'],k['p'])[0]==0
    result={'table':'T764','mode':'stored' if stored else 'offline','checked_entries':len(details),
            'total_entries':112,'failures':[],'known_answer_control':True,'negative_control_rejected':True,
            'versions':{'sage':SAGE_VERSION,'pari':str(pari('version()')),'python':sys.version},
            'methods':['exact modular newforms','BCM Theorem 1.3 at 384 bits','all-half quadratic convolution'],
            'recognition':recognition,'entries':details,'holdouts':holdouts,'convolution_controls':controls,
            'zero_traces':zeros,'measurement':measure(values),'elapsed_seconds':time.monotonic()-start,
            'negative_controls':['reversed nonzero trace rejected','omitted character rejected','wrong sign character rejected'],
            'skill_manifest':'../20261119T014035Z-build-skills/manifest.json',
            'skill_bundle_sha256':'b5c3c7985b7c9e178b4899d083a9e3bc4284989dff76f05e5b0e52835d47eed2'}
    print('RESULTS_JSON',json.dumps(result,default=str),flush=True)
    return result

if __name__=='__main__':
    if os.environ.get('NUMBERDB_KEY_FROM_STDIN')=='1':
        os.environ['NUMBERDB_API_KEY']=sys.stdin.read().strip()
    main('--stored' in sys.argv or os.environ.get('NUMBERDB_CHECK_STORED')=='1')
