independent_check.py

back to table · edit · history · where entries came from · files · download

10534 bytes, as of the version from 2026-11-18 19:41 (current). Recorded here, not run.

"""Independent theta-integral/Li and Bareiss check of screw-moment Hankel determinants.

Run with SageMath, Arb/FLINT and numberdb; no production generator is imported.
  sage -python independent_check.py
  sage -python independent_check.py --stored stored-document.json
Checkpoint/result paths default to this file's directory; --resume uses an
existing theta-checkpoint.json, whose stored definition/version is checked.
Suzuki 2206.03682v4 (8.3); DLMF 25.5.13-14. See numerical-evidence.md
for the independently derived uniform theta and integration tail bounds.
The common dependencies are completed-xi theory and Arb/FLINT arithmetic.
This checker imports neither the production generator nor its helper. It
recomputes every moment input and uses factorial row/column scaling with
a separately implemented fraction-free Bareiss determinant.
The family moment checker supplies the reusable analytic routines; all
quadratures and transforms are executed anew for this run.
"""
import sys,json,pathlib,time,argparse
from math import factorial,comb
from fractions import Fraction
import numberdb.sage as numberdb
from sage.rings.complex_arb import ComplexBallField
from sage.rings.real_arb import RealBallField
from sage.rings.rational_field import QQ

VERSION='theta-li-scaled-bareiss-shifted-v1'
BITS=1152;M=16;LIMIT=256;NMAX=41;DMAX=20
C=ComplexBallField(BITS);R=RealBallField(BITS)

def narrow(x,bits=400):
    return bool(x.is_finite() and not x.contains_zero() and x.accuracy() >= bits)

def compare(a,b,minimum=300):
    if not narrow(a,minimum) or not narrow(b,minimum):return False
    return bool((a-b).contains_zero())

def theta_coefficients(progress):
    pi=C.pi()
    # |log(x)/2|^k/k! <= sqrt(x) for x>=1, all k>=0.
    # Together with |sqrt(x)+(-1)^k| <= 2sqrt(x), this gives an
    # integrand bound 2*sum exp(-pi*m*m*x), uniform in every k.
    tail_x=2*(-R.pi()*LIMIT).exp()/(R.pi()*(1-(-3*R.pi()*LIMIT).exp()))
    a=M+1
    tail_m=2*(-R.pi()*a*a).exp()/(R.pi()*a*a*(1-(-R.pi()*(2*a+1)).exp()))
    tail=(tail_x+tail_m).upper()
    coeffs=[]
    for k in range(NMAX+1):
        def f(x,analytic):
            if analytic and x.real().lower() <=0:return C('nan')
            z=x.log();theta=sum(((-pi*m*m*x).exp() for m in range(1,M+1)),C(0))
            return (x.sqrt()+(-1)**k)*(z/2)**k*theta/(x*factorial(k))
        z=C.integral(f,1,LIMIT,abs_tol=R(2)**(-1000),rel_tol=R(2)**(-1000),eval_limit=100000,depth_limit=30)
        if not (z.real().is_finite() and z.imag().is_finite() and z.imag().contains_zero()):
            raise ArithmeticError('Theta quadrature failed at order '+str(k))
        value=z.real()+R(0,rad=tail)
        if not value.is_finite():raise ArithmeticError('Bad theta coefficient')
        coeffs.append(value)
        progress(coeffs,tail_x,tail_m)
        print('theta coefficient',k,'accuracy',value.accuracy(),flush=True)
    return coeffs,tail_x,tail_m

def li_from_theta(A):
    # xi(1+u)=1/2+(u+u^2)*A(u)/2.
    q=[R(QQ(1)/2)]
    for j in range(1,NMAX+2):
        q.append((A[j-1]+(A[j-2] if j>=2 else 0))/2)
    # Substitute u=w/(1-w) using binomial coefficients, no FLINT log series.
    b=[q[0]]+[sum((comb(n-1,j-1)*q[j] for j in range(1,n+1)),R(0)) for n in range(1,NMAX+2)]
    lam=[R(0)]
    for n in range(1,NMAX+2):
        lam.append((n*b[n]-sum((lam[k]*b[n-k] for k in range(1,n)),R(0)))/b[0])
    return lam

def moments_from_li(lam):
    values=[]
    for n in range(NMAX+1):
        v=R(0)
        for j in range(1,n+2):
            c=sum(k*2**(k-1)*comb(n-k+2,j) for k in range(1,n-j+3))
            v+=c*(-1)**(j+1)*lam[j]
        values.append(factorial(n)*v)
    return values

def stored_bounds(s):
    # Exact rational endpoints of the interval claimed by NumberDB spelling.
    s=str(s)
    if '+/-' in s:
        c,r=s.split('+/-');c=Fraction(c.strip());r=Fraction(r.strip())
        return QQ(c-r),QQ(c+r)
    if s.startswith('['):
        lo,hi=s[1:-1].split(',');return QQ(Fraction(lo)),QQ(Fraction(hi))
    f=Fraction(s)
    if '.' not in s and 'e' not in s.lower():return QQ(f),QQ(f)
    mant,_,exponent=s.lower().partition('e');ex=int(exponent or 0)
    places=len(mant.split('.')[1]) if '.' in mant else 0
    ulp=Fraction(10)**(ex-places)
    return QQ(f-ulp),QQ(f+ulp)

def bareiss(A):
    a=[list(row) for row in A];N=len(a)
    if N==0:return QQ(1)
    one=a[0][0]*0+1;prev=one;sgn=1
    for k in range(N-1):
        if not a[k][k]:
            p=next((i for i in range(k+1,N) if a[i][k]),None)
            if p is None:return one*0
            a[k],a[p]=a[p],a[k];sgn=-sgn
        pivot=a[k][k]
        if hasattr(pivot,'contains_zero') and pivot.contains_zero():
            raise ArithmeticError('Unresolved Bareiss pivot')
        for i in range(k+1,N):
            for j in range(k+1,N):
                a[i][j]=(a[i][j]*pivot-a[i][k]*a[k][j])/prev
        for i in range(k+1,N):a[i][k]=one*0
        prev=pivot
    return sgn*a[-1][-1]

def determinant(mu,n,offset=1):
    # Independent scaling, undone exactly. The production matrix is unscaled.
    f=[factorial(i) for i in range(n+1)]
    A=[[mu[i+j+offset]/(f[i]*f[j]) for j in range(n+1)] for i in range(n+1)]
    scale=1
    for x in f:scale*=x*x
    return bareiss(A)*scale

def run():
    parser=argparse.ArgumentParser();parser.add_argument('--stored',type=pathlib.Path);parser.add_argument('--resume',action='store_true');a=parser.parse_args()
    work=pathlib.Path(__file__).parent;cp=work/'theta-checkpoint.json';start=time.time()
    def progress(values,tx,tm):
        data={'version':VERSION,'working_bits':BITS,'M':M,'limit':LIMIT,'coefficients':[str(v) for v in values],'tail_x':str(tx),'tail_m':str(tm)}
        print('THETA_CHECKPOINT_JSON '+json.dumps(data),flush=True)
        try:cp.write_text(json.dumps(data,indent=2))
        except OSError:pass
    if a.resume:
        p=json.loads(cp.read_text());assert p['version']==VERSION and p['working_bits']==BITS and p['M']==M and p['limit']==LIMIT and len(p['coefficients'])==NMAX+1
        A=[R(v) for v in p['coefficients']];tx=R(p['tail_x']);tm=R(p['tail_m'])
    else:A,tx,tm=theta_coefficients(progress)
    lam=li_from_theta(A);mu=moments_from_li(lam)
    values=[determinant(mu,n) for n in range(DMAX+1)]
    # Quadrature with a known nonzero antiderivative and independent mu_0.
    pi=C.pi();quad=C.integral(lambda x,_:(-pi*x).exp(),1,LIMIT,abs_tol=R(2)**(-1000),rel_tol=R(2)**(-1000)).real()
    exact=((-R.pi()).exp()-(-R.pi()*LIMIT).exp())/R.pi()
    mu0=1+(R.euler_constant()-(4*R.pi()).log())/2
    checks={'quadrature':compare(quad,exact,800),'initial moment':compare(mu[0],mu0,750),
            'E0':compare(values[0],mu[1],600),'E1 formula':compare(values[1],mu[1]*mu[3]-mu[2]**2,600)}
    # Exact known-answer matrices test determinant recurrence and offset controls.
    ex=[QQ(factorial(k)) for k in range(18)]
    det_controls=[]
    for n in range(9):
        du=QQ(1);ds=QQ(1)
        for j in range(n+1):du*=factorial(j)**2;ds*=factorial(j)*factorial(j+1)
        ok=bool(determinant(ex,n,0)==du and determinant(ex,n,1)==ds)
        det_controls.append({'n':n,'unshifted':str(du),'shifted':str(ds),'pass':ok})
    signed=[QQ(1)-QQ(2)**k/16 for k in range(4)]
    checks['factorial moments']=all(x['pass'] for x in det_controls)
    checks['signed measure']=bool(all(v>0 for v in signed) and determinant(signed,1)==-QQ(1)/8)
    checks['row swap']=bareiss([[QQ(0),QQ(2)],[QQ(3),QQ(4)]])==-6
    wrong={'wrong sign':not compare(values[1],-values[1]),
           'wrong factor':not compare(values[1],4*values[1]),
           'matrix size off by one':not compare(values[1],values[0]),
           'unshifted matrix':not compare(values[1],determinant(mu,1,0)),
           'factorial-normalized moments':not compare(values[1],determinant([mu[k]/factorial(k) for k in range(4)],1)),
           'scaling not undone':not compare(values[5],values[5]/(factorial(5)**2)),
           'NaN':not compare(values[1],R('nan')),
           'vacuous ball':not compare(values[1],R('0 +/- 1e100'))}
    result={'method':VERSION,'working_bits':BITS,'checked_entries':0,'total_entries':21,'failures':[],
            'known_answer_control':all(bool(x) for x in checks.values()),'negative_control_rejected':all(wrong.values()),
            'known_controls':{k:bool(v) for k,v in checks.items()},'negative_controls':wrong,'factorial_determinant_controls':det_controls,
            'signed_control_moments':[str(x) for x in signed],'signed_control_E1':str(determinant(signed,1)),
            'minimum_relative_bits':min(int(v.accuracy()) for v in values),'moment_minimum_relative_bits':min(int(v.accuracy()) for v in mu),
            'moments':[str(v) for v in mu],'li_coefficients':[str(v) for v in lam[1:]],'determinants':[str(v) for v in values],
            'tail_x':str(tx),'tail_m':str(tm),'seconds':time.time()-start}
    production=work/'production.json'
    if production.exists():
        p=json.loads(production.read_text());m1=[R(x) for x in p['moments']]
        result['moment_comparisons']=[{'k':k,'overlap':compare(mu[k],m1[k],400)} for k in range(NMAX+1)]
        if not all(x['overlap'] for x in result['moment_comparisons']):result['failures'].append('Moment disagreement')
    if a.stored:
        doc=json.loads(a.stored.read_text());numbers=doc['Numbers']
        if isinstance(numbers,dict):rows=[{'params':{'n':str(k)},'number':v['number'] if isinstance(v,dict) else v} for k,v in numbers.items()]
        else:rows=numbers
        assert [int(row['params']['n']) for row in rows]==list(range(21))
        comparisons=[]
        for row in rows:
            n=int(row['params']['n']);lo,hi=stored_bounds(row['number']);v=values[n]
            ok=bool(narrow(v,400) and v>R(lo) and v<R(hi) and v.rad_as_ball()<R(hi-lo)/1000)
            comparisons.append({'n':n,'stored_contains_independent_ball':ok,'independent_relative_bits':int(v.accuracy())})
            if not ok:result['failures'].append('Stored determinant '+str(n))
        result['checked_entries']=21;result['comparisons']=comparisons
    if not result['known_answer_control'] or not result['negative_control_rejected']:result['failures'].append('Control failed')
    if not all(narrow(v,400) for v in values):result['failures'].append('Insufficient determinant precision')
    print('CHECK_RESULTS_JSON '+json.dumps(result),flush=True)
    try:(work/'check-results.json').write_text(json.dumps(result,indent=2))
    except OSError:pass
    if result['failures']:raise SystemExit('Independent checks failed')
if __name__=='__main__':run()