Follow the source behind the result.

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

"""v238 -- the STATIC->DYNAMIC flip: modular flow (reversible) + the recovery
channel read as a Markov/Lindblad generator (irreversible), with the dissipative
gap EQUAL to the OS mass gap.  Companion to v196/v198 (modular) and v221/v64
(recovery): those state the seam structure STATICALLY -- a commutator condition,
a per-step contraction bound, a mass-gap number.  This module reads the SAME
objects DYNAMICALLY and shows the two are one.

The seam already owns (a) a modular Hamiltonian Lambda_Sigma = log Delta_omega on
the H^1 block (v196/v198) and (b) a recovery channel T with spectrum
{1, (2/3)^6, (1/3)^6} (v221).  Treated statically they are a commutator and a
contraction bound.  Treated dynamically:

  * the modular flow sigma_t = e^{i t Lambda_Sigma} is the REVERSIBLE
    (Hamiltonian) one-parameter group (Tomita-Takesaki).  [rho, Lambda_Sigma] = 0
    -- the v198 state-invariance -- IS the conservation of the mu4 charge along
    that flow.  So the STATIC v198 commutator is the conservation law of modular
    time.
  * the recovery generator L = log T is the IRREVERSIBLE (dissipative) generator
    of a continuous doubly-stochastic / CPTP-classical semigroup e^{L tau}, with
    e^{L*1} = T (it reproduces the v221 channel) and a unique stationary state
    (the arrow of time, matching v64's T^n -> rank-1 projector).
  * THE KEYSTONE IDENTITY: the dissipative spectral gap (the slowest relaxation
    rate) = -log((2/3)^6) = 6 log(3/2) = the OS/RP mass gap Delta of v64.  The
    STATIC recovery bound (2/3)^6 (v221) and the DYNAMICAL mass gap 6 log(3/2)
    (v64) are ONE number, one exponentiated -- exactly the point at which the
    static compiler becomes a dynamics.

  [E] 1. MODULAR FLOW = REVERSIBLE GENERATOR.  sigma_t = e^{i t Lambda_Sigma} is a
        unitary one-parameter group (sigma_s sigma_t = sigma_{s+t}, generator
        d/dt|_0 = i Lambda_Sigma); the mu4 clock is conserved, rho sigma_t
        rho^{-1} = sigma_t for all t  <=>  [rho, Lambda_Sigma] = 0 (the v198
        state-invariance).  NEG: a mu4-breaking off-diagonal Lambda breaks it.
  [E] 2. RECOVERY = DISSIPATIVE GENERATOR.  L = log T is real-symmetric with
        off-diagonals >= 0 and zero row/column sums (a valid doubly-stochastic /
        CPTP-classical Markov generator); e^{L*1} = T, and e^{L tau} -> the
        rank-1 projector onto the stationary (democratic) mode (the arrow of
        time).
  [E] 3. KEYSTONE: dissipative gap = OS mass gap.  -log((2/3)^6) = 6 log(3/2) =
        Delta (v64).  NEG: a free rate r != (2/3)^6 breaks the identity.
  [E] 4. GKSL SPLIT.  G = i Lambda_Sigma + L: reversible part anti-Hermitian
        (purely imaginary spectrum, conserving) + dissipative part symmetric
        (real spectrum <= 0, gap Delta) -- the canonical Hamiltonian + Lindbladian
        split of a quantum dynamical semigroup; the arrow of time is the
        dissipative (real) part.
  [O] 5. THE RESIDUAL.  What is NOT closed: (a) that sigma_t is the GEOMETRIC
        modular flow on the FULL seam algebra (Connes-Rovelli 'thermal time =
        physical time' = the Bisognano-Wichmann / QGEO.SYM.01 residual, v198), and
        (b) that L's continuum embedding extends beyond the finite block.  The
        same single open premise as v196/v198 -- a target, not a closure.

  Python-only (finite-block linear algebra; matrix exp/log via the symmetric
  eigendecomposition, numpy only).  The finite identities are exact; the
  geometric-modular-flow premise is the open QGEO.SYM.01 residual (v198), [O].
"""
import numpy as np

from tfpt_constants import check, summary, reset

LAMBDA2 = (2 / 3) ** 6      # 64/729, the v221 recovery rate
LAMBDA3 = (1 / 3) ** 6


def _sym_funcm(M, f):
    """f(M) for a real-symmetric M via its eigendecomposition (numpy only)."""
    w, V = np.linalg.eigh(M)
    return (V * f(w)) @ V.T


def _expm_iH(H, t):
    """exp(i t H) for a Hermitian H via its eigendecomposition (numpy only)."""
    w, V = np.linalg.eigh(H)
    return (V * np.exp(1j * t * w)) @ V.conj().T


def run():
    reset()
    print("v238  static->dynamic flip: modular flow + recovery Markov generator; "
          "dissipative gap = OS mass gap 6 log(3/2)")

    # ---- the seam recovery channel T (exactly as v221) ---------------------
    u2 = np.array([1.0, -1.0, 0.0]); u2 /= np.linalg.norm(u2)
    u3 = np.array([1.0, 1.0, -2.0]); u3 /= np.linalg.norm(u3)   # Nariai traceless anchor
    J = np.ones((3, 3)) / 3.0
    T = J + LAMBDA2 * np.outer(u2, u2) + LAMBDA3 * np.outer(u3, u3)

    # ---- 1. modular flow = reversible (Hamiltonian) generator --------------
    rho = np.diag([1j, -1.0 + 0j, -1j])                 # the mu4 clock (v196/v198)
    Lam = np.diag([1.0, 2.0, 3.0]).astype(complex)       # Lambda_Sigma = log Delta_omega (any real diagonal)
    ts = [0.3, 0.7, 1.1]

    def sigma(t):
        return _expm_iH(Lam, t)

    grp = all(np.allclose(sigma(s) @ sigma(t), sigma(s + t)) for s in ts for t in ts)
    unitary = all(np.allclose(sigma(t).conj().T @ sigma(t), np.eye(3)) for t in ts)
    dt = 1e-6
    gen_ok = np.allclose((sigma(dt) - np.eye(3)) / dt, 1j * Lam, atol=1e-4)
    conserved = all(np.allclose(rho @ sigma(t) @ np.linalg.inv(rho), sigma(t)) for t in ts)
    comm0 = np.allclose(rho @ Lam - Lam @ rho, 0)
    check("MODULAR FLOW = REVERSIBLE GENERATOR [E]: sigma_t = e^{i t Lambda_Sigma} "
          "is a unitary one-parameter group (sigma_s sigma_t = sigma_{s+t}, "
          "d/dt|_0 = i Lambda_Sigma); the mu4 clock is CONSERVED -- rho sigma_t "
          "rho^{-1} = sigma_t for all t  <=>  [rho,Lambda_Sigma]=0 -- so the STATIC "
          "v198 state-invariance IS the conservation law of modular time",
          grp and unitary and gen_ok and conserved and comm0)

    # NEG: a mu4-breaking off-diagonal Lambda breaks the conservation law
    Lam_b = Lam.copy(); Lam_b[0, 1] = 0.5; Lam_b[1, 0] = 0.5
    sig_b = _expm_iH(Lam_b, 0.7)
    broken = not np.allclose(rho @ sig_b @ np.linalg.inv(rho), sig_b)
    comm_b = not np.allclose(rho @ Lam_b - Lam_b @ rho, 0)
    check("NEG mu4-breaking [E]: an off-diagonal (mu4-breaking) Lambda_Sigma gives "
          "[rho,Lambda]!=0, so rho sigma_t rho^{-1} != sigma_t -- the mu4 charge is "
          "no longer conserved by modular time (cf. v196's E_fail perturbation)",
          broken and comm_b)

    # ---- 2. recovery = dissipative (Lindblad/Markov) generator -------------
    L = _sym_funcm(T, np.log)                            # generator log T (T real-symmetric PD)
    offdiag_nonneg = all(L[i, j] >= -1e-12 for i in range(3) for j in range(3) if i != j)
    zero_sums = np.allclose(L.sum(axis=1), 0) and np.allclose(L.sum(axis=0), 0)
    reproduces = np.allclose(_sym_funcm(L, np.exp), T)   # e^{L*1} = T
    big = _sym_funcm(50.0 * L, np.exp)                   # e^{L tau}, tau=50
    arrow = np.allclose(big, J, atol=1e-6)
    check("RECOVERY = DISSIPATIVE GENERATOR [E]: L = log T is a valid continuous "
          "generator -- real-symmetric, off-diagonals >= 0, zero row/column sums "
          "(a doubly-stochastic / CPTP-classical Markov generator); e^{L*1} = T "
          "reproduces the v221 channel and e^{L tau} -> the rank-1 projector onto "
          "the stationary (democratic) mode as tau->inf (the arrow of time, "
          "matching v64's T^n -> projector)",
          offdiag_nonneg and zero_sums and reproduces and arrow)

    # ---- 3. KEYSTONE: dissipative gap = OS mass gap ------------------------
    evL = sorted(np.linalg.eigvalsh(L))                  # {-6 log 3, -6 log(3/2), 0}
    diss_gap = -max(e for e in evL if e < -1e-9)         # slowest non-zero rate = -log((2/3)^6)
    Delta = 6 * np.log(1.5)                              # the OS/RP mass gap (v64)
    check("KEYSTONE: DISSIPATIVE GAP = OS MASS GAP [E]: the slowest relaxation rate "
          "of L = -log((2/3)^6) = 6 log(3/2) = %.6f = the OS/RP mass gap Delta (v64). "
          "The STATIC recovery bound (2/3)^6 (v221) and the DYNAMICAL mass gap "
          "6 log(3/2) (v64) are ONE number, one exponentiated -- the point where the "
          "static compiler becomes a dynamics" % diss_gap,
          abs(diss_gap - Delta) < 1e-9 and abs(diss_gap + np.log(LAMBDA2)) < 1e-9)

    # NEG: a free recovery rate r != (2/3)^6 breaks the gap=mass-gap identity
    r_free = 0.5
    Tf = J + r_free * np.outer(u2, u2) + LAMBDA3 * np.outer(u3, u3)
    Lf = _sym_funcm(Tf, np.log)
    evLf = sorted(np.linalg.eigvalsh(Lf))
    gap_f = -max(e for e in evLf if e < -1e-9)
    check("NEG free rate [E]: replacing (2/3)^6 by r=0.5 gives dissipative gap "
          "-log(0.5) = %.4f != 6 log(3/2) = %.4f -- the gap=mass-gap identity is NOT "
          "generic (anti-numerology, cf. v221's free-ratio control)" % (gap_f, Delta),
          abs(gap_f + np.log(r_free)) < 1e-9 and abs(gap_f - Delta) > 0.3)

    # ---- 4. GKSL split: reversible (imaginary) + dissipative (real <= 0) ----
    rev_spec = np.linalg.eigvals(1j * Lam)
    rev_imag = np.allclose(rev_spec.real, 0)
    sym = np.allclose(L, L.T)
    check("GKSL SPLIT [E]: G = i Lambda_Sigma (reversible) + L (dissipative): the "
          "reversible generator is anti-Hermitian (spectrum purely IMAGINARY, "
          "unitary/conserving) and the dissipative generator is symmetric (spectrum "
          "REAL and <= 0, gap Delta) -- the canonical Hamiltonian + Lindbladian split "
          "of a quantum dynamical semigroup; the arrow of time is the dissipative "
          "(real) part",
          rev_imag and sym and max(evL) < 1e-9)

    # ---- 5. the residual, honestly typed ----------------------------------
    check("THE RESIDUAL [O] (honest, NOT a closure): this EXHIBITS the static->"
          "dynamic flip on the finite block -- modular flow as the reversible "
          "generator, log T as the dissipative one, dissipative gap = OS mass gap. "
          "NOT closed: (a) that sigma_t is GEOMETRIC modular flow on the FULL seam "
          "algebra (Connes-Rovelli 'thermal time = physical time' = the "
          "Bisognano-Wichmann / QGEO.SYM.01 residual, v198), and (b) that L's "
          "continuum embedding extends beyond the finite block. Same single open "
          "premise as v196/v198 -- a target, not a closure", True)

    return summary("v238 static->dynamic flip (modular flow + recovery Lindblad "
                   "generator; dissipative gap = OS mass gap)")


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

7938425550d9ad7f199e875f22c52609f4eeeb25b9f51df9a49af508a3576645

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.