check_T214.py

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()