Follow the source behind the result.

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

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""v1008 -- QFT4D.LATTICE.FUNDAMENTAL.01 / GAUGE.DETLINE.FIXPOINT.01
[O]: compressed 2+1D master-object scaffold (prototype, matter,
wall/mirror, four-block assembly).

Provenance: experiments/tfpt-discovery/tfpt2p1d_{prototype,matter,
wall_mirror,master_assembly}_probe.py (review wave 7, 2026-08-30;
16/16 + 20/20 + 13/13 + 15/15).  Helpers are copied; experiments/ is
not imported.

THE POINT.  Four stages are scaffold-coherent.  No marker moves.

  Prototype [E-finite]: combinatorial K=0 -- every oriented plaquette
        has vanishing flat-x-holonomy exponent; Z2 L=2 Gauss sector
        dimension 32.  L=3 262144 is out of suite.
  Matter [N]: live frozen-link companion: K(q=0)=0, q^2 ~ 4;
        unique-contractive protocol is |R'|<1.  L2/L3 selector
        numbers (0.578 -> 0.936, pair 2.00 -> 0.31, R' 0.0005/0.028)
        are harvest pins, not L=3 Lanczos.  v1 SHA frozen negative.
  Wall/mirror [N]: QWZ physical slope ~ -0.9989; DET mirror gap >= 1.5
        (probe min 1.866) through t=0.6; DET-on-physical / remove-DET
        mutants.
  Assembly [N]: Z6 content (1,2,3,0); clock [0,1,1,2]; D H D^dag
        covariance; chi_phys vs chi_mirror; grading mutant.  Frozen
        SHA e5566dc4....  Dim 1024.

MUST-FAIL: charge-0 stiffness is zero; remove-DET leaves both edges
gapless; DET-on-physical gaps the wrong edge; Psi^2 doubles the
clock ground sector.

HONEST SCOPE (firewall): 2+1D analogue scaffold; no 4D volume
theorem, no dynamical compact-group links, no continuum limit.
QFT4D.LATTICE.FUNDAMENTAL.01 and GAUGE.DETLINE.FIXPOINT.01 stay [O].
Python-only / Wolfram mirror deferred.
"""
from __future__ import annotations

import hashlib
import itertools
import math
from dataclasses import dataclass

import numpy as np

from tfpt_constants import check, summary, reset


def report(name, ok, extra=""):
    check("%s -- %s" % (name, extra) if extra else name, ok)


HERE = __file__.rsplit("/", 1)[0]
ROOT = HERE.rsplit("/", 1)[0]
MATTER_PROBE = ROOT + "/experiments/tfpt-discovery/tfpt2p1d_matter_probe.py"
ASSEMBLY_PROBE = (
    ROOT + "/experiments/tfpt-discovery/tfpt2p1d_master_assembly_probe.py"
)

HOPPING = 0.6
STAGGERED_MASS = 0.2
BETA_MATTER = 40.0
RICHARDSON_STEP = 0.04
FROZEN_SHA256_V1 = (
    "301bd3e2270b903fe0717f65ae6f45292a0eb18cd4c0b49e3b77001fbf80dfd2"
)
FROZEN_SHA256_V2 = (
    "cc1ebf2b8237e9688a13914fcca14f99a73b191ae0bdf714eccb1436000826b0"
)
HARVEST_G_SEL_L2 = 0.578
HARVEST_G_SEL_L3 = 0.936
HARVEST_PAIR_L2 = 2.00
HARVEST_PAIR_L3 = 0.31
HARVEST_RPRIME = (0.0005, 0.028)

LX = 32
LY = 8
MASS = 1.0
FLAVORS = 4
DET_STRENGTH = 2.0
DET_PHASE = math.pi / 7.0
HOPPING_VALUES = (0.0, 0.2, 0.4, 0.6)
MOMENTA = np.linspace(-math.pi, math.pi, 129)
INTERACTION_BETA = 0.7
INTERACTION_STRENGTH = 0.4
EDGE_GAP_TOL = 1.0e-9
MIRROR_GAP_MIN = 1.5
LOCALIZATION_MIN = 0.95
MIRROR_OVERLAP_MAX = 1.0e-8
CONTENT_CHARGES = (1, 2, 3, 0)
CONTENT_NAMES = ("Q", "u^c", "L", "e^c")
CLOCK_COUPLING = 0.5
SEAM_COUPLING = 0.2
TRANSDUCTION_BETA = 0.7
SOURCE_STEP = 1.0e-4
FROZEN_SHA256_ASSEMBLY = (
    "e5566dc4582dcbdb76e57de087943da3c6528cc15aa564d2f67377ce8dc58224"
)

SX = np.array([[0.0, 1.0], [1.0, 0.0]], dtype=complex)
SY = np.array([[0.0, -1j], [1j, 0.0]], dtype=complex)
SZ = np.diag([1.0, -1.0]).astype(complex)
TY = SY / (2j) - SZ / 2.0


def file_has(path: str, snippet: str) -> bool:
    with open(path, encoding="utf-8") as handle:
        return snippet in handle.read()


def plaquette_flat_holonomy_exponent(linear_size: int, x: int, y: int) -> int:
    """Net x-boundary incidence of the oriented plaquette at (x,y)."""
    exponent = 0
    boundary = linear_size - 1
    for x_link, orientation in ((x, +1), (x, -1)):
        if (x_link % linear_size) == boundary:
            exponent += orientation
    return exponent


def gauss_physical_dimension(linear_size: int, group_order: int) -> int:
    site_count = linear_size**2
    link_count = 2 * site_count
    full_dimension = group_order**link_count
    physical = 0
    for code in range(full_dimension):
        digits = [
            (code // group_order**link) % group_order
            for link in range(link_count)
        ]
        divergences_ok = True
        for y in range(linear_size):
            for x in range(linear_size):
                site = y * linear_size + x
                outgoing_x = digits[2 * site]
                outgoing_y = digits[2 * site + 1]
                incoming_x = digits[
                    2 * (y * linear_size + (x - 1) % linear_size)
                ]
                incoming_y = digits[
                    2 * (((y - 1) % linear_size) * linear_size + x) + 1
                ]
                if (outgoing_x + outgoing_y - incoming_x - incoming_y) % group_order:
                    divergences_ok = False
                    break
            if not divergences_ok:
                break
        if divergences_ok:
            physical += 1
    return physical


def fixed_weight_masks(site_count: int, filling: int) -> tuple[int, ...]:
    return tuple(
        sum(1 << site for site in occupied)
        for occupied in itertools.combinations(range(site_count), filling)
    )


def hop_mask(mask: int, source: int, target: int):
    if not (mask & (1 << source)) or mask & (1 << target):
        return None
    sign_annihilate = -1 if (mask & ((1 << source) - 1)).bit_count() % 2 else 1
    intermediate = mask ^ (1 << source)
    sign_create = (
        -1 if (intermediate & ((1 << target) - 1)).bit_count() % 2 else 1
    )
    return intermediate | (1 << target), sign_annihilate * sign_create


def logsumexp(values: np.ndarray) -> float:
    maximum = float(np.max(values))
    return maximum + math.log(float(np.sum(np.exp(values - maximum))))


def frozen_matter_gamma(theta: float, charge: int) -> float:
    linear_size = 2
    masks = fixed_weight_masks(4, 2)
    mask_to_row = {mask: row for row, mask in enumerate(masks)}
    matrix = np.zeros((len(masks), len(masks)), dtype=complex)
    for row, mask in enumerate(masks):
        matrix[row, row] = STAGGERED_MASS * sum(
            ((-1) ** ((site % 2) + (site // 2)))
            * (((mask >> site) & 1) - ((0b0110 >> site) & 1))
            for site in range(4)
        )
        for y in range(linear_size):
            for x in range(linear_size):
                source = y * 2 + x
                for direction, target in (
                    (0, y * 2 + (x + 1) % 2),
                    (1, ((y + 1) % 2) * 2 + x),
                ):
                    boundary = direction == 0 and x == 1
                    for a, b, phase_sign in (
                        (source, target, +1),
                        (target, source, -1),
                    ):
                        hopped = hop_mask(mask, a, b)
                        if hopped is None:
                            continue
                        new_mask, sign = hopped
                        phase = (
                            np.exp(1j * phase_sign * charge * theta)
                            if boundary
                            else 1.0
                        )
                        matrix[mask_to_row[new_mask], row] += (
                            -HOPPING * sign * phase
                        )
    return -logsumexp(-BETA_MATTER * np.linalg.eigvalsh(matrix))


def frozen_stiffness(charge: int) -> float:
    zero = frozen_matter_gamma(0.0, charge)

    def second(step: float) -> float:
        return (
            frozen_matter_gamma(step, charge)
            - 2.0 * zero
            + frozen_matter_gamma(-step, charge)
        ) / (step**2 * 4)

    coarse = second(RICHARDSON_STEP)
    fine = second(RICHARDSON_STEP / 2.0)
    return (4.0 * fine - coarse) / 3.0


def qwz_strip(momentum: float, hopping: float = 1.0) -> np.ndarray:
    onsite = (
        hopping * math.sin(momentum) * SX
        + (MASS - hopping * math.cos(momentum)) * SZ
    )
    transverse = hopping * TY
    matrix = np.zeros((2 * LY, 2 * LY), dtype=complex)
    for y in range(LY):
        site = slice(2 * y, 2 * y + 2)
        matrix[site, site] = onsite
    for y in range(LY - 1):
        lower = slice(2 * y, 2 * y + 2)
        upper = slice(2 * (y + 1), 2 * (y + 1) + 2)
        matrix[upper, lower] = transverse
        matrix[lower, upper] = transverse.conj().T
    return matrix


def localized_zero_profiles():
    eigenvalues, eigenvectors = np.linalg.eigh(qwz_strip(0.0))
    zero_indices = np.where(np.abs(eigenvalues) < 1.0e-10)[0]
    if len(zero_indices) != 2:
        raise RuntimeError("QWZ strip did not have exactly two zero modes")
    zero_frame = eigenvectors[:, zero_indices]
    y_operator = np.diag(np.repeat(np.arange(LY, dtype=float), 2))
    positions, rotation = np.linalg.eigh(zero_frame.conj().T @ y_operator @ zero_frame)
    localized = zero_frame @ rotation
    return localized[:, 0], localized[:, 1], float(abs(np.vdot(localized[:, 0], localized[:, 1])))


def edge_branch(momentum: float, edge: str):
    eigenvalues, eigenvectors = np.linalg.eigh(qwz_strip(momentum))
    candidates = np.where(np.abs(eigenvalues) < 0.9)[0]
    boundary = slice(0, 2) if edge == "physical" else slice(-2, None)
    weights = [
        float(np.sum(np.abs(eigenvectors[boundary, index]) ** 2))
        for index in candidates
    ]
    selected = int(candidates[int(np.argmax(weights))])
    return float(eigenvalues[selected]), max(weights)


def jw_annihilator(mode: int) -> np.ndarray:
    dimension = 1 << FLAVORS
    matrix = np.zeros((dimension, dimension), dtype=complex)
    for state in range(dimension):
        if state & (1 << mode):
            target = state ^ (1 << mode)
            sign = -1 if (state & ((1 << mode) - 1)).bit_count() % 2 else 1
            matrix[target, state] = sign
    return matrix


ANNIHILATORS = tuple(jw_annihilator(mode) for mode in range(FLAVORS))
NUMBER = sum(operator.conj().T @ operator for operator in ANNIHILATORS)
PARITY = np.diag(
    [(-1.0) ** state.bit_count() for state in range(1 << FLAVORS)]
).astype(complex)


def determinant_projector() -> np.ndarray:
    omega = np.zeros(1 << FLAVORS, dtype=complex)
    omega[0] = 1.0 / math.sqrt(2.0)
    omega[-1] = np.exp(1j * DET_PHASE) / math.sqrt(2.0)
    return np.outer(omega, omega.conj())


P_PHI = determinant_projector()
H_DET = np.eye(1 << FLAVORS, dtype=complex) - P_PHI


def edge_cluster_hamiltonian(dispersion: float, det_enabled: bool) -> np.ndarray:
    matrix = dispersion * (NUMBER - 0.5 * FLAVORS * np.eye(1 << FLAVORS))
    if det_enabled:
        matrix = matrix + DET_STRENGTH * H_DET
    return matrix


@dataclass(frozen=True)
class SpectralThreshold:
    gap: float
    zero_weight: float


def cluster_spectral_threshold(matrix: np.ndarray) -> SpectralThreshold:
    eigenvalues, eigenvectors = np.linalg.eigh(matrix)
    ground_energy = float(eigenvalues[0])
    ground_indices = np.where(np.abs(eigenvalues - ground_energy) < 1.0e-10)[0]
    minimum = math.inf
    zero_weight = 0.0
    for ground_index in ground_indices:
        ground = eigenvectors[:, ground_index]
        for annihilator in ANNIHILATORS:
            for field in (annihilator, annihilator.conj().T):
                amplitudes = eigenvectors.conj().T @ (field @ ground)
                weights = np.abs(amplitudes) ** 2
                for target in np.where(weights > 1.0e-12)[0]:
                    cost = float(eigenvalues[target] - ground_energy)
                    if cost >= -1.0e-10:
                        minimum = min(minimum, max(0.0, cost))
                        if abs(cost) < EDGE_GAP_TOL:
                            zero_weight += float(weights[target])
    if not math.isfinite(minimum):
        raise RuntimeError("edge spectral function had no support")
    return SpectralThreshold(minimum, zero_weight)


def edge_spectral_scan(hopping: float, det_enabled: bool, chirality_sign: int):
    minimum_gap = math.inf
    zero_weight = 0.0
    for momentum in MOMENTA:
        dispersion = chirality_sign * hopping * math.sin(float(momentum))
        threshold = cluster_spectral_threshold(
            edge_cluster_hamiltonian(dispersion, det_enabled)
        )
        minimum_gap = min(minimum_gap, threshold.gap)
        if threshold.gap < EDGE_GAP_TOL:
            zero_weight = max(zero_weight, threshold.zero_weight)
    return SpectralThreshold(minimum_gap, zero_weight)


def clock_operators():
    deck = np.diag([1.0, 1j, -1.0, -1j]).astype(complex)
    raising = np.roll(np.eye(4, dtype=complex), 1, axis=0)
    return deck, raising


DECK, PSI = clock_operators()
CLOCK_OBSERVABLE = 0.5 * (PSI + PSI.conj().T)
IDENTITY_EDGE = np.eye(1 << FLAVORS, dtype=complex)
IDENTITY_CLOCK = np.eye(4, dtype=complex)
Q_NUMBER = ANNIHILATORS[0].conj().T @ ANNIHILATORS[0]
Q_DENSITY = Q_NUMBER - 0.5 * IDENTITY_EDGE


def content_charge_operator() -> np.ndarray:
    phases = []
    for state in range(1 << FLAVORS):
        charge = sum(
            CONTENT_CHARGES[mode]
            for mode in range(FLAVORS)
            if state & (1 << mode)
        )
        phases.append(np.exp(2j * math.pi * charge / 6.0))
    return np.diag(phases).astype(complex)


Z6_CHARGE = content_charge_operator()


def seam_hamiltonian(phi: float, grading: int = 1) -> np.ndarray:
    charged = np.linalg.matrix_power(PSI, grading)
    return -CLOCK_COUPLING * (
        np.exp(-1j * phi) * charged + np.exp(1j * phi) * charged.conj().T
    )


def physical_clock_hamiltonian(
    dispersion: float,
    seam_coupling: float = SEAM_COUPLING,
    phi: float = 0.0,
) -> np.ndarray:
    physical = edge_cluster_hamiltonian(dispersion, False)
    return (
        np.kron(physical, IDENTITY_CLOCK)
        + np.kron(IDENTITY_EDGE, seam_hamiltonian(phi))
        + seam_coupling * np.kron(Q_DENSITY, CLOCK_OBSERVABLE)
    )


def full_assembly_hamiltonian(dispersion: float) -> np.ndarray:
    physical_clock = physical_clock_hamiltonian(dispersion)
    mirror = edge_cluster_hamiltonian(-dispersion, True)
    return (
        np.kron(physical_clock, IDENTITY_EDGE)
        + np.kron(np.eye(physical_clock.shape[0]), mirror)
    )


def spectral_threshold(matrix: np.ndarray, fields):
    eigenvalues, eigenvectors = np.linalg.eigh(matrix)
    ground_energy = float(eigenvalues[0])
    ground_indices = np.where(np.abs(eigenvalues - ground_energy) < 1.0e-10)[0]
    minimum = math.inf
    zero_weight = 0.0
    for ground_index in ground_indices:
        ground = eigenvectors[:, ground_index]
        for field in fields:
            for operator in (field, field.conj().T):
                weights = np.abs(eigenvectors.conj().T @ (operator @ ground)) ** 2
                for target in np.where(weights > 1.0e-12)[0]:
                    cost = float(eigenvalues[target] - ground_energy)
                    if cost >= -1.0e-10:
                        minimum = min(minimum, max(cost, 0.0))
                        if abs(cost) < EDGE_GAP_TOL:
                            zero_weight += float(weights[target])
    return SpectralThreshold(minimum, zero_weight)


PHYSICAL_FIELDS = tuple(
    np.kron(operator, IDENTITY_CLOCK) for operator in ANNIHILATORS
)


def physical_seam_scan(hopping: float) -> SpectralThreshold:
    minimum_gap = math.inf
    zero_weight = 0.0
    for momentum in MOMENTA:
        matrix = physical_clock_hamiltonian(hopping * math.sin(float(momentum)))
        threshold = spectral_threshold(matrix, PHYSICAL_FIELDS)
        minimum_gap = min(minimum_gap, threshold.gap)
        if threshold.gap < EDGE_GAP_TOL:
            zero_weight = max(zero_weight, threshold.zero_weight)
    return SpectralThreshold(minimum_gap, zero_weight)


def log_trace_exp(matrix: np.ndarray) -> float:
    eigenvalues = np.linalg.eigvalsh(0.5 * (matrix + matrix.conj().T))
    maximum = float(np.max(eigenvalues))
    return maximum + math.log(float(np.sum(np.exp(eigenvalues - maximum))))


SEAM_SOURCE_PC = np.kron(IDENTITY_EDGE, CLOCK_OBSERVABLE)
PHYSICAL_SOURCE_PC = np.kron(Q_DENSITY, IDENTITY_CLOCK)
MIRROR_SOURCE = Q_DENSITY


def mixed_derivative(function) -> float:
    step = SOURCE_STEP
    return (
        function(+step, +step)
        - function(+step, -step)
        - function(-step, +step)
        + function(-step, -step)
    ) / (4.0 * step**2)


def transduction_pack(seam_coupling: float):
    base_pc = physical_clock_hamiltonian(0.0, seam_coupling)
    base_mirror = edge_cluster_hamiltonian(0.0, True)

    def physical_w(seam_source: float, physical_source: float) -> float:
        exponent = (
            -TRANSDUCTION_BETA * base_pc
            + seam_source * SEAM_SOURCE_PC
            + physical_source * PHYSICAL_SOURCE_PC
        )
        return log_trace_exp(exponent)

    def mirror_w(seam_source: float, mirror_source: float) -> float:
        pc_exponent = (
            -TRANSDUCTION_BETA * base_pc + seam_source * SEAM_SOURCE_PC
        )
        mirror_exponent = (
            -TRANSDUCTION_BETA * base_mirror + mirror_source * MIRROR_SOURCE
        )
        return log_trace_exp(pc_exponent) + log_trace_exp(mirror_exponent)

    return mixed_derivative(physical_w), mixed_derivative(mirror_w)


def run():
    reset()
    print("v1008  2+1D master-object scaffold (four stages, compressed)")

    print("\nSTAGE 1  PROTOTYPE K=0")
    exponents = [
        plaquette_flat_holonomy_exponent(linear_size, x, y)
        for linear_size in (2, 3)
        for y in range(linear_size)
        for x in range(linear_size)
    ]
    report(
        "combinatorial K=0: plaquette exponents cancel [E-finite]",
        all(value == 0 for value in exponents),
        "all %d oriented plaquettes on L=2,3 have exponent 0"
        % len(exponents),
    )
    physical_dim = gauss_physical_dimension(2, 2)
    report(
        "Z2 L=2 Gauss sector dimension 32 [E-finite]",
        physical_dim == 32 == 2 ** (4 + 1),
        "physical=%d (N^(L^2+1)); L=3 262144 out of suite" % physical_dim,
    )

    print("\nSTAGE 2  MATTER FROZEN-LINK + SELECTOR PINS")
    k0 = frozen_stiffness(0)
    k1 = frozen_stiffness(1)
    k2 = frozen_stiffness(2)
    report(
        "frozen-link K(q=0)=0 [N]",
        abs(k0) < 1.0e-10,
        "K(0)=%.3e" % k0,
    )
    report(
        "frozen-link q^2 content law K(2)/K(1)~4 [N]",
        abs(k2 / k1 - 4.0) < 1.0e-4,
        "K(1)=%.9f K(2)=%.9f ratio=%.9f" % (k1, k2, k2 / k1),
    )
    report(
        "v1 SHA frozen (typed negative protocol) [N]",
        file_has(MATTER_PROBE, FROZEN_SHA256_V1)
        and hashlib.sha256(
            "protocol=v2_contractive_selector".encode("utf-8")
        ).hexdigest()
        != FROZEN_SHA256_V1,
        FROZEN_SHA256_V1,
    )
    report(
        "v2 SHA frozen (contractive selector) [N]",
        file_has(MATTER_PROBE, FROZEN_SHA256_V2)
        and file_has(
            MATTER_PROBE, "physical_selector=unique_root_with_abs_dK_dy_lt_1"
        ),
        FROZEN_SHA256_V2,
    )
    report(
        "unique-contractive protocol is |R'|<1 [N]",
        file_has(MATTER_PROBE, "unique_root_with_abs_dK_dy_lt_1"),
        "selector falsifies a root with |R'|>=1; L=3 Lanczos out of suite",
    )
    report(
        "L2/L3 selector harvest pins (not recomputed) [N]",
        HARVEST_G_SEL_L3 > HARVEST_G_SEL_L2
        and HARVEST_PAIR_L3 < HARVEST_PAIR_L2
        and all(abs(value) < 1.0 for value in HARVEST_RPRIME),
        "g_sel %.3f -> %.3f; pair %.2f -> %.2f; R'=%s"
        % (
            HARVEST_G_SEL_L2,
            HARVEST_G_SEL_L3,
            HARVEST_PAIR_L2,
            HARVEST_PAIR_L3,
            HARVEST_RPRIME,
        ),
    )

    print("\nSTAGE 3  QWZ WALL + DET4 MIRROR")
    physical_profile, mirror_profile, profile_overlap = localized_zero_profiles()
    physical_weight = float(np.sum(np.abs(physical_profile[:2]) ** 2))
    mirror_weight = float(np.sum(np.abs(mirror_profile[-2:]) ** 2))
    delta = 0.08
    physical_minus, _ = edge_branch(-delta, "physical")
    physical_plus, _ = edge_branch(delta, "physical")
    physical_slope = (physical_plus - physical_minus) / (2.0 * delta)
    report(
        "QWZ physical slope ~ -0.9989 [N]",
        abs(physical_slope + 0.9989) < 0.01
        and physical_weight > LOCALIZATION_MIN
        and mirror_weight > LOCALIZATION_MIN
        and profile_overlap < MIRROR_OVERLAP_MAX,
        "slope=%+.6f; y0 weight=%.6f; overlap=%.1e"
        % (physical_slope, physical_weight, profile_overlap),
    )

    table = {}
    assignments = {
        "integrated": (False, True),
        "no_DET": (False, False),
        "wrong_side": (True, False),
    }
    for assignment, (physical_det, mirror_det) in assignments.items():
        for hopping in HOPPING_VALUES:
            table[(assignment, hopping, "physical")] = edge_spectral_scan(
                hopping, physical_det, +1
            )
            table[(assignment, hopping, "mirror")] = edge_spectral_scan(
                hopping, mirror_det, -1
            )
    integrated_mirror = [
        table[("integrated", hopping, "mirror")].gap for hopping in HOPPING_VALUES
    ]
    report(
        "DET mirror gap >= 1.5 through t=0.6 [N]",
        min(integrated_mirror) > MIRROR_GAP_MIN,
        "min=%.9f (probe min 1.866)" % min(integrated_mirror),
    )
    report(
        "physical edge remains gapless [N]",
        all(
            table[("integrated", hopping, "physical")].gap < EDGE_GAP_TOL
            and table[("integrated", hopping, "physical")].zero_weight > 0.1
            for hopping in HOPPING_VALUES
        ),
        "all physical thresholds zero with A_edge(0)>0",
    )
    report(
        "MUST-FAIL: remove-DET leaves both edges gapless",
        all(
            table[("no_DET", hopping, edge)].gap < EDGE_GAP_TOL
            for hopping in HOPPING_VALUES
            for edge in ("physical", "mirror")
        ),
        "mirror doubler visible at every t",
    )
    report(
        "MUST-FAIL: DET-on-physical gaps the wrong side",
        all(
            table[("wrong_side", hopping, "physical")].gap > MIRROR_GAP_MIN
            and table[("wrong_side", hopping, "mirror")].gap < EDGE_GAP_TOL
            for hopping in HOPPING_VALUES
        ),
        "edge-exchange symmetry",
    )

    print("\nSTAGE 4  FOUR-BLOCK ASSEMBLY")
    report(
        "assembly frozen SHA [N]",
        file_has(ASSEMBLY_PROBE, FROZEN_SHA256_ASSEMBLY),
        FROZEN_SHA256_ASSEMBLY,
    )
    report(
        "minimal faithful Z6 content (1,2,3,0) [N]",
        CONTENT_NAMES == ("Q", "u^c", "L", "e^c")
        and CONTENT_CHARGES == (1, 2, 3, 0)
        and math.gcd(*CONTENT_CHARGES) == 1
        and sum(CONTENT_CHARGES) % 6 == 0,
        "charges=%s; DET is Z6-neutral" % (CONTENT_CHARGES,),
    )
    representative = full_assembly_hamiltonian(0.6 * math.sin(0.37))
    hermiticity = float(np.max(np.abs(representative - representative.conj().T)))
    charge_full = np.kron(np.kron(Z6_CHARGE, IDENTITY_CLOCK), Z6_CHARGE)
    charge_error = float(
        np.max(np.abs(representative @ charge_full - charge_full @ representative))
    )
    report(
        "assembled H Hermitian, dim 1024, Z6 exact [N]",
        representative.shape == (1024, 1024)
        and hermiticity < 1.0e-13
        and charge_error < 1.0e-13,
        "dim=%d |H-Hdag|=%.1e [H,Q6]=%.1e"
        % (representative.shape[0], hermiticity, charge_error),
    )

    covariance_errors = []
    sector_spectra = []
    expected_clock = np.array([0.0, 1.0, 1.0, 2.0])
    for sector in range(4):
        phi = sector * math.pi / 2.0
        current = seam_hamiltonian(phi)
        target = seam_hamiltonian(phi - math.pi / 2.0)
        covariance_errors.append(
            float(np.max(np.abs(DECK @ current @ DECK.conj().T - target)))
        )
        shifted = np.linalg.eigvalsh(current)
        shifted -= shifted[0]
        sector_spectra.append(shifted)
    report(
        "quarter-deck covariance + clock [0,1,1,2] [N]",
        max(covariance_errors) < 1.0e-13
        and all(
            np.max(np.abs(spectrum - expected_clock)) < 1.0e-12
            for spectrum in sector_spectra
        ),
        "max |D H Ddag-H_(k-1)|=%.1e" % max(covariance_errors),
    )

    wall_ok = True
    mirror_minimum = math.inf
    for hopping in HOPPING_VALUES:
        physical = physical_seam_scan(hopping)
        mirror = edge_spectral_scan(hopping, True, -1)
        wall_ok = wall_ok and physical.gap < EDGE_GAP_TOL and physical.zero_weight > 0.1
        mirror_minimum = min(mirror_minimum, mirror.gap)
    report(
        "physical wall + DET mirror survive the seam [N]",
        wall_ok and mirror_minimum > MIRROR_GAP_MIN,
        "min mirror gap=%.9f through t=0.6" % mirror_minimum,
    )

    physical_cross, mirror_cross = transduction_pack(SEAM_COUPLING)
    removed_cross, removed_mirror = transduction_pack(0.0)
    report(
        "chi_phys nonzero, chi_mirror suppressed [N]",
        abs(physical_cross) > 1.0e-4
        and abs(mirror_cross) < 1.0e-6
        and abs(mirror_cross) < 1.0e-3 * abs(physical_cross),
        "chi_phys=%+.6e chi_mirror=%.3e" % (physical_cross, mirror_cross),
    )
    wrong = seam_hamiltonian(0.0, grading=2)
    wrong_spectrum = np.linalg.eigvalsh(wrong)
    wrong_spectrum -= wrong_spectrum[0]
    wrong_ground = int(np.sum(np.abs(wrong_spectrum) < 1.0e-12))
    report(
        "MUST-FAIL: Psi^2 doubles the clock ground sector",
        np.max(np.abs(wrong_spectrum - np.array([0.0, 0.0, 2.0, 2.0]))) < 1.0e-12
        and wrong_ground == 2,
        "q=1 [0,1,1,2] unique -> q=2 [0,0,2,2] doubled",
    )
    report(
        "MUST-FAIL: remove seam kills cross response",
        abs(removed_cross) < 1.0e-6 and abs(removed_mirror) < 1.0e-6,
        "|chi_phys(off)|=%.3e" % abs(removed_cross),
    )
    report(
        "FIREWALL: QFT4D.LATTICE.FUNDAMENTAL.01 and "
        "GAUGE.DETLINE.FIXPOINT.01 stay [O]",
        True,
        "2+1D analogue; no 4D volume theorem; no marker move",
    )
    return summary(
        "v1008 master-object scaffold: K=0 + frozen q^2 + wall/mirror "
        "+ Z6/clock assembly; contracts stay [O]"
    )


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

3c45ac92fabdcb4d572a4f5c1b51d6b33639e6538f30b0168adca12a5d3fcb37

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.