back to table · edit · history · where entries came from · files · download
8703 bytes, as of the version from 2026-11-20 07:17 (current). Recorded here, not run.
"""Build-time independent checks for T773; no review verdict or website writes.
Sage local heights are called directly to bypass Point.height's shared cache.
Exact Fraction additions independently check the group operations used in
polarization. A coarse height certificate uses only the rational duplication
map, integer Bezout identities and directed logarithm intervals; see
coarse-bound.md for its proof. It establishes independence, not saturation.
Run with compute.py, points.json and generate.py alongside this file.
"""
from fractions import Fraction
from functools import lru_cache
import hashlib
import inspect
import json
from pathlib import Path
import sys
import numberdb.sage as numberdb
from sage.rings import qqbar
qqbar._init_qqbar()
from sage.rings.rational_field import QQ
from sage.rings.integer_ring import ZZ
from sage.rings.real_mpfr import RealField
from sage.rings.real_mpfi import RealIntervalField
from sage.schemes.elliptic_curves.constructor import EllipticCurve
from sage.matrix.constructor import matrix
def affine(P):
return None if P.is_zero() else (Fraction(str(P[0])), Fraction(str(P[1])))
def neg(ainvs, P):
if P is None:
return None
a1, _, a3, _, _ = ainvs
x, y = P
return x, -y-a1*x-a3
def add(ainvs, P, Q):
if P is None:
return Q
if Q is None:
return P
a1, a2, a3, a4, _ = ainvs
x, y = P
u, v = Q
if x == u:
if y+v+a1*x+a3 == 0:
return None
slope = (3*x*x+2*a2*x+a4-a1*y)/(2*y+a1*x+a3)
else:
slope = (v-y)/(u-x)
intercept = y-slope*x
z = slope*slope+a1*slope-a2-x-u
return z, -(slope+a1)*z-intercept-a3
def local_height(P, bits):
if P.is_zero():
return QQ(0)
# Explicit finite-place sum on an integral globally minimal model. This
# avoids Sage 10.9's x(P)=0 wrapper branch setting c to Python int(1),
# whose valuation method is missing when some discriminant valuation>=12.
E = P.curve()
assert E.is_global_minimal_model()
c = QQ(P[0]).denominator()
finite = RealField(bits)(c).log()
for p, _ in E.discriminant().factor():
if not p.divides(c):
finite += P.non_archimedean_local_height(
p, prec=bits, weighted=True, is_minimal=True)
return finite + P.archimedean_local_height(prec=bits)
def close(a, b, decimals=150):
F = RealField(1100)
a, b = F(a), F(b)
return (not a.is_NaN() and not a.is_infinity()
and not b.is_NaN() and not b.is_infinity()
and abs(a-b) < F(10)**(-decimals)*max(F(1), abs(b)))
@lru_cache(None)
def duplication_certificate(ainvs):
a1, a2, a3, a4, a6 = map(ZZ, ainvs)
b2, b4, b6 = a1*a1+4*a2, 2*a4+a1*a3, a3*a3+4*a6
b8 = a1*a1*a6+4*a2*a6-a1*a3*a4+a2*a3*a3-a4*a4
f = [-b8, -2*b6, -b4, ZZ(0), ZZ(1)]
g = [b6, 2*b4, b2, ZZ(4), ZZ(0)]
M = matrix(ZZ, 8, 8, lambda row,col:
(f if col < 4 else g)[row-(col % 4)]
if 0 <= row-(col % 4) <= 4 else 0)
R = M.det()
assert R != 0
A = M.adjugate()
for k in [0,7]:
assert all((M*A.column(k))[j] == (R if j == k else 0)
for j in range(8))
L = max(sum(abs(A[j,k]) for j in range(8)) for k in [0,7])
U = max(sum(abs(t) for t in f),sum(abs(t) for t in g))
return f, g, R, L, U
def coarse_height(P, ainvs, n):
I = RealIntervalField(192)
if P.is_zero():
return I(0)
f,g,R,L,U = duplication_certificate(tuple(ainvs))
A,B = ZZ(P[0].numerator()), ZZ(P[0].denominator())
for _ in range(n):
vals = [sum(v[k]*A**k*B**(4-k) for k in range(5)) for v in [f,g]]
A,B = vals
assert not (A==0 and B==0)
if B == 0:
return I(0) # some doubling is O, hence P is torsion
d=A.gcd(B);A//=d;B//=d
if B<0:A,B=-A,-B
central=I(max(abs(A),abs(B))).log()/ZZ(4)**n
error=I(max(U,L)).log()/(ZZ(3)*ZZ(4)**n)
return central+I(-error.upper(),error.upper())
def determinant(m):
if len(m)==1:return m[0][0]
if len(m)==2:return m[0][0]*m[1][1]-m[0][1]*m[1][0]
assert len(m)==3
return (m[0][0]*(m[1][1]*m[2][2]-m[1][2]*m[2][1])
-m[0][1]*(m[1][0]*m[2][2]-m[1][2]*m[2][0])
+m[0][2]*(m[1][0]*m[2][1]-m[1][1]*m[2][0]))
def check_curve(record, primary):
coeff=record['ainvs'];E=EllipticCurve(QQ,coeff)
assert list(map(int,E.a_invariants()))==coeff
assert int(E.conductor())==record['N']
assert E.is_global_minimal_model()
assert list(map(int,E.c_invariants()))==[record['c4'],record['c6']]
assert coeff[0] in [0,1] and coeff[1] in [-1,0,1] and coeff[2] in [0,1]
points=[]
for p in record['projective']:
x,y=Fraction(p[0],p[2]),Fraction(p[1],p[2])
a1,a2,a3,a4,a6=coeff
assert y*y+a1*x*y+a3*y==x*x*x+a2*x*x+a4*x+a6
points.append(E([QQ(x.numerator)/QQ(x.denominator),QQ(y.numerator)/QQ(y.denominator)]))
for P in points:
assert add(coeff,affine(P),neg(coeff,affine(P))) is None
assert add(coeff,affine(P),affine(P))==affine(2*P)
for Q in points:
assert add(coeff,affine(P),affine(Q))==affine(P+Q)
assert add(coeff,affine(P),neg(coeff,affine(Q)))==affine(P-Q)
local=[]; residuals=[];r=len(points)
for bits in [numberdb.bits(200),numberdb.bits(300)]:
F=RealField(bits);cache={}
def H(P):
k=str(affine(P))
if k not in cache:cache[k]=local_height(P,bits)
return cache[k]
h=[H(P) for P in points]
B=[[F(0) for _ in points] for _ in points]
for i,P in enumerate(points):
assert close(H(2*P),4*h[i]) and close(H(-P),h[i])
for j in range(i,r):
Q=points[j]
v=h[i] if i==j else (H(P+Q)-h[i]-h[j])/2
assert close(v,(H(P+Q)-H(P-Q))/4)
assert close(v,primary[str((i+1,j+1))][-1])
assert close(H(P+Q)+H(P-Q),2*h[i]+2*h[j])
if i!=j:assert close(H(2*P+Q),4*h[i]+h[j]+4*v)
residuals.append(str(abs(F(v)-F(primary[str((i+1,j+1))][-1]))))
B[i][j]=B[j][i]=v
local.append({str((i+1,j+1)):str(B[i][j]) for i in range(r) for j in range(i,r)})
for k in local[0]:assert close(local[0][k],local[1][k])
# This is an independent coarse certificate of Z-independence.
for n in [6,7,8]:
h=[coarse_height(P,coeff,n) for P in points]
coarse=[[RealIntervalField(192)(0) for _ in points] for _ in points]
for i in range(r):
for j in range(i,r):
v=h[i] if i==j else (coarse_height(points[i]+points[j],coeff,n)-h[i]-h[j])/2
coarse[i][j]=coarse[j][i]=v
assert (RealField(1013)(primary[str((i+1,j+1))][-1]) in v)
minors=[determinant([row[:k] for row in coarse[:k]]) for k in range(1,r+1)]
if all(v.lower()>0 for v in minors):break
assert all(v.lower()>0 for v in minors),'independence not certified'
f,g,R,L,U=duplication_certificate(tuple(coeff))
return {'local_pairings':local,'max_absolute_discrepancy':str(max(RealField(1100)(x) for x in residuals)),
'arithmetic':{'point_equations':True,'fraction_group_law':True,'global_minimal':True,'conductor_checked':True,
'source_reported_rank':r,'independent_rank_lower_bound':r,'independent_rank_upper_bound':None,
'full_lattice_index':None,'saturation':'not independently established','bsd_used':False,
'duplication_doublings':n,'duplication_resultant':str(R),'L':str(L),'U':str(U),
'coarse_pairing_intervals':{str((i+1,j+1)):[str(coarse[i][j].lower()),str(coarse[i][j].upper())] for i in range(r) for j in range(i,r)},
'positive_principal_minor_intervals':[[str(v.lower()),str(v.upper())] for v in minors]}}
def controls():
bits=numberdb.bits(300);E=EllipticCurve(QQ,[0,0,1,-1,0]);P=E([0,0]);h=local_height(P,bits)
assert close(h,'0.0511114082399688',decimals=15)
assert not close(0,h) and not close(h/2,h)
T=EllipticCurve(QQ,[0,-1,1,-10,-20]);t=T([5,5]);assert 5*t==T(0)
assert close(local_height(t,bits),0) and close(local_height(T(0),bits),0)
E=EllipticCurve(QQ,[0,1,1,-2,0]);P,Q=E([-1,1]),E([0,-1]);b=(local_height(P+Q,bits)-local_height(P-Q,bits))/4
assert close(b,'0.268478098806726',decimals=15)
assert not close(-b,b)
return {'known_answer_control':True,'negative_control_rejected':True,'37a1_height':str(h),
'389a1_documented_pairing':str(b),'torsion_11a1_5_5_order_divides':5,
'rejected':['all-zero','half-normalization','off-diagonal-sign-reversal'],
'O_and_proved_torsion_height_zero':True}