Follow the source behind the result.

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

"""v777 -- FTRANSFER.CLOCKS.01 EXECUTED + the fibered refinement of CONTRACT.F.01: the preregistered external-clock kill and the projective-groupoid reading, ONE module from two probes (24 + 14 checks, 0 failures each, ~7 s; discovery probes run_clocks_executor.py NO-COMMON-CONNECTION -- the K1 kill EXACTLY as the frozen prior expected -- and ftransfer_projective_groupoid_probe.py FTRANSFER-FIBERED-CARRIES, both 2026-08-05).  THE EXECUTED KILL (byte-frozen preregistration: YAML sha256 880224f7..., frozen 2026-08-04; data tables curated + SHA-frozen BEFORE the first run: Saikawa-Shirai 2018 g_*s 8ae2a4fe..., PDG 2024 alpha_s 2ca6332d...): all four dictionaries are construction-VALID (Koide scheme check: |Q_run - 2/3| = 571 x |Q_pole - 2/3|, the on-shell chart is right; washout entropy-chart drift 1.15e-4; QCD 1-loop overlay max dev 0.83% on [m_t, 1 TeV]; relic onset slope dev 0.0602) -- and the one-class prediction FTC.P1 dies sympy-EXACTLY: the transported Schwarzians are {-Delta^2/2, -Delta^2/2, 0} (Delta = 6 log(3/2); symbolic difference exactly nonzero, no tolerance involved).  K1 duty discharged: the reparametrization a pass WOULD need is exhibited -- h = Moebius(e^{+-Delta sigma}), the NON-affine exponential clock change the freeze forbids (exactly the v578 u = e^{Delta t}).  K2/K3 quiet.  THE FIBERED REFINEMENT (the architectural reading the kill leaves standing, all gates frozen before the first run): F_transfer is NOT one common continuous clock but a FIBERED functor -- a shared DISCRETE PGL2 base (cross-ratio of the four anchor quadruples = 4/3 EXACTLY symbolic and through the frozen g_*s table, dev 6.5e-4; deck unit |Delta sigma| = 1 exact; the deck generator is the unit parabolic translation, tr^2 - 4 det = 0 -- the v632 lattice-explicit discrete half) + channel-specific projective connections whose obstruction is the CONSTANT seam cocycle: antisymmetry and the cocycle identity exact (27 triples), values EXACTLY {0, +-Delta^2/2}, d/dsigma identically zero (symbolic + 50-digit spot checks); the classification matches the predeclared marker -- thermal/proper-time clocks {tau, beta} -> coset -Delta^2/2, RG clock {log mu} -> coset 0, relic degenerate NOT classified; all three controls fire (wrong slope leaves the value set, scrambled anchors give CR = 3/4, the v578 Moebius transplant moves QCD onto -Delta^2/2).  FIRST-RUN DISCLOSURE (carried verbatim in the probe docstring): the groupoid's G2b spot checks were first evaluated with float64 lambdify (dev 3.0e-9), violating the frozen sympy-exact kernel method; the arithmetic was conformed to the frozen method (50-digit evalf), the 1e-12 bar UNTOUCHED.  CONSEQUENCE: the jet route of CONTRACT.F.01 closes at the physical-clock level (the v578 diagnosis finalized) and the contract's surviving form is the fibered functor with the constant obstruction cocycle; the one named proof-grade next step: derive the coset assignment from KMS/modular clock typing.  The four observables stay [C]/[O]; no marker move.  NO RH claim.  Python-only per GATE.WOLFRAM.02.

PROVENANCE: discovery executor run_clocks_executor.py (2026-08-05, 24 checks 0 failures, NO-COMMON-CONNECTION, matches the frozen prior) + ftransfer_projective_groupoid_probe.py (2026-08-05, 14 checks 0 failures, FTRANSFER-FIBERED-CARRIES); both re-run identically at promotion.  Promoted verbatim; transforms: the data/YAML paths point read-only at experiments/ftransfer-clocks/ (freeze guards unchanged, abort-on-mismatch), the results-JSON writes are DROPPED (the experiments-side scripts remain the writers of record), and run() encodes both preregistered patterns (v757 precedent).  Numbers unchanged.

Original executor docstring (verbatim):
FTRANSFER.CLOCKS.01 -- the experiments-side executor of the frozen
external-clock contract (hypotheses/ftransfer_clocks_v1.yaml, byte-frozen
2026-08-04).

WHAT THIS IS.  The preregistered kill test for the jet residual of
CONTRACT.F.01, executed EXACTLY as frozen: four external clocks (proper time
tau / inverse temperature beta / RG time t / e-folds ln a), four affine
dictionaries with frozen slopes (-1, -1, +1, -1) into the common chart
sigma = ln(mu/M_Z), symbolic (sympy-exact) Schwarzian-cocycle transport, the
one-class prediction FTC.P1, the three kill criteria K1/K2/K3 with frozen
bars, the four data-driven dictionary-validity legs FTC.01.K/B/Q/R, and the
three controls FTC.C1/C2/C3.  NO frozen value is altered; the executor
verifies the sha256 of the preregistration YAML and of the two curated data
tables (data/DATA_FREEZE.sha256) at startup and aborts on any mismatch.

WHAT THIS IS NOT.  Not load-bearing: experiments/ only, typed [X]; no ledger
row moves, no marker, no paper/website surface.  The preregistration's
executor clause names a FUTURE verification module (vN_ftransfer_clock_jets
pattern) entered via the promotion workflow; this script is the
experiments-side execution that produces the adjudicated numbers for that
promotion round -- it creates no vN module and upgrades nothing.

HONEST PRIOR (frozen in the YAML before execution): expected verdict
NO-COMMON-CONNECTION (K1) -- affine transport scales a Schwarzian by
slope^2 and cannot move 0 (the QCD value) onto -Delta^2/2 (the seam value).
ONE-CLASS would be the surprise.

Data interfaces (curated + byte-frozen BEFORE this executor first ran):
  data/gstar_saikawa_shirai_2018.csv   (Saikawa & Shirai 2018, arXiv:1803.01038)
  data/alphas_pdg2024_running.csv      (PDG 2024 world average + 4-loop running)

Run:  . experiments/tfpt-discovery/.venv/bin/activate
      python experiments/ftransfer-clocks/run_clocks_executor.py
Output: results/ftransfer_clocks_v1_execution.json + console report.

Original groupoid probe docstring (verbatim):
ftransfer_projective_groupoid_probe -- the fibered-functor probe after the K1 kill.

PLACEMENT.  experiments/ftransfer-clocks/ (this probe reuses the byte-frozen
preregistration YAML and the two SHA-frozen data tables of the executed
contract as its freeze guards; separating it into tfpt-discovery/ would
duplicate the freeze surface).  Exploration only: no verification/ module,
no ledger row, no paper/website surface, typed [X] work product.

THE ARCHITECTURAL READING UNDER TEST (the review's, confirmed by the
executed K1 kill of FTRANSFER.CLOCKS.01, verdict NO-COMMON-CONNECTION):
F_transfer is NOT one common continuous clock.  The correct category is a
FIBERED functor Sheet-Diamond -> {proper time tau, inverse temperature
beta, RG time log mu, e-folds log a}: a shared DISCRETE common PGL2
structure (the base) + channel-specific projective connections (the
fibers), with the Schwarzian differences stored as an OBSTRUCTION COCYCLE
-- not fitted away.

ALL GATES FROZEN HERE, BEFORE THE FIRST RUN (2026-08-05; no bar, set,
convention or marker below may be changed after execution):

  FREEZE GUARDS (abort on mismatch):
    prereg YAML sha256  880224f76380c77dce2c1e3d7651bccc9e1619e74c60b7e15326ee0ee2bbf4d0
    gstar table sha256  8ae2a4fec098fd68d3a469fbf2b7806ee1630f5595498a3e6cf2abca2d79b939
    alphas table sha256 2ca6332dd1ee0caa089f64be58e90a8c916c94bbe612125eca41da50c33a2ac2

  G1 -- THE SHARED DISCRETE LAYER (make-or-break: if this differs, the
  whole F_transfer category dies):
    Anchor quadruples: four consecutive clock e-fold ticks {0,1,2,3} from
    the frozen base point of each channel (pole: x1* = -sigma*,
    sigma* = ln(m_tau/M_Z); Boltzmann: z = 1; QCD: sigma_t = ln(m_t/M_Z);
    relic: four points equally spaced in ln a spanning the frozen validated
    window [onset - 0.5, onset + 0.5], onset = ln a at 3H(T_osc) = m_a).
    G1a cross-ratio (symbolic): CR of the dictionary images of the anchor
        quadruple equals 4/3 EXACTLY for all four affine dictionaries
        (equally-spaced lattice cross-ratio; sympy zero).
    G1b cross-ratio (data): pole/Boltzmann/QCD legs |CR - 4/3| <= 1e-9
        (pure affine, float noise only); relic leg THROUGH THE FROZEN
        g_*s TABLE |CR - 4/3| <= 0.15 (bar mirrors the frozen prereg
        slope tolerance class -- the only frozen tolerance of that leg).
    G1c deck unit: one clock e-fold maps to |Delta sigma| = 1 EXACTLY
        (symbolic) for the three affine channels; relic measured mean
        |d sigma/d ln a| in [0.85, 1.15] on the frozen window.
    G1d deck class + objects: the deck generator (one clock e-fold pushed
        to sigma) is the unit translation -- PGL2 matrix [[1, +-1],[0,1]],
        parabolic: tr^2 - 4 det = 0 EXACTLY; all four dictionaries target
        the SAME object (the sigma-line); orientations recorded
        (-1,-1,+1,-1) and identified under inverse-conjugation (a
        translation is PGL2-conjugate to its inverse; the YAML freezes
        'orientation is irrelevant to the class data').

  G2 -- THE OBSTRUCTION COCYCLE (on the transported Schwarzians S_i):
    Degenerate-leg convention (FROZEN): F_relic carries NO Schwarzian
    (v578/prereg honesty clause) -- it is an object of the groupoid with
    identity morphism only and is EXCLUDED from the cocycle carrier set;
    the cocycle lives on the three non-degenerate channels.
    G2a antisymmetry: omega_ij = -omega_ji EXACT (sympy zero).
    G2b cocycle identity omega_ij + omega_jk = omega_ik EXACT, and the
        STRUCTURAL content: omega is a CONSTANT cocycle, not a running
        function -- d/dsigma of every transported Schwarzian expression
        vanishes IDENTICALLY (symbolic), plus 5-point numeric spot checks
        per channel across the frozen evaluation windows (pole: sigma in
        sigma* + [0, 3]; Boltzmann: z in [1, 10]; QCD: mu in [m_t, 1 TeV]),
        max deviation from the channel constant <= 1e-12.
    G2c values: the cocycle takes values EXACTLY in {0, +-Delta^2/2},
        Delta^2/2 = 18 log^2(3/2) = 2.959235170076978, closed form
        (sympy zero against 18*log(3/2)**2).

  G3 -- THE CLASSIFICATION (marker predeclared HERE, before computing):
    The two-coset split of the cocycle must be
      THERMAL/PROPER-TIME CLOCKS {tau, beta} -> coset S = -Delta^2/2
      (the two channels whose clock is a wall/modular time on which the
      seam contraction acts per e-fold),
      RG CLOCK {log mu} -> coset S = 0
      (the one channel whose clock IS the native flow variable),
      RELIC {log a} -> degenerate object, NOT classified (predeclared:
      honesty forbids assigning the jet-free channel to a coset).
    The torsor difference between the two cosets is the seam constant
    Delta^2/2 exactly.

  G4 -- CONTROLS (all three MUST fire):
    G4a wrong-slope dictionary (slope 2 on the Koide channel): the deck
        unit breaks (|Delta sigma| = 2 != 1) AND the transported
        Schwarzian leaves the frozen value set (slope^2 scaling:
        -4 * Delta^2/2 not in {0, +-Delta^2/2}).
    G4b scrambled anchors (frozen scramble: swap the LAST TWO anchors of
        the F_pole quadruple): cross-ratio mismatch detected
        (CR = 3/4 != 4/3).
    G4c v578 Moebius clock transplanted to QCD: t = h(sigma) =
        e^{Delta sigma} moves the QCD Schwarzian from 0 onto -Delta^2/2
        EXACTLY (symbolic) -- the obstruction is exactly the forbidden
        non-affine freedom (the K1-duty check transplanted).

  VERDICT ENUM (frozen):
    FTRANSFER-FIBERED-CARRIES  -- all G1-G3 pass and all G4 controls fire
    FTRANSFER-FIBERED-PARTIAL  -- G1 holds but some later gate fails (name it)
    FTRANSFER-FIBERED-DEAD     -- G1 fails (the category dies entirely)

FIREWALL: search-surface probe; a CARRIES verdict does NOT upgrade any
marker, does NOT close CONTRACT.F.01, and enters papers only via a future
promotion round.  No new state, no new scale; all constants from the
frozen corpus (Delta = 6 log(3/2), the v184/v185 anchors, the two frozen
data tables).
"""

from __future__ import annotations

import hashlib
import json
import math
import os
import time

import sympy as sp
import yaml

T_START = time.time()
HERE = os.path.abspath(os.path.join(os.path.dirname(
    os.path.abspath(__file__)), "..", "experiments", "ftransfer-clocks"))

# ---------------------------------------------------------------------------
# Frozen freeze-guard hashes.  The YAML hash is the byte-freeze of record
# (committed 2026-08-04, commit 368df86f); the data hashes were frozen by
# scripts/curate_data_tables.py BEFORE the executor first ran (2026-08-05).
# ---------------------------------------------------------------------------
YAML_PATH = os.path.join(HERE, "hypotheses", "ftransfer_clocks_v1.yaml")
YAML_SHA256 = "880224f76380c77dce2c1e3d7651bccc9e1619e74c60b7e15326ee0ee2bbf4d0"
DATA_FREEZE = os.path.join(HERE, "data", "DATA_FREEZE.sha256")
GSTAR_CSV = os.path.join(HERE, "data", "gstar_saikawa_shirai_2018.csv")
ALPHAS_CSV = os.path.join(HERE, "data", "alphas_pdg2024_running.csv")

# Corpus anchors entering ONLY through base points / window edges (v184, v185,
# tfpt_constants); affine offsets by construction, outside the class data.
PHI0 = 0.053171952176845526      # tfpt_constants phi0 (retained seed)
V_EW = 174.0                     # GeV (v184)
M3_EV = 0.05                     # eV, m_3 ~ sqrt(dm^2_atm) (v184)
MBAR = 2.435323e18               # GeV, reduced Planck mass (v184/v185)
DIM_SPLUS = 16                   # v185: f_a = M_scal/(2 * dim S+ * |mu4|) = M_scal/128
N_EFF_SM = 3.044                 # SM value the Planck N_eff certificate is tested against

CHECKS = []


def check(name: str, ok: bool, detail: str = "") -> bool:
    CHECKS.append({"name": name, "ok": bool(ok), "detail": detail})
    print("[%s] %s%s" % ("PASS" if ok else "FAIL", name, (": " + detail) if detail else ""))
    return bool(ok)


def sha256_file(path: str) -> str:
    h = hashlib.sha256()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(65536), b""):
            h.update(chunk)
    return h.hexdigest()


def schwarzian(y, x):
    y1, y2, y3 = sp.diff(y, x), sp.diff(y, x, 2), sp.diff(y, x, 3)
    return sp.simplify(y3 / y1 - sp.Rational(3, 2) * (y2 / y1) ** 2)


def read_csv(path: str):
    rows = []
    with open(path) as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith("#"):
                continue
            rows.append([float(v) for v in line.split(",")])
    return rows


def loglog_interp(table, x, xi=0, yi=1):
    """log-log linear interpolation in column yi against column xi."""
    lx = math.log(x)
    lo, hi = 0, len(table) - 1
    if not (table[lo][xi] <= x <= table[hi][xi]):
        raise ValueError("interpolation out of range: %g" % x)
    while hi - lo > 1:
        mid = (lo + hi) // 2
        if table[mid][xi] <= x:
            lo = mid
        else:
            hi = mid
    x0, x1 = math.log(table[lo][xi]), math.log(table[hi][xi])
    y0, y1 = math.log(table[lo][yi]), math.log(table[hi][yi])
    return math.exp(y0 + (y1 - y0) * (lx - x0) / (x1 - x0))


def main() -> int:
    print("=" * 78)
    print("FTRANSFER.CLOCKS.01 -- frozen external-clock contract: EXECUTION")
    print("=" * 78)

    # -----------------------------------------------------------------------
    # 0. FREEZE GUARD (K2 machine form): byte-frozen YAML + frozen data tables.
    # -----------------------------------------------------------------------
    yaml_hash = sha256_file(YAML_PATH)
    check("G0.1 preregistration YAML byte-freeze verified (sha256 == frozen record)",
          yaml_hash == YAML_SHA256, yaml_hash)
    frozen_data_hashes = {}
    with open(DATA_FREEZE) as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith("#"):
                continue
            h, name = line.split()
            frozen_data_hashes[name] = h
    for path in (GSTAR_CSV, ALPHAS_CSV):
        name = os.path.basename(path)
        check("G0.2 frozen data table %s hash verified" % name,
              sha256_file(path) == frozen_data_hashes[name], frozen_data_hashes[name])
    if not all(c["ok"] for c in CHECKS):
        print("\nVERDICT: ABORT -- freeze guard failed; nothing executed")
        return 1

    with open(YAML_PATH) as f:
        prereg = yaml.safe_load(f)
    D = prereg["data"]

    # -----------------------------------------------------------------------
    # Frozen symbolic kernel.
    # -----------------------------------------------------------------------
    Delta = 6 * sp.log(sp.Rational(3, 2))
    Dsq2 = Delta**2 / 2                     # = 18 log(3/2)^2 = 2.959235170076978
    sigma = sp.symbols("sigma", real=True)
    x1, x2, t, la = sp.symbols("x1 x2 t la", real=True)
    C1, cg, k1, k2, k4 = sp.symbols("C1 c_g k1 k2 k4", positive=True)
    B1, a0, th_i = sp.symbols("B1 alpha0 theta_i", positive=True)

    # Native trajectories, each in its OWN frozen clock (v99/v425/v159/v632):
    u_pole = C1 * sp.exp(Delta * (x1 + cg))          # frozen gauge t_v99 = x1 + const
    q_pole = (5 - 2 * u_pole) / (1 - u_pole)         # v99 Moebius flow, fixed pts {2,5}
    y_boltz = B1 * sp.exp(-Delta * x2)               # v425 contraction (2/3)^6 / beta e-fold
    y_qcd = a0 / (1 + 7 * a0 * t / (2 * sp.pi))      # 1-loop b0 = 7 Riccati flow
    y_relic = th_i + 0 * la                          # frozen constant (identity element)

    exports = {"F_pole": (q_pole, x1), "F_Boltzmann": (y_boltz, x2),
               "F_QCD": (y_qcd, t), "F_relic": (y_relic, la)}

    # Frozen affine dictionaries into sigma (slopes -1, -1, +1, -1):
    dicts = {"F_pole": -sigma + k1, "F_Boltzmann": -sigma + k2,
             "F_QCD": sigma, "F_relic": -sigma + k4}

    # -----------------------------------------------------------------------
    # FTC.01 -- dictionary validity (data-driven, floats; frozen tolerances).
    # -----------------------------------------------------------------------
    print("-" * 78)
    print("FTC.01 dictionary validity (data legs; floats enter HERE only)")
    print("-" * 78)

    # FTC.01.K -- Koide base point + scheme check (PDG 2024 pole masses frozen in YAML).
    k = D["koide"]
    me, mmu, mtau = k["m_e_MeV"], k["m_mu_MeV"], k["m_tau_MeV"]
    Q_exp = (me + mmu + mtau) / (math.sqrt(me) + math.sqrt(mmu) + math.sqrt(mtau)) ** 2
    dm = 1e-4  # numerical derivative step for the m_tau error propagation [MeV]
    Qp = (me + mmu + mtau + dm) / (math.sqrt(me) + math.sqrt(mmu) + math.sqrt(mtau + dm)) ** 2
    sigma_Q = abs(Qp - Q_exp) / dm * 0.09
    pull = (Q_exp - 2.0 / 3.0) / sigma_Q
    q_exp = 3 * Q_exp
    sigma_q = 3 * sigma_Q
    ftc01k_base = abs(q_exp - 2) <= 3 * sigma_q
    check("FTC.01.K base point: q_exp = %.10f, |q_exp - 2| = %.3e <= 3*sigma_q = %.3e "
          "(frozen tolerance); Q_exp = %.10f (frozen record %.10f), pull = %+.3f sigma "
          "(frozen record %+.3f)"
          % (q_exp, abs(q_exp - 2), 3 * sigma_q, Q_exp, k["frozen_check_values"]["Q_exp"],
             pull, k["frozen_check_values"]["pull_vs_two_thirds"]),
          ftc01k_base and abs(Q_exp - k["frozen_check_values"]["Q_exp"]) < 1e-9
          and abs(pull - k["frozen_check_values"]["pull_vs_two_thirds"]) < 0.01)
    r = k["scheme_check"]
    Q_run = (r["m_e_run_MeV"] + r["m_mu_run_MeV"] + r["m_tau_run_MeV"]) / (
        math.sqrt(r["m_e_run_MeV"]) + math.sqrt(r["m_mu_run_MeV"])
        + math.sqrt(r["m_tau_run_MeV"])) ** 2
    ratio = abs(Q_run - 2.0 / 3.0) / abs(Q_exp - 2.0 / 3.0)
    ftc01k_scheme = abs(Q_run - 2.0 / 3.0) > 10 * abs(Q_exp - 2.0 / 3.0)
    check("FTC.01.K scheme check: Q_run(M_Z) = %.7f, |Q_run - 2/3| = %.3e = %.0f x "
          "|Q_pole - 2/3| > 10x (frozen bar) -- the on-shell/proper-time clock "
          "assignment is the right chart, the running chart fails it"
          % (Q_run, abs(Q_run - 2.0 / 3.0), ratio), ftc01k_scheme)
    ftc01k = ftc01k_base and ftc01k_scheme

    # FTC.01.B -- radiation certificate + g_*s chart consistency on the washout window.
    gstar = read_csv(GSTAR_CSV)          # T, g_rho, g_rho_err, g_s, g_s_err
    M_R = V_EW**2 / (M3_EV * 1e-9)
    M1 = M_R * PHI0**4
    T_win = [M1 / 10.0, M1]              # washout window z = M_1*beta in [1, 10]
    gs_lo = loglog_interp(gstar, T_win[0], yi=3)
    gs_hi = loglog_interp(gstar, T_win[1], yi=3)
    slope_B = abs(math.log(gs_hi / gs_lo) / math.log(T_win[1] / T_win[0]))
    drift_B = slope_B / 3.0              # entropy-chart slope contamination
    neff = D["boltzmann"]["radiation_certificate"]
    neff_pull = abs(N_EFF_SM - 2.99) / 0.17
    ftc01b = (drift_B <= 0.15) and (neff_pull <= 2.0)
    check("FTC.01.B: washout window T in [%.3e, %.3e] GeV (M_1 = %.3e GeV, affine "
          "offset only); g_*s = %.4f..%.4f, |dln g_*s/dln T| = %.2e, entropy-chart "
          "drift %.2e <= 0.15 (frozen slope-tolerance class); radiation certificate "
          "N_eff = 2.99 +- 0.17 vs SM 3.044: %.2f sigma"
          % (T_win[0], T_win[1], M1, gs_lo, gs_hi, slope_B, drift_B, neff_pull),
          ftc01b, "certificate frozen in YAML: %s" % neff)

    # FTC.01.Q -- 1-loop overlay within 10% on [m_t, 1 TeV].
    qd = D["qcd"]
    a_mz, mz, mt = qd["alpha_s_MZ"], qd["M_Z_GeV"], qd["m_t_GeV"]
    a_mt_1l = 1.0 / (1.0 / a_mz + (23.0 / 3.0) / (2 * math.pi) * math.log(mt / mz))
    chain_ok = abs(a_mt_1l - float(qd["frozen_chain"].split(":")[-1])) < 1e-9
    check("FTC.01.Q frozen chain reproduced: alpha_s^(1l)(m_t) = %.10f (frozen "
          "0.1080741169; b0 = 23/3 leg M_Z -> m_t)" % a_mt_1l, chain_ok)
    alphas = read_csv(ALPHAS_CSV)        # Q, alpha, lo, hi
    lo_w, hi_w = qd["overlay_window_GeV"]
    devs = []
    for row in alphas:
        Q = row[0]
        if lo_w - 1e-9 <= Q <= hi_w + 1e-9:
            a1l = a_mt_1l / (1.0 + 7.0 * a_mt_1l * math.log(Q / mt) / (2 * math.pi))
            devs.append((abs(a1l - row[1]) / row[1], Q, a1l, row[1]))
    max_dev, Qm, a1m, adm = max(devs)
    ftc01q = chain_ok and max_dev <= 0.10
    check("FTC.01.Q overlay: max |alpha_1loop - alpha_data|/alpha_data = %.4f at "
          "Q = %.1f GeV (1-loop %.6f vs 4-loop PDG %.6f; %d grid points on "
          "[%.2f, %.0f]) <= 0.10 (frozen tolerance, honestly covering the >= 2-loop "
          "truncation)" % (max_dev, Qm, a1m, adm, len(devs), lo_w, hi_w), ftc01q)

    # FTC.01.R -- relic entropy-chart slope at the frozen onset 3H(T_osc) = m_a.
    M_scal = (1.0 / (8 * math.pi)) ** 3.5 * MBAR
    f_a = M_scal / (2 * DIM_SPLUS * 4)   # = M_scal/128 (v185)
    m_a_GeV = 5.70 * (1e12 / f_a) * 1e-15  # 5.70 ueV * (1e12/f_a), in GeV
    lo_T, hi_T = 1.0, 1e4

    def hubble3(T):
        g_rho = loglog_interp(gstar, T, yi=1)
        return 3.0 * math.sqrt(math.pi**2 * g_rho / 90.0) * T * T / MBAR

    for _ in range(200):
        mid = math.sqrt(lo_T * hi_T)
        if hubble3(mid) < m_a_GeV:
            lo_T = mid
        else:
            hi_T = mid
    T_osc = math.sqrt(lo_T * hi_T)
    gs0 = gstar[0][3]                    # low-T plateau g_*s(T0) = 3.9309363 (const offset)

    def ln_a_of_T(T):                    # adiabatic chart g_*s T^3 a^3 = const (offset free)
        return -math.log(T) - (1.0 / 3.0) * math.log(loglog_interp(gstar, T, yi=3) / gs0)

    lna_osc = ln_a_of_T(T_osc)
    n_pts, half = 201, 0.5               # onset window: ln a in [lna_osc - 0.5, lna_osc + 0.5]
    Ts = [T_osc * math.exp(1.2 * (i / (n_pts - 1) - 0.5)) for i in range(n_pts)]
    pts = sorted((ln_a_of_T(T), math.log(T / mz)) for T in Ts)
    worst = 0.0
    for i in range(1, len(pts) - 1):
        if abs(pts[i][0] - lna_osc) <= half:
            dslope = (pts[i + 1][1] - pts[i - 1][1]) / (pts[i + 1][0] - pts[i - 1][0])
            worst = max(worst, abs(dslope + 1.0))
    ftc01r = worst <= 0.15
    check("FTC.01.R: onset 3H(T_osc) = m_a (m_a = %.3f ueV from f_a = M_scal/128 = "
          "%.4e GeV, v185) gives T_osc = %.2f GeV; entropy-chart slope max "
          "|dsigma/dln a + 1| = %.4f over ln a in [onset - 0.5, onset + 0.5] <= 0.15 "
          "(frozen tolerance)" % (m_a_GeV * 1e15, f_a, T_osc, worst), ftc01r)
    # informational only (no adjudication): worst entropy-chart drift anywhere on the table
    worst_any, at_T = 0.0, 0.0
    for i in range(1, len(gstar) - 1):
        dlg = math.log(gstar[i + 1][3] / gstar[i - 1][3])
        dlT = math.log(gstar[i + 1][0] / gstar[i - 1][0])
        s = (dlg / dlT) / 3.0
        d = abs(s / (1.0 + s))           # |dsigma/dln a + 1| via the chain rule
        if d > worst_any:
            worst_any, at_T = d, gstar[i][0]
    print("       [info] worst entropy-chart drift anywhere on the table: "
          "|dsigma/dln a + 1| = %.3f at T = %.3f GeV (QCD crossover) -- the frozen "
          "onset at %.1f GeV sits far above it" % (worst_any, at_T, T_osc))

    construction_ok = ftc01k and ftc01b and ftc01q and ftc01r

    # -----------------------------------------------------------------------
    # FTC.02 -- THE one-class test (symbolic; the contract itself).
    # -----------------------------------------------------------------------
    print("-" * 78)
    print("FTC.02 the one-class test (sympy-exact transport; frozen dictionaries)")
    print("-" * 78)
    S_sigma = {}
    for name in ("F_pole", "F_Boltzmann", "F_QCD"):
        y, x = exports[name]
        S_sigma[name] = sp.simplify(schwarzian(y.subs(x, dicts[name]), sigma))
    check("FTC.02 seam transport exact: {q,sigma} = {y_B,sigma} = -Delta^2/2 = "
          "-18 log(3/2)^2 = %.15f (slope^2 = 1, cocycle term 0 for affine h)"
          % float(-Dsq2),
          sp.simplify(S_sigma["F_pole"] + Dsq2) == 0
          and sp.simplify(S_sigma["F_Boltzmann"] + Dsq2) == 0)
    check("FTC.02 QCD transport exact: {alpha_s,sigma} = 0 (identity dictionary; "
          "Moebius flow stays Moebius)", sp.simplify(S_sigma["F_QCD"]) == 0)
    diff_pair = sp.simplify(S_sigma["F_QCD"] - S_sigma["F_pole"])
    one_class = (sp.simplify(S_sigma["F_pole"] - S_sigma["F_Boltzmann"]) == 0
                 and diff_pair == 0)
    check("FTC.02 FTC.P1 one-class prediction: transported Schwarzians all equal "
          "-- %s (symbolic difference QCD - seam = %s = %.15f, EXACTLY nonzero)"
          % ("YES" if one_class else "NO", diff_pair, float(diff_pair)),
          not one_class if diff_pair != 0 else one_class,
          "the prediction FTC.P1 %s" % ("holds" if one_class else "FAILS -- contract dies"))

    # -----------------------------------------------------------------------
    # FTC.03 -- degeneracy honesty + K3 single-clock structural assertion.
    # -----------------------------------------------------------------------
    print("-" * 78)
    print("FTC.03 degeneracy honesty + K3 single-clock assertion (structural)")
    print("-" * 78)
    check("FTC.03 relic degeneracy: theta(ln a) = theta_i constant, y' = 0 "
          "identically -- jets degenerate, NO Schwarzian, channel scored on "
          "kills/dictionary only (frozen honesty clause)",
          sp.diff(y_relic, la) == 0)
    clock_syms = {x1, x2, t, la, sigma}
    k3_fired = False
    for name, (y, x) in exports.items():
        used = y.free_symbols & clock_syms
        ok = used <= {x}
        k3_fired = k3_fired or not ok
        check("FTC.03 K3 watch %s: export references exactly one clock (%s)"
              % (name, sorted(str(s) for s in used) or "constant"), ok)

    # -----------------------------------------------------------------------
    # Controls FTC.C1 / C2 / C3.
    # -----------------------------------------------------------------------
    print("-" * 78)
    print("controls (C1 calibration must pass, C2 swap must fail, C3 frame must pass)")
    print("-" * 78)
    S_nat = {n: (None if n == "F_relic" else sp.simplify(schwarzian(*exports[n])))
             for n in exports}
    check("FTC.C1 calibration: identity dictionaries reproduce the v578 native "
          "quadruple {-Delta^2/2, -Delta^2/2, 0, degenerate} EXACTLY",
          sp.simplify(S_nat["F_pole"] + Dsq2) == 0
          and sp.simplify(S_nat["F_Boltzmann"] + Dsq2) == 0
          and S_nat["F_QCD"] == 0 and S_nat["F_relic"] is None)
    S_swap = sp.simplify(schwarzian(q_pole.subs(x1, dicts["F_QCD"]), sigma))
    check("FTC.C2 swap control: QCD dictionary (identity, slope +1) on the Koide "
          "channel still leaves {q,sigma} = -Delta^2/2 != 0 = {alpha_s,sigma} -- "
          "the class split IS detected (the statistic cannot trivially pass)",
          sp.simplify(S_swap + Dsq2) == 0 and sp.simplify(S_swap - S_sigma["F_QCD"]) != 0)
    frame_ok = True
    for name in ("F_pole", "F_Boltzmann", "F_QCD"):
        y, x = exports[name]
        y_framed = (2 * y - 1) / (y + 3)             # frozen nontrivial Moebius frame
        S_f = sp.simplify(schwarzian(y_framed.subs(x, dicts[name]), sigma))
        frame_ok = frame_ok and sp.simplify(S_f - S_sigma[name]) == 0
    check("FTC.C3 frame independence: post-composing every y with the frozen "
          "Moebius map (2y-1)/(y+3) changes NO transported Schwarzian (cocycle "
          "correctness)", frame_ok)

    # -----------------------------------------------------------------------
    # Kill adjudication (frozen order: construction gate, then K3, K1; K2 guard).
    # -----------------------------------------------------------------------
    print("-" * 78)
    print("kill adjudication")
    print("-" * 78)
    k1_duty = {}
    if not one_class:
        # K1 duty: exhibit, per failing pair, the reparametrization h that WOULD
        # be needed (solving {h,sigma} = S_target - S_source * (h')^2 for the
        # QCD source S = 0: {h,sigma} = -Delta^2/2 => h = Moebius(e^{+-Delta*sigma})).
        h_req = sp.exp(Delta * sigma)
        S_h = sp.simplify(schwarzian(h_req, sigma))
        needed_ok = sp.simplify(S_h + Dsq2) == 0
        nonaffine = sp.simplify(sp.diff(h_req, sigma, 2)) != 0
        for pair in (("F_QCD", "F_pole"), ("F_QCD", "F_Boltzmann")):
            k1_duty["%s->%s" % pair] = (
                "h(sigma) = Moebius(e^{+-Delta*sigma}), Delta = 6 log(3/2): "
                "{h,sigma} = -Delta^2/2 exactly; NON-affine (h'' != 0) -- the "
                "forbidden exponential clock change, exactly the v578 u = e^{Delta t}")
        check("K1 duty: the reparametrization that WOULD be needed per failing pair "
              "is exhibited -- h = Moebius(e^{+-Delta*sigma}) with {h,sigma} = "
              "-Delta^2/2 (verified symbolically), and it is NON-AFFINE: the pass "
              "would require exactly the freedom the freeze forbids",
              needed_ok and nonaffine)
        check("K1 fired: NO-COMMON-CONNECTION -- with clocks and dictionaries "
              "exactly as frozen, the transported Schwarzians differ symbolically "
              "({-Delta^2/2, -Delta^2/2, 0}); no tolerance involved, the kernel is "
              "exact", True)
    check("K2 guard: executed against the byte-frozen YAML (sha256 %s...); NO "
          "post-freeze deviation of any gauge, dictionary, slope, xi, mu_0, scheme, "
          "window or frame was applied -- K2 does not fire (the exhibited h above "
          "is the deviation a pass WOULD need, i.e. any pass is K2-forbidden)"
          % YAML_SHA256[:12], True)
    check("K3 guard: every channel export is a function of exactly one clock "
          "(structural assertion above) -- K3 does not fire", not k3_fired)

    # -----------------------------------------------------------------------
    # Verdict (frozen enum).
    # -----------------------------------------------------------------------
    if not construction_ok:
        verdict = "CONSTRUCTION-FAIL"
    elif k3_fired:
        verdict = "SECOND-CLOCK-NEEDED"
    elif one_class:
        verdict = "ONE-CLASS"
    else:
        verdict = "NO-COMMON-CONNECTION"
    matches_prior = (verdict == "NO-COMMON-CONNECTION")

    n_fail = sum(1 for c in CHECKS if not c["ok"])
    print("\nVERDICT: %s -- %s the frozen prior (prereg_expected: K1 kill)"
          % (verdict, "MATCHES" if matches_prior else "*** DOES NOT MATCH ***"))
    print("transported Schwarzians on sigma: F_pole = F_Boltzmann = -Delta^2/2 = "
          "%.15f, F_QCD = 0, F_relic degenerate" % float(-Dsq2))
    print("checks: %d, failures: %d" % (len(CHECKS), n_fail))
    print("elapsed: %.1f s" % (time.time() - T_START))

    out = {
        "contract": "FTRANSFER.CLOCKS.01",
        "executed": time.strftime("%Y-%m-%d %H:%M:%S"),
        "execution_surface": "experiments-only (typed [X]; no vN module, no marker move)",
        "prereg_yaml_sha256": yaml_hash,
        "data_tables": frozen_data_hashes,
        "transported_schwarzians_sigma": {
            "F_pole": str(S_sigma["F_pole"]),
            "F_Boltzmann": str(S_sigma["F_Boltzmann"]),
            "F_QCD": str(S_sigma["F_QCD"]),
            "F_relic": "degenerate",
            "numeric_seam": -float(Dsq2), "numeric_qcd": 0.0,
        },
        "ftc01": {
            "K": {"pass": ftc01k, "q_exp": q_exp, "abs_dev": abs(q_exp - 2),
                  "bar_3sigma_q": 3 * sigma_q, "Q_run": Q_run, "scheme_ratio": ratio},
            "B": {"pass": ftc01b, "M1_GeV": M1, "window_GeV": T_win,
                  "gstar_s": [gs_lo, gs_hi], "chart_drift": drift_B,
                  "neff_pull_sigma": neff_pull},
            "Q": {"pass": ftc01q, "alpha_mt_1loop": a_mt_1l, "max_rel_dev": max_dev,
                  "at_Q_GeV": Qm, "bar": 0.10},
            "R": {"pass": ftc01r, "T_osc_GeV": T_osc, "m_a_ueV": m_a_GeV * 1e15,
                  "max_slope_dev": worst, "bar": 0.15,
                  "info_worst_anywhere": {"dev": worst_any, "T_GeV": at_T}},
        },
        "one_class": one_class,
        "kills": {"K1_fired": (not one_class) and construction_ok and not k3_fired,
                  "K2_fired": False, "K3_fired": k3_fired,
                  "K1_duty_reparametrizations": k1_duty},
        "verdict": verdict,
        "matches_frozen_prior": matches_prior,
        "checks_total": len(CHECKS), "checks_failed": n_fail,
        "checks": CHECKS,
    }
    _ = out   # promoted module: adjudication only -- the experiments-
    # side executor remains the writer of record for the results JSON
    print("(promoted module: results JSON not rewritten; writer of "
          "record = experiments/ftransfer-clocks/run_clocks_executor.py)")
    return 1 if n_fail else 0


_run_part1 = main


def _run_part2():
    # PART 2 -- ftransfer_projective_groupoid_probe.py (verbatim; module-
    # level names local to this function scope; HERE re-pointed, JSON
    # write dropped as declared)
    # (the probe's `from __future__ import annotations` is subsumed by the
    # module-level import above -- a __future__ import is illegal inside a
    # function body)
    import hashlib
    import json
    import math
    import os
    import time

    import sympy as sp

    T_START = time.time()
    HERE = os.path.abspath(os.path.join(os.path.dirname(
        os.path.abspath(__file__)), "..", "experiments", "ftransfer-clocks"))

    YAML_PATH = os.path.join(HERE, "hypotheses", "ftransfer_clocks_v1.yaml")
    YAML_SHA256 = "880224f76380c77dce2c1e3d7651bccc9e1619e74c60b7e15326ee0ee2bbf4d0"
    GSTAR_CSV = os.path.join(HERE, "data", "gstar_saikawa_shirai_2018.csv")
    GSTAR_SHA256 = "8ae2a4fec098fd68d3a469fbf2b7806ee1630f5595498a3e6cf2abca2d79b939"
    ALPHAS_CSV = os.path.join(HERE, "data", "alphas_pdg2024_running.csv")
    ALPHAS_SHA256 = "2ca6332dd1ee0caa089f64be58e90a8c916c94bbe612125eca41da50c33a2ac2"

    # Corpus anchors (identical to the executed contract; affine offsets only).
    PHI0 = 0.053171952176845526
    V_EW, M3_EV, MBAR = 174.0, 0.05, 2.435323e18
    M_Z, M_T, M_TAU = 91.1880, 172.57, 1.77693      # GeV
    DIM_SPLUS = 16

    CHECKS = []


    def check(name, ok, detail=""):
        CHECKS.append({"name": name, "ok": bool(ok), "detail": detail})
        print("[%s] %s%s" % ("PASS" if ok else "FAIL", name, (": " + detail) if detail else ""))
        return bool(ok)


    def sha256_file(path):
        h = hashlib.sha256()
        with open(path, "rb") as f:
            for chunk in iter(lambda: f.read(65536), b""):
                h.update(chunk)
        return h.hexdigest()


    def schwarzian(y, x):
        y1, y2, y3 = sp.diff(y, x), sp.diff(y, x, 2), sp.diff(y, x, 3)
        return y3 / y1 - sp.Rational(3, 2) * (y2 / y1) ** 2


    def cross_ratio(a, b, c, d):
        return ((a - c) * (b - d)) / ((b - c) * (a - d))


    def read_csv(path):
        rows = []
        with open(path) as f:
            for line in f:
                line = line.strip()
                if line and not line.startswith("#"):
                    rows.append([float(v) for v in line.split(",")])
        return rows


    def loglog_interp(table, x, yi):
        lx = math.log(x)
        lo, hi = 0, len(table) - 1
        while hi - lo > 1:
            mid = (lo + hi) // 2
            if table[mid][0] <= x:
                lo = mid
            else:
                hi = mid
        x0, x1 = math.log(table[lo][0]), math.log(table[hi][0])
        y0, y1 = math.log(table[lo][yi]), math.log(table[hi][yi])
        return math.exp(y0 + (y1 - y0) * (lx - x0) / (x1 - x0))


    def main() -> int:
        print("=" * 78)
        print("F_TRANSFER PROJECTIVE GROUPOID -- the fibered-functor probe (post-K1)")
        print("=" * 78)

        # -- freeze guards ------------------------------------------------------
        ok_y = check("G0 prereg YAML byte-freeze reused", sha256_file(YAML_PATH) == YAML_SHA256)
        ok_g = check("G0 frozen g_*s table hash matches executed contract",
                     sha256_file(GSTAR_CSV) == GSTAR_SHA256)
        ok_a = check("G0 frozen alpha_s table hash matches executed contract",
                     sha256_file(ALPHAS_CSV) == ALPHAS_SHA256)
        if not (ok_y and ok_g and ok_a):
            print("\nVERDICT: ABORT -- freeze guard failed")
            return 1

        # -- frozen kernel ------------------------------------------------------
        Delta = 6 * sp.log(sp.Rational(3, 2))
        Dsq2 = Delta**2 / 2
        sigma = sp.symbols("sigma", real=True)
        x1, x2, t, la, n = sp.symbols("x1 x2 t la n", real=True)
        C1, cg, k1, k2, k4, B1, a0, th_i = sp.symbols(
            "C1 c_g k1 k2 k4 B1 alpha0 theta_i", positive=True)

        q_pole = (5 - 2 * C1 * sp.exp(Delta * (x1 + cg))) / (1 - C1 * sp.exp(Delta * (x1 + cg)))
        y_boltz = B1 * sp.exp(-Delta * x2)
        y_qcd = a0 / (1 + 7 * a0 * t / (2 * sp.pi))
        exports = {"F_pole": (q_pole, x1), "F_Boltzmann": (y_boltz, x2), "F_QCD": (y_qcd, t)}
        dicts = {"F_pole": (x1, -sigma + k1, -1), "F_Boltzmann": (x2, -sigma + k2, -1),
                 "F_QCD": (t, sigma, +1), "F_relic": (la, -sigma + k4, -1)}
        # inverse dictionaries sigma(clock) for pushing anchor ticks forward:
        inv_dicts = {"F_pole": (k1 - x1).subs(x1, n), "F_Boltzmann": (k2 - x2).subs(x2, n),
                     "F_QCD": n, "F_relic": (k4 - la).subs(la, n)}

        # =======================================================================
        # G1 -- the shared discrete layer.
        # =======================================================================
        print("-" * 78)
        print("G1 the shared discrete layer (make-or-break)")
        print("-" * 78)
        base_sym = {"F_pole": sp.symbols("b1", real=True), "F_Boltzmann": sp.symbols("b2", real=True),
                    "F_QCD": sp.symbols("b3", real=True), "F_relic": sp.symbols("b4", real=True)}
        cr_sym, deck_sym = {}, {}
        for name in ("F_pole", "F_Boltzmann", "F_QCD", "F_relic"):
            b = base_sym[name]
            imgs = [inv_dicts[name].subs(n, b + j) for j in range(4)]     # ticks {0,1,2,3}
            cr = sp.simplify(cross_ratio(*imgs))
            cr_sym[name] = cr
            deck_sym[name] = sp.simplify(imgs[1] - imgs[0])               # one e-fold in sigma
        g1a = all(sp.simplify(cr_sym[nm] - sp.Rational(4, 3)) == 0 for nm in cr_sym)
        check("G1a cross-ratio (symbolic): CR(dictionary images of ticks {0,1,2,3}) "
              "= 4/3 EXACTLY for ALL FOUR channels (offsets k_i and base points drop "
              "out symbolically)", g1a,
              "CR = %s" % {nm: str(cr_sym[nm]) for nm in cr_sym})

        # data legs
        gstar = read_csv(GSTAR_CSV)
        sig_star = math.log(M_TAU / M_Z)
        M1 = (V_EW**2 / (M3_EV * 1e-9)) * PHI0**4
        cr_data = {}
        cr_data["F_pole"] = cross_ratio(*[-(-sig_star + j) for j in range(4)])
        cr_data["F_Boltzmann"] = cross_ratio(*[-(math.log(M_Z / M1) + j) for j in range(4)])
        cr_data["F_QCD"] = cross_ratio(*[math.log(M_T / M_Z) + j * math.log(1000.0 / M_T) / 3.0
                                         for j in range(4)])
        # relic through the frozen table: invert ln a(T), 4 points across the window
        m_a_GeV = 5.70 * (1e12 / ((1.0 / (8 * math.pi)) ** 3.5 * MBAR / 128.0)) * 1e-15
        lo_T, hi_T = 1.0, 1e4
        for _ in range(200):
            mid = math.sqrt(lo_T * hi_T)
            g_rho = loglog_interp(gstar, mid, 1)
            if 3.0 * math.sqrt(math.pi**2 * g_rho / 90.0) * mid * mid / MBAR < m_a_GeV:
                lo_T = mid
            else:
                hi_T = mid
        T_osc = math.sqrt(lo_T * hi_T)
        gs0 = gstar[0][3]

        def ln_a_of_T(T):
            return -math.log(T) - (1.0 / 3.0) * math.log(loglog_interp(gstar, T, 3) / gs0)

        def T_of_ln_a(lna):
            tl, th = 1e-2, 1e6
            for _ in range(200):
                tm = math.sqrt(tl * th)
                if ln_a_of_T(tm) > lna:      # ln a decreases with T
                    tl = tm
                else:
                    th = tm
            return math.sqrt(tl * th)

        lna_osc = ln_a_of_T(T_osc)
        lnas = [lna_osc - 0.5 + j / 3.0 for j in range(4)]
        sig_relic = [math.log(T_of_ln_a(v) / M_Z) for v in lnas]
        cr_data["F_relic"] = cross_ratio(*sig_relic)
        relic_slope = abs((sig_relic[-1] - sig_relic[0]) / (lnas[-1] - lnas[0]))
        g1b = (all(abs(cr_data[nm] - 4.0 / 3.0) <= 1e-9
                   for nm in ("F_pole", "F_Boltzmann", "F_QCD"))
               and abs(cr_data["F_relic"] - 4.0 / 3.0) <= 0.15)
        check("G1b cross-ratio (data): pole %.12f / Boltzmann %.12f / QCD %.12f "
              "(bar 1e-9) and relic THROUGH the frozen g_*s table %.6f, |dev| = %.2e "
              "<= 0.15 (frozen bar; window ln a in [onset-0.5, onset+0.5], "
              "T_osc = %.2f GeV)"
              % (cr_data["F_pole"], cr_data["F_Boltzmann"], cr_data["F_QCD"],
                 cr_data["F_relic"], abs(cr_data["F_relic"] - 4.0 / 3.0), T_osc), g1b)

        g1c = (all(sp.simplify(sp.Abs(deck_sym[nm]) - 1) == 0
                   for nm in ("F_pole", "F_Boltzmann", "F_QCD", "F_relic"))
               and 0.85 <= relic_slope <= 1.15)
        check("G1c deck unit: one clock e-fold -> |Delta sigma| = 1 EXACTLY for all "
              "four affine dictionaries (symbolic: %s); relic measured mean slope "
              "%.4f in [0.85, 1.15] (frozen window)"
              % ({nm: str(deck_sym[nm]) for nm in deck_sym}, relic_slope), g1c)

        orientations = {nm: dicts[nm][2] for nm in dicts}
        deck_cls, target_ok = {}, True
        for nm, s in orientations.items():
            M = sp.Matrix([[1, s], [0, 1]])                # unit translation in sigma
            deck_cls[nm] = sp.simplify(sp.trace(M) ** 2 - 4 * M.det())
        g1d = (all(v == 0 for v in deck_cls.values())
               and sp.simplify(sp.Matrix([[1, 1], [0, 1]]).inv()
                               - sp.Matrix([[1, -1], [0, 1]])) == sp.zeros(2)
               and target_ok)
        check("G1d deck class + objects: the pushed deck generator is the unit "
              "translation [[1,+-1],[0,1]], tr^2 - 4 det = 0 EXACTLY (parabolic -- "
              "the v632 'one common parabolic action on the discrete half'); all four "
              "dictionaries target the ONE sigma-line; orientations (%+d,%+d,%+d,%+d) "
              "identified under inverse-conjugation (translation ~ its inverse in PGL2)"
              % (orientations["F_pole"], orientations["F_Boltzmann"],
                 orientations["F_QCD"], orientations["F_relic"]), g1d)
        g1 = g1a and g1b and g1c and g1d

        # =======================================================================
        # G2 -- the obstruction cocycle.
        # =======================================================================
        print("-" * 78)
        print("G2 the obstruction cocycle (relic EXCLUDED by frozen convention)")
        print("-" * 78)
        S = {}
        S_expr = {}
        for name, (y, x) in exports.items():
            expr = schwarzian(y.subs(x, dicts[name][1]), sigma)
            S_expr[name] = expr
            S[name] = sp.simplify(expr)
        names3 = ["F_pole", "F_Boltzmann", "F_QCD"]
        omega = {(i, j): sp.simplify(S[i] - S[j]) for i in names3 for j in names3}
        g2a = all(sp.simplify(omega[(i, j)] + omega[(j, i)]) == 0
                  for i in names3 for j in names3)
        check("G2a antisymmetry: omega_ij = -omega_ji EXACT on all 9 pairs", g2a)

        coc = all(sp.simplify(omega[(i, j)] + omega[(j, k)] - omega[(i, k)]) == 0
                  for i in names3 for j in names3 for k in names3)
        dconst = all(sp.simplify(sp.diff(S_expr[nm], sigma)) == 0 for nm in names3)
        # numeric spot checks: 5 sigma points per frozen channel window
        spots = {"F_pole": [sig_star + 3.0 * j / 4 for j in range(5)],
                 "F_Boltzmann": [math.log(M_Z / M1) + math.log(10.0) * j / 4 for j in range(5)],
                 "F_QCD": [math.log(M_T / M_Z)
                           + math.log(1000.0 / M_T) * j / 4 for j in range(5)]}
        subs_num = {C1: sp.Rational(37, 100), cg: sp.Rational(21, 100),
                    k1: sp.Rational(13, 10), k2: sp.Rational(-7, 10),
                    B1: sp.Rational(21, 10), a0: sp.Rational(118, 1000)}
        # Spot evaluation at 50 digits (sympy evalf) -- the frozen kernel method
        # ('all kernel steps symbolic/sympy exact; floats only at the data
        # interfaces'; this is a kernel-side check).  FIRST-RUN RECORD (2026-08-05,
        # radical honesty): the initial implementation evaluated these spots with
        # float64 lambdify, VIOLATING the frozen method, and showed max dev 3.0e-9
        # (double-precision cancellation in the Moebius-of-exponential expressions
        # at sigma ~ -18); the frozen bar 1e-12 is UNCHANGED, only the arithmetic
        # was conformed to the frozen method.
        max_spot = 0.0
        for nm in names3:
            diff_expr = (S_expr[nm] - S[nm]).subs(subs_num)
            for sv in spots[nm]:
                dev = abs(sp.N(diff_expr.subs(sigma, sp.Float(sv, 50)), 50))
                max_spot = max(max_spot, float(dev))
        g2b = coc and dconst and max_spot <= 1e-12
        check("G2b cocycle identity EXACT (27 triples) + CONSTANT cocycle: "
              "d/dsigma of every transported Schwarzian vanishes IDENTICALLY "
              "(symbolic) and 15 numeric spot checks (sympy evalf, 50 digits, the "
              "frozen kernel method) across the frozen windows deviate <= %.1e "
              "from the channel constants (bar 1e-12) -- the obstruction is a "
              "constant cocycle, not a running function" % max_spot, g2b)

        vals = {"omega(pole,B)": omega[("F_pole", "F_Boltzmann")],
                "omega(pole,QCD)": omega[("F_pole", "F_QCD")],
                "omega(B,QCD)": omega[("F_Boltzmann", "F_QCD")]}
        g2c = (sp.simplify(vals["omega(pole,B)"]) == 0
               and sp.simplify(vals["omega(pole,QCD)"] + Dsq2) == 0
               and sp.simplify(vals["omega(B,QCD)"] + Dsq2) == 0)
        check("G2c values: omega(pole,B) = 0, omega(pole,QCD) = omega(B,QCD) = "
              "-Delta^2/2 = -18 log^2(3/2) = %.15f -- the cocycle takes values "
              "EXACTLY in {0, +-Delta^2/2}, closed form" % float(-Dsq2), g2c)
        g2 = g2a and g2b and g2c

        # =======================================================================
        # G3 -- the classification against the predeclared marker.
        # =======================================================================
        print("-" * 78)
        print("G3 classification (marker predeclared in the docstring)")
        print("-" * 78)
        coset = {nm: ("seam" if sp.simplify(S[nm] + Dsq2) == 0
                      else ("rg" if sp.simplify(S[nm]) == 0 else "OTHER")) for nm in names3}
        g3 = (coset["F_pole"] == "seam" and coset["F_Boltzmann"] == "seam"
              and coset["F_QCD"] == "rg")
        check("G3 the two-coset split matches the predeclared marker: thermal/"
              "proper-time clocks {tau, beta} -> coset -Delta^2/2 (%s, %s), RG clock "
              "{log mu} -> coset 0 (%s); relic {log a} degenerate, NOT classified "
              "(predeclared honesty); torsor difference between cosets = Delta^2/2 "
              "= %.15f exactly"
              % (coset["F_pole"], coset["F_Boltzmann"], coset["F_QCD"], float(Dsq2)), g3)

        # =======================================================================
        # G4 -- controls (must fire).
        # =======================================================================
        print("-" * 78)
        print("G4 controls (all three must fire)")
        print("-" * 78)
        # G4a wrong slope 2 on the Koide channel
        S_wrong = sp.simplify(schwarzian(q_pole.subs(x1, -2 * sigma + k1), sigma))
        deck_wrong = sp.simplify((k1 - (-2 * sigma + k1)).subs(sigma, 1))   # image of 1 e-fold
        in_set = any(sp.simplify(S_wrong - v) == 0 for v in (sp.S.Zero, Dsq2, -Dsq2))
        g4a = (sp.simplify(S_wrong + 4 * Dsq2) == 0) and (deck_wrong != 1) and not in_set
        check("G4a wrong-slope control FIRES: slope 2 breaks the deck unit "
              "(|Delta sigma| = 2 != 1) AND scales the Schwarzian by slope^2 = 4 "
              "onto -2 Delta^2 = %.6f -- OUTSIDE the frozen value set {0, +-Delta^2/2}"
              % float(-4 * Dsq2), g4a)
        # G4b scrambled anchors (frozen scramble: swap last two pole anchors)
        b = base_sym["F_pole"]
        imgs = [inv_dicts["F_pole"].subs(n, b + j) for j in (0, 1, 3, 2)]
        cr_scr = sp.simplify(cross_ratio(*imgs))
        g4b = sp.simplify(cr_scr - sp.Rational(3, 4)) == 0 and cr_scr != sp.Rational(4, 3)
        check("G4b scrambled-anchor control FIRES: swapping the last two F_pole "
              "anchors gives CR = %s != 4/3 -- the cross-ratio gate detects anchor "
              "misalignment" % cr_scr, g4b)
        # G4c v578 Moebius clock transplanted to QCD
        S_moeb = sp.simplify(schwarzian(y_qcd.subs(t, sp.exp(Delta * sigma)), sigma))
        g4c = sp.simplify(S_moeb + Dsq2) == 0
        check("G4c Moebius-transplant control FIRES: t = e^{Delta sigma} moves the "
              "QCD Schwarzian from 0 onto -Delta^2/2 EXACTLY -- the obstruction "
              "cocycle is exactly the forbidden non-affine freedom (K1 duty "
              "transplanted)", g4c)
        g4 = g4a and g4b and g4c

        # =======================================================================
        # Verdict (frozen enum).
        # =======================================================================
        if not g1:
            verdict = "FTRANSFER-FIBERED-DEAD"
        elif g2 and g3 and g4:
            verdict = "FTRANSFER-FIBERED-CARRIES"
        else:
            verdict = "FTRANSFER-FIBERED-PARTIAL"
        failed_gates = [g for g, ok in
                        (("G1", g1), ("G2", g2), ("G3", g3), ("G4", g4)) if not ok]

        n_fail = sum(1 for c in CHECKS if not c["ok"])
        print("\nVERDICT: %s%s" % (verdict,
              "" if not failed_gates else " -- failed gates: %s" % failed_gates))
        print("base: ONE discrete parabolic deck action (unit sigma-translation, "
              "CR = 4/3); fibers: projective connections with the constant seam "
              "cocycle omega in {0, +-Delta^2/2}; classes: {tau, beta} | {log mu} | "
              "relic degenerate")
        print("checks: %d, failures: %d" % (len(CHECKS), n_fail))
        print("elapsed: %.1f s" % (time.time() - T_START))

        out = {
            "probe": "ftransfer_projective_groupoid",
            "executed": time.strftime("%Y-%m-%d %H:%M:%S"),
            "freeze": {"yaml": YAML_SHA256, "gstar": GSTAR_SHA256, "alphas": ALPHAS_SHA256},
            "discrete_layer": {
                "cross_ratio_symbolic": {nm: str(cr_sym[nm]) for nm in cr_sym},
                "cross_ratio_data": cr_data,
                "relic_mean_slope": relic_slope,
                "deck_unit": {nm: str(deck_sym[nm]) for nm in deck_sym},
                "deck_class": "parabolic unit translation (tr^2 = 4 det exact)",
                "orientations": orientations,
                "T_osc_GeV": T_osc,
            },
            "cocycle": {
                "convention": "relic excluded (degenerate; identity morphism only)",
                "values": {kk: str(sp.simplify(vv)) for kk, vv in vals.items()},
                "numeric": {"omega(pole,B)": 0.0,
                            "omega(pole,QCD)": float(-Dsq2), "omega(B,QCD)": float(-Dsq2)},
                "constant_cocycle_max_spot_dev": max_spot,
            },
            "classification": {"cosets": coset, "relic": "degenerate, not classified",
                               "torsor_difference": float(Dsq2)},
            "controls": {"G4a": g4a, "G4b": g4b, "G4c": g4c},
            "verdict": verdict,
            "checks_total": len(CHECKS), "checks_failed": n_fail,
            "checks": CHECKS,
        }
        _ = out   # promoted module: adjudication only -- the experiments-
        # side probe remains the writer of record for the results JSON
        print("(promoted module: results JSON not rewritten; writer of "
              "record = ftransfer_projective_groupoid_probe.py)")
        return 1 if n_fail else 0
    return main(), list(CHECKS)


def run():
    """run_all entry point (combined adjudication, frozen): part 1 must
    reproduce the preregistered K1-kill pattern (24 checks green incl.
    'K1 fired', verdict NO-COMMON-CONNECTION == the frozen prior); part 2
    must reproduce FTRANSFER-FIBERED-CARRIES (14 checks green)."""
    rc1 = _run_part1()
    fails1 = [c["name"] for c in CHECKS if not c["ok"]]
    k1 = any(c["name"].startswith("K1 fired") for c in CHECKS)
    part1_ok = (rc1 == 0 and not fails1 and len(CHECKS) == 24 and k1)
    print("\n[%s] PART-1 PATTERN GATE: expected 24 green checks with the "
          "K1 kill fired (NO-COMMON-CONNECTION, matches the frozen prior) "
          "-- fails: %s" % ("PASS" if part1_ok else "FAIL",
                            fails1 or "none"))
    rc2, chks2 = _run_part2()
    fails2 = [c["name"] for c in chks2 if not c["ok"]]
    part2_ok = (rc2 == 0 and not fails2 and len(chks2) == 14)
    print("\n[%s] PART-2 PATTERN GATE: expected 14 green checks "
          "(FTRANSFER-FIBERED-CARRIES) -- fails: %s"
          % ("PASS" if part2_ok else "FAIL", fails2 or "none"))
    ok = part1_ok and part2_ok
    print("\nCOMBINED ADJUDICATION: %s -- NO-COMMON-CONNECTION + "
          "FTRANSFER-FIBERED-CARRIES: the frozen external-clock contract "
          "dies on the exact K1 kill ({-Delta^2/2, -Delta^2/2, 0}, no "
          "tolerance), and the surviving architecture is the fibered "
          "functor -- ONE discrete parabolic deck action (CR = 4/3, unit "
          "sigma-translation) with the constant seam obstruction cocycle "
          "omega in {0, +-Delta^2/2}; classes {tau, beta} | {log mu} | "
          "relic degenerate.  The jet route of CONTRACT.F.01 is closed at "
          "the physical-clock level; next named step: derive the coset "
          "assignment from KMS/modular clock typing.  NO RH claim."
          % ("PASS" if ok else "FAIL"))
    return 0 if ok else 1


if __name__ == "__main__":
    raise SystemExit(run())

af2e26cb676946b868807b5ba1dbbf367ae1805c3c8ca5177f4d52d81da80dde

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.