#!/usr/bin/env python3
"""Validated low-zero brackets + argument-principle completeness, not PARI scans."""
from pathlib import Path
import json,time,math
from flint import arb,acb,ctx
R=Path(__file__).resolve().parent
ctx.prec=256
old=json.loads((R/'q8-results.json').read_text())['fields']
classic=json.loads((R/'q8-magma-results.json').read_text())
seeds=json.loads((R/'q8-sprint-results.json').read_text())['fields']
fields=[dict(label=f['label'],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'],Q=205,nu=0,sign=-1,a=classic['certificate']['coefficients']))
def S2(r,m):return r**m*(m*m/(1-r)+2*m*r/(1-r)**2+r*(1+r)/(1-r)**3)
def ballstr(x):return x.str(70,more=True)
rec=dict(arb_bits=ctx.prec,height=2,rectangle=dict(real=[-.5,1.5],imag=[-2,2]),method='Validated theta-Mellin sign enclosures and interval-image polygon homotopy/winding count',fields=[])
for f,seed in zip(fields,seeds):
 start=time.monotonic();Q=f['Q'];nu=f['nu'];W=f['sign'];M=len(f['a']);T=2048;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*T).exp();et=C*(arb(T)/c+1/c**2)*rt*(1+rt)/(1-rt)**3
 tail=en+et
 # On the critical line the Hardy component is real; only validated real integrals are needed.
 def hardy(t):
  def fun(u,analytic):
   if not u.real>0:return acb('nan')
   v=u.log(analytic=analytic)
   theta=4*(u/Q)**nu*sum((cn*u).bessel_k(0)*an for cn,an in terms)
   trig=(t*v).sin() if W==-1 else (t*v).cos()
   return 2*theta*(-v/2).exp()*trig
  val=acb(0)
  for j in range(11):
   val+=acb.integral(fun,2**j,2**(j+1),rel_tol=arb('1e-35'),abs_tol=arb('1e-35'),eval_limit=30000)
  assert val.is_finite() and val.imag.contains(0)
  return val.real+arb(0,tail.upper())
 # Endpoints are exact decimal rationals enclosing the first previously reported candidate.
 digits=12;lower=int(seed['zeros'][0]['height'].replace('.','')[:digits+1]);den=10**digits
 # String slicing above assumes the three seeds have one integer digit, asserted here.
 assert str(lower)[0]=='1'
 lo=arb(lower)/den;hi=arb(lower+1)/den
 hl=hardy(lo);hr=hardy(hi)
 sl=1 if hl>0 else -1 if hl<0 else 0;sr=1 if hr>0 else -1 if hr<0 else 0
 assert sl*sr==-1,(f['label'],hl,hr)
 bracket=dict(left=f'{lower/den:.12f}',right=f'{(lower+1)/den:.12f}',width='1e-12',left_hardy=ballstr(hl),right_hardy=ballstr(hr),left_sign=sl,right_sign=sr,validated=True)
 print('BRACKET',f['label'],bracket['left'],bracket['right'],ballstr(hl),ballstr(hr),flush=True)
 # Coarse interval Riemann sums are sufficient on a contour far from the zeros.
 def grid(steps):
  cells=[];left=None
  for band in range(11):
   for k in range(steps):
    a=arb(2)**band*(1+arb(k)/steps);b=arb(2)**band*(1+arb(k+1)/steps)
    if left is None:left=[(cn*a).bessel_k(0) for cn,an in terms]
    right=[(cn*b).bessel_k(0) for cn,an in terms];u=a.union(b)
    theta=4*(u/Q)**nu*sum(an*ka.union(kb) for (cn,an),ka,kb in zip(terms,left,right))
    cells.append((u.log(),2*theta/u.sqrt()*(b-a)))
    left=right
  return cells
 def image(s,cells):
  z=s-acb(arb(1)/2);v=acb(0)
  for logu,weight in cells:
   w=z*logu
   v+=weight*(w.sinh() if W==-1 else w.cosh())
  return v+acb(arb(0,tail.upper()),arb(0,tail.upper()))
 # Counter-clockwise dyadic contour. Each accepted image box is convex and misses 0.
 points=[]
 corners=[(-.5,-2),(1.5,-2),(1.5,2),(-.5,2),(-.5,-2)]
 for (x,y),(X,Y) in zip(corners,corners[1:]):
  n=int((abs(X-x)+abs(Y-y))*16)
  for k in range(n):points.append((x+(X-x)*k/n,y+(Y-y)*k/n))
 attempts=[]
 for steps in [64,128,256,512]:
  cells=grid(steps)
  def sb(a,b):return acb(arb(a[0]).union(arb(b[0])),arb(a[1]).union(arb(b[1])))
  boxes=[image(sb(a,b),cells) for a,b in zip(points,points[1:]+points[:1])]
  misses=[not b.contains(0) for b in boxes]
  attempts.append(dict(cells_per_band=steps,total_cells=len(cells),segments=len(boxes),zero_free_segments=sum(misses)))
  print('CONTOUR',f['label'],attempts[-1],flush=True)
  if not all(misses):continue
  for b in boxes:
   assert not acb(arb(ballstr(b.real)),arb(ballstr(b.imag))).contains(0)
  polygon=[]
  for j,point in enumerate(points):
   # An endpoint value belongs to BOTH adjacent image rectangles. Choose a point in their intersection.
   a,b=boxes[j-1],boxes[j]
   re=a.real.intersection(b.real);im=a.imag.intersection(b.imag)
   z=acb(re.mid(),im.mid())
   assert a.contains(z) and b.contains(z) and not z.contains(0)
   polygon.append(z)
  angle=arb(0)
  for a,b in zip(polygon,polygon[1:]+polygon[:1]):
   increment=(b/a).arg()
   assert increment> -arb.pi() and increment<arb.pi()
   angle+=increment
  winding=angle/(2*arb.pi());count=round(float(winding.mid()))
  assert winding>arb(count)-arb(1)/4 and winding<arb(count)+arb(1)/4
  expected=3 if W==-1 else 2
  assert count==expected,(f['label'],count)
  break
 else:raise AssertionError('No certified contour enclosure')
 countrecord=dict(certified=True,height=2,zeros_with_multiplicity=count,winding_enclosure=ballstr(winding),attempts=attempts,
  reason='Convex zero-free interval images certify homotopy to a polygon; its winding is the completed entire function zero count.',
  consequence='The certified conjugate first-zero pair and previously certified simple central zero (negative sign only) exhaust all zeros in |Im(s)|<2. The positive zero is unique and simple in this window; no off-line zeros in this finite window.',
  turing_caveat='Argument-principle completeness comparison, NOT implementation of Turing integral bounds or a claim based on a mesh scan.',
  polygon=[[ballstr(z.real),ballstr(z.imag)] for z in polygon],image_boxes=[dict(real=ballstr(b.real),imag=ballstr(b.imag)) for b in boxes])
 rec['fields'].append(dict(label=f['label'],sign=W,gamma_shift=nu,Q=Q,coefficient_cutoff=M,t_cutoff=T,
  coefficient_tail=ballstr(en),integral_tail=ballstr(et),bracket=bracket,count=countrecord,elapsed_seconds=time.monotonic()-start))
 (R/'q8-low-zeros-results.json').write_text(json.dumps(rec,indent=2)+'\n')
 print('PASS',f['label'],'count',count,'elapsed',time.monotonic()-start,flush=True)
print('PASS three first-zero brackets and complete zero counts through height 2',flush=True)
