checks.py

back to table · edit · history · where entries came from · files · download

10174 bytes, as of the version from 2026-11-10 11:43 (current). Recorded here, not run.

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

Run: sage -python checks.py
After filling: sage -python checks.py --stored --stdin-key
Place generate.py and the read-only snapshots T15.json, T381.json, T659.json
beside this file. No writes to the website occur here.

The theta-moment routine and its tail bounds are adapted from the public
T659 checks.py, retrieved 2026-11-10. It evaluates no zeta or gamma function.
Root candidates are independently recomputed from theta coefficients;
strict endpoint signs certify all roots before the product is used.
This build validation is not the campaign's separate critique.
"""
import sys, os, json, time, ast, operator, platform
from math import factorial, comb
from decimal import Decimal
from pathlib import Path
import numberdb.sage as numberdb
from numberdb._write import to_text
from sage.rings.complex_arb import ComplexBallField
from sage.rings.real_arb import RealBallField
from sage.rings.rational_field import QQ
from sage.env import SAGE_VERSION
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from generate import JensenDiscriminants, coefficients, discriminant


def finite_narrow(x, bits=350):
    assert not x.is_NaN() and not x.is_infinity()
    assert x.accuracy() >= bits, (x.accuracy(), bits)

def decimal_rational(s):
    t=Decimal(str(s)).as_tuple()
    a=int(''.join(map(str,t.digits))) * (-1 if t.sign else 1)
    return QQ(a)*QQ(10)**t.exponent


def written_interval(s, R):
    value=decimal_rational(s)
    unit=QQ(10)**Decimal(str(s)).as_tuple().exponent
    return R(value-unit), R(value+unit), R(value,unit)


def moments(max_index=28, bits=832):
    C, R=ComplexBallField(bits), RealBallField(bits)
    # Known-answer controls, including a nonzero non-polynomial integral.
    control=C.integral(lambda u, analytic: (-C.pi()*u).exp(),1,256,
                       abs_tol=R(2)**(-750),rel_tol=R(2)**(-750))
    expected=((-C.pi()).exp()-(-256*C.pi()).exp())/C.pi()
    finite_narrow(control.real(),650)
    assert control.overlaps(expected) and control.real()>0
    negative=C.integral(lambda u, analytic: -u*u,0,1)
    assert negative.overlaps(-C(1)/3) and negative.real()<0
    print(json.dumps({'control':'known_integrals','nonzero':str(control),'negative':str(negative)}),flush=True)
    result=[]
    for j in range(max_index+1):
        m=2*j
        def integrand(u,analytic):
            logu=u.log(analytic=analytic)
            q=(-C.pi()*u).exp()
            theta=sum((q**(ell*ell) for ell in range(1,13)),C(0))
            return (-3*logu/4).exp()*theta*(logu/2)**m/factorial(m)
        v=sum((C.integral(integrand,a,2*a,abs_tol=R(2)**(-750),
                         rel_tol=R(2)**(-750)) for a in (1,2,4,8,16,32,64,128)),C(0))
        # ln(u)<=u; u^m <= exp(m*(u-1)) for u>=1.
        A=169*R.pi()
        theta_tail=(-A).exp()/((1-(-27*R.pi()).exp())*(A-m)*2**m*factorial(m))
        # For u>=U: (ln u)^m <= u^m <= U^m exp(m*(u-U)/U).
        U=256
        integral_tail=R(U)**m*(-U*R.pi()).exp()/((1-(-3*U*R.pi()).exp())*(R.pi()-R(m)/U)*2**m*factorial(m))
        assert v.imag().contains_zero()
        I=v.real()+R(0,(theta_tail+integral_tail).upper())
        finite_narrow(I,430)
        result.append(I)
        print(json.dumps({'moment':j,'ball':str(I),'accuracy_bits':int(I.accuracy()),'theta_tail':str(theta_tail),'integral_tail':str(integral_tail)}),flush=True)
    gamma=[R(1)/2-result[0]/4]
    gamma.extend(factorial(j)*(result[j-1]-result[j]/4) for j in range(1,max_index+1))
    for g in gamma: finite_narrow(g,420)
    return gamma



def horner(c, x):
    result=x.parent()(0)
    for v in reversed(c): result=result*x+v
    return result


def root_product(c):
    d=len(c)-1
    R=c[0].parent(); C=ComplexBallField(R.precision())
    P=PolynomialRing(C,'X')
    candidates=sorted(P(c).roots(multiplicities=False),key=lambda z:z.real().mid())
    assert len(candidates)==d
    roots=[]
    for z in candidates:
        finite_narrow(z.real(),400)
        assert z.imag().contains_zero()
        radius=R(2)**(-390)*max(R(1),abs(R(z.real().mid())))
        b=R(z.real().mid(),radius.upper())
        lo,hi=R(b.lower()),R(b.upper())
        assert lo<hi<0
        a,t=horner(c,lo),horner(c,hi)
        assert (a<0 and t>0) or (a>0 and t<0)
        if roots: assert roots[-1].upper()<b.lower()
        roots.append(b)
    value=c[-1]**(2*d-2)
    for i in range(d):
        for j in range(i+1,d): value *= (roots[i]-roots[j])**2
    finite_narrow(value,350)
    # Independently check every Vieta coefficient using these root intervals.
    v=[R(1)]
    for r in roots:
        w=[R(0)]*(len(v)+1)
        for j,a in enumerate(v): w[j]-=r*a; w[j+1]+=a
        v=w
    assert all(a.overlaps(b/c[-1]) for a,b in zip(v,c))
    return value,roots


def universal_expression(source, values):
    """Evaluate the T381 polynomial with a small whitelisted AST interpreter."""
    def run(n):
        if isinstance(n,ast.Expression): return run(n.body)
        if isinstance(n,ast.Constant) and type(n.value) is int: return n.value
        if isinstance(n,ast.Name): return values[n.id]
        if isinstance(n,ast.UnaryOp) and isinstance(n.op,ast.USub): return -run(n.operand)
        if isinstance(n,ast.BinOp):
            op={ast.Add:operator.add,ast.Sub:operator.sub,ast.Mult:operator.mul,ast.Pow:operator.pow}[type(n.op)]
            return op(run(n.left),run(n.right))
        raise ValueError('Unexpected universal-polynomial syntax')
    return run(ast.parse(source.replace('^','**'),mode='eval'))


def number(v): return v['number'] if isinstance(v,dict) else v


def records(document):
    block=document['Numbers']
    if isinstance(block,list): return [(e['params'],e['number']) for e in block]
    return [({'d':d,'n':n},number(v)) for d,ns in block.items() for n,v in ns.items()]


def contains_written(v,s):
    center=decimal_rational(s)
    unit=QQ(10)**Decimal(str(s)).as_tuple().exponent
    R=v.parent()
    assert abs(v-R(center)).upper()<R(unit).lower(), ('outside written interval',s,str(v))
    for sign in (-1,1):
        assert abs(v-R(center+sign*10*unit)).lower()>R(unit).upper()


def main():
    start=time.time();R=RealBallField(896)
    # Nonzero algebraic controls distinguish sign and leading-coefficient conventions.
    for c,target in [([-1,0,1],4),([0,-1,0,1],4),([4,0,5,0,1],5184),([1,2,2],-4),([-2,0,2],16)]:
        assert target in discriminant(list(map(R,c)))
    # The positive quartic discriminant 5184 does not imply real roots:
    # x^4+5*x^2+4=(x^2+1)(x^2+4)>0 for real x.
    gamma=moments(); R=gamma[0].parent()
    direct=coefficients(); higher=coefficients(28,1024)
    for j,(a,b,h) in enumerate(zip(gamma,direct,higher)):
        finite_narrow(a,420);finite_narrow(b,350);finite_narrow(h,350)
        assert a.overlaps(b) and b.overlaps(h), ('coefficient disagreement',j)
    base=Path(__file__).parent
    t15=json.loads((base/'T15.json').read_text())['Numbers']['a_n/n!']
    for j,g in enumerate(gamma): contains_written(g/factorial(j),number(t15[str(2*j)]))
    t381=json.loads((base/'T381.json').read_text())['Numbers']
    t659=json.loads((base/'T659.json').read_text())['Numbers']
    gen=JensenDiscriminants()
    if '--stored' in sys.argv:
        if '--stdin-key' in sys.argv or os.environ.get('NUMBERDB_KEY_FROM_STDIN')=='1':
            numberdb.configure(api_key=sys.stdin.read().strip())
        entries=records(numberdb.table('T704'))
    else: entries=[(p,to_text(gen.value(p,100),100)) for p in gen.enumerate()]
    expected_keys=[(p['d'],p['n']) for p in gen.enumerate()]
    assert [(int(p['d']),int(p['n'])) for p,s in entries]==expected_keys
    product_bits=[]; main_bits=[]; universal_count=0; roots_count=0;rows=[]
    for p,s in entries:
        d,n=int(p['d']),int(p['n'])
        c=[comb(d,j)*gamma[n+j] for j in range(d+1)]
        value,rr=root_product(c)
        assert value>0
        contains_written(value,s)
        root_bits=min(int(r.accuracy()) for r in rr)
        # Verify the entire root family against the live T659 snapshot.
        for k,r in enumerate(rr,1): contains_written(r,number(t659[str(d)][str(n)][str(k)]))
        roots_count+=len(rr)
        generated=gen.value(p,100)
        assert value.overlaps(generated)
        main_bits.append(int(generated.accuracy()));product_bits.append(int(value.accuracy()))
        if d<=5:
            u=universal_expression(t381[str(d)],{'a'+str(j):a for j,a in enumerate(c)})
            finite_narrow(u,350);contains_written(u,s);universal_count+=1
        if d==2:
            u=4*(gamma[n+1]**2-gamma[n]*gamma[n+2])
            contains_written(u,s)
        if d==3:
            a,b,c0,e=gamma[n:n+4]
            u=27*(4*(b*b-a*c0)*(c0*c0-b*e)-(b*c0-a*e)**2)
            contains_written(u,s)
        # Scaling by eight must multiply the raw discriminant by 8^(2d-2).
        scaled=discriminant([8*a for a in c])
        finite_narrow(scaled,350);contains_written(scaled/8**(2*d-2),s)
        rows.append({'d':d,'n':n,'number':s,'main_accuracy_bits':int(generated.accuracy()),'root_product_accuracy_bits':int(value.accuracy()),'root_min_accuracy_bits':root_bits})
    report={'result':'PASS','stored':'--stored' in sys.argv,'table':'T704','entries':len(entries),'independent_coefficients':29,'roots_certified':roots_count,'universal_discriminants_checked':universal_count,'quadratic_cases':21,'cubic_cases':21,'scaling_cases':147,'shifted_decimal_controls_rejected':2*len(entries),'vieta_all_coefficients':True,'coefficient_min_bits':min(int(x.accuracy()) for x in direct),'integral_coefficient_min_bits':min(int(x.accuracy()) for x in gamma),'discriminant_min_bits':min(main_bits),'root_product_min_bits':min(product_bits),'working_bits':896,'integral_working_bits':832,'higher_precision_bits':1024,'seconds':time.time()-start,'versions':{'sage':SAGE_VERSION,'numberdb':numberdb.__version__,'python':platform.python_version()},'skill_manifest':'agents/runs/20261110T024815Z-build-skills/manifest.json','skill_sha256':'886390324dd1971e381a43cf3b46b822ab0bc67d62f31d8481e29ec79556746b','rows':rows}
    print('FINAL_REPORT '+json.dumps(report),flush=True)


if __name__=='__main__': main()