"""Independent numerical checks for numberdb.org/T502.

Run: sage -python checks.py (generate.py in the same directory).
Set NUMBERDB_API_KEY and pass --stored to test the database entries as well.
For the campaign wrapper, pipe the key with NUMBERDB_KEY_FROM_STDIN=1;
that mode also checks the stored table. This script never writes to the site.

The generator uses Halphen's sparse series. This check instead brackets the
root of K(m)-2E(m) using Arb's complete elliptic integrals, maps it through the
elliptic nome, and checks a separate divisor-sum power series at both endpoints
of each written decimal interval. OEIS digit fixtures were read from the
sequence pages A072558 and A073007 on 2026-10-25; both b-files returned 403.
"""
import json
import os
import sys
from decimal import Decimal
from pathlib import Path
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
from numberdb._write import to_text
from generate import OneNinthConstant, lambda_ball, theta_residual

R = RealBallField(640)
C = ComplexBallField(640)


def real(z):
    assert z.imag().contains_zero()
    x = z.real()
    assert x.is_finite() and R(x.rad()) < R(2)**(-500)
    return x


def elliptic_pair(m):
    z = C(m)
    return real(z.elliptic_k()), real(z.elliptic_e())


def elliptic_root():
    k, e = elliptic_pair(0)
    assert (k-R.pi()/2).contains_zero()
    assert (e-R.pi()/2).contains_zero()
    k, e = elliptic_pair(QQ(1)/2)
    assert (2*k*e-k*k-R.pi()/2).contains_zero()
    assert ((-R.pi()*k/k).exp()-(-R.pi()).exp()).contains_zero()
    lo, hi = QQ(4)/5, QQ(9)/10
    def residual(m):
        k,e = elliptic_pair(m)
        return k-2*e
    assert residual(lo) < 0 < residual(hi)
    for _ in range(530):
        mid = (lo+hi)/2
        y = residual(mid)
        if y < 0: lo = mid
        elif y > 0: hi = mid
        else: raise ArithmeticError('Unresolved elliptic bisection sign')
    m = R((lo+hi)/2,R((hi-lo)/2).upper())
    k,e = elliptic_pair(m)
    kc,_ = elliptic_pair(1-m)
    q = (-R.pi()*kc/k).exp()
    assert q.is_finite() and R(q.rad()) < R(2)**(-500)
    return m,q


COEFF = [0] + [abs(sum((-1)**d*d for d in range(1,j+1) if j%d == 0))
               for j in range(1,241)]
assert COEFF[1:9] == [1,1,4,5,6,4,8,13]


def divisor_series(q):
    """Sum a_j*q^j with a rigorous j^2 majorant for j>=241."""
    assert 0 <= q <= QQ(1)/8
    x = R(q)
    total = R(0)
    for a in reversed(COEFF[1:]):
        total = (total+a)*x
    # sum_{j=M}^inf j^2*r^j = r^M*(M^2/(1-r) +
    #                 2*M*r/(1-r)^2 + r*(1+r)/(1-r)^3).
    r, m = QQ(1)/8, 241
    tail = r**m*(m*m/(1-r)+2*m*r/(1-r)**2+r*(1+r)/(1-r)**3)
    return total + R(0,R(tail).upper())


def exact_decimal(text):
    a,b = Decimal(text).as_integer_ratio()
    return QQ(a)/QQ(b)


def decimal_interval(text):
    # NumberDB decimal convention: plus or minus one unit in the last place.
    d = Decimal(text)
    mid = exact_decimal(text)
    ulp = QQ(10)**d.as_tuple().exponent
    return mid-ulp,mid+ulp


def validate_written(written, independent, label):
    q = independent
    for form,s in written.items():
        lo,hi = decimal_interval(s)
        expected = q if form == 'Lambda' else 1/q
        assert R(lo) < expected < R(hi), (label,form,'decimal enclosure')
        a,b = (lo,hi) if form == 'Lambda' else (1/hi,1/lo)
        assert divisor_series(a) < R(1)/8 < divisor_series(b), (label,form,'root bracket')
        assert 0 < a < b < QQ(1)/9
        print(label,form,'decimal enclosure and independent divisor-series bracket: PASS')
    qlo,qhi = decimal_interval(written['Lambda'])
    vlo,vhi = decimal_interval(written['V'])
    assert qlo*vlo < 1 < qhi*vhi
    print(label,'reciprocal intervals: PASS')


def oeis_check(q):
    raw = {
      'Lambda': '1,0,7,6,5,3,9,1,9,2,2,6,4,8,4,5,7,6,6,1,5,3,2,3,4,4,5,0,9,0,9,4,7,1,9,0,5,8,7,9,7,6,5,6,3,2,9,0,1,1,5,0,8,6,6,9,8,5,6,8,1,4,6,9,8,1,9,2,4,3,4,1,4,6,2,6,4,2,6,4,3,4,1,2,7,7,6,1,9,9,0,4,0,9,1,5,8,7,3,1,9,2,9,6,7',
      'V': '9,2,8,9,0,2,5,4,9,1,9,2,0,8,1,8,9,1,8,7,5,5,4,4,9,4,3,5,9,5,1,7,4,5,0,6,1,0,3,1,6,9,4,8,6,7,7,5,0,1,2,4,4,0,8,2,3,9,7,0,0,6,1,4,2,1,7,2,9,3,7,5,2,4,7,2,8,6,5,0,7,0,7,0,5,2,4,1,5,8,7,0,6,1,4,2,4,7,1,4,4'
    }
    for form,seq in raw.items():
        digits = seq.replace(',','')
        scale = len(digits) if form == 'Lambda' else len(digits)-1
        lo = QQ(int(digits))/QQ(10)**scale
        hi = lo+QQ(10)**(-scale)
        x = q if form == 'Lambda' else 1/q
        assert R(lo) < x < R(hi), ('OEIS',form)
        print('OEIS',form,len(digits),'significant digits: PASS')


def main():
    stored = '--stored' in sys.argv or os.environ.get('NUMBERDB_KEY_FROM_STDIN') == '1'
    if os.environ.get('NUMBERDB_KEY_FROM_STDIN') == '1':
        os.environ['NUMBERDB_API_KEY'] = sys.stdin.read().strip()
    assert (theta_residual(QQ(0),R,25)-1).contains_zero()
    assert divisor_series(QQ(0)).contains_zero()
    assert R(divisor_series(QQ(0)).rad()) < R(2)**(-600)
    m,q = elliptic_root()
    print('Elliptic controls at m=0 and m=1/2: PASS')
    print('Elliptic m:',m)
    print('Independent Lambda:',q)
    g = OneNinthConstant()
    written = {}
    for params in g.enumerate():
        form=params['form']; x=g.value(params,100)['number']
        assert x.is_finite() and R(x.rad()) < R(2)**(-350)
        assert (R(x)-(q if form=='Lambda' else 1/q)).contains_zero()
        written[form]=to_text(x,100)
        print('Generated',form,written[form], 'radius:',x.rad())
    validate_written(written,q,'generated')
    oeis_check(q)
    high=lambda_ball(150)
    assert (R(high)-q).contains_zero()
    assert R(high.rad()) < R(2)**(-520)
    print('150-digit rerun agrees: PASS')
    if stored:
        t=numberdb.table('T502')
        def rows(nodes, form=None):
            for n in nodes:
                form_here=n.get('params',{}).get('form',n.get('param',form))
                if 'number' in n: yield form_here,n['number']
                if 'numbers' in n: yield from rows(n['numbers'],form_here)
        written=dict(rows(t['Numbers']))
        assert set(written)=={'Lambda','V'},written
        validate_written(written,q,'stored')
        result=g.verify(sample=None)
        print(result)
        assert result.ok
    print('ALL CHECKS PASSED')


if __name__=='__main__': main()
