"""Builder numerical evidence, not an independent critic's verdict.

sage -python build_check.py
Keep generator, roster.py and pinned source files beside this file.
Emits resumable CHECKPOINT JSON records for every completed curve. The final
SUMMARY record records actual checks. PARI comparisons are noncertified
832/1024-bit approximations; the production bound is Arb's certified AGM.
Direct defining-integral quadrature is separately certified by Arb/acb_calc.
The same Sage algebraic-root implementation and Arb library are shared by
AGM and quadrature, but the integral evaluation does not use the AGM formula.
"""
import json,hashlib,time,sys,platform
from pathlib import Path
from fractions import Fraction
from decimal import Decimal
import numberdb.sage as numberdb
from numberdb._write import to_text
from sage.rings.rational_field import QQ
from sage.rings.integer_ring import ZZ
from sage.rings.real_mpfr import RealField
from sage.rings.real_arb import RealBallField
from sage.rings.complex_arb import ComplexBallField
from sage.rings.qqbar import AA
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.libs.pari import pari
import generate
BASE=Path(__file__).resolve().parent
INPUTS=['generate.py','build_check.py','roster.py','allgens.00000-09999','alllabels.00000-09999']
HASHES={n:hashlib.sha256((BASE/n).read_bytes()).hexdigest() for n in INPUTS}
DIGEST=hashlib.sha256(json.dumps(HASHES,sort_keys=True).encode()).hexdigest()
B=RealBallField(640);C=ComplexBallField(640);R=PolynomialRing(QQ,'x');X=R.gen()

def emit(r):
 r['input_sha256']=DIGEST
 print('CHECKPOINT '+json.dumps(r,sort_keys=True),flush=True)

def rational(s):
 f=Fraction(Decimal(s));return QQ(f.numerator)/ZZ(f.denominator)

def bounds(text):
 d=Decimal(text);q=rational(text);u=QQ(10)**d.as_tuple().exponent
 return q-u,q+u

def accepts(text,v):
 lo,hi=bounds(text)
 return bool(v.is_finite() and v>0 and v.accuracy()>=350 and B(lo)<v and v<B(hi))

def direct_integral(row):
 # omega=dx/sqrt(f(x)); w1=2 integral from largest real root e to infinity.
 # x=e+u^2 and u=t/(1-t) remove the square-root and infinite endpoints:
 # w1=2 integral_0^1 [t^4+A*t^2*(1-t)^2+D*(1-t)^4]^(-1/2) dt,
 # A=3e+b2/4, D=f'(e)/4. D>0 because e is largest, simple real root.
 a1,a2,a3,a4,a6=map(ZZ,row['ainvs'])
 b2=a1*a1+4*a2;b4=a1*a3+2*a4;b6=a3*a3+4*a6
 f=4*X**3+b2*X**2+2*b4*X+b6
 roots=f.roots(AA,multiplicities=False);e=max(roots);v=B(e)
 A=3*v+B(b2)/4;D=3*v*v+B(b2)*v/2+B(b4)/2
 assert D>0
 def fun(t,analytic):
  q=t**4+C(A)*t*t*(1-t)**2+C(D)*(1-t)**4
  return 1/q.sqrt(analytic=analytic)
 z=2*C.integral(fun,0,1,rel_tol=B(2)**(-430),abs_tol=B(2)**(-430))
 assert z.real().is_finite() and z.imag().is_finite() and z.imag().contains_zero()
 ans=z.real();assert ans.accuracy()>=400 and ans>0
 return ans,A,D

def main():
 cache={}
 if (BASE/'checkpoint.json').exists():
  for r in json.loads((BASE/'checkpoint.json').read_text()):
   assert r['input_sha256']==DIGEST
   cache[r['label']]=r
 rows=generate.ROSTER['curves'];checked=[]
 for row in rows:
  label=row['cremona_label']
  if label in cache:emit(cache[label]);checked.append(cache[label]);continue
  start=time.monotonic();key=tuple(row[k] for k in ('N','c4','c6'))
  assert all(type(x) is int for x in key+tuple(row['ainvs']))
  P=pari.ellinit(row['ainvs']);rank=P.ellrank();red=P.ellglobalred()
  assert [int(rank[i]) for i in (0,1)]==[0,0]
  assert int(red[0])==row['N']
  minimal,change=P.ellminimalmodel()
  assert [int(x) for x in list(minimal)[:5]]==row['ainvs']
  assert [int(P[9]),int(P[10]),int(P.disc())]==[row['c4'],row['c6'],row['discriminant']]
  tors=P.elltors();assert int(tors[0])==row['source_torsion']
  local=[]
  for p,m in list(ZZ(row['N']).factor()):
   d=P.elllocalred(p)
   assert int(d[0])==m
   local.append({'p':int(p),'conductor_exponent':int(d[0]),'kodaira_code':int(d[1]),'tamagawa':int(d[3]),'a_p':int(P.ellap(p))})
  value=generate.period(key);assert type(value).__name__=='RealBall'
  text=to_text(value,digits=100).rstrip('?');lo,hi=bounds(text)
  assert value.accuracy()>=600 and B(lo)<value and value<B(hi)
  parivalues=[]
  for precision in [832,1024]:
   pp=pari.ellinit(row['ainvs'],precision=precision);w=pp.omega()[0]
   assert w.bitprecision()>=precision
   # This conversion represents a floating approximation, not a certified ball.
   approximation=B(w);assert accepts(text,approximation)
   assert abs(value-approximation)<B(10)**(-185)
   parivalues.append({'precision_bits':int(w.bitprecision()),'approximation':str(RealField(precision)(w))})
  integral,A,D=direct_integral(row)
  assert integral.overlaps(value) and accepts(text,integral)
  c_inf=2 if row['discriminant']>0 else 1
  rep=next(r for r in rows if r['cremona_class']==row['cremona_class'] and r['curve_number']==1)
  r={'label':label,'lmfdb_label':row['lmfdb_label'],'params':dict(zip(('N','c4','c6'),key)),
     'ainvs':row['ainvs'],'discriminant':row['discriminant'],'source_class':row['cremona_class'],
     'curve_number':row['curve_number'],'source_rank':0,'rank_bounds':[0,0],
     'rank_raw':str(rank),'rank_method':'PARI ellrank algebraic 2-descent, effort=0',
     'minimal_model_change':[str(x) for x in change], 'differential_scale':'1',
     'global_model_change':[str(x) for x in red[1]],'torsion_order':int(tors[0]),
     'bad_local_data':local,'c_inf':c_inf,'rank_zero_regulator':'1',
     'class_L_value_table':'T771','class_L_value_params':{k:rep[k] for k in ('N','c4','c6')},
     'cm':row['c4']==0 or row['c6']==0 or str(P.j()) in ['-3375','8000','-32768','54000','287496','-884736','-12288000','16581375','-884736000','-147197952000','-262537412640768000'],
     'stored_text':text,'production_ball':str(value),'production_accuracy_bits':int(value.accuracy()),
     'production_radius':str(value.rad()),'full_BSD_period_ball':str(c_inf*value),
     'pari':parivalues,'integral_ball':str(integral),'integral_accuracy_bits':int(integral.accuracy()),
     'integral_A':str(A),'integral_D':str(D),'seconds':time.monotonic()-start}
  emit(r);checked.append(r)
 # Independent nonzero control: source LMFDB 11.a2 at its supported precision.
 control=next(r for r in checked if r['label']=='11a1')
 reference='1.2692093042795534216887946168';q=rational(reference)
 assert abs(B(q)-B(generate.period((11,496,20008))))<B(10)**(-28)
 # Outside the roster: 37a1, a two-component real curve, documented by Sage.
 row37={'ainvs':[0,0,1,-1,0]};i37,_,_=direct_integral(row37)
 assert abs(i37-B(rational('2.99345864623196')))<B(10)**(-14)
 assert accepts(control['stored_text'],B(generate.period((11,496,20008))))
 negative=not accepts(control['stored_text'],2*B(generate.period((11,496,20008))))
 assert negative
 # CM control: E:y^2=x^3-x has w1=Gamma(1/4)^2/(2*sqrt(2*pi)).
 rowcm=next(r for r in rows if r['ainvs']==[0,0,0,-1,0]);vcm=generate.period(tuple(rowcm[k] for k in ('N','c4','c6')))
 cm=(B(QQ(1)/4).gamma()**2)/(2*(2*B.pi()).sqrt())
 assert cm.overlaps(vcm)
 summary={'checked_entries':len(checked),'total_entries':len(rows),'quadrature_entries':len(checked),'failures':[],
 'known_answer_control':True,'negative_control_rejected':negative,'control_11a1':reference,
 'control_37a1':str(i37),'CM_gamma_control':str(cm),'CM_gamma_label':rowcm['cremona_label'],
 'minimum_production_accuracy_bits':min(r['production_accuracy_bits'] for r in checked),
 'minimum_integral_accuracy_bits':min(r['integral_accuracy_bits'] for r in checked),
 'positive_discriminants':sum(r['discriminant']>0 for r in checked),
 'negative_discriminants':sum(r['discriminant']<0 for r in checked),
 'dependency_hashes':HASHES,'input_sha256':DIGEST,
 'skill_manifest_sha256':hashlib.sha256((BASE/'skill-manifest.json').read_bytes()).hexdigest(),
 'versions':{'python':sys.version,'platform':platform.platform(),'PARI':str(pari('version()'))},
 'independence':'PARI period implementation at 832/1024 bits for every row; certified direct defining integral for every row; production and integration share Sage algebraic roots and Arb arithmetic. No L-value or BSD quotient is used.'}
 print('SUMMARY '+json.dumps(summary,sort_keys=True),flush=True)
if __name__=='__main__':main()
