"""Builder's executable checks for T740, separate from controller critique.

sage -python checks.py > checks.log
Requires offline-results.json; optional stored.json checks the website readback.
The product generator is imported ONLY for a higher-precision enclosure check.
Expected determinant values instead use mpmath and source equation (29), with
independent base values. Integral matrices are separately built by direct-t
quadrature using Arb Bessel midpoints and tanh-sinh; this quadrature is heuristic.
JSON checkpoint lines retain every integrated moment and determinant.
Skill manifest: ../20261117T143346Z-build-skills/manifest.json.
"""
import sys,json,time,math
from pathlib import Path
from functools import lru_cache
from fractions import Fraction
from itertools import permutations
import mpmath as mp
import numberdb.sage as numberdb
from numberdb._compare import _complex_parts,_claim,_as_fraction
from numberdb._write import _as_interval
from sage.rings.rational_field import QQ
from sage.rings.real_arb import RealBallField
from sage.rings.complex_arb import ComplexBallField
from sage.env import SAGE_VERSION
from generate import normalized
HERE=Path(__file__).resolve().parent


def df(n):
    return math.prod(range(n,0,-2))


def exact_q(x):
    x=Fraction(x)
    return QQ(x.numerator)/QQ(x.denominator)


def parts(text):
    if text.startswith('-i*'): return '0','-'+text[3:]
    if text.startswith('i*'): return '0',text[2:]
    return _complex_parts(text) or (text,'0')


def bounds(text):
    q=_as_fraction(text)
    if q is not None:return q,q
    v,e=_claim(text)
    return Fraction(v)-Fraction(e),Fraction(v)+Fraction(e)


def contains(text,z):
    if not mp.isfinite(z.real) or not mp.isfinite(z.imag):return False
    for t,v in zip(parts(text),(z.real,z.imag)):
        lo,hi=bounds(t)
        if lo!=hi and (hi-lo)>max(abs(lo),abs(hi))*Fraction(1,10**98):return False
        q=Fraction(mp.nstr(v,175))
        if not lo<=q<=hi:return False
    return True


def recurrence():
    mp.mp.dps=190
    M={1:mp.pi/2};N={1:mp.pi**2/4}
    for r in range(1,8):
        alpha=(mp.mpf(2)**r*mp.factorial(r)*mp.sqrt(2*r+1)/df(2*r+1))**(2*r+1)*mp.gamma(mp.mpf(r+1)/2)**2/2
        M[r+1]=alpha*N[r]**2/M[r]
        k=r+1
        beta=mp.mpf(2)**k/mp.factorial(k-1)*(df(2*k-1)*mp.sqrt(2*k)/(mp.mpf(2)**k*mp.factorial(k)))**(2*k)
        N[k]=beta*M[k]**2/N[k-1]
    return {n:(M if n%2 else N)[(n+1)//2] for n in range(1,17)}


def phase(n):
    r=(n+1)//2
    return mp.fprod([(-1)**(n-a)*mp.mpf(2)**n*(mp.pi*mp.j)**a for a in range(r)])*mp.fprod([mp.mpf(2)**(-2*j) for j in range(r)])


def leibniz(a):
    d=len(a);v=mp.mpf(0)
    for p in permutations(range(d)):
        sign=(-1)**sum(p[i]>p[j] for i in range(d) for j in range(i+1,d))
        v+=sign*mp.fprod(a[i][p[i]] for i in range(d))
    return v


def quadrature(dps,expected):
    mp.mp.dps=dps
    maxbits=[0];stop=3*(dps+50)
    @lru_cache(maxsize=50000)
    def factors(t):
        arg=exact_q(mp.nstr(t,dps+15));bits=numberdb.bits(dps+20,losing=32)
        while True:
            C=ComplexBallField(bits);z=C(arg)
            first=z.bessel_I(0).real()
            second=(C.pi().sqrt()*(-z).exp()*(2*z).hypergeometric_U(QQ(1)/2,1)).real()
            if all(x.is_finite() and x>0 and x.accuracy()>(dps+12)*math.log2(10) for x in (first,second)):
                maxbits[0]=max(maxbits[0],bits)
                return mp.mpf(str(first.mid())),mp.mpf(str(second.mid()))
            bits*=2
            if bits>12000:raise ArithmeticError('factor accuracy failure')
    def moment(a,b,q):
        def f(t):
            if not t:return mp.mpf(0)
            i,k=factors(t)
            return i**a*k**b*t**q
        return mp.quad(f,[0,1,5,20,stop],method='tanh-sinh')
    controls=[]
    for a,b,q,known in [(0,1,0,mp.pi/2),(0,2,0,mp.pi**2/4),(0,1,1,mp.mpf(1)),(0,2,1,mp.mpf(1)/2)]:
        v=moment(a,b,q);err=abs(v/known-1)
        assert mp.isfinite(v) and err<mp.mpf(10)**(-dps+15),(a,b,q,err)
        controls.append({'moment':[a,b,q],'value':mp.nstr(v,dps),'relative_error':mp.nstr(err,10)})
    rows=[]
    for n in range(1,17):
        r=(n+1)//2
        mat=[[moment(a,n-a,2*j) for j in range(r)] for a in range(r)]
        v=mp.det(mp.matrix(mat));err=abs(v/expected[n]-1)
        assert mp.isfinite(v) and v>0 and err<mp.mpf('1e-45'),(n,dps,mp.nstr(err,12))
        if r<=4:assert abs(leibniz(mat)/v-1)<mp.mpf(10)**(-dps+15)
        row={'working_digits':dps,'n':n,'matrix':[[mp.nstr(x,dps) for x in a] for a in mat],'determinant':mp.nstr(v,dps),'relative_error':mp.nstr(err,10),'log10_row_norm_product_over_det':mp.nstr(mp.log10(mp.fprod(sum(abs(x) for x in a) for a in mat)/v),10)}
        rows.append(row);print('QUADRATURE_CHECKPOINT='+json.dumps(row),flush=True)
    return {'working_digits':dps,'cutoff':stop,'controls':controls,'rows':rows,'cached_nodes':factors.cache_info().currsize,'max_bessel_working_bits':maxbits[0]}


def main():
    started=time.time();expected=recurrence();offline=json.loads((HERE/'offline-results.json').read_text());rows=[]
    for entry in offline['entries']:
        n=int(entry['params']['n']);norm=entry['params']['normalization'];v=expected[n]*(phase(n) if norm=='period' else 1)
        assert contains(entry['number'],v),(n,norm,'recurrence outside stored interval')
        high=normalized(n,norm,180)
        for t,component in zip(parts(entry['number']),(high.real(),high.imag())):
            lo,hi=bounds(t);interval=_as_interval(component)
            assert exact_q(lo)<=interval.lower().exact_rational() and interval.upper().exact_rational()<=exact_q(hi)
        rows.append({'n':n,'normalization':norm,'recurrence_inside_100_digit_interval':True,'high_ball_contained':True})
    first=offline['entries'][0]['number']
    assert contains(first,mp.pi/2)
    assert not contains(first,-mp.pi/2)
    assert not contains(first,mp.pi/2*(1+mp.mpf('1e-90')))
    assert not contains(first,mp.mpf('nan'))
    assert not contains('1 +/- 100',mp.pi/2)
    assert not contains(first,mp.mpf('inf'))
    for text,z in [('i*'+first,mp.pi/2),(first,mp.j*mp.pi/2)]:assert not contains(text,z)
    print('RECURRENCE_CHECKPOINT='+json.dumps(rows),flush=True)
    quad=[quadrature(dps,expected) for dps in (70,100)]
    stored=[]
    if (HERE/'stored.json').exists():
        doc=json.loads((HERE/'stored.json').read_text());mp.mp.dps=190
        assert len(doc['Numbers'])==16
        for n in range(1,17):
            for norm in ['bessel','period']:
                t=doc['Numbers'][str(n)][norm];t=t['number'] if isinstance(t,dict) else t
                assert contains(t,expected[n]*(phase(n) if norm=='period' else 1));stored.append([n,norm])
    result={'table':'T740','skill_manifest':'../20261117T143346Z-build-skills/manifest.json','versions':{'sage':SAGE_VERSION,'numberdb':numberdb.__version__,'mpmath':mp.__version__},'recurrence_checked_entries':len(rows),'checks':rows,'quadratures':quad,'stored_checked_entries':stored,'known_answer_control':True,'negative_control_rejected':True,'failures':[],'elapsed_seconds':time.time()-started}
    print('CHECKS_JSON='+json.dumps(result),flush=True)

if __name__=='__main__':main()
