back to table · edit · history · where entries came from · files · download
4934 bytes, as of the version from 2026-11-16 12:25 (current). Recorded here, not run.
"""Independent numerical checks for T724 (Sage Python, mpmath 1.4.1).
Run: sage -python checks.py
Reads entries.json beside this file; prints JSON evidence to stdout.
Independent mpmath Bessel functions, direct-t tanh-sinh integration and
Leibniz permutation determinant. The generator uses Sage/Arb, log-t
quadrature and matrix elimination. All 13 values are checked; these
numerical comparisons are heuristic and do not certify stored precision.
The certificate for stored precision is the generator's full Arb enclosure.
The Gamma control uses Zhou (4.37)--(4.38), not a sibling table's digits.
"""
import json,sys,time,itertools,math
from pathlib import Path
from functools import lru_cache
import numberdb.sage as numberdb
import mpmath as mp
mp.mp.dps=130
entries=json.loads(Path(__file__).with_name('entries.json').read_text())
failures=[]
def emit(kind,**data):
print(json.dumps({'kind':kind,**data}),flush=True)
@lru_cache(maxsize=60000)
def functions(t):
return mp.besseli(0,t),mp.besselk(0,t)
@lru_cache(maxsize=None)
def integral(a,b,r):
def f(t):
if t==0:return mp.mpf(0)
I,K=functions(t)
return I**a*K**b*t**r
return mp.quad(f,[0,1,4,16,64,mp.inf],method='tanh-sinh')
def det(rows):
d=len(rows);out=mp.mpf(0)
for p in itertools.permutations(range(d)):
inversions=sum(p[i]>p[j] for i in range(d) for j in range(i+1,d))
out+=(-1)**inversions*mp.fprod(rows[i][p[i]] for i in range(d))
return out
def stored_interval(text):
# Decimal-last-place interpretation, including a possible exponent.
from decimal import Decimal
x=Decimal(text);power=x.as_tuple().exponent
return mp.mpf(text),mp.power(10,power)
def close(actual,expected,tolerance=mp.mpf('1e-110')):
return bool(mp.isfinite(actual) and mp.isfinite(expected) and
abs(actual-expected)<=tolerance*max(abs(expected),mp.mpf('1e-200')))
start=time.time()
control1=integral(0,1,1);control2=integral(0,2,1)
known=close(control1,mp.mpf(1)) and close(control2,mp.mpf(1)/2)
negative=not close(-control1,mp.mpf(1)) and not close(control1/mp.pi,mp.mpf(1)) and not close(mp.nan,mp.mpf(1)) and not close(mp.inf,mp.mpf(1))
assert known and negative
emit('controls',known_answer_control=known,negative_control_rejected=negative,
first=mp.nstr(control1,132),second=mp.nstr(control2,132),seconds=time.time()-start)
expected_dimensions={3:1,5:1,6:1,7:2,8:1,9:2,10:2,11:3,12:2,13:3,14:3,15:4,16:3}
assert {int(k) for k in entries}==set(expected_dimensions)
values={}
for text_n,text in entries.items():
n=int(text_n);d=expected_dimensions[n];st=time.time()
rows=[[integral(2*i+1,n-2*i-1,2*j+1) for j in range(d)] for i in range(d)]
v=det(rows);values[n]=v
midpoint,ulp=stored_interval(text);error=abs(v-midpoint)/ulp
# Bound precision of the *comparison* before interpreting stored-interval containment.
assert mp.isfinite(v) and v>0 and all(mp.isfinite(x) for row in rows for x in row)
ok=bool(error<1)
if not ok:failures.append('n=%d: independent result outside stored decimal interval'%n)
emit('entry',n=n,dimension=d,value=mp.nstr(v,125),stored_ulp_error=mp.nstr(error,14),passed=ok,seconds=time.time()-st)
# Source-independent low scalar control and published Gamma identity.
controls={3:mp.pi/(3*mp.sqrt(3)),5:mp.fprod(mp.gamma(mp.mpf(j)/15) for j in [1,2,4,8])/(240*mp.sqrt(5))}
for n,v in controls.items():
assert close(values[n],v)
mid,ulp=stored_interval(entries[str(n)])
assert abs(v-mid)<ulp
emit('closed-form',n=n,expected=mp.nstr(v,130),stored_ulp_error=mp.nstr(abs(v-mid)/ulp,14))
# Proved reflection formula (Zhou 1.21), additional independently integrated rows.
for n in [5,7,9]:
k=(n-1)//2;d=k//2
rows=[[integral(2*i+2,n-2*i-2,2*j+1) for j in range(d)] for i in range(d)]
even=det(rows)
def df(m):return math.prod(range(m,0,-2))
factor=mp.sqrt(mp.mpf(df(2*k+1))**(2-(-1)**k))/(mp.pi**((k+1)//2)*2**(k//2)*df(k-1)*mp.mpf(df(k))**(1-(-1)**k))
assert close(even,factor*values[n])
emit('reflection',n=n,even_value=mp.nstr(even,130),factor=mp.nstr(factor,130),relative_error=mp.nstr(abs(even/(factor*values[n])-1),14))
# A genuine wrong dimension at a reduced case is not the selected value.
wrong8=det([[integral(1,7,1),integral(1,7,3)],
[integral(3,5,1),integral(3,5,3)]])
assert not close(wrong8,values[8])
emit('wrong-dimension-control',n=8,rejected=True)
emit('complete',checked_entries=len(values),total_entries=len(entries),failures=failures,
known_answer_control=known,negative_control_rejected=negative,
mpmath=mp.__version__,working_dps=mp.mp.dps,elapsed_seconds=time.time()-start,
independence='mpmath Bessel functions; direct-t tanh-sinh quadrature; permutation determinant; closed forms and reflection formula',
limitations='Numerical quadrature agreement is heuristic; it is separate from the Arb enclosures.')
assert not failures