Follow the source behind the result.

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

"""v471 -- The Seam-Horizon replica chain exercised NUMERICALLY on a
discretized seam collar: the kernel-identification premise of SEAM.THEOREM.01
(the residual isolated by v150/v151/v152) is discharged AT THE FINITE/MODEL
LEVEL for the seam's own kernel, with real replica sheets.  [I] numerical
determinant computations against exact conical constants; the gate does NOT
close -- the residual retypes to the continuum leg (the same MMST class as
SEAM.EQUIV.01, v336) plus the standing v152 anchor.

After v150 (replica of a gapped determinant = EH form, symbolic), v151 (BFK:
the Calderon kernel is conically clean, symbolic corner constants) and v152
(the normalisation is the anchor), the single residual of SEAM.THEOREM.01 was
the KERNEL-IDENTIFICATION premise: "the RP seam kernel IS this BFK Calderon
datum".  This module exercises that premise on a CONCRETE discretized cone
operator (finite-volume polar grid, geometric tip grading, fixed angular
stencil across geometries so all extensive terms cancel exactly in the
matched deficit G(gamma,m) = log det L(gamma,m) - (gamma/2pi) log det
L(2pi,m)):

  [I] 1. REPLICA => EH FORM ON A REAL OPERATOR.  d G / d ln m = 2 C(gamma),
        C(gamma) = (1/12)(2pi/gamma - gamma/2pi), verified on deficit cones
        gamma/2pi = 1/4, 1/2, 3/4 (rel. err 0.01-0.05%) AND on REAL REPLICA
        SHEETS gamma/2pi = 2 (0.8%), 3 (1.5%) -- beyond the linearised
        deficit, the regime the replica trick actually uses.
  [I] 2. COEFFICIENT FORCED, SCALE = ANCHOR (v152 exhibited on data).  The
        EH slope is stable under IR/size refinement (~0.5% drift); the
        intercept (the zeta-scale mu_lat) is lattice data and drifts.  NO
        canonical ln(m/mu) = 3/4 emerges -- recorded honestly; the anchor
        stays a declared anchor, exactly as v152 types it.
  [I] 3. BFK SPLIT FOR THE DISCRETIZED CALDERON KERNEL.  Cutting the cone
        through the tip: log det L = log det(halves_D) + log det S exactly
        (Schur, ~1e-16), and across three angles the Calderon/Schur factor's
        deficit slope follows a PURE CUT-EDGE law E(1-gamma/2pi) with tip
        term T = 0 (power check: the same law FAILS on the full
        determinant), while the halves carry the whole tip term 2 C_cone via
        the Kac doubling C_cone(gamma) = 2 C_D(gamma/2) (exact).  This is
        v151's statement measured on the kernel itself.
  [I] 4. THE SEAM'S OWN SPECTRUM.  The collar transfer has spec(T) =
        {1, (2/3)^6, (1/3)^6} (v302); the two gapped one-particle masses
        m2 = 6 ln(3/2), m3 = 6 ln 3 (bend m3/m2 = ln3/ln(3/2), v124/v147)
        sit ON the calibrated EH line (<=0.05%), i.e. det'(collar) inherits
        the EH variation mode-wise; and the PERRON/ATTRACTOR mode (m = 0) is
        demonstrably IR-DIVERGENT (its conical term runs exactly as
        -2C ln(IR ratio)) -- the recovery gap Delta = 6 ln(3/2) is what makes
        the induced-gravity coefficient finite.  The same gap that makes the
        attractor unique (v56) makes Newton's constant finite.
  [P] 5. HONEST SCOPE.  Finite/discretized level only.  SEAM.THEOREM.01
        stays open [A/O]: the remaining residual is the CONTINUUM scaling
        limit of this very statement (the MMST class -- the single residual
        of SEAM.EQUIV.01, v336) plus the one dimensionful anchor (v152).
        NOT claimed: a continuum proof, or a derivation of ln(m/mu) = 3/4.

Numerical (sparse lattice determinants, numpy/scipy), Python-only by nature;
the exact ingredients (C(gamma), Kac doubling, S = A/4 <=> c3 = 1/(8pi)) are
sympy-verified inline.
"""
import numpy as np
import sympy as sp
from scipy.sparse import coo_matrix
from scipy.sparse.linalg import splu

from tfpt_constants import check, summary, reset, N_fam

# ---------------------------------------------------------------------------
# geometry / constants (identical to the exploration contract, 2026-07-02)
# ---------------------------------------------------------------------------
N0 = 64                                  # angular sites per 2*pi
H_THETA = 2.0 * np.pi / N0
LN3 = float(np.log(3.0))
LN32 = float(np.log(1.5))
SEAM_MASSES = (6.0 * LN32, 6.0 * LN3)    # gapped one-particle masses of spec(T)
BEND = LN3 / LN32
K_DEFICIT = [16, 32, 48]                 # gamma/2pi = 1/4, 1/2, 3/4
K_REPLICA = [128, 192]                   # gamma/2pi = 2, 3 (real replica sheets)
K_REF = N0
K_BFK = [32, 48, 128]
M_GRID = np.array([0.020, 0.028, 0.040, 0.057, 0.080])
M_BFK = M_GRID[1:4]
N_R_MAIN = 240
N_R_ALT = 160
EPS_SEAM = 0.012                         # seam masses in lattice units (anchor)


def c_cone(gamma: float) -> float:
    return (2.0 * np.pi / gamma - gamma / (2.0 * np.pi)) / 12.0


def c_dir(theta: float) -> float:
    return (np.pi ** 2 - theta ** 2) / (24.0 * np.pi * theta)


def radial_mesh(n_r: int):
    """Geometrically tip-graded cell edges/centers/widths, identical for all k."""
    fine = 2.0 * 0.5 ** np.arange(7, -1, -1.0)
    coarse = np.arange(3.0, float(n_r) + 1e-12, 1.0)
    edges = np.concatenate([[0.0], fine, coarse])
    centers = 0.5 * (edges[:-1] + edges[1:])
    widths = np.diff(edges)
    return edges, centers, widths


def build_cone(k: int, n_r: int, m: float):
    """Finite-volume form matrix of (-Delta + m^2) on the cone gamma = 2pi k/N0."""
    edges, r, w = radial_mesh(n_r)
    n_ring = len(r)
    n = n_ring * k
    diag = np.zeros(n)
    rows_l, cols_l, vals_l = [], [], []

    def add_edge(s, t, c):
        rows_l.extend((s, t))
        cols_l.extend((t, s))
        vals_l.extend((-c, -c))
        np.add.at(diag, s, c)
        np.add.at(diag, t, c)

    i_idx = np.repeat(np.arange(n_ring), k)
    j_idx = np.tile(np.arange(k), n_ring)
    s_idx = i_idx * k + j_idx

    t_ang = i_idx * k + (j_idx + 1) % k
    add_edge(s_idx, t_ang, w[i_idx] / (r[i_idx] * H_THETA))

    mask = i_idx < n_ring - 1
    inner = s_idx[mask]
    ii = i_idx[mask]
    add_edge(inner, inner + k, edges[ii + 1] * H_THETA / (r[ii + 1] - r[ii]))

    last = s_idx[i_idx == n_ring - 1]
    np.add.at(diag, last, edges[-1] * H_THETA / (edges[-1] - r[-1]))
    diag += (m * m) * r[i_idx] * w[i_idx] * H_THETA

    rows = np.concatenate([np.concatenate(rows_l), np.arange(n)])
    cols = np.concatenate([np.concatenate(cols_l), np.arange(n)])
    vals = np.concatenate([np.concatenate(vals_l), diag])
    return coo_matrix((vals, (rows, cols)), shape=(n, n)).tocsc()


def logdet(L) -> float:
    return float(np.sum(np.log(np.abs(splu(L).U.diagonal()))))


_LD: dict = {}


def logdet_cone(k: int, n_r: int, m: float) -> float:
    key = (k, n_r, float(m))
    if key not in _LD:
        _LD[key] = logdet(build_cone(k, n_r, m))
    return _LD[key]


def deficit(k: int, n_r: int, m: float) -> float:
    return logdet_cone(k, n_r, m) - (k / N0) * logdet_cone(K_REF, n_r, m)


def slope_intercept(k: int, n_r: int, masses=M_GRID):
    g = np.array([deficit(k, n_r, m) for m in masses])
    a, b = np.polyfit(np.log(masses), g, 1)
    return float(a), float(b)


def bfk_parts(k: int, n_r: int, m: float):
    """(logdet_full, logdet_halves_D, logdet_Schur), cut through the tip."""
    L = build_cone(k, n_r, m)
    n = L.shape[0]
    j_all = np.arange(n) % k
    gam = np.where((j_all == 0) | (j_all == k // 2))[0]
    h1 = np.where((j_all > 0) & (j_all < k // 2))[0]
    h2 = np.where(j_all > k // 2)[0]
    interior = np.concatenate([h1, h2])
    ld_full = logdet_cone(k, n_r, m)
    ld_halves = logdet(L[np.ix_(h1, h1)].tocsc()) + logdet(L[np.ix_(h2, h2)].tocsc())
    L_ii = L[np.ix_(interior, interior)].tocsc()
    L_ig = L[np.ix_(interior, gam)].toarray()
    S = L[np.ix_(gam, gam)].toarray() - L_ig.T @ splu(L_ii).solve(L_ig)
    sign, ld_s = np.linalg.slogdet(S)
    return ld_full, ld_halves, float(ld_s), float(sign)


def bfk_deficit_slopes(k: int, n_r: int, masses):
    q = k / N0
    G = {"full": [], "halves": [], "schur": []}
    ident = 0.0
    for m in masses:
        f, h, s, sg = bfk_parts(k, n_r, m)
        fr, hr, sr, _ = bfk_parts(K_REF, n_r, m)
        ident = max(ident, abs(f - (h + s)) / abs(f), abs(fr - (hr + sr)) / abs(fr))
        G["full"].append(f - q * fr)
        G["halves"].append(h - q * hr)
        G["schur"].append(s - q * sr)
    ln_m = np.log(np.asarray(masses))
    out = {n_: float(np.polyfit(ln_m, np.array(v), 1)[0]) for n_, v in G.items()}
    out["identity_residual"] = float(ident)
    return out


def run():
    reset()
    print("v471 Seam-Horizon replica chain on the discretized collar "
          "(kernel premise at model level)")

    # (1) replica => EH form, deficit AND replica sheets
    slopes = {}
    for k in K_DEFICIT + K_REPLICA:
        gamma = 2.0 * np.pi * k / N0
        a, b = slope_intercept(k, N_R_MAIN)
        pred = 2.0 * c_cone(gamma)
        slopes[k] = (a, b)
        check(f"REPLICA => EH FORM (gamma/2pi = {k/N0:g}): d G/d ln m = "
              f"2 C(gamma) on the discretized cone operator",
              a, pred, tol=0.05)

    # (2) coefficient cutoff-independent; intercept = the anchor
    kx = 32
    a_main, b_main = slopes[kx]
    a_alt, b_alt = slope_intercept(kx, N_R_ALT)
    check("COEFFICIENT CUTOFF-INDEPENDENT: EH slope stable under IR/size "
          "refinement (n_r 240 vs 160, drift < 2%)",
          abs(a_alt - a_main) / abs(a_main) < 0.02)
    mu_main = float(np.exp(-b_main / a_main))
    mu_alt = float(np.exp(-b_alt / a_alt))
    check("NORMALISATION = THE ANCHOR (v152, exhibited): the implied "
          "zeta-scale mu_lat drifts with the discretization "
          f"(mu 240: {mu_main:.1f}, 160: {mu_alt:.1f}); NO canonical "
          "ln(m/mu) = 3/4 emerges -- the anchor stays declared, not derived",
          abs(mu_main - mu_alt) > 1.0 and mu_main > 10.0)

    # (3) BFK split for the discretized Calderon kernel
    bfk = {k: bfk_deficit_slopes(k, N_R_ALT, M_BFK) for k in K_BFK}
    check("SCHUR/BFK IDENTITY EXACT: log det L = log det(halves_D) + "
          "log det S to machine precision on all cut geometries",
          max(bfk[k]["identity_residual"] for k in K_BFK) < 1e-8)
    qs = np.array([k / N0 for k in K_BFK])
    s_meas = np.array([bfk[k]["schur"] for k in K_BFK])
    E = float(np.sum(s_meas * (1.0 - qs)) / np.sum((1.0 - qs) ** 2))
    t_max = float(np.max(np.abs(s_meas - E * (1.0 - qs))))
    f_meas = np.array([bfk[k]["full"] for k in K_BFK])
    E_f = float(np.sum(f_meas * (1.0 - qs)) / np.sum((1.0 - qs) ** 2))
    f_resid = float(np.max(np.abs(f_meas - E_f * (1.0 - qs))))
    tip_scale = float(np.max(np.abs(f_meas)))
    check("CALDERON KERNEL CONICALLY CLEAN (v151, measured): the Schur "
          "factor's deficit slope is a pure cut-edge law E(1-q) with tip "
          f"term |T| <= {t_max:.4f} (scale {tip_scale:.3f}); power check: "
          f"the same law on the FULL determinant leaves {f_resid:.3f}",
          t_max < 0.05 * tip_scale and f_resid > 5.0 * t_max)
    halves_ok = True
    for k in K_BFK:
        gamma = 2.0 * np.pi * k / N0
        tip_h = bfk[k]["halves"] + E * (1.0 - k / N0)
        halves_ok &= abs(tip_h - 2.0 * c_cone(gamma)) / abs(2.0 * c_cone(gamma)) < 0.06
    kac = sp.symbols('theta', positive=True)
    kac_id = sp.simplify(
        (4 * sp.pi ** 2 - (2 * kac) ** 2) / (24 * sp.pi * (2 * kac))
        - 2 * (sp.pi ** 2 - kac ** 2) / (24 * sp.pi * kac))
    check("HALVES CARRY THE WHOLE TIP TERM: tip(halves) = 2 C_cone(gamma) "
          "(<6% on all angles); Kac doubling C_cone(gamma) = 2 C_D(gamma/2) "
          "exact (sympy)",
          halves_ok and kac_id == 0)

    # (4) the seam's own spectrum
    m2, m3 = (EPS_SEAM * SEAM_MASSES[0], EPS_SEAM * SEAM_MASSES[1])
    for k in (32, 128):
        g23 = deficit(k, N_R_MAIN, m2) + deficit(k, N_R_MAIN, m3)
        a, b = slopes[k]
        pred = a * (np.log(m2) + np.log(m3)) + 2.0 * b
        check(f"SEAM KERNEL ON THE EH LINE (gamma/2pi = {k/N0:g}): "
              "det'(collar) with the v302 transfer masses m2 = 6 ln(3/2), "
              "m3 = 6 ln 3 matches the calibrated EH prediction",
              g23, pred, tol=0.02)
    check("THE BEND IS THE MASS RATIO: m3/m2 = ln3/ln(3/2) (v124/v147 "
          "walled-clock bend), the only compiler-fixed part of the "
          "normalisation (audit: ln(m3/m2) = 0.99677, NOT 3/4)",
          SEAM_MASSES[1] / SEAM_MASSES[0], BEND, tol=1e-12)
    k = 32
    g0_a = deficit(k, N_R_ALT, 0.0)
    g0_b = deficit(k, N_R_MAIN, 0.0)
    pred_run = -2.0 * c_cone(2.0 * np.pi * k / N0) * np.log(N_R_MAIN / N_R_ALT)
    check("ATTRACTOR MODE IR-DIVERGENT, GAP LOAD-BEARING: the massless "
          "Perron mode's conical term runs exactly as -2C ln(IR ratio); "
          "det' is finite BECAUSE Delta = 6 ln(3/2) > 0 (v302) -- the same "
          "gap that makes the attractor unique makes 1/G finite",
          g0_b - g0_a, pred_run, tol=0.10)

    # (5) capstone arithmetic + honest scope
    c3 = sp.Rational(1, 1) / (8 * sp.pi)
    c_sym = sp.Symbol('c', positive=True)
    sol = sp.solve(sp.Eq(4 * sp.pi * (c_sym / 2), sp.Rational(1, 4)), c_sym)
    check("CAPSTONE (v73/v90): S = 4 pi (c3/2) A = A/4 and c3 = 1/(8pi) is "
          "the UNIQUE solution of 4pi(c/2) = 1/4 (sympy)",
          sp.simplify(4 * sp.pi * (c3 / 2)) == sp.Rational(1, 4)
          and sol == [1 / (8 * sp.pi)])
    check("HONEST SCOPE [P] (recorded): finite/discretized level; "
          "SEAM.THEOREM.01 stays open -- residual retypes to the CONTINUUM "
          "scaling limit (MMST class, = the single residual of "
          "SEAM.EQUIV.01, v336) + the v152 anchor; NOT claimed: a continuum "
          "proof or a derivation of ln(m/mu) = 3/4 = N_fam/4",
          sp.Rational(3, 4) == sp.Rational(N_fam, 4))

    return summary("v471 seam-horizon replica (collar level)")


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

63d231c01c497a519bc93befbd159facbe7ed86137c2b41db0b10ee6ed2b9973

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.