"""Independent source-formula checks for T739, without importing its generator.

Run under SageMath: sage -python check_values.py prepared-values.json
or check_values.py stored-values.json, which uses the same record structure.
BCM, Finite hypergeometric functions, Theorem 1.3 supplies all nonsplit traces.
Gauss sums are discrete Fourier transforms of the standard additive character;
Bluestein convolution uses native Arb complex-ball polynomial multiplication.
192-bit balls isolate integers only after finite/radius/imaginary checks.
The production generator instead uses p-adic Gross--Koblitz computations.
PARI is an additional implementation check, with related mathematical ancestry.
"""
import numberdb.sage as numberdb
from sage.rings.integer_ring import ZZ
from sage.rings.rational_field import QQ
from sage.rings.complex_arb import ComplexBallField
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.rings.finite_rings.finite_field_constructor import GF
from sage.symbolic.ring import SR
from sage.libs.pari import pari
from pathlib import Path
from functools import lru_cache
from collections import Counter
from math import gcd,lcm
import sys,json,time
C=ComplexBallField(192);R=PolynomialRing(C,'x');Z=PolynomialRing(ZZ,'T');T=Z.gen()
# Independent transcription of DPVZ Table 2.10, pages 5--6, no generator import.
ROWS=[('2.2.2.2.2','-1/4'),('2.2.2.2.2','-4'),('2.2.2.2.2','-1/1024'),('2.2.2.2.2','-1024'),('2.2.2.3','27/64'),('2.2.2.3','-27'),('2.5','-3125/256'),('2.2.2.4','1/16'),('2.3.4','-1/48'),('2.3.4','-27/16'),('2.3.6','-729/4096'),('2.3.6','729/15625'),('2.3.6','-1/512000'),('2.4.6','-1/1024'),('2.8','1/2401')]

def mobius(n):
 count=0;p=2
 while p*p<=n:
  if n%p==0:
   n//=p;count+=1
   if n%p==0:return 0
  p+=1
 if n>1:count+=1
 return (-1)**count

def gamma_data(template):
 gam=Counter({1:-5})
 for d in map(int,template.split('.')):
  for e in range(1,d+1):
   if d%e==0:gam[e]+=mobius(d//e)
 pos=[k for k,v in gam.items() for _ in range(max(v,0))]
 neg=[k for k,v in gam.items() for _ in range(max(-v,0))]
 M=QQ(1)
 for k,v in gam.items():M*=QQ(k)**(k*v)
 assert sum(pos)==sum(neg)
 return pos,neg,M

@lru_cache(None)
def field_data(p,r):
 q=p**r;n=q-1;F=GF(q,'a');g=F.multiplicative_generator()
 ell={};tr=[];x=F.one()
 for k in range(n):ell[x]=k;tr.append(int(x.trace()));x*=g
 root=(C(0,2)*C.pi()/(2*n)).exp()
 chirp=[root**((k*k)%(2*n)) for k in range(n)]
 addroot=(C(0,2)*C.pi()/p).exp();addpowers=[addroot**k for k in range(p)]
 aa=R([addpowers[tr[k]]*chirp[k] for k in range(n)])
 bb=R([root**((-j*j)%(2*n)) for j in range(-n+1,n)])
 conv=aa*bb;gauss=[chirp[m]*conv[m+n-1] for m in range(n)]
 assert (-1 in gauss[0])
 return F,ell,gauss,root**2

@lru_cache(None)
def trace_sum(template,ztext,p,r):
 pos,neg,M=gamma_data(template);z=QQ(ztext);q=p**r;n=q-1
 F,logs,gs,root=field_data(p,r)
 ell=logs[F(QQ((-1)**sum(neg))*z/M)]
 s0=min(len(pos),len(neg));ans=C.zero()
 for m in range(n):
  sm=min(sum((k*m)%n==0 for k in pos),sum((k*m)%n==0 for k in neg))
  term=C(QQ(q)**(sm-s0))
  for k in pos:term*=gs[(k*m)%n]
  for k in neg:term*=gs[(-k*m)%n]
  ans+=term*root**((ell*m)%n)
 ans*=QQ((-1)**(len(pos)+len(neg)))/(1-q)
 assert all(x.is_finite() for x in (ans.real(),ans.imag())) and (0 in ans.imag())
 assert ans.real().rad()<QQ(1)/4 and ans.imag().rad()<QQ(1)/4
 result=ZZ(ans.real().lower().ceil())
 assert result==ans.real().upper().floor()
 assert (result in ans.real())
 return int(result),{'real_radius':str(ans.real().rad()),'imag_radius':str(ans.imag().rad()),'field_size':q}

def determinant_sign(ztext,p):
 # Watkins 11.1.1: t_tilde=1/z, product Delta(Phi_1)^5=1.
 # u=-t_tilde*(1-t_tilde)=(1-z)/z^2. c5/p^10=-chi_u(p).
 z=QQ(ztext);u=int(z.denominator()*(z.denominator()-z.numerator()))%p
 symbol=pow(u,(p-1)//2,p);assert symbol in (1,p-1)
 return -1 if symbol==1 else 1

def trace_from_poly(cs,r):
 s=[]
 for k in range(1,r+1):
  v=-sum(ZZ(cs[j])*s[k-j-1] for j in range(1,min(k,len(cs)-1)+1) if j<k)
  if k<len(cs):v-=k*ZZ(cs[k])
  s.append(v)
 return int(s[-1])

def expected_selection():
 out=[]
 for a,ztext in ROWS:
  z=QQ(ztext);d=lcm(*map(int,a.split('.')))
  for p in range(2,32):
   prime=all(p%j for j in range(2,int(p**0.5)+1))
   if prime and (d*z.numerator()*z.denominator()*(z.numerator()-z.denominator()))%p:
    out.append((a,ztext,p))
 return out

CONTROLS=[('2.2.2.2.2','-1/4',3,(1-9*T)*(1-81*T*T)*(1+10*T+81*T*T)),
 ('2.3.4','-1/48',5,(1-25*T)**2*(1+25*T)*(1+28*T+625*T*T)),
 ('2.3.6','-1/512000',11,(1-121*T)*(1-14641*T*T)*(1+30*T+14641*T*T)),
 ('2.3.6','-1/512000',13,(1+169*T)*(1-64*T-22854*T*T-1827904*T**3+815730721*T**4))]

def check(records,higher=True):
 start=time.monotonic();results={'checked_entries':0,'total_entries':len(records),'failures':[],'known_answer_control':False,'negative_control_rejected':False,'method':'BCM Theorem 1.3; 192-bit Arb complex balls; independent determinant character; PARI at reciprocal coordinate','checks':[],'higher_extension_checks':[]}
 ids=[(x['params']['template'],str(x['params']['z']),int(x['params']['p'])) for x in records]
 assert ids==expected_selection(), 'Selection differs from independently transcribed source roster/filter'
 byid=dict(zip(ids,records))
 # Check Bluestein Gauss sums against direct O(q^2) character sums on F_25.
 F,logs,gs,root=field_data(5,2);g=F.multiplicative_generator();aroot=(C(0,2)*C.pi()/5).exp()
 for m in range(24):
  direct=sum((root**((m*k)%24))*aroot**int((g**k).trace()) for k in range(24))
  assert (0 in (direct-gs[m]))
 for a,z,p,poly in CONTROLS:
  rec=byid[(a,z,p)];assert Z(rec['coefficients'])==poly,(a,z,p,Z(rec['coefficients']),poly)
  for r in (1,2):assert trace_sum(a,z,p,r)[0]==trace_from_poly(poly.list(),r)
 results['known_answer_control']=True
 results['source_discrepancy']={'location':'DPVZ (3.16), p=11','printed_quadratic':'1-30*T+14641*T^2','definition_consistent_quadratic':'1+30*T+14641*T^2','trace':91,'printed_trace':151,'resolution':'Independent exact cyclotomic BCM sum in exact_control.py gives 91; Sage, PARI and complex-ball sums agree. This is a sign error in the displayed source example, not a coordinate change.'}
 for rec,(a,z,p) in zip(records,ids):
  cs=rec['coefficients'];assert len(cs)==6 and cs[0]==1
  assert all(type(c) is int for c in cs)
  sg=determinant_sign(z,p);assert cs[5]==sg*p**10
  assert all(ZZ(p)**n>10*ZZ(p)**(2*r) for r,n in enumerate(rec.get('precisions',[100,100]),1))
  traces=[]
  for r in (1,2):
   tr,ev=trace_sum(a,z,p,r);assert tr==trace_from_poly(cs,r),(a,z,p,r,tr,cs)
   traces.append({'r':r,'trace':tr,**ev})
  h=pari.hgminit(list(map(int,a.split('.'))),[1]*5)
  pp=pari.hgmeulerfactor(h,pari(1/QQ(z)),p)
  pc=[int(pp.polcoef(j)) for j in range(6)];assert pc==cs
  results['checks'].append({'params':rec['params'],'traces':traces,'determinant_sign':sg,'pari_agrees':True})
  results['checked_entries']+=1
  print('CHECKED',results['checked_entries'],a,z,p,flush=True)
 if higher:
  sample=[];seen=set()
  for a,z,p in ids:
   if a not in seen:sample.append((a,z,p,3));seen.add(a)
  # Largest prime, both determinant signs, plus fourth/fifth powers at small primes.
  sample.extend([('2.8','1/2401',31,3),('2.2.2.2.2','-1/4',3,4),('2.2.2.2.2','-1/4',3,5),('2.2.2.2.2','-1/4',7,4)])
  for a,z,p,r in sample:
   tr,ev=trace_sum(a,z,p,r);assert tr==trace_from_poly(byid[(a,z,p)]['coefficients'],r)
   results['higher_extension_checks'].append({'params':{'template':a,'z':z,'p':p},'r':r,'trace':tr,**ev})
   print('HIGHER',a,z,p,r,flush=True)
 # Mutations must disagree with the independent trace/determinant tests.
 a,z,p,poly=CONTROLS[1];cs=list(map(int,poly.list()));mutations={}
 for label,wrong in [('trace sign',[cs[0],-cs[1],*cs[2:]]),('coefficient',[cs[0],cs[1],cs[2]+1,*cs[3:]]),('omitted factor',list(map(int,(poly//(1-25*T)).list())))]:
  mutations[label]=any(trace_from_poly(wrong,r)!=trace_sum(a,z,p,r)[0] for r in (1,2)) or len(wrong)!=6
 mutations['determinant sign']=(-cs[5]!=determinant_sign(z,p)*p**10)
 # Published row 9 at p=11 is asymmetric under z -> 1/z.
 asymmetric=next((a,z,p) for a,z,p in ids if a=='2.3.4' and any(trace_sum(a,z,p,r)[0]!=trace_sum(a,str(1/QQ(z)),p,r)[0] for r in (1,2)))
 mutations['reversed coordinate']=True;results['asymmetric_control']={'template':asymmetric[0],'z':asymmetric[1],'p':asymmetric[2]}
 results['mutations']=mutations;assert all(mutations.values());results['negative_control_rejected']=True
 results['elapsed_seconds']=time.monotonic()-start
 return results

if __name__=='__main__':
 path=Path(sys.argv[1]) if len(sys.argv)>1 else Path('/work/prepared-values.json')
 print('RESULT '+json.dumps(check(json.loads(path.read_text()))),flush=True)
