Blame for research/code/verify.py

#!/usr/bin/env python3
"""Reproducible finite-dimensional checks and exact sector-capacity evaluations.

Numerical checks illustrate the mathematical statements; they do not replace
their proofs or establish scientific priority. All logarithms are base two.
Requires Python 3.10+, NumPy, SciPy; Matplotlib only for the optional figure.
Run: python3 verify.py --output-dir results
"""
from __future__ import annotations

import argparse
import csv
import itertools
import json
import math
from pathlib import Path

import numpy as np
from scipy.linalg import eigh, expm
from scipy.special import gammaln
from scipy.stats import binom

SEED = 20261101
ATOL = 3e-11
I2 = np.eye(2, dtype=complex)
X = np.array([[0, 1], [1, 0]], dtype=complex)
Y = np.array([[0, -1j], [1j, 0]], dtype=complex)
Z = np.diag([1, -1]).astype(complex)
NUMBER = np.diag([0, 1]).astype(complex)


def kron_all(ops: list[np.ndarray]) -> np.ndarray:
    out = np.ones((1, 1), dtype=complex)
    for op in ops:
        out = np.kron(out, op)
    return out


def local(op: np.ndarray, site: int, n: int) -> np.ndarray:
    return kron_all([op if j == site else I2 for j in range(n)])


def collective(op: np.ndarray, sites: list[int], n: int) -> np.ndarray:
    return sum((local(op, j, n) for j in sites), np.zeros((2**n, 2**n), complex))


def embed(op: np.ndarray, sites: list[int], n: int) -> np.ndarray:
    """Embed an arbitrary operator with the specified ordered qubit sites."""
    k = len(sites)
    assert op.shape == (2**k, 2**k)
    out = np.zeros((2**n, 2**n), complex)
    for col in range(2**n):
        bits = [(col >> (n - 1 - j)) & 1 for j in range(n)]
        subcol = sum(bits[site] << (k - 1 - r) for r, site in enumerate(sites))
        for subrow in range(2**k):
            rowbits = bits.copy()
            for r, site in enumerate(sites):
                rowbits[site] = (subrow >> (k - 1 - r)) & 1
            row = sum(bit << (n - 1 - j) for j, bit in enumerate(rowbits))
            out[row, col] += op[subrow, subcol]
    return out


def random_hermitian(d: int, rng: np.random.Generator) -> np.ndarray:
    a = rng.normal(size=(d, d)) + 1j * rng.normal(size=(d, d))
    h = (a + a.conj().T) / 2
    return h / np.linalg.norm(h, 2)


def reduced_pure(psi: np.ndarray, keep: list[int], n: int) -> np.ndarray:
    others = [j for j in range(n) if j not in keep]
    matrix = psi.reshape([2] * n).transpose(keep + others).reshape(2**len(keep), -1)
    return matrix @ matrix.conj().T


def reduced_density(rho: np.ndarray, keep: list[int], n: int) -> np.ndarray:
    others = [j for j in range(n) if j not in keep]
    order = keep + others
    tensor = rho.reshape([2] * (2 * n)).transpose(order + [j + n for j in order])
    dk, de = 2**len(keep), 2**len(others)
    return np.trace(tensor.reshape(dk, de, dk, de), axis1=1, axis2=3)


def entropy(rho: np.ndarray) -> float:
    eigenvalues = np.linalg.eigvalsh(rho)
    positive = eigenvalues[eigenvalues > 1e-13]
    return float(-np.sum(positive * np.log2(positive)))


def trace_distance(a: np.ndarray, b: np.ndarray) -> float:
    return float(np.abs(np.linalg.eigvalsh((a - b + (a - b).conj().T) / 2)).sum() / 2)


def maximally_entangled_encoding(code: np.ndarray) -> np.ndarray:
    """Physical qubits, pure |0> bath qubit, then reference qubit."""
    assert code.shape[1] == 2
    amplitudes = np.zeros((code.shape[0], 2, 2), complex)
    amplitudes[:, 0, 0] = code[:, 0] / math.sqrt(2)
    amplitudes[:, 0, 1] = code[:, 1] / math.sqrt(2)
    return amplitudes.reshape(-1)


def evolve(psi: np.ndarray, h_phys_bath: np.ndarray, duration: float) -> np.ndarray:
    return (expm(-1j * duration * h_phys_bath) @ psi.reshape(h_phys_bath.shape[0], 2)).reshape(-1)


def twirl_two_spins_with_reference(rho: np.ndarray) -> np.ndarray:
    """Exact SU(2) Haar twirl for two surviving spins and a reference qubit."""
    singlet = np.array([0, 1, -1, 0], complex) / math.sqrt(2)
    p0 = np.outer(singlet, singlet.conj())
    p1 = np.eye(4) - p0
    out = np.zeros_like(rho)
    for projector, dimension in [(p0, 1), (p1, 3)]:
        projected = np.kron(projector, I2) @ rho @ np.kron(projector, I2)
        reference_state = np.trace(projected.reshape(4, 2, 4, 2), axis1=0, axis2=2)
        out += np.kron(projector / dimension, reference_state)
    return out


def check_su2_moving_boundary(rng: np.random.Generator) -> dict:
    n = 4
    js = [collective(a / 2, list(range(n)), n) for a in (X, Y, Z)]
    casimir = sum(j @ j for j in js)
    eigenvalues, vectors = eigh(casimir)
    code = vectors[:, np.abs(eigenvalues) < 1e-10]
    assert code.shape == (16, 2)
    for j in js:
        assert np.linalg.norm(j @ code) < ATOL
    initial = maximally_entangled_encoding(code)
    psi = initial.copy()
    stages = [(list(range(4)), [], 0.83), ([1, 2, 3], [0], 1.27), ([2, 3], [0, 1], 1.91)]
    stage_details = []
    for active, lost, duration in stages:
        jx, jy, jz = [collective(a / 2, active, n) for a in (X, Y, Z)]
        h = 0.73 * np.kron(jx, X) + 0.51 * np.kron(jy, Z) + 0.27 * np.kron(jz, Y)
        h += 0.19 * np.kron(jx @ jx, Y)
        h += np.kron(np.eye(16), 0.23 * X + 0.37 * Z)
        if lost:
            h += 1.1 * embed(random_hermitian(2 ** (len(lost) + 1), rng), lost + [4], 5)
        assert np.linalg.norm(h - h.conj().T) < ATOL
        psi = evolve(psi, h, duration)
        stage_details.append({"active": active, "lost": lost, "duration_hbar_units": duration})
    # Physical positions 2 and 3 survive; position 5 is the reference.
    target = reduced_pure(initial, [2, 3, 5], 6)
    noisy = reduced_pure(psi, [2, 3, 5], 6)
    after_twirl = twirl_two_spins_with_reference(noisy)
    residual = trace_distance(after_twirl, target)
    assert residual < ATOL
    before = trace_distance(noisy, target)
    assert before > 1e-4, "Bath should visibly change the irrep gauge before twirling"
    return {
        "physical_qubits": 4,
        "bath_dimension": 2,
        "reference_dimension": 2,
        "joint_dimension": 64,
        "stages": stage_details,
        "trace_distance_before_final_twirl": before,
        "trace_distance_after_final_twirl": residual,
        "state_norm_error": float(abs(np.vdot(psi, psi) - 1)),
    }


def check_u1_moving_boundary(rng: np.random.Generator) -> dict:
    n, weight = 6, 3
    indices = [x for x in range(2**n) if x.bit_count() == weight]
    a = rng.normal(size=(len(indices), 2)) + 1j * rng.normal(size=(len(indices), 2))
    q, _ = np.linalg.qr(a)
    code = np.zeros((2**n, 2), complex)
    code[indices] = q
    initial = maximally_entangled_encoding(code)
    psi = initial.copy()
    stages = [(list(range(n)), 0.7), ([1, 2, 3, 4, 5], 1.3), ([1, 3, 4, 5], 2.1)]
    for active, duration in stages:
        charge = collective(NUMBER, active, n)
        h = np.kron(charge, 0.71 * X + 0.19 * Z)
        h += np.kron(charge @ charge, 0.13 * Y - 0.17 * Z)
        h += np.kron(np.eye(2**n), 0.31 * X + 0.23 * Y)
        psi = evolve(psi, h, duration)
    keep = [1, 3, 4, 5, 7]
    target = reduced_pure(initial, keep, 8)
    noisy = reduced_pure(psi, keep, 8)
    residual = trace_distance(noisy, target)
    assert residual < ATOL
    return {
        "physical_qubits": n,
        "weight": weight,
        "erased_positions": [0, 2],
        "joint_dimension": 256,
        "trace_distance_to_bare_erasure_without_twirl": residual,
    }


def ten_seal_supports() -> list[list[str]]:
    x, y = "1111100000", "1100011100"
    complement = lambda s: "".join("1" if c == "0" else "0" for c in s)
    return [[x, complement(x)], [y, complement(y)]]


def reduced_code_operator(mu: int, nu: int, erased: tuple[int, ...]) -> dict:
    """Sparse exact reduced |mu_L><nu_L| on the erased region.

    Values are doubled, hence integer, to keep the KL test exact.
    """
    supports = ten_seal_supports()
    kept = [j for j in range(10) if j not in erased]
    result: dict[tuple[str, str], int] = {}
    for a in supports[mu]:
        for b in supports[nu]:
            if all(a[j] == b[j] for j in kept):
                key = ("".join(a[j] for j in erased), "".join(b[j] for j in erased))
                result[key] = result.get(key, 0) + 1
    return result


def check_ten_seal_code() -> dict:
    counts, correctable = {}, {}
    for size in range(6):
        good = []
        for erased in itertools.combinations(range(10), size):
            if (reduced_code_operator(0, 0, erased) == reduced_code_operator(1, 1, erased)
                    and not reduced_code_operator(0, 1, erased)
                    and not reduced_code_operator(1, 0, erased)):
                good.append(list(erased))
        counts[str(size)] = {"correctable": len(good), "total": math.comb(10, size)}
        correctable[str(size)] = good
    assert counts["1"]["correctable"] == 10
    assert [0, 2] not in correctable["2"]
    # Inhomogeneous single-site fields: at time pi/2,
    # exp[-i*pi/2*(Z_0-Z_2)] = Z_0 Z_2 = logical Z on this code.
    signs = []
    for support in ten_seal_supports():
        signs.append([(-1) ** (int(s[0]) + int(s[2])) for s in support])
    assert signs == [[1, 1], [-1, -1]]
    return {
        "zero_based_positions": True,
        "correctability_counts": counts,
        "correctable_erased_subsets": correctable,
        "inhomogeneous_counterexample": {
            "Hamiltonian_in_hbar_units": "Z_0 - Z_2",
            "duration": math.pi / 2,
            "logical_action": "Z",
            "Bell_reference_trace_distance_from_identity": 1.0,
            "exact_basis_signs": signs,
        },
    }


def logchoose(n: int, k: int) -> float:
    if k < 0 or k > n:
        return -math.inf
    return float((gammaln(n + 1) - gammaln(k + 1) - gammaln(n - k + 1)) / math.log(2))


def charge_marginal_entropy(b: int, w: int, size: int) -> float:
    """Entropy of any `size` sites of uniform fixed-weight b-qubit state."""
    logd = logchoose(b, w)
    answer = logd
    for k in range(max(0, w - (b - size)), min(size, w) + 1):
        log_rest = logchoose(b - size, w - k)
        probability = 2 ** (logchoose(size, k) + log_rest - logd)
        answer -= probability * log_rest
    return max(0.0, answer)


def spin_multiplicity(n: int, twice_j: int) -> int:
    if twice_j < 0 or twice_j > n or (n - twice_j) % 2:
        return 0
    k = (n - twice_j) // 2
    return math.comb(n, k) - (math.comb(n, k - 1) if k else 0)


def singlet_marginal_entropy(b: int, size: int) -> float:
    """Schur-Weyl entropy of a marginal of the uniform total-singlet state."""
    assert b % 2 == 0
    d = spin_multiplicity(b, 0)
    answer = 0.0
    normalization = 0.0
    for twice_j in range(size % 2, min(size, b - size) + 1, 2):
        m_left = spin_multiplicity(size, twice_j)
        m_right = spin_multiplicity(b - size, twice_j)
        if not m_left or not m_right:
            continue
        probability = (m_left * m_right) / d
        eigenvalue = m_right / (d * (twice_j + 1))
        normalization += probability
        answer -= probability * math.log2(eigenvalue)
    assert abs(normalization - 1) < 1e-10
    return answer


def sector_capacity(b: int, p: float, family: str, w: int | None = None) -> float:
    if p >= 0.5:
        return 0.0
    if family == "charge":
        w = b // 2 if w is None else w
        entropies = [charge_marginal_entropy(b, w, size) for size in range(b + 1)]
    elif family == "singlet":
        entropies = [singlet_marginal_entropy(b, size) for size in range(b + 1)]
    else:
        raise ValueError(f"Unknown family: {family}")
    return float(sum(binom.pmf(t, b, p) * (entropies[b - t] - entropies[t]) for t in range(b + 1)))


def check_marginal_entropy_formulas() -> dict:
    """Compare combinatorial formulas with independently diagonalized matrices."""
    residuals = {}
    for b in (4, 6):
        w = b // 2
        weight_projector = np.diag([float(x.bit_count() == w) for x in range(2**b)])
        rho_charge = weight_projector / np.trace(weight_projector)
        js = [collective(a / 2, list(range(b)), b) for a in (X, Y, Z)]
        _, vectors = eigh(sum(j @ j for j in js))
        d = spin_multiplicity(b, 0)
        rho_singlet = vectors[:, :d] @ vectors[:, :d].conj().T / d
        for family, rho, formula in [
            ("charge", rho_charge, lambda size: charge_marginal_entropy(b, w, size)),
            ("singlet", rho_singlet, lambda size: singlet_marginal_entropy(b, size)),
        ]:
            errors = [abs(entropy(reduced_density(rho, list(range(size)), b)) - formula(size))
                      for size in range(b + 1)]
            residuals[f"{family}_b{b}_maximum_entropy_error_bits"] = max(errors)
            assert max(errors) < ATOL
    return residuals


def capacity_data() -> tuple[list[dict], dict]:
    rows = []
    for b in (4, 10, 20, 100):
        for p in (0.1, 0.25, 0.4):
            charge = sector_capacity(b, p, "charge")
            singlet = sector_capacity(b, p, "singlet")
            unrestricted = b * (1 - 2 * p)
            lower_bound = unrestricted - 0.5 * math.log2(2 / p)
            spin_lower_bound = unrestricted - (0.5 + 1.5 * math.log2((b + 2) / ((b + 1) * p)))
            assert charge <= unrestricted + 1e-9
            assert singlet <= charge + 1e-9
            assert charge >= lower_bound - 1e-9
            assert singlet >= spin_lower_bound - 1e-9
            rows.append({
                "block_qubits": b,
                "erasure_probability": p,
                "unrestricted_qubits_per_block": unrestricted,
                "fixed_half_charge_qubits_per_block": charge,
                "singlet_qubits_per_block": singlet,
                "fixed_half_charge_per_physical_qubit": charge / b,
                "singlet_per_physical_qubit": singlet / b,
                "charge_constant_penalty_lower_bound_per_block": lower_bound,
                "singlet_constant_penalty_lower_bound_per_block": spin_lower_bound,
            })
    checks = {}
    for b in (2, 4, 10):
        assert abs(sector_capacity(b, 0, "charge") - logchoose(b, b // 2)) < ATOL
        assert abs(sector_capacity(b, 0, "singlet") - math.log2(spin_multiplicity(b, 0))) < ATOL
        assert sector_capacity(b, 0.5, "charge") == 0
        assert sector_capacity(b, 0.75, "singlet") == 0
    # For half filling the fixed-interior-p penalty tends to this constant.
    for p in (0.1, 0.25, 0.4):
        b = 400
        actual_penalty = b * (1 - 2 * p) - sector_capacity(b, p, "charge")
        predicted = (math.log((1 - p) / p) - (1 - 2 * p)) / (2 * math.log(2))
        checks[str(p)] = {
            "block_qubits": b,
            "numerical_charge_penalty": actual_penalty,
            "predicted_large_block_constant": predicted,
            "absolute_difference": abs(actual_penalty - predicted),
        }
        assert abs(actual_penalty - predicted) < 0.04
        spin_penalty = b * (1 - 2 * p) - sector_capacity(b, p, "singlet")
        checks[str(p)]["numerical_singlet_penalty"] = spin_penalty
        checks[str(p)]["predicted_singlet_constant"] = 3 * predicted
        checks[str(p)]["singlet_absolute_difference"] = abs(spin_penalty - 3 * predicted)
        assert abs(spin_penalty - 3 * predicted) < 0.04
    return rows, checks


def plot_capacities(output: Path) -> None:
    import matplotlib
    matplotlib.use("Agg")
    import matplotlib.pyplot as plt
    plt.rcParams.update({"font.size": 10, "axes.spines.top": False, "axes.spines.right": False})
    ps = np.linspace(0, 0.5, 101)
    fig, ax = plt.subplots(figsize=(7, 4.4), layout="constrained")
    ax.plot(ps, 1 - 2 * ps, color="#151f33", linewidth=2, label="Unrestricted erasure capacity")
    for b, color in [(10, "#9071c9"), (100, "#257a81")]:
        ax.plot(ps, [sector_capacity(b, float(p), "charge") / b for p in ps], color=color,
                label=f"Fixed half charge, b={b}")
        ax.plot(ps, [sector_capacity(b, float(p), "singlet") / b for p in ps], color=color,
                linestyle="--", label=f"SU(2) singlet, b={b}")
    ax.set(xlabel="Independent flagged erasure probability p", ylabel="Qubits per physical qubit",
           xlim=(0, 0.5), ylim=(0, 1.02), title="Exact sector-restricted erasure capacities")
    ax.grid(alpha=0.17)
    ax.legend(frameon=False, fontsize=8)
    fig.savefig(output / "sector_capacity.png", dpi=220)
    fig.savefig(output / "sector_capacity.pdf")
    plt.close(fig)


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--output-dir", type=Path, default=Path(__file__).resolve().parent / "results")
    parser.add_argument("--no-plot", action="store_true")
    args = parser.parse_args()
    args.output_dir.mkdir(parents=True, exist_ok=True)
    rng = np.random.default_rng(SEED)
    summary = {"seed": SEED, "numerical_tolerance": ATOL,
               "status": "Numerical illustrations, not mathematical proofs or novelty certification"}
    summary["su2_moving_boundary"] = check_su2_moving_boundary(rng)
    summary["u1_moving_boundary"] = check_u1_moving_boundary(rng)
    summary["ten_seal_code"] = check_ten_seal_code()
    summary["direct_matrix_marginal_entropy_checks"] = check_marginal_entropy_formulas()
    rows, asymptotics = capacity_data()
    summary["finite_block_capacity_table"] = rows
    summary["charge_penalty_asymptotics_check"] = asymptotics
    with (args.output_dir / "verification.json").open("w") as f:
        json.dump(summary, f, indent=2)
        f.write("\n")
    with (args.output_dir / "capacity_table.csv").open("w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=list(rows[0]))
        writer.writeheader()
        writer.writerows(rows)
    if not args.no_plot:
        plot_capacities(args.output_dir)
    print(json.dumps({"all_assertions_passed": True,
                      "su2_trace_distance_before_twirl": summary["su2_moving_boundary"]["trace_distance_before_final_twirl"],
                      "su2_trace_distance_after_twirl": summary["su2_moving_boundary"]["trace_distance_after_final_twirl"],
                      "u1_trace_distance": summary["u1_moving_boundary"]["trace_distance_to_bare_erasure_without_twirl"],
                      "ten_seal_correctability": summary["ten_seal_code"]["correctability_counts"],
                      "capacity_rows": len(rows)}, indent=2))


if __name__ == "__main__":
    main()