#!/usr/bin/env python3
"""Validated reusable Gauss sum, local parameter Taylor bounds, total zero counts."""
from pathlib import Path
import json,time,math
from decimal import Decimal,ROUND_FLOOR
from flint import arb,acb
from flint import ctx
from cypari2 import Pari
R=Path(__file__).resolve().parent;ctx.prec=768
p=Pari();p.allocatemem(512000000);p.set_real_precision(60)
old=json.loads((R/'q8-results.json').read_text())['fields'];classic=json.loads((R/'q8-magma-results.json').read_text())
fields=[dict(label=f['label'],polynomial=f['polynomial'],Q=48,nu=f['gamma'][0],sign=f['sign'],a=f['coefficients_first_2000'][:1000]) for f in old]
fields.append(dict(label=classic['label'],polynomial=classic['lmfdb_polynomial'],Q=205,nu=0,sign=-1,a=json.loads((R/'q8-coefficients-results.json').read_text())['coefficients']))
START=time.monotonic();LIMIT=1200;MAXHEIGHT=50;GAUSS=128;DEGREE=30;U=8192
rec=dict(arb_bits=ctx.prec,compute_budget_seconds=LIMIT,method='Validated Gauss-Legendre theta exponential sum and local Taylor contour images',target_height=MAXHEIGHT,gauss_order=GAUSS,taylor_degree=DEGREE,fields=[])
def bs(x):return x.str(65,more=True)
def S2(r,m):return r**m*(m*m/(1-r)+2*m*r/(1-r)**2+r*(1+r)/(1-r)**3)
def budget():
 if time.monotonic()-START>LIMIT:raise TimeoutError('Declared compute budget exceeded; no unproved result accepted')
def save():(R/'q8-extended-results.json').write_text(json.dumps(rec,indent=2)+'\n')
roots=[arb.legendre_p_root(GAUSS,k,weight=True) for k in range(GAUSS)]
assert sum(w for x,w in roots).contains(2) and all(w>0 for x,w in roots)
for f in fields:
 budget();beg=time.monotonic();Q=f['Q'];nu=f['nu'];W=f['sign'];M=len(f['a']);c=2*arb.pi()/Q
 terms=[(c*n,f['a'][n-1]*n**nu) for n in range(1,M+1) if f['a'][n-1]]
 C=8*arb(Q)**(-nu)*(arb.pi()/(2*c)).sqrt();en=C*(1/c+1/c**2)*S2((-c).exp(),M+1)
 rt=(-c*U).exp();eu=C*(arb(U)/c+1/c**2)*rt*(1+rt)/(1-rt)**3
 alpha=(arb(2)/3).asin();quaderror=arb(0);nodes=[];bands=[]
 assert U>1 and U&(U-1)==0
 for j in range(U.bit_length()-1):
  a=arb(2)**j;mid=3*a/2;half=a/2
  absolute=sum(abs(an)*(cn*a/2).bessel_k(0) for cn,an in terms)
  Ma=16/a*(5*a/(2*Q))**nu*(5*a/2)**(arb(3)/2)*(MAXHEIGHT*alpha).exp()*absolute
  err=4*a*Ma*arb(2)**(-2*GAUSS);quaderror+=err
  bands.append(dict(left=2**j,right=2**(j+1),analytic_circle_radius=str(2**j),M_bound=bs(Ma),gauss_error=bs(err)))
  for root,weight in roots:
   u=mid+half*root;logu=u.log();theta=4*(u/Q)**nu*sum(an*(cn*u).bessel_k(0) for cn,an in terms)
   B=half*weight*theta/u.sqrt();powers=[B]
   for k in range(1,DEGREE+1):powers.append(powers[-1]*logu/k)
   nodes.append((u,logu,B,powers))
 assert bands[-1]["right"]==U
 error=en+eu+quaderror
 print('KERNEL',f['label'],'nodes',len(nodes),'error',bs(error),'elapsed',time.monotonic()-beg,flush=True)
 def hardy(t):
  value=2*sum(B*((t*l).sin() if W==-1 else (t*l).cos()) for u,l,B,ps in nodes)
  return value+arb(0,error.upper())
 # Seeds select brackets only; their signs and the total counts below are independent certificates.
 p(f'P={f["polynomial"]};NF=nfinit(P);G=galoisinit(NF);TC=galoischartable(G);L=lfunartin(NF,G,TC[1][,5],TC[2]);LI=lfuninit(L,[1/2,0,{MAXHEIGHT}],1);')
 seeds=[str(z) for z in p(f'lfunzeros(LI,[1e-6,{MAXHEIGHT}],32)')]
 zeros=[]
 for seed in seeds:
  budget()
  for digits in [12,10,8,6]:
   denominator=10**digits;n=int((Decimal(seed)*denominator).to_integral_value(rounding=ROUND_FLOOR))
   a=arb(n)/denominator;b=arb(n+1)/denominator;ha=hardy(a);hb=hardy(b)
   sa=1 if ha>0 else -1 if ha<0 else 0;sb=1 if hb>0 else -1 if hb<0 else 0
   if sa*sb==-1:break
  else:raise AssertionError(('Cannot certify seed',seed))
  left=str(Decimal(n)/denominator);right=str(Decimal(n+1)/denominator)
  zeros.append(dict(left=left,right=right,width='1e-'+str(digits),midpoint=float((Decimal(left)+Decimal(right))/2),left_sign=sa,right_sign=sb,left_hardy=bs(ha),right_hardy=bs(hb)))
 print('BRACKETS',f['label'],len(zeros),'widths',sorted(set(z['width'] for z in zeros)),flush=True)
 # Uniform local Taylor remainder, independent of the oscillatory centre.
 remcache={};cache={};canonical_calls=0
 def remainder(h):
  key=str(h)
  if key not in remcache:
   remcache[key]=sum(2*abs(B)*u*((h*l).exp())*(h*l)**(DEGREE+1)/math.factorial(DEGREE+1) for u,l,B,ps in nodes)
  return remcache[key]
 def image(x,y,hx,hy):
  left=x<.5;negative=y<0;X=.5+abs(x-.5);Y=abs(y);key=(X,Y,hx,hy)
  if key not in cache:
   budget();z=acb(arb(X)-arb(1)/2,arb(Y));coeff=[acb(0) for k in range(DEGREE+1)]
   for u,l,B,ps in nodes:
    ep=(z*l).exp();em=1/ep;even=ep+W*em;odd=ep-W*em
    for k in range(DEGREE+1):coeff[k]+=ps[k]*(odd if k%2 else even)
   delta=acb(arb(0,hx),arb(0,hy));v=acb(0)
   for a in reversed(coeff):v=v*delta+a
   rr=error+remainder(arb(hx+hy));v+=acb(arb(0,rr.upper()),arb(0,rr.upper()))
   cache[key]=v
  v=cache[key]
  if left!=negative:v=v.conjugate()
  if left:v*=W
  return v
 counts=[]
 for height in [10,20,MAXHEIGHT]:
  for mesh in [16,32,64]:
   pts=[];corners=[(-.5,-height),(1.5,-height),(1.5,height),(-.5,height),(-.5,-height)]
   for (x,y),(X,Y) in zip(corners,corners[1:]):
    n=int((abs(X-x)+abs(Y-y))*mesh)
    for k in range(n):pts.append((x+(X-x)*k/n,y+(Y-y)*k/n))
   boxes=[]
   for index,(a,b) in enumerate(zip(pts,pts[1:]+pts[:1])):
    v=image((a[0]+b[0])/2,(a[1]+b[1])/2,abs(a[0]-b[0])/2,abs(a[1]-b[1])/2);boxes.append(v)
   misses=sum(not b.contains(0) for b in boxes)
   print('CONTOUR',f['label'],height,'mesh',mesh,misses,'/',len(boxes),'elapsed',time.monotonic()-beg,flush=True)
   if misses==len(boxes):break
  else:raise AssertionError('Contour failed; no certificate claimed')
  polygon=[]
  for i,box in enumerate(boxes):
   before=boxes[i-1];z=acb(before.real.intersection(box.real).mid(),before.imag.intersection(box.imag).mid())
   assert box.contains(z) and before.contains(z) and not z.contains(0);polygon.append(z)
   assert not acb(arb(bs(box.real)),arb(bs(box.imag))).contains(0)
  angle=arb(0)
  for a,b in zip(polygon,polygon[1:]+polygon[:1]):
   arg=(b/a).arg();assert arg>-arb.pi() and arg<arb.pi();angle+=arg
  winding=angle/(2*arb.pi());count=round(float(winding.mid()));assert winding>count-arb(1)/4 and winding<count+arb(1)/4
  selected=[z for z in zeros if z['midpoint']<height];expected=2*len(selected)+(W==-1);assert count==expected,(f['label'],height,count,expected)
  t=arb(height);main=t/arb.pi()*(arb(Q)*t/(2*arb.pi()*arb(1).exp())).log()
  phase=(t*arb(Q).log()-t*arb.pi().log()+2*acb(arb(1)/4+arb(nu)/2,t/2).lgamma().imag)/arb.pi()
  counts.append(dict(height=height,certified=True,total_count=count,positive_count=len(selected),central_count=int(W==-1),mesh_per_unit=mesh,segments=len(boxes),canonical_image_count=len(cache),
   winding_enclosure=bs(winding),smooth_main_term=bs(main),positive_minus_main=float(len(selected)-float(main.mid())),gamma_phase_over_pi=bs(phase),
   argument_term_implied_by_count=bs(arb(len(selected))+arb(int(W==-1))/2-phase),
   polygon=[[bs(z.real),bs(z.imag)] for z in polygon],image_boxes=[dict(real=bs(b.real),imag=bs(b.imag)) for b in boxes]))
  print('COUNT',f['label'],height,'positive',len(selected),'total',count,'main',float(main.mid()),flush=True)
 row=dict(label=f['label'],sign=W,Q=Q,gamma_shift=nu,coefficient_cutoff=M,integration_cutoff=U,gauss_nodes=len(nodes),analytic_bands=bands,
   coefficient_tail=bs(en),integration_tail=bs(eu),quadrature_error=bs(quaderror),total_uniform_error=bs(error),
   parameter_taylor_remainders={k:bs(v) for k,v in remcache.items()},zeros=zeros,counts=counts,elapsed_seconds=time.monotonic()-beg)
 rec['fields'].append(row);rec['elapsed_seconds']=time.monotonic()-START;save()
 print('PASS',f['label'],'elapsed',row['elapsed_seconds'],flush=True)
print('PASS all extended certificates; compute seconds',time.monotonic()-START,flush=True)
