back to table · edit · history · where entries came from · files · download
7300 bytes, as of the version from 2026-11-01 21:11 (current). Recorded here, not run.
"""Independent coefficient and root checks for numberdb.org/T659.
Run: sage -python checks.py
After filling: NUMBERDB_API_KEY=... sage -python checks.py --stored
This reads but never edits the draft. Place generate.py beside this file.
The independent route integrates the theta representation, with explicit
bounds on both omitted theta terms and the infinite integration tail.
It shares neither analytic zeta/gamma series nor their product with the
coefficient generator. The bracket checks apply to the actual 100-digit
serialized intervals (or read-back entries with --stored), not midpoints.
See certification.md for the bounds. JSON lines retain all numerical evidence.
"""
import sys, os, json, time
from math import factorial, comb
from decimal import Decimal
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 generate import JensenRoots, coefficients, roots, polynomial_coefficients, evaluate, certify_bracket, finite_narrow
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 read_entries():
if '--stored' not in sys.argv:
generator=JensenRoots()
return [(p,to_text(generator.value(p,100),100)) for p in generator.enumerate()]
if os.environ.get('NUMBERDB_KEY_FROM_STDIN')=='1':
numberdb.configure(api_key=sys.stdin.read().strip())
doc=numberdb.table('T659')
block=doc['Numbers']
if isinstance(block,list): return [(e['params'],e['number']) for e in block]
result=[]
for d,ns in block.items():
for n,ks in ns.items():
for k,v in ks.items():
result.append(({'d':d,'n':n,'k':k},v.get('number') if isinstance(v,dict) else v))
return result
def main():
start=time.time()
gamma=moments()
direct=coefficients()
assert len(gamma)==len(direct)==29
for j,(a,b) in enumerate(zip(gamma,direct)):
assert a.overlaps(b), ('coefficient disagreement',j,a,b)
# Published 2019 paper, section 4: gamma_10=1.6323380490e-17
# in the convention eight times the sequence used here.
assert (8*gamma[10]).overlaps(RealBallField(832)(decimal_rational('1.6323380490e-17'), decimal_rational('1e-27')))
entries=read_entries(); assert len(entries)==756
groups={}; smallest_bits=10000; shifted_rejections=0
for p,s in entries:
d,n,k=(int(p[x]) for x in ('d','n','k'))
R=gamma[0].parent(); lo,hi,ball=written_interval(s,R)
coeffs=polynomial_coefficients(d,n,gamma)
certify_bracket(coeffs,lo,hi)
groups.setdefault((d,n),[]).append((k,ball))
for sign in (-1,1):
unit=QQ(10)**Decimal(str(s)).as_tuple().exponent
shifted=ball+sign*10*unit
left=evaluate(coeffs,R(shifted.lower()))
right=evaluate(coeffs,R(shifted.upper()))
assert (left>0 and right>0) or (left<0 and right<0)
derivative=[(j+1)*coeffs[j+1] for j in range(d)]
assert not evaluate(derivative,shifted).contains_zero()
shifted_rejections+=1
smallest_bits=min(smallest_bits,int(roots(d,n)[k-1].accuracy()))
assert len(groups)==168
for (d,n),values in groups.items():
values.sort(); rr=[b for k,b in values]
assert [k for k,b in values]==list(range(1,d+1))
for a,b in zip(rr,rr[1:]): assert a.upper()<b.lower()
# Vieta: all elementary symmetric coefficients, not just a sum.
coeffs=[R(1)]
for root in rr:
new=[R(0)]*(len(coeffs)+1)
for j,c in enumerate(coeffs):
new[j]-=root*c; new[j+1]+=c
coeffs=new
target=polynomial_coefficients(d,n,gamma)
for j,c in enumerate(coeffs): assert c.overlaps(target[j]/target[-1])
# Algebraic derivative identity checked coefficient by coefficient.
other=polynomial_coefficients(d-1,n+1,gamma)
for j in range(d): assert ((j+1)*target[j+1]).overlaps(d*other[j])
if d==1: assert rr[0].overlaps(-gamma[n]/gamma[n+1])
if d==2:
delta=gamma[n+1]**2-gamma[n]*gamma[n+2]
assert delta>0
expected=[(-gamma[n+1]-delta.sqrt())/gamma[n+2],(-gamma[n+1]+delta.sqrt())/gamma[n+2]]
assert all(a.overlaps(b) for a,b in zip(rr,expected))
# Precision escalation is supplemental; theta quadrature supplies independence.
higher=coefficients(28,1024)
assert all(a.overlaps(b) for a,b in zip(direct,higher))
print(json.dumps({'result':'PASS','stored':'--stored' in sys.argv,'entries':len(entries),'polynomials':len(groups),'independent_coefficients':29,'coefficient_min_bits':min(int(x.accuracy()) for x in direct),'integral_coefficient_min_bits':min(int(x.accuracy()) for x in gamma),'root_min_bits':smallest_bits,'shifted_intervals_rejected':shifted_rejections,'vieta_all_coefficients':True,'linear_and_quadratic_controls':True,'derivative_identity':True,'seconds':time.time()-start}),flush=True)
if __name__=='__main__': main()