back to table · edit · history · where entries came from · files · download
7930 bytes, as of the version from 2026-10-31 10:48 (current). Recorded here, not run.
"""Independent numerical and algebraic checks -- numberdb.org/T634.
Run beside generate.py and algebraic-check-data.json:
sage -python checks.py # computed and serialized entries
sage -python checks.py --stored # entries read from the API
For a private draft set NUMBERDB_API_KEY, or pass the key on stdin with
NUMBERDB_KEY_FROM_STDIN=1. The campaign may set NUMBERDB_CHECK_STORED=1.
No writes are performed. JSON evidence is printed to stdout.
The independent product uses 128 factors. For 0<q<1 the omitted product
lies in [1-q^(129)/(1-q),1]; interval arithmetic propagates this error.
Independent theta sums with 21 terms give j through lambda. All tails have
explicit geometric majorants. The exact canonical equations and Hilbert
class polynomials are archived from T309 and T129, not fitted to these values.
"""
import json
import os
import sys
from decimal import Decimal
from functools import lru_cache
from pathlib import Path
import numberdb.sage as numberdb
from numberdb._write import to_text
from numberdb._generate import _stored_entries
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 McKayThompsonCM, configure_key
B = RealBallField(560)
M = 128
N = 20
def good(v, relative_digits=120):
v = B(v)
assert v.is_finite(), 'nonfinite enclosure'
assert B(v.rad()) < max(B(1), abs(v)) * B(10)**(-relative_digits), 'wide enclosure'
return v
def overlap(a, b, digits=120):
a, b = good(a, digits), good(b, digits)
assert a.overlaps(b), 'disjoint enclosures'
def finite_product(q):
prod, power = B(1), q
for n in range(1, M+1):
prod *= 1-power
power *= q
tail = q**(M+1)/(1-q)
assert tail < B(10)**(-300)
return prod * B(1).add_error(tail)
@lru_cache(maxsize=None)
def independent_ratio(p, r):
q = (-2*B.pi()*B(r).sqrt()).exp()
return good((finite_product(q)/finite_product(q**p))**(24//(p-1))/q)
def independent_value(g, r):
p = int(g[:-1])
R = independent_ratio(p, r)
v = R + 24//(p-1)
if g[-1] == 'A':
v += B(p)**(12//(p-1))/R
return good(v)
@lru_cache(maxsize=None)
def independent_j(r):
q = (-B.pi()*B(r).sqrt()).exp()
th2 = 2*q.sqrt().sqrt()*sum((q**(n*(n+1)) for n in range(N+1)), B(0))
th2 = th2.add_error(2*q**(QQ((2*N+3)**2)/4)/(1-q**(2*N+4)))
th3 = 1 + 2*sum((q**(n*n) for n in range(1,N+1)), B(0))
th3 = th3.add_error(2*q**((N+1)**2)/(1-q**(2*N+3)))
lam = (th2/th3)**4
return good(256*(1-lam+lam**2)**3/(lam**2*(1-lam)**2))
def decimal_q(text):
d = Decimal(text)
sign, digits, exponent = d.as_tuple()
m = ZZ(''.join(map(str,digits))) * (-1 if sign else 1)
return QQ(m)*QQ(10)**int(exponent)
def written_interval(text):
if '.' not in text and 'e' not in text.lower():
v = QQ(text)
return v, v
d = Decimal(text)
v = decimal_q(text)
ulp = QQ(10)**int(d.as_tuple().exponent)
return v-ulp, v+ulp
def as_ball(text):
lo,hi = written_interval(text)
return B((lo+hi)/2).add_error(B((hi-lo)/2))
def controls():
overlap(independent_j(1), 1728)
overlap(independent_ratio(2,1), 512)
overlap(independent_value('2A',1), 544)
overlap(independent_value('2B',1), 536)
for a,b in ((B(1),B(2)), (B(0).add_error(B(10)**10),B(0)),
(B('nan'),B(0))):
failed=False
try: overlap(a,b)
except AssertionError: failed=True
assert failed, 'negative control was accepted'
assert written_interval('3.14') == (QQ(313)/100, QQ(315)/100)
assert written_interval('544') == (QQ(544),QQ(544))
def main(stored=False):
controls()
gen = McKayThompsonCM()
if stored:
configure_key()
doc = numberdb.table('T634')
numbers = _stored_entries(doc)
else:
numbers = {}
records=[]
primary_accuracy=[]
independent_accuracy=[]
raw={}
exact=[]
for params in gen.enumerate():
g,r=params['g'],params['r'];key=f'{g},{r}'
result=gen.value(params,100)
v=result['number'] if isinstance(result,dict) else result
vball=good(v)
expected=independent_value(g,r)
overlap(vball,expected)
text=numbers[key] if stored else to_text(v, digits=100)
lo,hi=written_interval(text)
if lo==hi:
assert (g,r) in (('2A',1),('2B',1))
assert ZZ(v)==lo and lo in expected
exact.append({'g':g,'r':r,'number':text})
else:
assert QQ(expected.lower()) >= lo and QQ(expected.upper()) <= hi, (key,'independent enclosure escapes decimal')
assert QQ(vball.lower()) >= lo and QQ(vball.upper()) <= hi, (key,'generator enclosure escapes decimal')
# Algebraic integers that are rational must be integers. Excluding
# every integer proves that no additional rational row is hidden.
assert expected.lower().floor()==expected.upper().floor()
assert expected.lower() > expected.lower().floor()
primary_accuracy.append(int(v.accuracy()))
independent_accuracy.append(int(expected.accuracy()))
raw[(g,r)] = as_ball(text)
records.append({'params':params,'number':text})
assert len(records)==300
if stored:
assert list(numbers)==[f"{x['params']['g']},{x['params']['r']}" for x in records]
data=json.loads((Path(__file__).parent/'algebraic-check-data.json').read_text())
ring=PolynomialRing(QQ, names=('x','y'));x,y=ring.gens()
uring=PolynomialRing(QQ,'x')
algebraic_count=0
for r in range(1,31):
J=independent_j(r)
h=uring(data['T129'][str(-4*r)])
residual=B(h(J))
scale=sum((abs(B(c))*abs(J)**k for k,c in enumerate(h.list())),B(1))
normalized=good(residual/scale)
assert normalized.contains_zero(), ('Hilbert class polynomial',r)
for p in (2,3,5,7,13):
b=24//(p-1);C=ZZ(p)**(12//(p-1))
A=raw[(str(p)+'A',r)];Bvalue=raw[(str(p)+'B',r)]
overlap(A,Bvalue+C/(Bvalue-b),digits=90)
R=Bvalue-b
xx=C/R
f=ring(data['T309'][str(p)])
residual=B(f(xx,J))
scale=sum((abs(B(c))*abs(xx)**int(ij[0])*abs(J)**int(ij[1]) for ij,c in f.dict().items()),B(1))
normalized=good(residual/scale,relative_digits=90)
assert normalized.contains_zero(), ('canonical modular polynomial',p,r)
algebraic_count+=1
report={'table':'T634','mode':'stored' if stored else 'computed',
'skill_manifest':'agents/runs/20261031T091932Z-build-skills/manifest.json',
'skill_sha256':'a2b28d9953264d7b0ca62663785c2952190c5be6d6d3597fd695d9a54d606278',
'sage_version':SAGE_VERSION,'numberdb_version':numberdb.__version__,
'controls':'known j(i), R2(i), 2A(i), 2B(i); shifted, wide, NaN and decimal-parser controls passed',
'entries':300,'exact_entries':exact,
'primary_working_bits':numberdb.bits(100, losing=96),
'primary_min_accuracy_bits':min(primary_accuracy),
'independent_working_bits':560,'independent_min_accuracy_bits':min(independent_accuracy),
'product_factors':M,'theta_max_index':N,
'independent_product_checks':300,'serialized_interval_containment_checks':298,
'noninteger_exclusions':298,'hilbert_class_checks':30,
'canonical_modular_checks':algebraic_count,'A_B_relation_checks':150,
'longest_written_value':max(len(x['number']) for x in records),
'records':records}
print(json.dumps(report,indent=2))
if __name__=='__main__':
main(stored='--stored' in sys.argv or os.environ.get('NUMBERDB_CHECK_STORED')=='1')