check_evidence.py

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

7869 bytes, as of the version from 2026-11-20 10:08 (current). Recorded here, not run.

"""Executable build checks for T774; this is not an independent actor verdict.

sage -python check_evidence.py                  # offline, ten entries
sage -python check_evidence.py stored.json      # check all stored entry intervals

The numerical checker shares Sage/Arb, indexing, and source identities with
the producer, but uses theta sums and a bounded AGM rather than eta products.
Exact eliminations use PARI polclass and rational polynomial arithmetic.
"""
import sys,json,pathlib,platform,importlib.metadata,hashlib
from fractions import Fraction
from decimal import Decimal
import numberdb.sage as numberdb
from sage.rings.rational_field import QQ
from sage.rings.integer_ring import ZZ
from sage.rings.real_arb import RealBallField
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.libs.pari import pari
from numberdb._write import to_text
from generate import coefficient,eta_quotient


def qrat(v):
    f=Fraction(v);return QQ(f.numerator)/f.denominator


def stored_bounds(text):
    # The generator emits plain decimal/scientific strings, one final ulp uncertain.
    d=Decimal(text); center=qrat(d); ulp=QQ(10)**int(d.as_tuple().exponent)
    return center-ulp,center+ulp


def bracket_ball(lo,hi,B):
    return B((lo+hi)/2).add_error(B((hi-lo)/2))


def theta_value(r,wrong_nome=False):
    B=RealBallField(900)
    q=(-(2 if wrong_nome else 1)*B.pi()*B(r).sqrt()).exp()
    N=24
    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)))
    th2=2*q.sqrt().sqrt()*sum((q**(n*(n+1)) for n in range(N+1)),B(0))
    th2=th2.add_error(2*q.sqrt().sqrt()*q**((N+1)*(N+2))/(1-q**(2*N+4)))
    lam=(th2/th3)**4
    assert 0<lam<1
    z=16*(1-lam)*lam**2/(lam-2)**4
    return z.sqrt().sqrt()**(-1),lam


def agm(a,b):
    for _ in range(18):
        a,b=(a+b)/2,(a*b).sqrt()
    return a.union(b)


def period_imag(t):
    B=t.parent();z=t**(-4)
    u=((1-(1-z).sqrt())/2).sqrt()
    lam=2*u/(1+u)
    return agm(B(1),(1-lam).sqrt())/agm(B(1),lam.sqrt())


def narrow(v,bits=350):
    return bool(v.is_finite() and v.parent()(v.rad()) < v.parent()(2)**(-bits))


def compare(v,w):
    return narrow(v) and narrow(w) and v.overlaps(w)


def algebraic_certificate(r,lam,R,t):
    S=PolynomialRing(QQ,'x');x=S.gen()
    H=S(pari(-4*r).polclass())
    if r==1:assert H==x-1728
    P=PolynomialRing(QQ,'m');m=P.gen(); h=H.degree()
    E=sum((H[i]*(m+16)**(3*i)*m**(h-i) for i in range(h+1)),P(0))
    mb=4096/R
    candidates=[f for f,e in E.factor() if f(mb).contains_zero()]
    assert len(candidates)==1
    f=candidates[0].monic()
    A=PolynomialRing(S,'m');mm=A.gen()
    resultant=S(A(f.list()).resultant(256*x**4*mm-(mm**2+128*mm+4096)))
    tfactors=[g for g,e in resultant.factor() if g(t).contains_zero()]
    assert len(tfactors)==1
    M=tfactors[0].monic();assert M.is_irreducible()
    # Each selected factor has a simple real root inside the stored claim.
    text=to_text(t,digits=100);lo,hi=stored_bounds(text)
    assert M(lo)*M(hi)<0
    deriv=M.derivative()(bracket_ball(lo,hi,t.parent()))
    assert not deriv.contains_zero()
    # Source-theorem algebraicity plus the isolated compatible factor pins the root.
    jtheta=256*(1-lam+lam**2)**3/(lam**2*(1-lam)**2)
    jeta=(mb+16)**3/mb
    assert compare(jtheta,jeta)
    assert H(jtheta).contains_zero()
    assert M.degree()>1, 'Rational value must be returned exactly'
    return {'discriminant':-4*r,'class_number':int(h),'class_polynomial':str(H),
            'm_factor':str(f),'t_minpoly':str(M),'degree':int(M.degree()),
            'root_bracket':text,'simple_root_and_unique_in_bracket':True,
            'theta_j_matches_eta_j':True,'class_polynomial_residual_contains_zero':True}


def main():
    stored=None
    if len(sys.argv)>1:
        stored=json.loads(pathlib.Path(sys.argv[1]).read_text())
        nums=stored.get('Numbers',stored.get('Data',[]))
        assert isinstance(nums,list) and len(nums)==10
        assert [str(e['params']['r']) for e in nums]==[str(i) for i in range(1,11)]
        stored={int(e['params']['r']):e['number'] for e in nums}
    rows=[];cert=[];fail=[]
    for r in range(1,11):
        t=coefficient(r);other,lam=theta_value(r);R,n,tail=eta_quotient(ZZ(r),600)
        assert compare(t,other)
        text=to_text(t,digits=100) if stored is None else stored[r]
        lo,hi=stored_bounds(text)
        assert lo<=t.lower().exact_rational()<=t.upper().exact_rational()<=hi
        assert lo<=other.lower().exact_rational()<=other.upper().exact_rational()<=hi
        p=period_imag(t);expected=t.parent()(r).sqrt();assert compare(p,expected)
        claim=bracket_ball(lo,hi,t.parent());pclaim=period_imag(claim)
        assert pclaim.is_finite() and pclaim.overlaps(expected) and narrow(pclaim,300)
        # Exact Gram-pairing, written out independently of any symbolic simplifier.
        gamma=[ZZ(0),ZZ(1),ZZ(-2*r)];G=[[4,0,0],[0,0,1],[0,1,0]]
        norm=sum(gamma[i]*G[i][j]*gamma[j] for i in range(3) for j in range(3))
        assert type(norm).__name__=='Integer' and norm==-4*r
        # Omega=(P,-1,-2r) at P=i*sqrt(r); h-component of gamma is zero.
        pairing=gamma[1]*ZZ(-2*r)+gamma[2]*ZZ(-1);assert pairing==0
        assert gamma[1].gcd(gamma[2])==1
        assert lo>1
        ac=algebraic_certificate(r,lam,R,t);cert.append(ac)
        rows.append({'r':r,'number':text,'native_type':type(t).__name__,
                     'eta_terms':n,'working_bits':600,'eta_tail_bound':str(tail),
                     'producer_radius':str(t.rad()),'theta_radius':str(other.rad()),
                     'producer_accuracy_bits':int(t.accuracy()),
                     'theta_accuracy_bits':int(other.accuracy()),
                     'period_imag':str(p),'stored_period_imag':str(pclaim),
                     'stored_contains_both_enclosures':True,'gamma':[str(a) for a in gamma],
                     'gamma_norm':str(norm),'gamma_period_pairing':str(pairing)})
    t=coefficient(1);v,lam=theta_value(1);B=t.parent()
    known=bool(compare(t**4,B(QQ(81)/32)) and compare(lam,lam.parent()(QQ(1)/2)) and compare(4096/eta_quotient(ZZ(1),600)[0],B(8)))
    R=eta_quotient(ZZ(1),600)[0];wrong_nome,_=theta_value(1,True)
    controls={
      'factor_255':not compare(((R+128+4096/R)/255).sqrt().sqrt(),v),
      'shift_105':not compare(((R+129+4096/R)/256).sqrt().sqrt(),v),
      'negative_branch':not compare(-t,v),
      'square_instead_of_fourth_root':not compare(((R+128+4096/R)/256).sqrt(),v),
      'eta_nome_used_for_theta':not compare(wrong_nome,t),
      'wrong_gamma_sign':ZZ(-2)+ZZ(2)*ZZ(-1)!=0,
      'nonzero_pairings':4!=0 and 1!=0,
      'nan_rejected':not narrow(B('nan')),
      'wide_ball_rejected':not narrow(B(1).add_error(B(100))) }
    assert known and all(controls.values())
    versions={d.metadata['Name']:d.version for d in importlib.metadata.distributions() if any(k in d.metadata['Name'].lower() for k in ('sage','numberdb','gmp','mpmath','pari','flint'))}
    result={'checked_entries':10,'total_entries':10,'failures':fail,'known_answer_control':known,
            'negative_control_rejected':all(controls.values()),'controls':controls,'rows':rows,
            'algebraic_certificates':cert,'python':platform.python_version(),'dependencies':versions,
            'pari_version':str(pari.version()),'source':'stored' if stored else 'offline',
            'limitations':'Build-session alternate formulas, not an independent actor verdict. Exact elimination uses PARI class polynomials and standard modular identities; numerical embedding isolation is explicit.',
            'skill_manifest':'../20261120T083619Z-build-skills/manifest.json',
            'skill_bundle_sha256':'b5c3c7985b7c9e178b4899d083a9e3bc4284989dff76f05e5b0e52835d47eed2'}
    print('RESULT_JSON='+json.dumps(result))

if __name__=='__main__': main()