Follow the source behind the result.

The registered Python source is shown as text. Displaying it does not execute the code.

"""v84 -- Blind-prediction registry: frozen, machine-enforced.

Backs the freeze conventions in
  tfpt_2_standard_model.tex   (keybox "The three theta_12 values, named")
  introduction.tex            (freeze file box)
  verification/freeze_file.csv

The registry `predictions_frozen.json` freezes every dimensionless prediction
of record (25 significant digits) BEFORE the next decisive data releases
(JUNO theta12/theta13, CMB-S4/LiteBIRD r and beta, DESI n_s).  This script
re-derives every frozen decimal from the two axioms {c3 = 1/(8 pi), g_car = 5}
on every suite run, so the registry cannot drift:

  * changing a formula in the theory without updating the registry  -> FAIL
  * changing a registry value without changing the formula          -> FAIL
  * swapping the theta_12 prediction of record for a variant        -> FAIL

Together with manifest.sha256 (content digest) and git history this makes the
freeze auditable: the prediction of record is one number, fixed in advance,
and the two theta_12 variants are explicitly typed as derived variants of the
same texture, never as alternative predictions (no look-elsewhere ambiguity).
"""
import json
import os
import hashlib

import mpmath as mp
from tfpt_constants import check, summary, reset, c3, phi0, PI

REGISTRY_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                             "predictions_frozen.json")

# relative tolerance for "digit-exact": values are stored at 25 significant
# digits, recomputation runs at mp.dps = 40
REL_TOL = mp.mpf('1e-22')


def alpha_root():
    """The unique root of F_U1 (same closure as v3_em_alpha.py, M = 41)."""
    pb = 1 / (6 * PI)
    dt = 48 * c3**4

    def F(a):
        Q = dt * mp.e**(-2 * a)
        ps = pb + Q * (1 - Q)**(mp.mpf(-5) / 4)
        return a**3 - 2 * c3**3 * a**2 - (mp.mpf(4) / 5) * c3**6 * 41 * mp.log(1 / ps)

    return mp.findroot(F, mp.mpf('0.0073'))


def theta12_nonlinear(eps):
    """Full (non-linearised) TBM + 1-2 charged-lepton rotation by eps."""
    Unu = mp.matrix([[mp.sqrt(mp.mpf(2) / 3), 1 / mp.sqrt(3), 0],
                     [-1 / mp.sqrt(6), 1 / mp.sqrt(3), -1 / mp.sqrt(2)],
                     [-1 / mp.sqrt(6), 1 / mp.sqrt(3), 1 / mp.sqrt(2)]])
    cs, sn = mp.cos(eps), mp.sin(eps)
    Ue = mp.matrix([[cs, sn, 0], [-sn, cs, 0], [0, 0, 1]])
    U = Ue.T * Unu
    return abs(U[0, 1])**2 / (1 - abs(U[0, 2])**2)


def computed_values():
    """Every registry id, re-derived from the two axioms alone."""
    a = alpha_root()
    ainv = 1 / a
    lamC = mp.sqrt(phi0 * (1 - phi0))
    return {
        # predictions
        "ALPHA_INV": ainv,
        "SIN2_THETA12_SEED": mp.mpf(1) / 3 - phi0 / 2,
        "SIN2_THETA13": phi0 * mp.e**(mp.mpf(-5) / 6),
        "BETA_BIREFRINGENCE_DEG": phi0 / (4 * PI) * 180 / PI,
        "OMEGA_B": (1 - 1 / (4 * PI)) * phi0,
        "LAMBDA_C": lamC,
        "S23_CKM": phi0 / (1 + lamC),
        "S13_CKM": lamC**3 / 3,
        "DELTA_CKM_RAD": PI / 3 + 3 * lamC**2,
        "MMU_OVER_MTAU": mp.mpf(8) / 7 * phi0,
        "ME_OVER_MMU": mp.mpf(12) / 7 * phi0**2,
        "MU_OVER_MD": mp.mpf(55) / 117,
        "MC_OVER_MS": mp.mpf(34) / 47 / phi0,
        "MT_OVER_MB": mp.mpf(3) / 26 / phi0**2,
        "MSCAL_OVER_MBAR": c3**(mp.mpf(7) / 2),
        "RHOL_OVER_MBAR4": 3 / (4 * PI**2) * mp.e**(-2 * ainv),
        # assigned texture values
        "DELTA_CP_NU_DEG": mp.mpf(240),
        "SIN2_THETA23": mp.mpf('0.5'),
        # derived theta_12 variants (same texture, NOT predictions)
        "SIN2_THETA12_SEAM": mp.mpf(1) / 3 - 1 / (12 * PI),
        "SIN2_THETA12_NONLIN": theta12_nonlinear(mp.mpf(3) / 4 * phi0),
        # conditional bands (N_star external in [50, 60])
        "R_TENSOR": (mp.mpf(12) / 60**2, mp.mpf(12) / 50**2),
        "N_S": (1 - mp.mpf(2) / 50, 1 - mp.mpf(2) / 60),
    }


def run():
    reset()
    # earlier suite modules may have lowered the global precision; the
    # digit-exact registry lock needs the full 40 digits back
    mp.mp.dps = 40
    print("v84 blind-prediction registry (frozen, machine-enforced)")

    with open(REGISTRY_PATH, "rb") as fh:
        raw = fh.read()
    reg = json.loads(raw)
    digest = hashlib.sha256(raw).hexdigest()
    print(f"  registry sha256: {digest}")

    vals = computed_values()

    # (1) the registry is frozen at a fixed date
    check("registry carries a fixed freeze_date (2026-06-09)",
          reg.get("freeze_date"), "2026-06-09", exact=True)

    # (2) every frozen prediction recomputes digit-exactly from the axioms
    for entry in reg["predictions"] + reg["assigned_texture_values"]:
        pid = entry["id"]
        check(f"{pid} frozen value recomputes from the axioms",
              vals[pid], mp.mpf(entry.get("frozen_value")), tol=REL_TOL)

    # (3) the conditional bands recompute at the declared N_star endpoints
    for entry in reg["conditional_bands"]:
        pid = entry["id"]
        lo, hi = vals[pid]
        check(f"{pid} band_min recomputes (N_star endpoint)",
              lo, mp.mpf(entry["band_min"]), tol=mp.mpf('1e-18'))
        check(f"{pid} band_max recomputes (N_star endpoint)",
              hi, mp.mpf(entry["band_max"]), tol=mp.mpf('1e-18'))

    # (4) theta_12 freeze discipline: exactly ONE prediction of record,
    #     and it is the seed variant 1/3 - phi0/2
    records = [e for e in reg["predictions"]
               if e.get("role") == "prediction_of_record"]
    check("exactly one theta_12 prediction of record in the registry",
          len(records), 1, exact=True)
    check("the prediction of record is the SEED variant 1/3 - phi0/2",
          records[0]["id"], "SIN2_THETA12_SEED", exact=True)

    # (5) the two variants are present but typed as derived variants
    #     (same texture), never as alternative predictions
    variant_ids = {e["id"] for e in reg["derived_variants_not_predictions"]}
    check("theta_12 seam + nonlin variants typed as derived (not predictions)",
          variant_ids == {"SIN2_THETA12_SEAM", "SIN2_THETA12_NONLIN"})
    pred_ids = {e["id"] for e in reg["predictions"]}
    check("no theta_12 variant leaked into the prediction list",
          len(variant_ids & pred_ids), 0, exact=True)
    for entry in reg["derived_variants_not_predictions"]:
        check(f"{entry['id']} variant value recomputes from the same texture",
              vals[entry["id"]], mp.mpf(entry["value"]), tol=REL_TOL)

    # (6) the three theta_12 numbers are distinct objects (must not be
    #     interchanged) and all sit within 0.1% of one another -- the very
    #     reason the freeze is needed before JUNO resolves the band
    seed = vals["SIN2_THETA12_SEED"]
    seam = vals["SIN2_THETA12_SEAM"]
    nonl = vals["SIN2_THETA12_NONLIN"]
    check("three distinct theta_12 values (seed < seam < nonlin)",
          seed < seam < nonl)
    check("variants within 0.1% of the frozen record (band JUNO will resolve)",
          max(abs(seam - seed), abs(nonl - seed)) / seed < mp.mpf('1e-3'))

    return summary("v84 frozen registry")


if __name__ == "__main__":
    raise SystemExit(1 if run() else 0)

89e4ca16f81718791923b1077f7428aef7b1a2256fcf12094c579442b41ec0e8

The public registry includes 116 document views, 6,693 section records and 985 physical LaTeX sources. Active publication documents, research material and archives retain their recorded roles. This is source navigation, not a new semantic review or proof run.