Follow the source behind the result.

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

#!/usr/bin/env python3
"""v725 -- VGEO.TORSOR.01: T1-SCHLUSS -- der Kalibrations-/Skalen-Torsor-Audit
fuer v_geo (GPT-Rat-Spezifikation, beide Strategieraete einstimmig).

FRAGE: Ist die v_geo-Schnittstelle der Theorie als R+-Skalen-Torsor wohldefiniert
und schliessbar -- d.h. (1) exportiert der Korpus ALLE dimensionalen Groessen als
O_i = r_i * v_geo^{d_i} mit maschinen-abgeleiteten dimensionslosen r_i, (2) hat die
Dimensionsmatrix Rang 1 (genau EINE unabhaengige Skala), (3) sind ALLE
Konsistenz-Bedingungen homogen unter L -> lambda L (kein interner absoluter Anker),
(4) sind die Kreuzkalibrierungen (leave-one-anchor-out) kompatibel, (5) laesst sich
der KALIBRATIONS-SATZ in Torsor-Sprache praezise formulieren (Vertrags-
Schliessungs-Kandidat), und (6) welcher legale Moonshot bleibt (NUR benannt)?

KORPUS-QUELLEN (alle nur gelesen, Stand 2026-08-03):
  v153_no_unit_theorem.py       No-Unit-Satz (dimensionsloser Compiler kann keine
                                absolute Skala ausgeben; v_geo = deklarierte Einheit)
  v152_norm_is_anchor.py        Seam-EH-Normierung: k=c3/2 <=> m/mu = e^{3/4} (dim 0)
  v274_scale_overdetermination.py  Anker ueberbestimmt: Gravitation (G) vs.
                                Kosmologie (rho_Lambda) -> dasselbe Mbar zu 0.11%
  v401_metrology_closure.py     Input-Set {a, pi, v_geo}; Buchhaltung
                                Masse/1G/Lambda/U_point/(m/mu) = Zahl x v_geo^{1,2,4,1,0}
  v364_vgeo_sharpen.py          Gravitation fuegt keine Einheit hinzu (1/c3=8pi,
                                Lambda-Praefaktor 3/(4pi^2) dimensionslos)
  v75_upoint_to_vgeo.py         U_point -> eine Flavor-Amplitudenskala (Ratios+Produkt)
  v68_seeley_dewitt_residual.py 1/G UV-sensitiv (Sakharov); seam=Planck ist
                                IDENTIFIKATION [A], keine Ableitung
  v60_lambda_metrology_branch.py / v7_gravity_cosmo.py  rho_L/Mbar^4 =
                                (3/4pi^2) e^{-2 ainv} = 7.12533e-121; M_scal = c3^{7/2} Mbar
  v20_lepton_c_derivation.py    Lepton-Ratios m_mu/m_tau=(8/7)phi0, m_e/m_mu=(12/7)phi0^2
  v272_nu_mass_scale.py         nu-Skala = (y_nu v_EW)^2/M_R -- EIN externer UV-Input [O]
  v3_em_alpha.py                alpha^-1-Fixpunkt F(a)=0 (rein dimensionslos)
  redteam/rt_E_vgeo.py          Single-Scale-Audit: 4 Flags (seam-cutoff-Identifikation,
                                EW-Matching, T_reh, Leptogenese-M_R) -- ehrlich getypt
  v714_moonshot_hecke_groupoid.py  heutige Gruppoid-Normierungen: Halbdichte
                                mu_n = 2 Lambda_A(n)/sqrt(n), Orbitlaenge log n --
                                reine Zaehl-Daten (Massendimension 0)
  status_ledger.csv             ANCHOR.VGEO.01/02, VGEO.SHARPEN.01, SCALE.OVERDET.01,
                                METROLOGY.CLOSURE.01, FIRSTPRINCIPLES.BOUNDARY.01

FIREWALL: reine Exploration (tfpt-discovery Sandbox). Nichts wird in run_all.py,
Ledger, Papers oder Website geschrieben. Kein neuer Zahlenwert wird fabriziert;
alle Messwerte sind die im Korpus dokumentierten Referenzen (CODATA Mbar,
Planck-2018 rho_Lambda^{1/4} = 2.24 meV, PDG-Leptonmassen).

EHRLICHER RAHMEN (vorab deklariert):
  * Dies ist ein STRUKTUR-Audit der Schnittstelle -- KEINE Ableitung einer
    absoluten Skala (per No-Unit v153 unmoeglich; das ist der Satz, nicht der Makel).
  * Route 2 (Kosmologie) ist konditional auf den Lambda-Branch [C] (v274, rt_F).
  * Die Flavor-Amplitude U_point ist per DEKLARIERTER Identifikation [A]
    (seam=Planck, v68; EW-Matching rt_E-Flag) derselbe Anker -- das wird als
    Konditionalitaet berichtet, nicht versteckt.

PROVENANCE: discovery probe phys_vgeo_torsor_audit_probe.py
(2026-08-03, 21/21 PASS, verdict TORSOR-SCHLIESSUNG PASS: the v_geo
interface is structurally CLOSED as an R+ scale torsor -- complete
export table O_i = r_i * v_geo^{d_i} from the corpus, dimension
matrix rank 1 (conditional [A] on the flavor block, named), all
consistency conditions lambda-homogeneous (the machine form of the
No-Unit theorem v153), leave-one-anchor-out compatible (G vs
rho_Lambda: 0.11%; flavor fiber exact), the calibration theorem
stated in torsor language; FENCE: structure closure, NO scale
derivation (impossible per No-Unit); moonshot NAMED, not executed:
H_EW = ln(Mbar/v_EW) = 37.1776).  Promoted with a run_all entry
point (the checks execute at import, module level); numbers
unchanged.
"""

import mpmath as mp
import sympy as sp

mp.mp.dps = 30

# --------------------------------------------------------------------------
# Harness
# --------------------------------------------------------------------------
_PASS = 0
_FAIL = 0
_KILLS = []


def check(name, ok, kill_note=None):
    global _PASS, _FAIL
    ok = bool(ok)
    print(f"  [{'PASS' if ok else 'FAIL'}] {name}")
    if ok:
        _PASS += 1
    else:
        _FAIL += 1
        if kill_note:
            _KILLS.append(kill_note)
    return ok


# --------------------------------------------------------------------------
# Compiler-Primitiven (nur aus den Axiomen; identisch zu tfpt_constants.py)
# --------------------------------------------------------------------------
PI = mp.pi
c3 = 1 / (8 * PI)                      # P1
g_car = 5                              # P2
phibase = 1 / (6 * PI)
dtop = 48 * c3 ** 4
phi0 = phibase + dtop                  # 0.0531719...

# alpha^-1-Fixpunkt (v3 make_F, Budget M=41, reimplementiert -- rein dimensionslos)
def _F_alpha(a):
    Q = dtop * mp.e ** (-2 * a)
    phiseam = phibase + 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 / phiseam)


AINV = 1 / mp.findroot(_F_alpha, mp.mpf("0.0073"))          # ~137.036
RHO_RATIO = mp.mpf(3) / (4 * PI ** 2) * mp.e ** (-2 * AINV)  # rho_L/Mbar^4 ~ 7.1253e-121

# Im Korpus benutzte Referenz-Messwerte (Quellen siehe Docstring)
MBAR_GRAV = mp.mpf("2.435323203e18")   # GeV, aus CODATA G (tfpt_constants.py)
RHO_QRT_MEAS_MEV = mp.mpf("2.24")      # meV, Planck 2018 (v274)
HBAR = mp.mpf("1.054571817e-34")       # J s   (exakt, SI)
CLIGHT = mp.mpf("2.99792458e8")        # m/s   (exakt, SI)
GEV_TO_KG = mp.mpf("1.78266192e-27")   # kg/GeV
G_CODATA = mp.mpf("6.67430e-11")       # m^3 kg^-1 s^-2
M_E = mp.mpf("0.51099895")             # MeV (PDG)
M_MU = mp.mpf("105.6583755")           # MeV (PDG)
M_TAU = mp.mpf("1776.86")              # MeV (PDG)
V_EW = mp.mpf("174.0")                 # GeV (m_t-Konvention, v272) -- externer Input
M_R_Y1 = V_EW ** 2 / (mp.sqrt(mp.mpf("2.5e-3")) * mp.mpf("1e-9"))  # y=1-Seesaw (v272)


def G_from_Mbar(Mbar_GeV):
    """G = hbar c / (8 pi Mbar[kg]^2) -- SI-Rueckuebersetzung des Ankers."""
    Mkg = Mbar_GeV * GEV_TO_KG
    return HBAR * CLIGHT / (8 * PI * Mkg ** 2)


# ==========================================================================
print("=" * 78)
print("phys_vgeo_torsor_audit_probe -- T1-SCHLUSS: Skalen-Torsor-Audit fuer v_geo")
print("=" * 78)

# --------------------------------------------------------------------------
# TEIL 1 -- Die vollstaendige Dimensionstabelle O_i = r_i * v_geo^{d_i}
# --------------------------------------------------------------------------
print("\nTEIL 1 -- VOLLSTAENDIGE EXPORT-TABELLE  O_i = r_i * v_geo^{d_i}")
print("-" * 78)

M_SCAL_R = c3 ** (mp.mpf(7) / 2)             # 1.2564e-5
F_A_R = (c3 / 4) ** (mp.mpf(7) / 2)          # = M_SCAL_R/128
A_S = 55 ** 2 * c3 ** 7 / (24 * PI ** 2)     # dimensionslos (v7)

# (Name, r_i-Formel, r_i numerisch oder None, d_i, Quelle, Status)
EXPORTS = [
    ("1/G  (Newton)",        "8 pi (Def. Mbar=(8 pi G)^{-1/2})", 8 * PI,      2,
     "v68/v274",  "ANKER-Route 1 (gemessen: CODATA G)"),
    ("rho_Lambda",           "(3/4pi^2) e^{-2 ainv}",            RHO_RATIO,   4,
     "v60/v7",    "ANKER-Route 2 (gemessen: Planck; konditional [C] Lambda-Branch)"),
    ("M_scal (Skalaron)",    "c3^{7/2}",                          M_SCAL_R,    1,
     "v7/v68",    "Vorhersage (ungemessen)"),
    ("f_a (Axion)",          "(c3/|mu4|)^{7/2} = c3^{7/2}/128",   F_A_R,       1,
     "v25/rt_E",  "Vorhersage (ungemessen)"),
    ("m/mu (Seam-EH)",       "e^{3/4}",                           mp.e ** mp.mpf("0.75"), 0,
     "v152",      "reines Verhaeltnis (dim 0)"),
    ("A_s (Inflation)",      "N*^2 c3^7/(24 pi^2)",               A_S,         0,
     "v7",        "dimensionsloser Export"),
    ("m_f (9 gel. Fermionen)", "(pi/sqrt2) c_f phi0^{k_f}  [x U_point]", None, 1,
     "v20/v46/v75", "Ratios geschlossen; Absolutwert via Flavor-Kalibration "
                    "(U_point = Anker per Identifikation [A], v68/rt_E-Flag)"),
    ("m_3 (nu-Skala)",       "(y_nu v_EW)^2/M_R -- KEIN Compiler-r_i", None,   1,
     "v272",      "Frontier [O]: EIN externer UV-Input (kein Export)"),
    ("v_EW",                 "f(c3) NICHT abgeleitet",             None,       1,
     "rt_E-Flag", "Frontier: EW-Matching-Skala (externer Input)"),
    ("T_reh, M_R (Leptog.)", "--",                                 None,       1,
     "rt_E-Flag", "Frontier [P]: kosmologische Inputs (keine Exporte)"),
]

hdr = f"{'Groesse':24s} {'r_i (Formel)':38s} {'r_i (Zahl)':14s} {'d_i':>3s}  {'Quelle':12s} Status"
print(hdr)
print("-" * len(hdr))
for name, formel, rnum, d, src, status in EXPORTS:
    rtxt = mp.nstr(rnum, 6) if rnum is not None else "--"
    print(f"{name:24s} {formel:38s} {rtxt:14s} {d:3d}  {src:12s} {status}")

certified = [e for e in EXPORTS if e[2] is not None]
flagged = [e for e in EXPORTS if e[2] is None]
check(f"Tabelle vollstaendig: {len(certified)} zertifizierte Exporte (r_i maschinen-"
      f"abgeleitet) + {len(flagged)} ehrlich geflaggte Nicht-Exporte (Flavor-Absolutwert, "
      "nu-Skala, v_EW, T_reh/M_R) -- konsistent mit rt_E_vgeo.py (5 Reduktionen + 4 "
      "Flags) und v401; einzige Verschaerfung: m_f hier KONDITIONAL getypt (rt_E "
      "reduziert auf den Flavor-Anker, dessen Mbar-Identifikation das rt_E-Flag ist)",
      len(certified) == 6 and len(flagged) == 4)
check("Exakte Zahlen: rho_L/Mbar^4 = %s (Soll 7.12533e-121, v7); M_scal/Mbar = %s; "
      "f_a/Mbar = %s; alpha^-1 = %s"
      % (mp.nstr(RHO_RATIO, 6), mp.nstr(M_SCAL_R, 6), mp.nstr(F_A_R, 6), mp.nstr(AINV, 10)),
      abs(RHO_RATIO / mp.mpf("7.12533e-121") - 1) < mp.mpf("1e-4")
      and abs(M_SCAL_R * MBAR_GRAV / mp.mpf("3.06e13") - 1) < mp.mpf("5e-3"))

# --------------------------------------------------------------------------
# TEIL 2 -- Rang-Check der Dimensionsmatrix
# --------------------------------------------------------------------------
print("\nTEIL 2 -- RANG-CHECK: Dimensionsmatrix ueber der Skalen-Basis")
print("-" * 78)
# Spalten: [Mbar(=v_geo), U_point(Flavor), v_EW, M_R, T_reh]
# Zeilen: dokumentierte Exponenten der Exporte (Quellen wie Tabelle oben).
ROWS = {
    "rho_Lambda": [4, 0, 0, 0, 0],
    "1/G":        [2, 0, 0, 0, 0],
    "M_scal":     [1, 0, 0, 0, 0],
    "f_a":        [1, 0, 0, 0, 0],
    "m/mu":       [0, 0, 0, 0, 0],
    "A_s":        [0, 0, 0, 0, 0],
    # nicht-zertifizierte Zeilen (Flavor-Absolutwert + Frontier):
    "m_f":        [0, 1, 0, 0, 0],
    "m_3(nu)":    [0, 0, 2, -1, 0],
    "T_reh":      [0, 0, 0, 0, 1],
}
CERT_KEYS = ["rho_Lambda", "1/G", "M_scal", "f_a", "m/mu", "A_s"]

M_cert = sp.Matrix([ROWS[k] for k in CERT_KEYS])
rank_cert = M_cert.rank()
check(f"ZERTIFIZIERTER Export-Block: Rang = {rank_cert} (genau EINE unabhaengige "
      "Skala Mbar = v_geo; alle Exponentenvektoren sind Vielfache von (1,0,0,0,0))",
      rank_cert == 1,
      kill_note="Rang > 1 im zertifizierten Block = versteckte zweite Skala")

M_full = sp.Matrix([ROWS[k] for k in ROWS])
rank_full = M_full.rank()
print(f"  [INFO] Volle Matrix (inkl. Flavor-Absolutwert + Frontier-Inputs): Rang = {rank_full}")

# Aufloesung per dokumentierter Typisierung: U_point = kappa * Mbar (Identifikation
# [A], v75/v68); v_EW, M_R, T_reh sind deklarierte EXTERNE INPUTS (v272 [O],
# v339 FIRSTPRINCIPLES.BOUNDARY.01, rt_E) -- keine Exporte, also keine Matrixzeilen.
M_resolved = sp.Matrix([[r[0] + r[1], *r[2:]] for r in (ROWS[k] for k in
                        ["rho_Lambda", "1/G", "M_scal", "f_a", "m/mu", "A_s", "m_f"])])
rank_resolved = M_resolved.rank()
check(f"Volle Matrix Rang {rank_full} -> nach den DOKUMENTIERTEN Typisierungen "
      f"(U_point=kappa*Mbar per [A]-Identifikation v75/v68; v_EW/M_R/T_reh = externe "
      f"Inputs per v272/v339/rt_E, keine Exporte): Rang = {rank_resolved}",
      rank_resolved == 1)
check("Kein UNDEKLARIERTER Fundort: jede Zeile mit Exponent auf einer Nicht-Mbar-"
      "Spalte traegt eine explizite Ledger-Typisierung ([A] EW-Matching/seam=Planck; "
      "[O] nu-UV-Input; [P] T_reh/M_R) -- die Rang-1-Aussage ist exakt auf dem "
      "zertifizierten Block und KONDITIONAL (benannt) auf dem Flavor-Block",
      all(ROWS[k][1:] == [0, 0, 0, 0] for k in CERT_KEYS))

# Mutations-Negativkontrolle: EIN zertifizierter Export mit verstecktem v_EW-Anteil
# muesste den Rang-Check sofort killen (Rang 2) -- der Detektor ist scharf.
M_mut = sp.Matrix([ROWS[k] for k in CERT_KEYS] + [[1, 0, 1, 0, 0]])
check("MUTATIONS-KONTROLLE: injiziert man einen hypothetischen zertifizierten Export "
      "mit verstecktem v_EW-Anteil (Exponentenvektor (1,0,1,0,0)), springt der Rang "
      f"auf {M_mut.rank()} -- der Kill-Detektor (Rang > 1 = versteckte zweite Skala) "
      "funktioniert nachweislich",
      M_mut.rank() == 2)

# --------------------------------------------------------------------------
# TEIL 3 -- lambda-Homogenitaet (symbolisch): kein interner absoluter Anker
# --------------------------------------------------------------------------
print("\nTEIL 3 -- LAMBDA-HOMOGENITAET (symbolisch, sympy): L -> lambda L")
print("-" * 78)

lam = sp.symbols("lambda", positive=True)
a_s, c3_s, n_s, LamA_s, mun_s = sp.symbols("a c_3 n Lambda_A mu_n", positive=True)  # dim 0
Mb_s, rho_s, Msc_s, fa_s, Gi_s, m_s, mu_s, v_s = sp.symbols(
    "Mbar rho_Lambda M_scal f_a Ginv m mu v_geo", positive=True)
ui_s, uj_s = sp.symbols("u_i u_j", real=True)

DIM = {a_s: 0, c3_s: 0, n_s: 0, LamA_s: 0, mun_s: 0,
       Mb_s: 1, rho_s: 4, Msc_s: 1, fa_s: 1, Gi_s: 2, m_s: 1, mu_s: 1, v_s: 1}


def scale(expr):
    """L -> lambda L: jede Groesse der Massendimension d skaliert als X -> lambda^{-d} X."""
    return expr.subs({x: lam ** (-d) * x for x, d in DIM.items()}, simultaneous=True)


pi_s = sp.pi
phib_s = 1 / (6 * pi_s)
dtop_s = 48 * c3_s ** 4
Q_s = dtop_s * sp.exp(-2 * a_s)
phiseam_s = phib_s + Q_s * (1 - Q_s) ** sp.Rational(-5, 4)

# Konsistenz-Bedingungen des Korpus (LHS == 0), mit erwartetem Homogenitaetsgrad d_C
CONSTRAINTS = [
    ("K1 c3-Fixpunkt F(a)=0 (v3): a^3 - 2c3^3 a^2 - (4/5)c3^6*41*ln(1/phi_seam)",
     a_s ** 3 - 2 * c3_s ** 3 * a_s ** 2
     - sp.Rational(4, 5) * c3_s ** 6 * 41 * sp.log(1 / phiseam_s), 0),
    ("K2 Seam-Normierung 2 pi c3 = 1/4 (v153)",
     2 * pi_s * c3_s - sp.Rational(1, 4), 0),
    ("K3 Seam-EH-Normierung 12 pi (c3/2) = ln(m/mu) (v152)",
     12 * pi_s * c3_s / 2 - sp.log(m_s / mu_s), 0),
    ("K4 Lambda-Branch rho_L = (3/4pi^2) e^{-2/a} Mbar^4 (v60/v7)",
     rho_s - sp.Rational(3, 4) / pi_s ** 2 * sp.exp(-2 / a_s) * Mb_s ** 4, 4),
    ("K5 Skalaron M_scal = c3^{7/2} Mbar (v7)",
     Msc_s - c3_s ** sp.Rational(7, 2) * Mb_s, 1),
    ("K6 Newton 1/G = 8 pi Mbar^2 (v68/v274)",
     Gi_s - 8 * pi_s * Mb_s ** 2, 2),
    ("K7 Axion f_a = (c3/4)^{7/2} Mbar (v25/rt_E)",
     fa_s - (c3_s / 4) ** sp.Rational(7, 2) * Mb_s, 1),
    ("K8 Gruppoid-Normierung (v714): mu_n = 2 Lambda_A(n)/sqrt(n) -- alle Symbole "
     "reine Zaehl-Daten (dim 0)",
     mun_s - 2 * LamA_s / sp.sqrt(n_s), 0),
]

all_hom = True
for name, lhs, d_expect in CONSTRAINTS:
    scaled = scale(lhs)
    hom = sp.simplify(sp.expand(scaled - lam ** (-d_expect) * lhs)) == 0
    all_hom &= bool(hom)
    tag = "PASS" if hom else "FAIL"
    print(f"  [{tag}] {name}  ->  Grad {d_expect} homogen")
check("ALLE Konsistenz-Bedingungen sind lambda-homogen (Grad 0 fuer dimensionslose, "
      "Grad d fuer dimensionale) -- die maschinelle Form des No-Unit-Satzes: "
      "KEINE Gleichung pinnt lambda",
      all_hom,
      kill_note="inhomogene Bedingung gefunden = interner absoluter Anker")

# Mutations-Negativkontrolle fuer den Homogenitaets-Scanner: typt man die
# Gruppoid-Masse mu_n FAELSCHLICH als dimensionsbehaftet (dim 1), wird K8
# inhomogen -- der Scanner haette eine dimensionsbehaftete Normierung gefunden.
_bad_dim = dict(DIM)
_bad_dim[mun_s] = 1
_k8_lhs = mun_s - 2 * LamA_s / sp.sqrt(n_s)
_k8_bad = _k8_lhs.subs({x: lam ** (-d) * x for x, d in _bad_dim.items()},
                       simultaneous=True)
check("MUTATIONS-KONTROLLE Homogenitaet: typt man die v714-Gruppoid-Masse mu_n "
      "faelschlich als dim 1, ist K8 weder Grad-0- noch Grad-1-homogen -- der "
      "Scanner erkennt dimensionsbehaftete Normierungen nachweislich",
      sp.simplify(_k8_bad - _k8_lhs) != 0
      and sp.simplify(_k8_bad - lam ** (-1) * _k8_lhs) != 0)

# Index-Identitaeten (Integer-Bedingungen, trivial invariant -- explizit geprueft)
N_fam = (2 ** (g_car - 1) - 1) // g_car
check("K9 Index-Identitaeten invariant: g_car + N_fam = 8 = rank E8; "
      "N_fam = (2^{g_car-1}-1)/g_car = 3; e-sym(1,1,2) = (4,5,2) = (|mu4|,g_car,|Z2|); "
      "det(Q,K,R,L)-Produkt = 1920 -- alles Massendimension 0",
      g_car + N_fam == 8 and N_fam == 3
      and (1 + 1 + 2, 1 * 1 + 1 * 2 + 1 * 2, 1 * 1 * 2) == (4, 5, 2)
      and 3 * 4 * 8 * 20 == 1920)

# Log-Achse der Montage: u -> u + ln(lambda) ist eine TRANSLATION; Lag-Differenzen
# (die Objekte der L1-Montage/Gruppoid-Fenster) sind exakt invariant -- die additive
# Spiegelung des multiplikativen R+-Torsors.
shift = sp.log(lam)
check("K10 Log-Achse (L1-Montage/v714): unter x -> lambda x verschiebt sich u = ln x "
      "um +ln(lambda); Lag-Differenzen (u_i - u_j) exakt invariant -- die Log-Achse "
      "ist ein affiner R-Torsor (kein absoluter Nullpunkt)",
      sp.simplify(((ui_s + shift) - (uj_s + shift)) - (ui_s - uj_s)) == 0)

# Freiheit + Transitivitaet der R+-Wirkung auf der Skalen-Faser
free = sp.solve(sp.Eq(lam * v_s, v_s), lam)
lam12 = sp.symbols("lambda_12", positive=True)
v1_s, v2_s = sp.symbols("v_1 v_2", positive=True)
trans = sp.solve(sp.Eq(lam12 * v1_s, v2_s), lam12)
check("K11 R+-Wirkung auf der Skalen-Faser ist FREI (lambda*v = v => lambda = 1) und "
      "TRANSITIV (zu v1,v2 > 0 existiert eindeutig lambda = v2/v1) -- die Faser ist "
      "ein R+-TORSOR",
      free == [1] and trans == [v2_s / v1_s])

# Negativ-Check (v153-Kern): eine Anker-Gleichung v_geo = f(dimensionslos) waere
# inhomogen (links Grad 1, rechts Grad 0) -- sie erzwingt lambda = 1 fuer alle
# Skalenwahlen, Widerspruch zur freien Wirkung.
anchor_lhs = v_s - sp.exp(a_s)          # Beispiel-Anker: dim 1 == dim 0
scaled_anchor = scale(anchor_lhs)
inhom = sp.simplify(scaled_anchor - lam ** (-1) * anchor_lhs) != 0 \
    and sp.simplify(scaled_anchor - anchor_lhs) != 0
check("K12 NEGATIV-KONTROLLE: eine hypothetische Anker-Gleichung v_geo = f(dim-0-Daten) "
      "ist NICHT homogen (weder Grad 0 noch Grad 1) -- der Scan haette sie gefunden; "
      "der Korpus enthaelt keine solche Gleichung",
      inhom)

# --------------------------------------------------------------------------
# TEIL 4 -- Kreuzkalibrierung: leave-one-anchor-out
# --------------------------------------------------------------------------
print("\nTEIL 4 -- KREUZKALIBRIERUNG (leave-one-anchor-out)")
print("-" * 78)

# ---- 4a. Mbar-Block: die zwei im Korpus benutzten Anker (v274) ----
# Anker A1 = Newton G (CODATA): Mbar = 2.435323203e18 GeV
# Anker A2 = Dunkle Energie (Planck 2018): rho_L^{1/4} = 2.24 meV, invertiert
Mbar_A1 = MBAR_GRAV
rho_qrt_GeV = RHO_QRT_MEAS_MEV * mp.mpf("1e-12")
Mbar_A2 = rho_qrt_GeV / RHO_RATIO ** (mp.mpf(1) / 4)
dev_anchor = Mbar_A2 / Mbar_A1 - 1

print(f"  Anker A1 (Gravitation, CODATA G):     Mbar = {mp.nstr(Mbar_A1, 8)} GeV")
print(f"  Anker A2 (Kosmologie, rho_L^1/4):     Mbar = {mp.nstr(Mbar_A2, 8)} GeV")
print(f"  relative Abweichung A2/A1 - 1       = {mp.nstr(100 * dev_anchor, 4)} %")

check("Anker-Kompatibilitaet (v274 reproduziert): |Mbar(A2)/Mbar(A1) - 1| = "
      f"{mp.nstr(100 * abs(dev_anchor), 3)} % < 1 % -- die zwei unabhaengigen "
      "Referenzen waehlen DENSELBEN Punkt im Torsor (konditional auf Lambda-Branch [C])",
      abs(dev_anchor) < mp.mpf("0.01"),
      kill_note="inkompatible Kalibrierungen im Mbar-Block")

# Vorhersage-Tabelle unter beiden Kalibrierungen
print("\n  Vorhersagen unter jeder Kalibrierung (leave-one-anchor-out):")
print(f"  {'Groesse':22s} {'unter A1 (G)':>18s} {'unter A2 (rho_L)':>18s} {'Messwert':>14s} {'Abw. LOO':>10s}")

rows_pred = []
# rho_L^{1/4} vorhergesagt aus A1, gemessen 2.24 meV  (leave A2 out)
p1 = RHO_RATIO ** (mp.mpf(1) / 4) * Mbar_A1 * mp.mpf("1e12")     # meV
rows_pred.append(("rho_L^1/4 [meV]", p1, RHO_QRT_MEAS_MEV, RHO_QRT_MEAS_MEV,
                  p1 / RHO_QRT_MEAS_MEV - 1))
# G vorhergesagt aus A2, gemessen CODATA  (leave A1 out)
G_A2 = G_from_Mbar(Mbar_A2)
rows_pred.append(("G [m^3/(kg s^2)]", G_from_Mbar(Mbar_A1), G_A2, G_CODATA,
                  G_A2 / G_CODATA - 1))
# ungemessene Vorhersagen: Verschiebung zwischen den Kalibrierungen = dev_anchor
rows_pred.append(("M_scal [GeV]", M_SCAL_R * Mbar_A1, M_SCAL_R * Mbar_A2, None, dev_anchor))
rows_pred.append(("f_a [GeV]", F_A_R * Mbar_A1, F_A_R * Mbar_A2, None, dev_anchor))

for name, pa1, pa2, meas, dev in rows_pred:
    mtxt = mp.nstr(meas, 6) if meas is not None else "--"
    print(f"  {name:22s} {mp.nstr(pa1, 8):>18s} {mp.nstr(pa2, 8):>18s} {mtxt:>14s} "
          f"{mp.nstr(100 * dev, 3):>9s}%")

check("LOO Mbar-Block: rho_L^{1/4}(A1) = %s meV vs gemessen 2.24 meV (%.2f %%); "
      "G(A2) = %s vs CODATA %s (%.2f %%); M_scal- und f_a-Vorhersagen verschieben "
      "sich um genau den EINEN gemeinsamen Faktor %.2f %% -- keine inkompatible "
      "Kalibrierung"
      % (mp.nstr(p1, 6), float(100 * (p1 / RHO_QRT_MEAS_MEV - 1)),
         mp.nstr(G_A2, 6), mp.nstr(G_CODATA, 6), float(100 * (G_A2 / G_CODATA - 1)),
         float(100 * dev_anchor)),
      abs(p1 / RHO_QRT_MEAS_MEV - 1) < mp.mpf("0.01")
      and abs(G_A2 / G_CODATA - 1) < mp.mpf("0.01"))

# ---- 4b. Flavor-Block: Kalibration mit je EINER Leptonmasse ----
# Korpus-Ratios (v20, Baum-Saat): m_e/m_mu = (12/7) phi0^2 ; m_mu/m_tau = (8/7) phi0
r_emu = mp.mpf(12) / 7 * phi0 ** 2
r_mutau = mp.mpf(8) / 7 * phi0
MEAS = {"m_e": M_E, "m_mu": M_MU, "m_tau": M_TAU}
# Amplitudenvektor relativ zu m_tau = 1 (nur Ratios, dimensionslos):
REL = {"m_e": r_emu * r_mutau, "m_mu": r_mutau, "m_tau": mp.mpf(1)}

print("\n  Flavor-Block (Baum-Saat-Ratios v20; Kalibration mit je EINER Masse):")
print(f"  {'Anker':8s} {'m_e pred [MeV]':>15s} {'m_mu pred [MeV]':>16s} "
      f"{'m_tau pred [MeV]':>17s} {'max |Abw.|':>11s}")

pred_vectors = {}
maxdevs = {}
for anchor in MEAS:
    scale_fac = MEAS[anchor] / REL[anchor]           # der gewaehlte Torsor-Punkt
    preds = {f: REL[f] * scale_fac for f in MEAS}
    pred_vectors[anchor] = preds
    devs = {f: preds[f] / MEAS[f] - 1 for f in MEAS}
    maxdevs[anchor] = max(abs(v) for v in devs.values())
    print(f"  {anchor:8s} {mp.nstr(preds['m_e'], 7):>15s} {mp.nstr(preds['m_mu'], 8):>16s} "
          f"{mp.nstr(preds['m_tau'], 8):>17s} {mp.nstr(100 * maxdevs[anchor], 3):>10s}%")

check("LOO Flavor-Block: jede Ein-Massen-Kalibration reproduziert die anderen zwei "
      "auf max %.2f %% (Baum-Saat-Niveau der v20-Ratios; die Abweichungen sind "
      "RATIO-Praezision, keine Skalen-Inkonsistenz -- sie sind ankerunabhaengig)"
      % float(100 * max(maxdevs.values())),
      max(maxdevs.values()) < mp.mpf("0.03"))

# Exakter Torsor-Faser-Check: Ankerwechsel = EIN globaler Faktor auf ALLEN Vorhersagen
fiber_ok = True
anchors = list(MEAS)
for i in range(len(anchors)):
    for j in range(i + 1, len(anchors)):
        f0 = pred_vectors[anchors[j]]["m_e"] / pred_vectors[anchors[i]]["m_e"]
        for f in MEAS:
            ratio = pred_vectors[anchors[j]][f] / pred_vectors[anchors[i]][f]
            fiber_ok &= abs(ratio / f0 - 1) < mp.mpf("1e-25")
check("TORSOR-FASER exakt: der Wechsel des Kalibrations-Ankers multipliziert ALLE "
      "Vorhersagen mit EINEM gemeinsamen lambda (maschinell auf < 1e-25 relativ, "
      "alle 3 Ankerpaare) -- Ankerwahl bewegt nur den Punkt in der Faser, nie die "
      "dimensionslosen Exporte",
      fiber_ok,
      kill_note="Ankerwechsel wirkt nicht als globaler Skalenfaktor")

# --------------------------------------------------------------------------
# TEIL 5 -- Der KALIBRATIONS-SATZ (Torsor-Formulierung, Vertrags-Kandidat)
# --------------------------------------------------------------------------
print("\nTEIL 5 -- KALIBRATIONS-SATZ (Vertrags-Schliessungs-Kandidat, Torsor-Sprache)")
print("-" * 78)

# Klausel (a): die Exporte r_i = O_i / v^{d_i} sind torsor-invariant (symbolisch)
r_sym = rho_s / v_s ** 4
inv_ok = sp.simplify(scale(r_sym) - r_sym) == 0
# Klausel (b): EINE Referenz mit d_j != 0 waehlt den Punkt eindeutig
O_meas, r_j = sp.symbols("O_meas r_j", positive=True)
sol_d2 = sp.solve(sp.Eq(r_j * v_s ** 2, O_meas), v_s)
sol_pos = [s for s in sol_d2 if s.is_positive]
# Klausel (b'): eine dim-0-Groesse kann NICHT kalibrieren
sol_d0 = sp.solve(sp.Eq(r_j * v_s ** 0, O_meas), v_s)

check("Klausel (a): jedes exportierte r_i = O_i/v_geo^{d_i} ist invariant unter der "
      "R+-Wirkung (symbolisch verifiziert) -- die Theorie exportiert genau die "
      "torsor-invarianten Funktionen",
      inv_ok)
check("Klausel (b): EINE gemessene Referenz O_j mit d_j != 0 waehlt den physischen "
      "Punkt EINDEUTIG: v_geo = (O_j/r_j)^{1/d_j} (einzige positive Loesung; "
      "symbolisch fuer d_j = 2 geprueft)",
      len(sol_pos) == 1 and sp.simplify(sol_pos[0] - sp.sqrt(O_meas / r_j)) == 0)
check("Klausel (b'): eine dim-0-Groesse (z.B. m/mu = e^{3/4}) kann NICHT kalibrieren "
      "(die Gleichung enthaelt v_geo nicht; sympy: keine Loesung nach v_geo) -- "
      "der Grad d_j != 0 ist notwendig UND hinreichend",
      sol_d0 == [])
check("Klausel (c): nach der Wahl sind ALLE weiteren dimensionalen Aussagen "
      "Vorhersagen; Ueberbestimmung = Kompatibilitaet mehrerer Referenzen "
      "(Teil 4: 0.11 % im Mbar-Block) -- maximale Praediktivitaet eines "
      "dimensionslosen Compilers (v274)",
      abs(dev_anchor) < mp.mpf("0.01"))

print("""
  KALIBRATIONS-SATZ (praezise Formulierung, Kandidat fuer die v_geo-Schnittstelle):

    Die Menge der zulaessigen Skalen-Zuweisungen der TFPT ist ein R+-TORSOR T:
    die Gruppe R+ wirkt frei und transitiv durch v_geo -> lambda * v_geo,
    O_i -> lambda^{d_i} * O_i. Die Theorie exportiert ausschliesslich die
    torsor-invarianten Daten { (r_i, d_i) } (dimensionslose Compiler-Verhaeltnisse
    plus Dimensionsgrade); KEIN Punkt von T ist intern ausgezeichnet (No-Unit,
    v153; Teil 3 maschinell). EINE gemessene Referenz (O_j, d_j != 0) waehlt den
    physischen Punkt v_geo = (O_j/r_j)^{1/d_j} in T eindeutig; danach ist jedes
    weitere O_i = r_i * v_geo^{d_i} eine Vorhersage, und jede weitere Referenz
    ist eine UEBERBESTIMMUNGS-Probe (aktuell: G vs. rho_Lambda, kompatibel zu
    0.11 %, konditional auf den Lambda-Branch [C]).

  EHRLICHER FENCE (Pflichtteil des Satzes):
    * Dies ist eine STRUKTUR-Schliessung: die Schnittstelle (Exporte = invariante
      Daten; Import = genau ein Kalibrationspunkt) ist wohldefiniert und
      maschinell zertifiziert. Es ist KEINE Ableitung einer absoluten Skala --
      die ist per No-Unit-Satz (v153) beweisbar unmoeglich, fuer jeden
      dimensionslosen Compiler.
    * Der Rang-1-Status ist EXAKT auf dem zertifizierten Export-Block
      {rho_Lambda, 1/G, M_scal, f_a, m/mu, A_s} und KONDITIONAL auf dem
      Flavor-Block (U_point = Anker nur per deklarierter [A]-Identifikation
      seam=Planck/EW-Matching, v68/v75/rt_E-Flag).
    * Route 2 (Kosmologie) haengt am Lambda-Branch [C] (v274/rt_F); v_EW, T_reh,
      M_R bleiben ehrlich getypte EXTERNE Inputs (v272/v339) -- keine Exporte.
""")

# --------------------------------------------------------------------------
# TEIL 6 -- Der einzige legale Moonshot (NUR benannt, nicht ausgefuehrt)
# --------------------------------------------------------------------------
print("TEIL 6 -- MOONSHOT-AUSBLICK (benannt, nicht ausgefuehrt)")
print("-" * 78)

H_EW = mp.log(MBAR_GRAV / V_EW)
log_c3_EW = mp.log(V_EW / MBAR_GRAV) / mp.log(c3)
log_phi0_EW = mp.log(V_EW / MBAR_GRAV) / mp.log(phi0)
log_c3_MR = mp.log(M_R_Y1 / MBAR_GRAV) / mp.log(c3)

print(f"  Der Korpus prediziert bereits EINEN Hierarchie-Exponenten: die "
      f"Lambda-Hierarchie\n    |log10(rho_L/M_Pl^4)| = 122.948 = 2 alpha^-1/ln10 "
      f"(= {mp.nstr(2 * AINV / mp.log(10), 6)}) + 3.920 (v60).")
print(f"  OFFEN bleibt genau EIN dimensionsloses Skalen-Verhaeltnis der Kette: die "
      f"EW-Hierarchie\n    H_EW = ln(Mbar/v_EW) = {mp.nstr(H_EW, 6)}   "
      f"(v_EW = 174 GeV, m_t-Konvention)")
print(f"  Ehrlicher Erstbefund (kein Fit, v184-Firewall respektiert):")
print(f"    log_c3(v_EW/Mbar)   = {mp.nstr(log_c3_EW, 6)}   (NICHT ganzzahlig)")
print(f"    log_phi0(v_EW/Mbar) = {mp.nstr(log_phi0_EW, 6)}   (NICHT ganzzahlig)")
print(f"    log_c3(M_R/Mbar)    = {mp.nstr(log_c3_MR, 6)}   (v272: 2.57, NICHT ganzzahlig)")

check("MOONSHOT BENANNT: 'Der EW-Hierarchie-Exponent H_EW = ln(Mbar/v_EW) ~ 37.18 "
      "als neues dimensionsloses Compiler-Verhaeltnis' -- das EINZIGE noch offene "
      "Skalen-Verhaeltnis, dessen Ableitung der No-Unit-Satz ERLAUBT (dim 0). "
      "Ein Erfolg wuerde die [A]-Identifikation des Flavor-Blocks zur Ableitung "
      "machen (Rang 1 unbedingt) und alle 9 Fermionmassen zu Mbar-Vorhersagen. "
      "Naive c3-/phi0-Leitern scheiden aus (11.53 / 12.67, nicht ganzzahlig) -- "
      "NICHT ausgefuehrt, nur benannt (Sekundaer-Kandidat: nu-Seesaw-Ratio, v272/v481)",
      abs(log_c3_EW - mp.nint(log_c3_EW)) > mp.mpf("0.05")
      and abs(log_phi0_EW - mp.nint(log_phi0_EW)) > mp.mpf("0.05"))

# --------------------------------------------------------------------------
# VERDIKT
# --------------------------------------------------------------------------
print("\n" + "=" * 78)
total = _PASS + _FAIL
if _FAIL == 0:
    print(f"VERDIKT: TORSOR-SCHLIESSUNG PASS ({_PASS}/{total} Checks)")
    print("""
  T1-SCHLUSS: Die v_geo-Schnittstelle ist als R+-Skalen-Torsor STRUKTURELL
  GESCHLOSSEN: (1) vollstaendige Export-Tabelle O_i = r_i * v_geo^{d_i} aus dem
  Korpus, (2) Dimensionsmatrix Rang 1 auf dem zertifizierten Block (konditional
  [A] auf dem Flavor-Block -- benannt), (3) alle Konsistenz-Bedingungen
  lambda-homogen (kein interner Anker; maschinelle Form des No-Unit-Satzes),
  (4) leave-one-anchor-out kompatibel (G vs. rho_Lambda: 0.11 %; Flavor-Faser
  exakt), (5) Kalibrations-Satz formuliert (eine Referenz waehlt den Punkt im
  Torsor; alles Weitere ist Vorhersage). FENCE: Struktur-Schliessung, KEINE
  Skalen-Ableitung (per No-Unit unmoeglich). Moonshot benannt: H_EW.""")
else:
    print(f"VERDIKT: FAIL ({_FAIL}/{total} Checks gescheitert)")
    for k in _KILLS:
        print(f"  KILL: {k}")
print("=" * 78)

def run():
    """run_all entry point: the checks execute at import (module
    level); report the failure count."""
    return _FAIL


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

13f14036812be4e37459ecab39180ae111c253f477a8b191a5bac7cfddac0afa

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.