"""Builder checks for the Chiral Potts Green function (no website writes).

sage -python checks.py beside generate.py and entries.json, or a saved full
stored-table.json. NUMBERDB_CHECK_OUTPUT controls the results file path.
Uses Arb hypergeometric and transformed elliptic formulas for every interval,
and independently derives a two-angle original-kernel integral evaluated by
SciPy for every t. Quadrature is double precision, not certification of all
100 digits. This is builder evidence, never an independent actor verdict.
"""
import os,sys,json,math,time,itertools,hashlib,platform,importlib.metadata,tempfile
from pathlib import Path
from fractions import Fraction
from collections import defaultdict
import numberdb.sage as numberdb
from sage.rings.rational_field import QQ
from sage.rings.real_arb import RealBallField
from sage.rings.complex_arb import ComplexBallField
import scipy.integrate as integrate
from numberdb._generate import _stored_entries
import generate
R=RealBallField(800);C=ComplexBallField(800);start=time.monotonic()
w=Path(__file__).parent
source=w/'stored-table.json'
document=json.loads(source.read_text()) if source.exists() else {'Numbers':json.loads((w/'entries.json').read_text())}
saved=_stored_entries(document)
table=generate.ChiralPottsGreen.table
result={'stage':'build','table':table,'checked_entries':0,'total_entries':66,'failures':[], 'known_answer_control':False,'negative_control_rejected':False,'comparisons':[],'quadrature':[], 'skill_manifest':'../20261118T063041Z-build-skills/manifest.json','skill_bundle_sha256':'d6e85d49873fac5bc748d068b0288cf242b0f9aebf3a9a0fff70295019227420'}

def q(text):
 f=Fraction(str(text));return QQ(f.numerator)/f.denominator

def stored_ball(text):
 text=str(text).strip()
 if '+/-' in text:
  a,b=text.split('+/-');return R(q(a.strip())).add_error(R(q(b.strip())))
 if text.startswith('['):
  a,b=text[1:-1].split(',');return R(q(a)).union(R(q(b)))
 if '.' not in text and 'e' not in text.lower():return R(q(text))
 mant,*exp=text.lower().split('e');expo=int(exp[0]) if exp else 0
 frac=len(mant.split('.')[1]) if '.' in mant else 0
 return R(q(text)).add_error(R(QQ(10)**(expo-frac)))

def narrow(x,digits):
 return x.is_finite() and x>0 and R(x.rad())<abs(x)*R(10)**(-digits)

def hyper(t):
 t=R(QQ(t));z=4/t**2
 v=C(z).hypergeometric([QQ(1)/8,QQ(5)/8],[1])
 assert v.real().is_finite() and v.imag().is_finite() and v.imag().contains_zero()
 return (1-z)**(-QQ(1)/4)*v.real()**2/t

def elliptic(t,wrong_modulus=False):
 t=R(QQ(t));u=2/(t+(t*t-4).sqrt());a=u*u/(2*(1+(1-u*u).sqrt()))
 assert 0<a and a<(R(2).sqrt()-1)**2
 arg=a.sqrt() if wrong_modulus else a
 K=C(arg).elliptic_k()
 assert K.real().is_finite() and K.imag().is_finite() and K.imag().contains_zero()
 return 8*(a*(1-a)).sqrt()*K.real()**2/(R.pi()**2*(1-2*a))

# Original Laurent kernel expansion by exact monomial multiplication.
H={}
for axis in range(3):
 for sign in [-1,1]:
  e=[0,0,0];e[axis]=sign;H[tuple(e)]=4
for e in itertools.product([-1,1],repeat=3):H[e]=-1
power={(0,0,0):1};moments={}
for n in range(1,9):
 nxt=defaultdict(int)
 for e,v in power.items():
  for f,c in H.items():nxt[tuple(a+b for a,b in zip(e,f))]+=v*c
 power=dict(nxt);moments[str(n)]=power.get((0,0,0),0)
assert moments['2']==104 and moments['4']==17880
assert all(moments[str(n)]==0 for n in [1,3,5,7])
field,M,poly=generate.series_data(100)
for r in range(1,5):assert QQ(moments[str(2*r)])/QQ(256)**r in R(poly[r])
assert sorted({sum(c)-c[0]*c[1]*c[2] for c in itertools.product([-1,1],repeat=3)})==[-2,2]
result['constant_terms']=moments
# Check the closed majorant against a separately summed polynomial-geometric tail.
for zz in [QQ(1)/4,QQ(256)/289]:
 z=R(zz);cut=4000
 explicit=sum((R((r+2)*(r+1))/2*z**r for r in range(1,cut+1)),R(0))
 closed=generate.geometric_majorant(z,0)
 remainder=generate.geometric_majorant(z,cut)
 assert explicit.add_error(remainder).overlaps(closed)
for t in generate.selected_arguments():
 s=stored_ball(saved[t]);h=hyper(t);e=elliptic(t)
 assert narrow(s,98) and narrow(h,150) and narrow(e,150),(t,s,h,e)
 assert h in s and e in s,(t,'narrow oracle not contained',s,h,e)
 result['comparisons'].append({'t':t,'stored':saved[t],'hypergeometric_contained':True,'elliptic_contained':True,'hypergeometric_radius':str(h.rad()),'elliptic_radius':str(e.rad())})
result['checked_entries']=len(result['comparisons'])
assert result['checked_entries']==len(saved)==66
# Kernel resolvent positivity gives strict decrease on the ordered arguments.
ordered=[stored_ball(saved[t]) for t in generate.selected_arguments()]
assert all(a>b for a,b in zip(ordered,ordered[1:]))
print('all high precision comparisons passed',flush=True)

# Integrating theta_3 exactly gives 1/sqrt((t-cos x-cos y)^2-(1-cos x cos y)^2).
# Factorization here avoids cancellation close to x=y=0.
def quad_kernel(t,zero=False,reverse=False,normalization=1):
 def f(y,x):
  if zero:return 1/t
  sx=math.sin(x/2)**2;sy=math.sin(y/2)**2
  cx=math.cos(x);cy=math.cos(y)
  if reverse:D=(t-cx-cy)**2-(1+cx*cy)**2
  else:D=(t-2+4*sx*sy)*(t-2+4*(sx+sy-sx*sy))
  return normalization/math.sqrt(D)
 val,err=integrate.dblquad(f,0,math.pi,lambda x:0,lambda x:math.pi,epsabs=2e-12,epsrel=2e-12)
 return val/math.pi**2,err/math.pi**2
known,knownerr=quad_kernel(3,zero=True)
assert abs(known-1/3)<2e-14
# Special-function controls include nonzero hypergeometric and elliptic anchors.
assert C(0).hypergeometric([QQ(1)/8,QQ(5)/8],[1])==1
assert (C(0).elliptic_k()-C.pi()/2).contains_zero()
result['known_answer_control']=True
result['known_controls']={'zero_kernel_t3':known,'expected':1/3,'reported_error':knownerr,'hypergeometric_origin':1,'elliptic_origin':'pi/2'}
for t in generate.selected_arguments():
 v,e=quad_kernel(float(QQ(t)));s=stored_ball(saved[t]);delta=abs(v-float(s.center()))
 assert math.isfinite(v) and math.isfinite(e) and e<2e-11
 assert delta<2e-11,(t,v,s,delta)
 result['quadrature'].append({'t':t,'integral':v,'reported_error':e,'absolute_difference':delta,'precision':'double precision, non-certified'})
# Reject common scientific errors rather than accepting mere numerical overlap.
s=stored_ball(saved['5']);h=hyper('5')
wrong_sign,_=quad_kernel(5,reverse=True)
right,_=quad_kernel(5)
assert abs(wrong_sign-right)>1e-6
assert not (h*R.pi()**3).overlaps(s)
assert not elliptic('5',wrong_modulus=True).overlaps(s)
assert not (h+R(8).log()).overlaps(s)
assert not (s+R('1e-90')).overlaps(h)
result['negative_control_rejected']=True
result['negative_controls']={'reversed_triple_product':{'wrong':wrong_sign,'right':right,'rejected':True},'omitted_measure_factor':True,'wrong_modulus':True,'additive_potential_shift':True,'perturbed_100_digit_entry':True}
result['precision']={'oracle_bits':800,'minimum_stored_relative_radius_requirement':'<1e-98','oracle_relative_radius_requirement':'<1e-150','full_original_kernel_quadrature':'66/66 arguments, double precision only','limitations':'Full high-precision comparisons use source-related identities; original-kernel quadrature checks normalization independently at about 10-12 digits, not 100.'}
result['seconds']=time.monotonic()-start
out=Path(os.environ.get('NUMBERDB_CHECK_OUTPUT',str(Path(tempfile.mkdtemp(prefix='numberdb-green-check-'))/'check-results.json')));out.write_text(json.dumps(result,indent=2))
print('RESULTS_JSON='+json.dumps(result))
print('checks finished',result['checked_entries'],result['seconds'],flush=True)
