Appendix M. Mass grand unification: geometric differentiation of lattice energy

Appendix M. Mass grand unification: Lock the mass=resistance axiom. If the canonical cell (cube) locks the independent channel count to κ_H=5 by removing one global reference degree of freedom from the 6 faces, and if the canonical cross-section of each channel is locked to π.

Lock the mass=resistance axiom. If the canonical cell (cube) locks the independent channel count to κ_H=5 by removing one global reference degree of freedom from the 6 faces, and if the canonical cross-section of each channel is locked to π.

M.0 Locked definitions (single source of truth)

\begin{equation} U_{\mathrm{lat}}:=\frac{h\,c_{\mathrm{ref}}}{a}. \end{equation}

Lock the mass=resistance axiom as

\begin{equation} \boxed{ m(X):=\frac{U_{\mathrm{lat}}}{\sigma_{\mathrm{eff}}(X)} } \end{equation}

as shown. Here, σ_eff(X) is the dimensionless resistance (effective cross-section coefficient) of object X.

M.1 Resistance coefficients of three objects (unique definitions)

(1) H-mode

If the canonical cell (cube) locks the independent channel count to κ_H=5 by removing one global reference degree of freedom from the 6 faces, and if the canonical cross-section of each channel is locked to π, then

\begin{equation} \boxed{ \sigma_{\mathrm{eff}}(H):=5\pi } \end{equation}

(2) Proton

Define the proton resistance integral as

S_p:=\int_0^{\lambda_C}\frac{dR}{a}=\frac{\lambda_C}{a}

as above, and

\begin{equation} \boxed{ \sigma_{\mathrm{eff}}(p):=S_p } \end{equation}

(3) Electron

Define the electron resistance integral over the mass-bearing Compton length (§13.5.4; not the event-rate radius rₑ=r₀δ, which governs only νₑ=1):

S:=\int_0^{\lambda_{C,e}}\frac{dR}{a}=\frac{\lambda_{C,e}}{a}=\frac{D_{\mathrm{anch}}}{2a}

as above, and

\begin{equation} \boxed{ \sigma_{\mathrm{eff}}(e):=S } \end{equation}

M.2 Mass grand-unification theorem (same format)

Theorem M.2.1

Under the same lock version, if (AppM_Ulat)–(AppM_sigmae) hold, then

\begin{equation} \boxed{ m_H=\frac{U_{\mathrm{lat}}}{5\pi},\quad m_p=\frac{U_{\mathrm{lat}}}{S_p},\quad m_e=\frac{U_{\mathrm{lat}}}{S} } \end{equation}

M.3 Invariants and dev definition (for cross-validation)

Define the invariants as follows.

\begin{align} I_H &:= \frac{m_H(5\pi)}{U_{\mathrm{lat}}}, \\ I_p &:= \frac{m_p S_p}{U_{\mathrm{lat}}}, \\ I_e &:= \frac{m_e S}{U_{\mathrm{lat}}}. \end{align}

By definition, ideally I_H=Iₚ=Iₑ=1 should hold (a channel that numerically reconfirms identical definitions).

Define the deviation of each invariant as

\begin{equation} \mathrm{dev}(I):=|I-1| \end{equation}

as above, and define the maximum deviation as

\begin{equation} \mathrm{dev}_{\max}:=\max\{\mathrm{dev}(I_H),\mathrm{dev}(I_p),\mathrm{dev}(I_e)\} \end{equation}

as above. The tolerance threshold dev_tol for dev_(max) is pre-locked in gate_lock.

M.4 Gate decision format

Lock the following decision formula as the standard form.

\begin{equation} \boxed{ \texttt{PASS} \Longleftrightarrow \mathrm{dev}_{\max}\le \mathrm{dev}_{\mathrm{tol}} \quad\text{AND}\quad \text{(sealing/lock\_id/schema match)} } \end{equation}

M.5 Deterministic verification script (mass-unification invariants)

# verify_appendix_M.py
# Purpose: compute U_lat, m_H, m_p, m_e and invariants I_H,I_p,I_e, dev_max, and generate Gate inputs.

import json
import hashlib
from math import pi

def sha256_file(path: str) -> str:
    h = hashlib.sha256()
    with open(path, "rb") as f:
        while True:
            b = f.read(1024 * 1024)
            if not b:
                break
            h.update(b)
    return h.hexdigest()

def read_json(path: str) -> dict:
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)

def main():
    canon = read_json("registry/canon_lock.json")
    realz = read_json("registry/realization_lock.json")
    prot  = read_json("registry/protocol_lock.json")
    gate  = read_json("registry/gate_lock.json")
    snap  = read_json("registry/registry_snapshot.json")

    h_Js = canon["constants"].get("h_Js", 6.62607015e-34)
    c_ref = realz["inputs"]["c_ref_m_s"]
    a_m   = realz["inputs"]["a_m"]
    r_p   = canon["inputs"]["r_p_m"]
    assert abs(r_p/8.412e-16 - 1) < 5e-4, "canon r_p not reconciled to v0.4.1 (0.8412 fm)"
    D_anch= canon["inputs"]["D_anch_m"]
    assert abs(D_anch/4.852620477e-12 - 1) < 1e-6, "canon D_anch not reconciled to v0.4.1 (2*lambda_Ce=4.8526 pm)"

    delta_item = canon["constants"].get("delta_rect", "1/pi^2")
    delta = float(delta_item) if isinstance(delta_item, (int, float)) else 1.0/(pi**2)

    GeV_to_J = prot["unit_conversions"]["GeV_to_J"]

    # U_lat
    U_lat_J = (h_Js * c_ref) / a_m
    U_lat_GeV = U_lat_J / GeV_to_J

    # m_H
    m_H = U_lat_GeV / (5.0 * pi)

    # proton: lambda_C, S_p, m_p
    lambda_C = (pi/2.0) * r_p
    S_p = lambda_C / a_m
    m_p = U_lat_GeV / S_p

    # electron: r_e, S, m_e
    r_e = (D_anch/2.0) * delta
    S = r_e / a_m
    m_e = U_lat_GeV / S

    # invariants
    I_H = (m_H * (5.0*pi)) / U_lat_GeV
    I_p = (m_p * S_p) / U_lat_GeV
    I_e = (m_e * S) / U_lat_GeV

    dev_H = abs(I_H - 1.0)
    dev_p = abs(I_p - 1.0)
    dev_e = abs(I_e - 1.0)
    dev_max = max(dev_H, dev_p, dev_e)

    dev_tol = gate["tolerances"]["dev_tol_max"]

    status = "PASS" if dev_max <= dev_tol else "FAIL"

    out = {
        "registry_snapshot_id": snap["registry_snapshot_id"],
        "locks": snap["locks"],
        "hashes": {
            "canon_lock_sha256": sha256_file("registry/canon_lock.json"),
            "realization_lock_sha256": sha256_file("registry/realization_lock.json"),
            "protocol_lock_sha256": sha256_file("registry/protocol_lock.json"),
            "gate_lock_sha256": sha256_file("registry/gate_lock.json"),
            "registry_snapshot_sha256": sha256_file("registry/registry_snapshot.json"),
        },
        "derived": {
            "U_lat_GeV": U_lat_GeV,
            "m_H_GeV": m_H,
            "m_p_GeV": m_p,
            "m_e_GeV": m_e,
            "lambda_C_m": lambda_C,
            "S_p_dimless": S_p,
            "r_e_m": r_e,
            "S_dimless": S,
            "I_H": I_H,
            "I_p": I_p,
            "I_e": I_e,
            "dev_max": dev_max,
            "dev_tol_max": dev_tol
        },
        "gate_eval": {
            "gate_id": "G-RATIO-MASS-UNIFICATION",
            "status": status
        }
    }

    print(json.dumps(out, indent=2, ensure_ascii=False))

if __name__ == "__main__":
    main()