back to table · edit · history · where entries came from · files · download
17684 bytes, as of the version from 2026-11-20 12:03 (current). Recorded here, not run.
"""Offline, public-safe independent checks of T214.
Dependencies: Python 3 and SymPy. Exporting the actual generator additionally
requires SageMath and numberdb. No command in this file performs network I/O.
sage -python check_T214.py --export-generator --document T214.json \
--output generator-rows.json
python3 check_T214.py --document T214.json --baseline before.json \
--generated generator-rows.json --output check-results.json
The baseline is optional for future users; it checks this repair's precise
edit scope. lmfdb-reference.json and generate.py default to adjacent files.
All exported evidence contains only public mathematical data, software
versions and content hashes, never credentials, environment dumps or paths.
"""
import argparse
from collections import Counter
from copy import deepcopy
from fractions import Fraction
import hashlib
import importlib.util
import json
from math import lcm
from pathlib import Path
import platform
import re
G1_COUNTS = {2: 5, 3: 7, 5: 9, 7: 11, 11: 13, 13: 15}
G2_COUNTS = {2: 35, 3: 63, 5: 129, 7: 207, 11: 401}
EXCEPTIONS = {
2: "2.2.a_ae", 3: "2.3.a_ag", 5: "2.5.a_ak",
7: "2.7.a_ao", 11: "2.11.a_aw",
}
def digest(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def save(path, value):
Path(path).write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n")
def load_module(path, name):
specification = importlib.util.spec_from_file_location(name, path)
module = importlib.util.module_from_spec(specification)
specification.loader.exec_module(module)
return module
def rows(document):
assert list(document["Parameters"]) == ["g", "q", "label"]
return [
{"params": {"g": int(dimension), "q": int(prime), "label": label},
"number": entry["number"], "comment": entry["comment"]}
for dimension, fields in document["Numbers"].items()
for prime, classes in fields.items()
for label, entry in classes.items()
]
def identity(row):
return tuple(row["params"][name] for name in ("g", "q", "label"))
def export_generator(arguments):
import numberdb
from sage.version import version as sage_version
module = load_module(arguments.generator, "t214_checked_generator")
generator = module.WeilPolynomialsOfAbelianVarieties()
document = json.loads(arguments.document.read_text())
class SnapshotClient:
def request(self, path, params):
assert path == "api/table" and str(params["id"]) == "T214"
return deepcopy(document)
report = generator.verify(sample=None, client=SnapshotClient())
assert report.ok and report.checked == report.matched == 895
exported = []
for parameters in generator.enumerate():
entry = generator.value(parameters, generator.digits)
exported.append({
"params": {"g": int(parameters["g"]), "q": int(parameters["q"]),
"label": str(parameters["label"])},
"number": str(entry["number"]), "comment": entry["comment"],
})
assert exported == rows(document), "Generator must reproduce full ordered rows"
checks = []
for prime, label in EXCEPTIONS.items():
variable = module.t
exceptional = (variable**2 - prime)**2
assert module._is_simple_class(2, prime, exceptional)
controls = [
(variable**2 + prime)**2,
(variable**2 + variable + prime)
* (variable**2 - variable + prime),
]
assert all(not module._is_simple_class(2, prime, value)
for value in controls)
checks.append({"q": prime, "exception": label, "elliptic_controls": 2})
legacy_results = None
if arguments.legacy_generator:
legacy = load_module(arguments.legacy_generator, "t214_legacy_generator")
legacy_results = {
label: bool(legacy._is_simple_class(2, (legacy.t**2 - prime)**2))
for prime, label in EXCEPTIONS.items()
}
assert not any(legacy_results.values())
save(arguments.output, {
"schema": "T214-generator-export-v1", "public_safe": True,
"python": platform.python_version(), "sage": sage_version,
"numberdb": numberdb.__version__, "generator_sha256": digest(arguments.generator),
"check_script_sha256": digest(__file__),
"document_sha256": digest(arguments.document),
"offline_verify": {"sample": None, "checked": report.checked,
"matched": report.matched, "ok": report.ok},
"full_comments_and_order_matched": len(exported),
"classification_controls": checks,
"legacy_exceptional_is_simple": legacy_results,
"rows": exported,
})
print("Actual Sage generator: 895 exact strings, comments and ordered identities matched")
def parse_polynomial(text, variable, sympy):
assert re.fullmatch(r"[0-9t*^+\- ]+", text), "Unexpected polynomial syntax"
return sympy.Poly(sympy.sympify(text.replace("^", "**")), variable,
domain=sympy.ZZ)
def decode_coefficient(code):
assert code and all("a" <= letter <= "z" for letter in code)
negative = len(code) > 1 and code.startswith("a")
digits = code[1:] if negative else code
assert len(digits) == 1 or digits[0] != "a"
value = 0
for letter in digits:
value = 26 * value + ord(letter) - ord("a")
assert not negative or value > 0
return -value if negative else value
def real_quadratic_admissible(prime, first, middle):
"""Test roots of u^2+first*u+middle-2*prime in [-2sqrt(p),2sqrt(p)]."""
discriminant = first * first - 4 * (middle - 2 * prime)
if discriminant < 0:
return False
margin = 16 * prime - first * first - discriminant
return margin >= 0 and margin * margin >= 4 * first * first * discriminant
def independent_enumeration(dimension, prime):
if dimension == 1:
return {(coefficient,) for coefficient in range(-2 * prime, 2 * prime + 1)
if coefficient * coefficient <= 4 * prime}
return {
(first, middle)
for first in range(-4 * prime, 4 * prime + 1)
for middle in range(-6 * prime, 6 * prime + 1)
if real_quadratic_admissible(prime, first, middle)
}
def classification(polynomial, dimension, prime):
factors = polynomial.factor_list()[1]
if dimension == 1:
simple = True
elif polynomial.is_irreducible:
simple = True
else:
exceptional = (
len(factors) == 1 and factors[0][1] == 2
and tuple(map(int, factors[0][0].all_coeffs())) == (1, 0, -prime)
)
if not exceptional:
assert sum(multiplicity for _, multiplicity in factors) == 2
for factor, multiplicity in factors:
assert factor.degree() == 2 and factor.LC() == 1
assert factor.nth(0) == prime
assert factor.nth(1)**2 <= 4 * prime
simple = exceptional
reduced_exponents = [
degree for degree in range(2 * dimension + 1)
if int(polynomial.nth(degree)) % prime
]
rank = 2 * dimension - min(reduced_exponents)
assert 0 <= rank <= dimension
return simple, rank, rank == dimension
def expected_comment(parameters, simple, rank, ordinary):
label = parameters["label"]
url = "https://www.lmfdb.org/Variety/Abelian/Fq/" + label.replace(".", "/")
return (
f"HREF{{{url}}}[LMFDB {label}]. The class is "
f"{'simple' if simple else 'not simple'}, has p-rank {rank}, and is "
f"{'ordinary' if ordinary else 'not ordinary'}."
)
def changes(before, after, path=()):
if isinstance(before, dict) and isinstance(after, dict):
assert list(before) == list(after), f"Mapping keys/order changed at {path}"
return [difference for key in before
for difference in changes(before[key], after[key], path + (key,))]
return [] if before == after else ["/".join(path)]
def check(arguments):
import sympy
variable = sympy.Symbol("t")
document = json.loads(arguments.document.read_text())
reference = json.loads(arguments.reference.read_text())
generated = json.loads(arguments.generated.read_text())
stored = rows(document)
assert generated["generator_sha256"] == digest(arguments.generator)
assert generated["document_sha256"] == digest(arguments.document)
assert generated["check_script_sha256"] == digest(__file__)
assert generated["rows"] == stored
assert len(stored) == len({identity(row) for row in stored}) == 895
assert document["Data properties"]["rigour"] == "exact"
assert document["Data properties"]["type"] == "Z[]"
assert decode_coefficient("a") == 0
assert decode_coefficient("aw") == -22
assert decode_coefficient("cg") == 58
assert real_quadratic_admissible(11, 0, -22)
assert not real_quadratic_admissible(11, 0, -23)
assert not real_quadratic_admissible(11, 0, 23)
assert not real_quadratic_admissible(11, 14, 66)
by_pair = {}
by_label = {}
counts = Counter()
classification_counts = Counter()
for row in stored:
parameters = row["params"]
dimension, prime, label = identity(row)
assert sympy.isprime(prime) and dimension in (1, 2)
polynomial = parse_polynomial(row["number"], variable, sympy)
coefficients = tuple(map(int, polynomial.all_coeffs()))
assert polynomial.degree() == 2 * dimension and polynomial.LC() == 1
assert polynomial.nth(0) == prime**dimension
for degree in range(dimension + 1):
assert polynomial.nth(degree) == (
prime**(dimension - degree) * polynomial.nth(2 * dimension - degree)
)
initial = coefficients[1:dimension + 1]
label_dimension, label_prime, encoded = label.split(".")
assert (int(label_dimension), int(label_prime)) == (dimension, prime)
assert tuple(map(decode_coefficient, encoded.split("_"))) == initial
simple, rank, ordinary = classification(polynomial, dimension, prime)
assert row["comment"] == expected_comment(parameters, simple, rank, ordinary), label
by_pair.setdefault((dimension, prime), set()).add(initial)
by_label[label] = (coefficients, simple, rank, ordinary)
counts[(dimension, prime)] += 1
classification_counts[(dimension, prime, simple)] += 1
expected_pairs = {(1, prime) for prime in G1_COUNTS}
expected_pairs |= {(2, prime) for prime in G2_COUNTS}
assert set(counts) == expected_pairs
enumerations = []
for dimension, prime in sorted(expected_pairs):
expected = (G1_COUNTS if dimension == 1 else G2_COUNTS)[prime]
independent = independent_enumeration(dimension, prime)
assert by_pair[(dimension, prime)] == independent
assert counts[(dimension, prime)] == len(independent) == expected
enumerations.append({
"g": dimension, "q": prime, "count": expected,
"simple": classification_counts[(dimension, prime, True)],
"nonsimple": classification_counts[(dimension, prime, False)],
})
primary = reference["q11_records"]
assert len(primary) == len({row["label"] for row in primary}) == 401
assert {row["label"] for row in primary} == {
row["params"]["label"] for row in stored
if row["params"]["g"] == 2 and row["params"]["q"] == 11
}
for record in primary:
assert record["g"] == 2 and record["q"] == 11
coefficients, simple, rank, ordinary = by_label[record["label"]]
assert coefficients == tuple(record["poly"])
assert simple == record["is_simple"] and rank == record["p_rank"]
assert ordinary == (record["p_rank"] == record["g"])
assert simple == (len(record["simple_distinct"]) == 1
and record["simple_multiplicities"] == [1])
exceptions = reference["exceptional_records"]
assert {record["label"] for record in exceptions} == set(EXCEPTIONS.values())
exceptional_evidence = []
for record in exceptions:
prime = record["q"]
label = record["label"]
assert record["poly"] == [1, 0, -2 * prime, 0, prime**2]
assert record["is_simple"] and not record["is_geometrically_simple"]
assert record["is_supersingular"] and record["p_rank"] == 0
assert record["max_divalg_dim"] == 4
assert record["geometric_extension_degree"] == 2
assert by_label[label] == (tuple(record["poly"]), True, 0, False)
invariants = [Fraction(1, 2), Fraction(1, 2), Fraction(1, 2) * 2 % 1]
exponent = lcm(*(invariant.denominator for invariant in invariants))
assert exponent == 2 and 2 * exponent // 2 == 2
assert sympy.Poly(variable**2 - prime, variable).is_irreducible
for product in ((variable**2 + prime)**2,
(variable**2 + variable + prime)
* (variable**2 - variable + prime)):
assert not classification(sympy.Poly(product, variable), 2, prime)[0]
exceptional_evidence.append({
"label": label, "simple": True, "geometrically_simple": False,
"p_rank": 0, "honda_tate_exponent": exponent,
"real_place_invariants": ["1/2", "1/2"], "prime_place_invariant": "0",
"endomorphism_algebra_dimension_over_center": 4,
})
controls = sympy.Poly(variable**4 - variable**3 - 2 * variable + 4, variable)
assert classification(controls, 2, 2) == (True, 1, False)
baseline_check = None
if arguments.baseline:
before = json.loads(arguments.baseline.read_text())
prior = rows(before)
assert [identity(row) for row in prior] == [identity(row) for row in stored]
assert [row["number"].encode() for row in prior] == [
row["number"].encode() for row in stored
]
changed_paths = changes(before, document)
assert set(changed_paths) == {
"Comments/comment-entry-data", "Data properties/complete-note",
"Data properties/rigour details", "Numbers/2/11/2.11.a_aw/comment",
}
changed_comments = [old["params"]["label"] for old, new in zip(prior, stored)
if old["comment"] != new["comment"]]
assert changed_comments == ["2.11.a_aw"]
baseline_check = {
"sha256": digest(arguments.baseline), "changed_paths": changed_paths,
"polynomial_strings_preserved_byte_for_byte": len(stored),
"ordered_parameter_identities_preserved": len(stored),
"unchanged_comments": 894, "corrected_comments": changed_comments,
}
result = {
"schema": "T214-independent-check-v1", "public_safe": True, "status": "pass",
"python": platform.python_version(), "sympy": sympy.__version__,
"inputs_sha256": {
"document": digest(arguments.document), "generator": digest(arguments.generator),
"generator_rows": digest(arguments.generated),
"lmfdb_reference": digest(arguments.reference), "check_script": digest(__file__),
},
"all_rows_checked": len(stored), "full_comments_checked": len(stored),
"enumeration_method": "Exact real-quadratic root bound in an independent coefficient box",
"classification_method": "SymPy factorization over QQ plus Honda-Tate real Weil exception",
"p_rank_method": "Degree minus t-adic valuation after reduction modulo the prime",
"enumeration_and_classification_counts": enumerations,
"lmfdb_q11": {"rows": 401, "labels_and_all_coefficients_matched": 401,
"simplicity_p_rank_ordinarity_matched": 401},
"exceptional_classes": exceptional_evidence,
"controls": {"exceptional_simple_squares": 5, "elliptic_squares": 5,
"distinct_elliptic_products": 5, "irreducible_p_rank_one": 1,
"inadmissible_real_quadratics": 3, "label_decode": 3},
"offline_generator_verify": generated["offline_verify"],
"baseline_preservation": baseline_check,
"limitations": [
"Checks concern dimensions 1 and 2 over the listed prime fields only.",
"No live NumberDB requests, writes, reviews or publication were performed.",
"Numerical exactness does not prove software or external data infallible.",
"External row-by-row comparison covers all q=11 surfaces and five exceptions; other rows use independent algebraic checks.",
],
}
save(arguments.output, result)
print("PASS: all 895 rows; all 401 q=11 primary records; five Honda-Tate exceptions")
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--document", type=Path, required=True)
parser.add_argument("--baseline", type=Path)
parser.add_argument("--generator", type=Path,
default=Path(__file__).with_name("generate.py"))
parser.add_argument("--legacy-generator", type=Path)
parser.add_argument("--reference", type=Path,
default=Path(__file__).with_name("lmfdb-reference.json"))
parser.add_argument("--generated", type=Path,
default=Path(__file__).with_name("generator-rows.json"))
parser.add_argument("--output", type=Path, required=True)
parser.add_argument("--export-generator", action="store_true")
arguments = parser.parse_args()
if arguments.export_generator:
export_generator(arguments)
else:
check(arguments)
if __name__ == "__main__":
main()