back to table · edit · history · where entries came from · files · download
12705 bytes, as of the version from 2026-11-10 11:25 (current). Recorded here, not run.
"""Independent build validation for numberdb.org/T705.
Run with SageMath: sage -python checks.py
For database readback: sage -python checks.py --stored --stdin-key
Keep generate.py and the snapshots T15.json, T103.json, T659.json beside it.
The default run checks generated decimal strings; --stored checks database
strings. NUMBERDB_CHECK_STORED=1 is equivalent to --stored. It writes no API.
The independent coefficient route uses theta integrals, not zeta or gamma
functions. Its implementation and explicit tail bounds are adapted from the
public T659/T704 checks.py read on 2026-11-10 and rederived in certification.md.
Polynomial coefficients are extracted directly from exp(2*X*t-t*t)*Theta^n(t),
without the generator's Hermite recurrence. Strict signs at the decimal
interval endpoints certify the stated precision and exhaust the roots.
This is build validation, not the campaign's separate independent critique.
"""
import sys
import os
import json
import time
import ast
import operator
import platform
from math import factorial
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.rings.integer_ring import ZZ
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.env import SAGE_VERSION
from generate import (HermiteCombinationRoots, coefficients, polynomial_coefficients,
hermite_coefficients, roots)
def finite_narrow(x, bits=350):
assert not x.is_NaN() and not x.is_infinity(), 'nonfinite ball'
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, shift=0):
value=decimal_rational(s)
unit=QQ(10)**Decimal(str(s)).as_tuple().exponent
mid=value+shift*unit
return R(mid-unit),R(mid+unit),R(mid,unit)
def moments(max_index=20, 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 independent_polynomial(d,n,gamma):
R=gamma[0].parent()
c=[]
for i in range(d+1):
a=R(0)
for r in range((d-i)//2+1):
j=d-i-2*r
exact=QQ(factorial(d)*2**i*(-1)**r)/QQ(factorial(i)*factorial(j)*factorial(r))
a+=exact*gamma[n+j]
c.append(a)
return c
def evaluate(c,x):
# Separate direct evaluation, not the generator's Horner routine.
return sum((a*x**i for i,a in enumerate(c)),x.parent()(0))
def changes_sign(c,lo,hi):
a,b=evaluate(c,lo),evaluate(c,hi)
assert not a.is_NaN() and not b.is_NaN()
return (a<0 and b>0) or (a>0 and b<0)
def contains_written(v,s):
mid=decimal_rational(s)
unit=QQ(10)**Decimal(str(s)).as_tuple().exponent
R=v.parent()
assert abs(v-R(mid)).upper()<R(unit).lower(),('not inside decimal',s,str(v))
def number(v):
return v['number'] if isinstance(v,dict) else v
def table_records(doc):
block=doc['Numbers']
if isinstance(block,list):
return [(e['params'],e['number']) for e in block]
return [({'d':d,'n':n,'k':k},number(v))
for d,ns in block.items() for n,ks in ns.items() for k,v in ks.items()]
def polynomial_text(source,P):
def run(n):
if isinstance(n,ast.Expression): return run(n.body)
if isinstance(n,ast.Constant) and type(n.value) is int: return P(n.value)
if isinstance(n,ast.Name) and n.id=='x': return P.gen()
if isinstance(n,ast.UnaryOp) and isinstance(n.op,ast.USub): return -run(n.operand)
if isinstance(n,ast.BinOp):
if isinstance(n.op,ast.Pow):
assert isinstance(n.right,ast.Constant) and type(n.right.value) is int
return run(n.left)**n.right.value
op={ast.Add:operator.add,ast.Sub:operator.sub,ast.Mult:operator.mul}[type(n.op)]
return op(run(n.left),run(n.right))
raise ValueError('unexpected polynomial syntax')
return run(ast.parse(source.replace('^','**'),mode='eval'))
def main():
start=time.time()
base=Path(__file__).parent
# Known-answer controls first: nonzero roots, and a converse failure.
R=RealBallField(832)
control=independent_polynomial(2,0,[R(1),R(1),R(2)])
assert all(x==y for x,y in zip(control,map(R,[0,4,4])))
assert changes_sign(control,R(-11)/10,R(-9)/10)
assert changes_sign(control,R(-1)/10,R(1)/10)
# The corresponding ordinary polynomial is 1+2X+2X^2, discriminant -4.
assert R(2)**2-4*R(1)*R(2)==-4
print('CONTROL Hermite combination 4X(X+1) has roots -1,0; ordinary discriminant -4',flush=True)
gamma=moments()
direct=coefficients()
high=coefficients(20,1024)
for j,(a,b,h) in enumerate(zip(gamma,direct,high)):
finite_narrow(a,420);finite_narrow(b);finite_narrow(h)
assert a.overlaps(b) and b.overlaps(h),('gamma disagreement',j)
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)]))
# Exact agreement with the existing basis, and the independent finite sum.
P=PolynomialRing(ZZ,'x')
X=P.gen()
t103=json.loads((base/'T103.json').read_text())['Numbers']
for d in range(11):
H=P(list(hermite_coefficients(d)[d]))
explicit=sum((ZZ(factorial(d)//(factorial(r)*factorial(d-2*r)))*(-1)**r*(2*X)**(d-2*r)
for r in range(d//2+1)),P(0))
assert H==explicit==polynomial_text(number(t103[str(d)]),P)
gen=HermiteCombinationRoots()
stored=('--stored' in sys.argv or os.environ.get('NUMBERDB_CHECK_STORED')=='1')
if stored:
if '--stdin-key' in sys.argv or os.environ.get('NUMBERDB_KEY_FROM_STDIN')=='1':
numberdb.configure(api_key=sys.stdin.read().strip())
entries=table_records(numberdb.table('T705'))
else:
entries=[(p,to_text(gen.value(p,100),100)) for p in gen.enumerate()]
keys=lambda p: tuple(int(p[name]) for name in ('d','n','k'))
assert [keys(p) for p,s in entries]==[keys(p) for p in gen.enumerate()]
groups={}
for p,s in entries: groups.setdefault(keys(p)[:2],[]).append((p,s))
all_rows=[]; main_bits=[]; derivative_cases=0; shifted=0; min_gap=None; min_derivative=None
t659=json.loads((base/'T659.json').read_text())['Numbers']
for (d,n),group in groups.items():
c=independent_polynomial(d,n,gamma)
cmain=polynomial_coefficients(d,n,direct)
assert all(a.overlaps(b) for a,b in zip(c,cmain))
assert c[-1]>0 and c[-1].overlaps(2**d*gamma[n])
scaled=independent_polynomial(d,n,[8*g for g in gamma])
assert all(a.overlaps(8*b) for a,b in zip(scaled,c))
assert len(group)==d
dc=[i*c[i] for i in range(1,d+1)]
lower=independent_polynomial(d-1,n,gamma)
assert all(a.overlaps(2*d*b) for a,b in zip(dc,lower))
derivative_cases+=1
written=[]
for p,s in group:
k=int(p['k'])
lo,hi,b=written_interval(s,R)
finite_narrow(b,320)
assert changes_sign(c,lo,hi),(p,'decimal sign bracket')
if written:
gap=lo-written[-1][1]
assert gap>0
min_gap=gap if min_gap is None or gap<min_gap else min_gap
derivative=evaluate(dc,b)
assert not derivative.contains_zero()
magnitude=abs(derivative)
min_derivative=magnitude if min_derivative is None or magnitude<min_derivative else min_derivative
for shift in (-10,10):
sl,sh,sb=written_interval(s,R,shift)
assert not changes_sign(c,sl,sh)
assert not evaluate(dc,sb).contains_zero()
# The endpoints have the same strict sign and the derivative
# does not vanish on the whole displaced interval.
assert (evaluate(c,sl)>0 and evaluate(c,sh)>0) or (evaluate(c,sl)<0 and evaluate(c,sh)<0)
shifted+=1
g=gen.value(p,100)
contains_written(g,s)
contains_written(roots(d,n,1024)[k-1],s)
main_bits.append(int(g.accuracy()))
written.append((lo,hi,b))
all_rows.append({'params':p,'number':s,'root_accuracy_bits':int(g.accuracy()),'endpoint_signs_certified':True})
# Vieta reconstructs every monic coefficient from stored intervals.
v=[R(1)]
for lo,hi,b in written:
out=[R(0)]*(len(v)+1)
for i,a in enumerate(v): out[i]-=b*a; out[i+1]+=a
v=out
assert all(a.overlaps(b/c[-1]) for a,b in zip(v,c))
assert sum((b for lo,hi,b in written),R(0)).overlaps(-d*gamma[n+1]/(2*gamma[n]))
if d==1:
contains_written(-gamma[n+1]/(2*gamma[n]),group[0][1])
# x(P1)=1/(2*x(J1)), checked against the stored ordinary root.
old=number(t659['1'][str(n)]['1'])
a,b,jroot=written_interval(old,R)
assert written[0][2].overlaps(1/(2*jroot))
if d==2:
a,b,c0=gamma[n:n+3]
delta=(b*b+2*a*a-a*c0).sqrt()
contains_written((-b-delta)/(2*a),group[0][1])
contains_written((-b+delta)/(2*a),group[1][1])
report={'result':'PASS','table':'T705','stored':stored,'entries':len(entries),'polynomials':len(groups),
'independent_coefficients':21,'T15_coefficients_checked':21,'T103_basis_polynomials_checked':11,
'linear_closed_forms_checked':11,'quadratic_roots_checked':22,'ordinary_linear_relations_checked':11,
'derivative_identities_checked':derivative_cases,'scaling_identities_checked':len(groups),'all_vieta_coefficients_checked':True,
'shifted_decimal_intervals_rejected':shifted,'higher_precision_all_roots_checked':True,
'working_bits':896,'independent_working_bits':832,'higher_precision_bits':1024,
'coefficient_min_accuracy_bits':min(int(g.accuracy()) for g in direct),
'theta_coefficient_min_accuracy_bits':min(int(g.accuracy()) for g in gamma),
'root_min_accuracy_bits':min(main_bits),'minimum_within_polynomial_gap':str(min_gap),
'minimum_absolute_derivative':str(min_derivative),'seconds':time.time()-start,
'versions':{'sage':SAGE_VERSION,'numberdb':numberdb.__version__,'python':platform.python_version()},
'skill_manifest':'agents/runs/20261110T105402Z-build-skills/manifest.json',
'skill_sha256':'886390324dd1971e381a43cf3b46b822ab0bc67d62f31d8481e29ec79556746b','rows':all_rows}
print('FINAL_REPORT '+json.dumps(report),flush=True)
if __name__=='__main__':
main()