back to table · edit · history · where entries came from · files · download
8802 bytes, as of the version from 2026-11-02 13:07 (current). Recorded here, not run.
"""Independent numerical and selection checks for numberdb.org/T678.
Run: sage -python checks.py
Optional: sage -python checks.py --stored (authenticated access for a draft).
Requires adjacent generate.py and check.py (the campaign's reusable checks).
The independent series code uses complete quotients (sqrt(D)+P)/Q and integer
convergents. It does not call generator root, orbit, step, or cycle_value.
800 terms and 4096 bits enclose rounding and an absolute tail
4*log(M+1)*2^(-400). The bound follows from x_j*x_(j+1)<1/2.
Both enclosures must be finite and narrower than 10^-110 relative; containment
in the exact written last-place interval is required, not just overlap.
"""
import json, sys, hashlib
from collections import Counter
from decimal import Decimal
from fractions import Fraction
from math import gcd, isqrt
from pathlib import Path
import numberdb.sage as numberdb
from sage.rings.real_arb import RealBallField
from sage.rings.real_mpfi import RealIntervalField
from sage.rings.rational_field import QQ
from sage.env import SAGE_VERSION
from numberdb._write import to_text
from check import exactness, measure, names_its_rings
import generate as gen
N = 800
CHECK_BITS = 4096
F = RealBallField(CHECK_BITS)
I = RealIntervalField(CHECK_BITS)
def independent_arguments(bound=100):
found = set()
for D in range(2, bound+1):
if isqrt(D)**2 == D:
continue
for B in range(1, isqrt(D)+1):
if (D-B*B) % 4:
continue
n = (D-B*B)//4
for A in range(1, n+1):
if n % A:
continue
K = n//A
if gcd(gcd(A,B),K)==1 and A+B>K and A<B+K:
found.add((A,B,K))
return found
def independent_series(t, n=N):
A, B, K = t
D = B*B+4*A*K
sd = F(D).sqrt()
x = (sd-B)/(2*A)
P, Q = B, 2*K
start = (P,Q)
visited, partials, states = set(), [], []
while (P,Q) not in visited:
visited.add((P,Q))
states.append((P,Q))
a = (isqrt(D)+P)//Q
assert a >= 1
partials.append(a)
P = a*Q-P
assert (D-P*P) % Q == 0
Q = (D-P*P)//Q
assert Q > 0
assert (P,Q) == start
M = max(partials)
pprev,qprev,pcur,qcur = 1,0,0,1
total = F(0)
for j in range(n):
P,Q = states[j % len(states)]
xj = F(Q)/(sd+P)
weight = abs(qprev*x-pprev)
total += (-1)**j * weight * (-xj.log())
a = partials[j % len(partials)]
pprev,pcur = pcur,a*pcur+pprev
qprev,qcur = qcur,a*qcur+qprev
tail = 4*F(M+1).log()*F(2)**(-(n//2))
return total.add_error(tail), partials, tail
def written_interval(text):
decimal = Decimal(text)
frac = Fraction(decimal)
mid = QQ(frac.numerator)/QQ(frac.denominator)
ulp = QQ(10)**int(decimal.as_tuple().exponent)
return I(mid-ulp,mid+ulp),ulp
def ensure_narrow(value, relative_digits=110):
assert value.is_finite()
assert not value.contains_zero()
assert F(value.rad()) < abs(value)*F(10)**(-relative_digits)
def contains_text(text,value):
interval,ulp = written_interval(text)
bounds = I(value)
assert interval.lower() <= bounds.lower() <= bounds.upper() <= interval.upper(), text
return float(F(value.rad())/F(ulp))
def controls():
# Known nonzero geometric answer exercises the alternating sum and tail.
r=F(1)/2
s=sum(((-r)**j for j in range(N)),F(0)).add_error(F(2)**(1-N))
assert I(2)/3 in I(s) and 0 not in I(s)
for a in [1,2,3,9]:
v,partials,tail = independent_series((1,a,1))
x=(F(a*a+4).sqrt()-a)/2
known=(-x.log())/(1+x)
ensure_narrow(v); ensure_narrow(known)
assert v.overlaps(known) and partials==[a]
return {'alternating_geometric_sum':'2/3 enclosed, zero excluded',
'fixed_point_series_controls':[1,2,3,9]}
def main(stored=False):
report={'table':'T678','controls':controls(), 'sage_version':SAGE_VERSION,
'numberdb_version':numberdb.__version__,'series_terms':N,
'series_bits':CHECK_BITS,'generator_bits':numberdb.bits(100,losing=gen.WORKING_GUARD),
'skill_manifest':'agents/runs/20261102T123618Z-build-skills/manifest.json',
'skill_local_sha256':'a2b28d9953264d7b0ca62663785c2952190c5be6d6d3597fd695d9a54d606278',
'skill_live_sha256':'a2b28d9953264d7b0ca62663785c2952190c5be6d6d3597fd695d9a54d606278',
'stored':stored,'source_sha256':{p:hashlib.sha256(Path(__file__).with_name(p).read_bytes()).hexdigest() for p in ['generate.py','checks.py','check.py']}}
ts=gen.arguments()
assert set(ts)==independent_arguments() and len(ts)==141
assert not names_its_rings(str(Path(__file__).with_name('generate.py')))
values={gen.identity(t):gen.Wilton().value({'x':gen.identity(t)},100) for t in ts}
assert not exactness(values)
report['measurement']=measure(values)
texts={k:to_text(v['number'],digits=100) for k,v in values.items()}
if stored:
doc=numberdb.table('T678')
numbers=doc['Numbers']
assert list(numbers)==list(texts)
for key,v in numbers.items():
assert v.get('param-latex')==values[key]['param-latex']
texts[key]=v['number']
verification=gen.Wilton().verify(sample=None)
assert verification.ok, str(verification)
report['verify']=str(verification)
cycles=set();counts=Counter();metadata=[];worst_cycle=0;worst_series=0;min_bits=10000
Fsmall=RealBallField(512)
for t in ts:
key=gen.identity(t)
rows,partials=gen.orbit(t)
assert set(rows).issubset(set(ts))
assert all(gen.discriminant(u)==gen.discriminant(t) for u in rows)
cycles.add(min(rows));counts[len(rows)]+=1
v=values[key]['number']
independent,other_partials,tail=independent_series(t)
assert other_partials==partials
ensure_narrow(v);ensure_narrow(independent)
assert v.overlaps(independent)
worst_cycle=max(worst_cycle,contains_text(texts[key],v))
worst_series=max(worst_series,contains_text(texts[key],independent))
min_bits=min(min_bits,int((-(I(F(v.rad())/abs(v)).log())/I(2).log()).lower().floor()))
# A separate exact primitive matrix polynomial validates the period.
p,q,r,s=1,0,0,1
for a in partials: p,q,r,s=q,p+a*q,s,r+a*s
triple=(r,s-p,q)
g=gcd(gcd(abs(r),abs(s-p)),abs(q))
assert tuple(vv//g for vv in triple)==t
# Functional equation on the written intervals (stored when requested).
here,_=written_interval(texts[key])
there,_=written_interval(texts[gen.identity(gen.step(t)[1])])
x=I(gen.root(t,F))
residual=here+x*there+x.log()
assert 0 in residual and I(residual.absolute_diameter()) < I(10)**(-95)
if len(rows)==1:
closed=-Fsmall(gen.root(t,Fsmall)).log()/(1+gen.root(t,Fsmall))
assert I(closed).overlaps(here)
metadata.append({'identity':key,'A':t[0],'B':t[1],'C':-t[2],'D':gen.discriminant(t),'period':partials,
'number':texts[key],'sign':-1 if v<0 else 1,'cycle_accuracy_bits':int((-(I(F(v.rad())/abs(v)).log())/I(2).log()).lower().floor()),
'series_radius_over_ulp':contains_text(texts[key],independent)})
assert counts==Counter({1:9,2:28,3:21,4:24,5:10,6:24,7:7,9:18})
assert len(cycles)==45 and len({gen.discriminant(t) for t in ts})==40
# Corpus control uses T131's written regulator rather than a repeated log call.
regulator=numberdb.table('T131')['Numbers']['5']['number']
rr,_=written_interval(regulator)
phi=(I(5).sqrt()+1)/2
ww,_=written_interval(texts['quad_1_1_m1'])
assert (ww-rr/phi).contains_zero()
brjuno=numberdb.table('T677')
assert set(brjuno['Numbers'])==set(texts)
for t in ts:
key=gen.identity(t)
bb,_=written_interval(brjuno['Numbers'][key]['number'])
ww,_=written_interval(texts[key])
assert abs(ww).upper() < bb.lower()
report.update(entries=len(ts),discriminants=40,cycles=45,period_counts=dict(counts),
max_partial_quotient=max(max(r['period']) for r in metadata),
negative_values=sum(r['sign']==-1 for r in metadata),
min_cycle_accuracy_bits=min_bits,max_cycle_radius_over_ulp=worst_cycle,
max_series_radius_over_ulp=worst_series,all_functional_equations=True,
matrix_period_check=True,regulator_control=True,brjuno_bound_and_argument_set=True,
max_written_length=max(map(len,texts.values())),metadata=metadata)
print(json.dumps(report,indent=2))
return report
if __name__=='__main__': main('--stored' in sys.argv)