Follow the source behind the result.

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

"""v990 -- FTRANSFER.GENERATING.01 + OBS.TRANSDUCTION.01 [O update:
content shadow + finite W[J] derivative identities + transduction
shadow executed; contracts stay Open].

THE POINT (promote round 2026-08-28).  Re-derives the executable
content of tfpt4d_content_candidate_probe (not imported):

  [E] Z6-CENTRE 6Y TABLE: Q -> 1, u^c -> 2, d^c -> 2, L -> 3,
        e^c -> 0 (6Y mod 6); T4 anomaly bookkeeping exact on the
        real one-generation content; drop-L mutant fires.

  [E/N] W[J] AT DIM 96 (2 sites, 1 quantum Z6, species Q + e^c):
        dW/dJ = <O> (thermal mean); Hessian = Kubo connected
        correlator.  Probe diffs ~6e-11 / ~1e-7.

  [N] TRANSDUCTION SHADOW d2W/dJ dtheta: dynamical-link mixed is
        nonzero on the seam-coupled link (~-9e-3 in the probe);
        decoupled e^c control is EXACTLY 0.  Frozen-link companion:
        Q-staggered transduces, e^c control stays 0.

HONEST SCOPE (firewall): 1+1D 2-site Hamiltonian ring; Z6 centre
shadow (u^c and d^c share charge 2); finite W[J], not the 4D
generating functional.  Contracts stay [O].  No marker move.
Python-only / Wolfram mirror deferred.

Provenance: experiments/tfpt-discovery/tfpt4d_content_candidate_probe.py
(ALL PASS; not imported).
"""
from fractions import Fraction as F

import numpy as np

from tfpt_constants import check, summary, reset

GEN = [
    ("Q",   3, 2, F(1, 6)),
    ("u^c", 3, 1, F(-2, 3)),
    ("d^c", 3, 1, F(1, 3)),
    ("L",   1, 2, F(-1, 2)),
    ("e^c", 1, 1, F(1, 1)),
]
CHARGES = [int(6 * g[3]) % 6 for g in GEN]

NS = 2
DL = 6
OMEGA = np.exp(2j * np.pi / 6)
Z1 = np.diag(OMEGA ** np.arange(6)).astype(complex)
X1 = np.roll(np.eye(6), 1, axis=0).astype(complex)
LAM_E, W_HOP, MASS = 1.0, 0.7, 0.5
BETA, THETA0, MU_Q = 0.35, 0.7, 0.5
EPS_J, EPS_TH = 1.0e-4, 1.0e-4
W_SZ = np.diag([1.0, -1.0])
W_ANN = np.array([[0.0, 1.0], [0.0, 0.0]], dtype=complex)


def anomaly_sums(fields):
    y3 = sum(c * w * y ** 3 for _, c, w, y in fields)
    su2y = sum(c * y for _, c, w, y in fields if w == 2)
    su3y = sum(w * y for _, c, w, y in fields if c == 3)
    grav = sum(c * w * y for _, c, w, y in fields)
    witten = sum(c for _, c, w, y in fields if w == 2)
    return y3, su2y, su3y, grav, witten


def w_ferm(alpha, n_modes, dl):
    out = np.array([[1.0]], dtype=complex)
    for j in range(n_modes):
        if j < alpha:
            out = np.kron(out, W_SZ)
        elif j == alpha:
            out = np.kron(out, W_ANN)
        else:
            out = np.kron(out, np.eye(2))
    return np.kron(np.eye(dl), out)


def log_tr_exp(A):
    ev = np.linalg.eigvalsh(0.5 * (A + A.conj().T))
    m = float(ev.max())
    return m + float(np.log(np.sum(np.exp(ev - m))))


def kubo_connected(Xe, Ye, p, evals):
    lam = -BETA * evals
    dlam = lam[None, :] - lam[:, None]
    psi = np.ones_like(dlam, dtype=complex)
    mask = np.abs(dlam) > 1e-12
    psi[mask] = (np.exp(dlam[mask]) - 1.0) / dlam[mask]
    x_mean = complex(np.dot(p, np.diag(Xe)))
    y_mean = complex(np.dot(p, np.diag(Ye)))
    acc = np.sum(p[:, None] * psi * Xe * Ye.T)
    return acc - x_mean * y_mean


def thermal_pack(Hm):
    evals, evecs = np.linalg.eigh(0.5 * (Hm + Hm.conj().T))
    lam = -BETA * evals
    lam_s = lam - lam.max()
    ww = np.exp(lam_s)
    p = ww / ww.sum()
    return evals, evecs, p


def run():
    reset()
    print("v990  FTRANSFER.GENERATING.01 / OBS.TRANSDUCTION.01: "
          "content shadow + W[J] + transduction")

    check("6Y TABLE [E]: 6Y mod 6 = [Q:1, u^c:2, d^c:2, L:3, e^c:0]",
          CHARGES == [1, 2, 2, 3, 0])
    xzx = X1 @ Z1 @ X1.conj().T
    check("Z6 WEYL [E]: X Z X^dag = omega^{-1} Z",
          float(np.max(np.abs(xzx - (OMEGA ** (-1)) * Z1))) < 1e-14)

    y3, su2y, su3y, grav, witten = anomaly_sums(GEN)
    check("T4 [E]: [U(1)]^3 = [SU(2)]^2 U(1) = [SU(3)]^2 U(1) = "
          "grav^2 U(1) = 0",
          y3 == su2y == su3y == grav == 0)
    check("T4 WITTEN [E]: %d SU(2) doublets even" % witten,
          witten % 2 == 0)
    y3m, su2ym, su3ym, gravm, wittenm = anomaly_sums(
        [f for f in GEN if f[0] != "L"])
    check("T4 MUTANT [E]: dropping L breaks [U(1)]^3, [SU(2)]^2 U(1), "
          "grav and makes Witten odd",
          y3m != 0 and su2ym != 0 and gravm != 0 and wittenm % 2 == 1)

    W_CHARGES = [1, 0]
    W_NMODES = 4
    W_DF = 16
    W_PSI = [w_ferm(a, W_NMODES, DL) for a in range(W_NMODES)]
    W_NUM = [p.conj().T @ p for p in W_PSI]
    W_X = np.kron(X1, np.eye(W_DF))
    W_Z = np.kron(Z1, np.eye(W_DF))

    def build_H_W(theta, lam_e=LAM_E, w=W_HOP, m=MASS, mu_q=MU_Q):
        Hm = -lam_e * (W_X + W_X.conj().T)
        for s, q in enumerate(W_CHARGES):
            a0, a1 = s * NS + 0, s * NS + 1
            Zq = np.linalg.matrix_power(W_Z, int(q) % 6)
            hop = W_PSI[a0].conj().T @ Zq @ W_PSI[a1]
            Hm = Hm + w * (hop + hop.conj().T)
            seam = (np.exp(1j * theta) ** q) * (
                W_PSI[a1].conj().T @ W_PSI[a0])
            Hm = Hm + w * (seam + seam.conj().T)
            Hm = Hm + m * (W_NUM[a0] - W_NUM[a1])
        Hm = Hm + mu_q * (W_NUM[0] + W_NUM[1])
        return Hm

    def dH_dtheta(theta, w=W_HOP):
        q = 1
        phase = np.exp(1j * theta) ** q
        dseam = (1j * q) * phase * (W_PSI[1].conj().T @ W_PSI[0])
        return w * (dseam + dseam.conj().T)

    O_Q = W_NUM[0] + W_NUM[1]
    O_Z = 0.5 * (W_Z + W_Z.conj().T)
    O_C = W_NUM[2] + W_NUM[3]
    OPS = [O_Q, O_Z, O_C]
    N_O = 3
    H_W0 = build_H_W(THETA0)
    check("W[J] HERMITIAN [E]: H = H^dag at theta0 (dim 96)",
          float(np.max(np.abs(H_W0 - H_W0.conj().T))) < 1e-12)

    def W_gen(Js, theta):
        A = -BETA * build_H_W(theta)
        for j, O in zip(Js, OPS):
            A = A + j * O
        return log_tr_exp(A)

    evals0, evecs0, p0 = thermal_pack(H_W0)
    Oe = [evecs0.conj().T @ O @ evecs0 for O in OPS]
    means = [complex(np.dot(p0, np.diag(Oe[a]))) for a in range(N_O)]
    dw_ok = True
    dw_max = 0.0
    for a in range(N_O):
        Jp = [0.0] * N_O
        Jm = [0.0] * N_O
        Jp[a] = EPS_J
        Jm[a] = -EPS_J
        dW = (W_gen(Jp, THETA0) - W_gen(Jm, THETA0)) / (2.0 * EPS_J)
        diff = abs(dW - means[a].real)
        dw_max = max(dw_max, diff)
        dw_ok &= diff < 1e-6
    print("   max |dW/dJ - <O>| = %.2e" % dw_max)
    check("W(a) [E/N]: dW/dJ = <O> (max diff %.1e; probe ~6e-11)"
          % dw_max, dw_ok)

    hess_ok = True
    hess_max = 0.0
    for a in range(N_O):
        for b in range(a, N_O):
            if a == b:
                hess = (W_gen([EPS_J if i == a else 0.0
                               for i in range(N_O)], THETA0)
                        - 2.0 * W_gen([0.0] * N_O, THETA0)
                        + W_gen([-EPS_J if i == a else 0.0
                                 for i in range(N_O)], THETA0)
                        ) / (EPS_J ** 2)
            else:
                def Jpair(sa, sb, aa=a, bb=b):
                    Js = [0.0] * N_O
                    Js[aa] = sa * EPS_J
                    Js[bb] = sb * EPS_J
                    return W_gen(Js, THETA0)
                hess = (Jpair(1, 1) - Jpair(1, -1) - Jpair(-1, 1)
                        + Jpair(-1, -1)) / (4.0 * EPS_J * EPS_J)
            kub = kubo_connected(Oe[a], Oe[b], p0, evals0)
            diff = abs(hess - kub.real)
            hess_max = max(hess_max, diff)
            hess_ok &= diff < 5e-5
    print("   max |Hess - Kubo| = %.2e" % hess_max)
    check("W(b) [E/N]: Hessian = Kubo connected (max diff %.1e; "
          "probe ~1e-7)" % hess_max, hess_ok)

    Kseam = -BETA * dH_dtheta(THETA0)
    Ke = evecs0.conj().T @ Kseam @ evecs0
    mixed_vals = []
    mix_ok = True
    for a in range(N_O):
        def Wm(j, th, aa=a):
            Js = [0.0] * N_O
            Js[aa] = j
            return W_gen(Js, th)
        mixed = (Wm(EPS_J, THETA0 + EPS_TH) - Wm(EPS_J, THETA0 - EPS_TH)
                 - Wm(-EPS_J, THETA0 + EPS_TH)
                 + Wm(-EPS_J, THETA0 - EPS_TH)
                 ) / (4.0 * EPS_J * EPS_TH)
        kub = kubo_connected(Oe[a], Ke, p0, evals0)
        diff = abs(mixed - kub.real)
        mix_ok &= diff < 5e-5
        mixed_vals.append(mixed)
        print("   mixed d2W/dJ[%d]dtheta = %.4e  (Kubo diff %.1e)"
              % (a, mixed, diff))
    check("W(c) KUBO [N]: mixed d2W/dJ dtheta = Kubo(O, -beta dH/dtheta)",
          mix_ok)
    m_Z, m_C, m_Q = mixed_vals[1], mixed_vals[2], mixed_vals[0]
    check("W(c) TRANSDUCTION [N]: seam-coupled link mixed != 0 "
          "(%.3e), e^c CONTROL = 0 (%.3e), Q-charge absorbed "
          "(%.3e ~ 0; probe seam-coupled ~-9.3e-3)"
          % (m_Z, m_C, m_Q),
          abs(m_Z) > 1e-6 and abs(m_C) < 1e-8 and abs(m_Q) < 1e-6)

    F_NMODES = 4
    F_D = 16

    def f_ferm(alpha):
        out = np.array([[1.0]], dtype=complex)
        for j in range(F_NMODES):
            if j < alpha:
                out = np.kron(out, W_SZ)
            elif j == alpha:
                out = np.kron(out, W_ANN)
            else:
                out = np.kron(out, np.eye(2))
        return out

    F_PSI = [f_ferm(a) for a in range(F_NMODES)]
    F_NUM = [p.conj().T @ p for p in F_PSI]
    F_STAG = F_NUM[0] - F_NUM[1]
    F_C = F_NUM[2] + F_NUM[3]
    F_OPS = [F_STAG, F_C]

    def build_H_frozen_W(theta, w=W_HOP, m=MASS, mu_q=MU_Q):
        Hm = np.zeros((F_D, F_D), dtype=complex)
        for s, q in enumerate((1, 0)):
            a0, a1 = s * NS + 0, s * NS + 1
            hop = F_PSI[a0].conj().T @ F_PSI[a1]
            Hm = Hm + w * (hop + hop.conj().T)
            seam = (np.exp(1j * theta) ** q) * (
                F_PSI[a1].conj().T @ F_PSI[a0])
            Hm = Hm + w * (seam + seam.conj().T)
            Hm = Hm + m * (F_NUM[a0] - F_NUM[a1])
        Hm = Hm + mu_q * (F_NUM[0] + F_NUM[1])
        return Hm

    def dH_frozen_dtheta(theta, w=W_HOP):
        phase = np.exp(1j * theta)
        dseam = 1j * phase * (F_PSI[1].conj().T @ F_PSI[0])
        return w * (dseam + dseam.conj().T)

    def W_frozen(Js, theta):
        A = -BETA * build_H_frozen_W(theta)
        for j, O in zip(Js, F_OPS):
            A = A + j * O
        return log_tr_exp(A)

    Hf0 = build_H_frozen_W(THETA0)
    fevals, fevecs, fp = thermal_pack(Hf0)
    FOe = [fevecs.conj().T @ O @ fevecs for O in F_OPS]
    Kef = fevecs.conj().T @ (-BETA * dH_frozen_dtheta(THETA0)) @ fevecs
    f_mixed = []
    f_ok = True
    for a in range(2):
        def Wfm(j, th, aa=a):
            Js = [0.0, 0.0]
            Js[aa] = j
            return W_frozen(Js, th)
        mixed = (Wfm(EPS_J, THETA0 + EPS_TH)
                 - Wfm(EPS_J, THETA0 - EPS_TH)
                 - Wfm(-EPS_J, THETA0 + EPS_TH)
                 + Wfm(-EPS_J, THETA0 - EPS_TH)
                 ) / (4.0 * EPS_J * EPS_TH)
        kub = kubo_connected(FOe[a], Kef, fp, fevals)
        f_ok &= abs(mixed - kub.real) < 5e-5
        f_mixed.append(mixed)
    check("W(c-frozen) KUBO [N]: frozen mixed = Kubo", f_ok)
    check("W(c-frozen) TRANSDUCTION [N]: Q-staggered mixed != 0 "
          "(%.3e) while e^c CONTROL = 0 (%.3e) -- the "
          "boundary-module half of OBS.TRANSDUCTION.01 from ONE W"
          % (f_mixed[0], f_mixed[1]),
          abs(f_mixed[0]) > 1e-6 and abs(f_mixed[1]) < 1e-8)

    check("FIREWALL (scope): 1+1D 2-site Z6 shadow; finite W[J]; "
          "FTRANSFER.GENERATING.01 and OBS.TRANSDUCTION.01 stay [O]; "
          "no marker move", True)
    return summary("v990 W[J] transduction: 6Y table + derivative "
                   "identities + transduction shadow")


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

d365bdab9884798ceb0cce13462a2d9bd8675ad9ea44b843a612eb6268bf099b

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.