back to table · edit · history · where entries came from · files · download
5634 bytes, as of the version from 2026-10-27 19:45 (current). Recorded here, not run.
"""Independent exact checks for Generalized Okamoto polynomials, T559.
Run: sage -python checks.py
Read and test the live draft: NUMBERDB_CHECK_STORED=1 sage -python checks.py
The draft read needs NUMBERDB_API_KEY, or NUMBERDB_KEY_FROM_STDIN=1 with
one token piped on stdin. No action in this file writes to the website.
The independent construction solves the polynomial differential equation
P''Q - 2P'Q' + PQ'' - 2x(P'Q - PQ') + 2(deg(P)-deg(Q))PQ = 0
coefficient by coefficient, with monic P. This is the Darboux eigenstate
identity for the harmonic oscillator (Clarkson 2009, Theorems 3.6 and 3.7,
equation (3.15)); it does not evaluate any Wronskian. Degree and leading term
make the coefficient system triangular. Known Hermite cases and deliberately
perturbed polynomials test the verifier. The source's equation (2.14) is not
used; the attached numerical evidence documents its indexing inconsistency.
"""
import json
import os
import re
import sys
from functools import lru_cache
from math import factorial
import numberdb.sage as numberdb
from sage.rings.rational_field import QQ
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.env import SAGE_VERSION
S = PolynomialRing(QQ, 'x')
z = S.gen()
def index_degree(m,n):
r=m+n
return sum(range(1,3*m,3)) + sum(range(2,3*n,3)) - r*(r-1)//2
def oscillator_residual(p,q):
delta=p.degree()-q.degree()
return (p.derivative(2)*q - 2*p.derivative()*q.derivative()
+ p*q.derivative(2) - 2*z*(p.derivative()*q-p*q.derivative())
+ 2*delta*p*q)
def extend(q,d):
p=z**d
for j in range(d-1,-1,-1):
residual=oscillator_residual(p,q)
coefficient=-residual[j+q.degree()]/QQ(2*(d-j))
p += coefficient*z**j
if oscillator_residual(p,q):
raise ArithmeticError('no monic polynomial satisfies the Darboux equation')
return p
@lru_cache(None)
def independent(m,n):
if m==0 and n==0:
return S.one()
previous = independent(m,n-1) if n else independent(m-1,0)
return extend(previous,index_degree(m,n))
def closed_monic_hermite(k):
return sum((QQ((-1)**j*factorial(k))/QQ(4**j*factorial(j)*factorial(k-2*j)))
*z**(k-2*j) for j in range(k//2+1))
def controls():
assert extend(S.one(),0)==1
assert extend(S.one(),1)==z
assert extend(S.one(),2)==z*z-QQ(1)/2
for k in range(26):
assert extend(S.one(),k)==closed_monic_hermite(k)
assert independent(1,1)==z*z+QQ(1)/2
assert independent(2,0)==z**4-z*z-QQ(1)/4
assert independent(2,1)==z**4+z*z-QQ(1)/4
assert independent(1,2)==z**5-QQ(5)/4*z
assert oscillator_residual(z*z+QQ(1)/2,S.one()) != 0
# The positive-index case m=n=1 also refutes the printed (2.14a).
p,q=independent(2,1),independent(1,1)
printed=(p.derivative(2)*q-2*p.derivative()*q.derivative()+p*q.derivative(2)
-2*z*(p.derivative()*q-p*q.derivative())+2*p*q)
assert printed == -2*p*q and printed != 0
print('Controls: H_0 through H_25; four small Okamoto cases; wrong-sign rejection; source (2.14a) counterexample.')
def inspect_values(values):
controls()
expected={(m,n) for m in range(20) for n in range(20)
if index_degree(m,n)<=60}
assert set(values)==expected
ordered=sorted(expected,key=lambda p:(index_degree(*p),*p))
assert list(values)==ordered
count_m=count_n=0
for (m,n),p in values.items():
assert p == independent(m,n), ('independent coefficients',m,n)
d=index_degree(m,n)
assert p.degree()==d and p.leading_coefficient()==1
assert p(-z)==(-1)**d*p
# Use stored neighbors wherever present, independent ones outside range.
next_m=values[(m+1,n)] if (m+1,n) in values else independent(m+1,n)
next_n=values[(m,n+1)] if (m,n+1) in values else independent(m,n+1)
assert oscillator_residual(next_m,p)==0, ('m direction',m,n)
assert oscillator_residual(next_n,p)==0, ('n direction',m,n)
count_m+=1
count_n+=1
# A changed coefficient must disagree with the independent reconstruction.
assert p+1 != independent(m,n)
print('Entries checked:',len(values))
print('Independent coefficient comparisons, degree, monicity, parity: all passed.')
print('Darboux equations:',count_m,'m-neighbor pairs;',count_n,'n-neighbor pairs.')
print('Numerical precision: exact rational coefficients throughout; no rounding.')
def read_stored():
from numberdb._generate import _stored_entries
document=numberdb.table('T559')
assert list(document['Parameters']) == ['m','n']
entries=_stored_entries(document)
values={tuple(int(part.strip()) for part in key.split(',')):S(value)
for key,value in entries.items()}
assert len(values)==len(entries)
return values
def authenticate():
if os.environ.get('NUMBERDB_KEY_FROM_STDIN')=='1':
key=sys.stdin.read().strip()
if re.match(r'^[A-Z_][A-Z0-9_]*\s*=',key):
key=key.split('=',1)[1].strip().strip('\"\'')
numberdb.configure(api_key=key)
if __name__=='__main__':
authenticate()
print('Sage',SAGE_VERSION,'numberdb',numberdb.__version__)
if os.environ.get('NUMBERDB_CHECK_STORED')=='1' or '--stored' in sys.argv:
values=read_stored()
print('Source: values read from T559 through the NumberDB API.')
else:
from generate import GeneralizedOkamoto
gen=GeneralizedOkamoto()
values={(p['m'],p['n']):S(gen.value(p,100)) for p in gen.enumerate()}
print('Source: local generator.')
inspect_values(values)