check_evidence.py

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

6327 bytes, as of the version from 2026-11-20 09:32 (current). Recorded here, not run.

"""Alternative-formula build checks; not an independent actor verdict.

sage -python check_evidence.py offline-values.json
sage -python check_evidence.py stored-flat.json

No producer function or sibling values are used. At every r, independent
bounded theta sums give lambda and t. Clearing denominators in H_D(j(lambda))
and t^4=(lambda-2)^4/(16*(1-lambda)*lambda^2) gives a different exact
elimination. The unique compatible irreducible factor must equal the stored
monic QQ polynomial. Shared dependencies: PARI's Hilbert class polynomials,
Sage factorization and Arb, and the mathematical CM/modular identities.
"""
import json,sys,pathlib,platform,importlib.metadata
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
S=PolynomialRing(QQ,'x');x=S.gen()


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
    t=((lam-2)**4/(16*(1-lam)*lam**2)).sqrt().sqrt()
    return t,lam


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


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 alt_elimination(r,t):
    H=S(pari(-4*r).polclass());h=H.degree()
    A=PolynomialRing(S,'l');l=A.gen()
    jnum=256*(1-l+l**2)**3;den=l**2*(1-l)**2
    E=sum((H[i]*jnum**i*den**(h-i) for i in range(h+1)),A(0))
    C=16*(1-l)*l**2*x**4-(l-2)**4
    res=S(E.resultant(C))
    factors=[f.monic() for f,e in res.factor()]
    possible=[f for f in factors if f(t).contains_zero()]
    assert len(possible)==1
    F=possible[0]
    assert all(not f(t).contains_zero() for f in factors if f!=F)
    return F,H,res,[str(f) for f in factors if f!=F]


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


def bounds100(t):
    text=to_text(t,digits=100);d=Decimal(text);mid=qrat(d);ulp=QQ(10)**int(d.as_tuple().exponent)
    return text,mid-ulp,mid+ulp


def validate(M,r):
    t,lam=theta_value(r)
    assert narrow(t) and t>1
    F,H,res,excluded=alt_elimination(r,t)
    assert M.parent() is S and M.is_monic() and M.is_irreducible() and M==F
    assert res%M==0
    text,lo,hi=bounds100(t);br=t.parent()((lo+hi)/2).add_error(t.parent()((hi-lo)/2))
    assert M(lo)*M(hi)<0 and not M.derivative()(br).contains_zero()
    pp=period_imag(br);expected=t.parent()(r).sqrt()
    assert narrow(pp,300) and pp.overlaps(expected)
    j=256*(1-lam+lam**2)**3/(lam**2*(1-lam)**2)
    assert narrow(j,300) and H(j).contains_zero()
    gamma=[ZZ(0),ZZ(1),ZZ(-2*r)];G=[[4,0,0],[0,0,1],[0,1,0]]
    norm=sum(gamma[i]*G[i][k]*gamma[k] for i in range(3) for k in range(3))
    pair=gamma[1]*ZZ(-2*r)+gamma[2]*ZZ(-1)
    assert type(norm).__name__=='Integer' and norm==-4*r and pair==0
    assert gamma[1].gcd(gamma[2])==1
    return {'r':r,'polynomial':str(M),'degree':int(M.degree()),'class_polynomial':str(H),
            'lambda_resultant':str(res),'excluded_factors':excluded,
            'root_100digits':text,'root_lower':str(lo),'root_upper':str(hi),
            'theta_accuracy_bits':int(t.accuracy()),'theta_radius':str(t.rad()),
            'opposite_exact_endpoint_signs':True,'unique_simple_root_in_bracket':True,
            'inverse_period_imag':str(pp),'full_bracket_period_matches':True,
            'gamma':[str(v) for v in gamma],'gamma_norm':str(norm),'gamma_pairing':str(pair)}


def rejected(M,r):
    try:validate(M,r)
    except (AssertionError,ArithmeticError,ValueError):return True
    return False


def main(path):
    doc=json.loads(pathlib.Path(path).read_text());entries=doc.get('Numbers',doc.get('Data'))
    assert len(entries)==10 and [str(e['params']['r']) for e in entries]==[str(r) for r in range(1,11)]
    rows=[validate(S(e['number']),int(e['params']['r'])) for e in entries]
    t,lam=theta_value(1);B=t.parent()
    known=bool((t**4).overlaps(B(QQ(81)/32)) and lam.overlaps(B(QQ(1)/2)) and S(entries[0]['number'])==x**4-QQ(81)/32 and S(pari(-8).polclass())==x-8000)
    wrong_nome,_=theta_value(1,True)
    controls={'wrong_constant':rejected(x**4-QQ(81)/32+1,1),
              'nonmonic':rejected(2*(x**4-QQ(81)/32),1),
              'wrong_index':rejected(x**4-QQ(81)/32,2),
              'wrong_nome':not t.overlaps(wrong_nome),
              'negative_branch':not t.overlaps(-t),
              'nan_rejected':not narrow(B('nan')),
              'wide_ball_rejected':not narrow(B(1).add_error(B(100))),
              'wrong_gamma_sign':ZZ(-2)+ZZ(2)*ZZ(-1)!=0,
              'nonzero_pairings':4!=0 and 1!=0}
    assert known and all(controls.values())
    deps={d.metadata['Name']:d.version for d in importlib.metadata.distributions() if any(k in d.metadata['Name'].lower() for k in ['sage','numberdb','pari','flint','mpmath'])}
    print('CHECK_JSON='+json.dumps({'checked_entries':10,'total_entries':10,'failures':[],
         'known_answer_control':known,'negative_control_rejected':all(controls.values()),
         'controls':controls,'rows':rows,'python':platform.python_version(),'dependencies':deps,
         'pari_version':str(pari.version()),'input_file':str(path),
         'skill_manifest':'../20261120T092423Z-build-skills/manifest.json',
         'skill_bundle_sha256':'b5c3c7985b7c9e178b4899d083a9e3bc4284989dff76f05e5b0e52835d47eed2',
         'independence':'Alternate lambda elimination and bounded theta/AGM implementation. Shares PARI polclass, Sage/Arb, CM theorem and modular identities; no sibling output or generator function used. This is build-session evidence, not an independent actor verdict.'}))


if __name__=='__main__':main(sys.argv[1])