Blame for research/code/verify_broad.py

#!/usr/bin/env python3
"""Reproducible finite checks for spectral shells and diagonal Dyson truncation.

The calculations illustrate stated theorems. They do not certify scientific
priority or replace the proofs. Requires Python 3.10+, numpy, scipy, matplotlib.
Run from any directory: python3 verify_broad.py --output-dir ../results/broad
"""
from __future__ import annotations

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

import numpy as np
from scipy.linalg import expm
from scipy.special import gammaln

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


def bits_table(n: int) -> np.ndarray:
    return np.array([[(a >> (n - 1 - j)) & 1 for j in range(n)]
                     for a in range(2**n)], dtype=int)


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


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


def shell_partition(features: np.ndarray, widths: np.ndarray) -> dict:
    """Partition every basis string into product charge bins; exact floating inputs."""
    n = features.shape[1]
    charges = bits_table(n) @ features.T
    lower = np.minimum(features, 0).sum(axis=1)
    upper = np.maximum(features, 0).sum(axis=1)
    labels = np.floor((charges - lower) / widths).astype(int)
    # An exact endpoint at a range boundary belongs to the final half-open bin.
    count = np.maximum(1, np.ceil((upper - lower) / widths).astype(int))
    labels = np.maximum(0, np.minimum(labels, count - 1))
    groups: dict[tuple[int, ...], list[int]] = {}
    for integer, label in enumerate(labels):
        groups.setdefault(tuple(int(v) for v in label), []).append(integer)
    best_label, indices = min(groups.items(), key=lambda item: (-len(item[1]), item[0]))
    left = lower + np.array(best_label) * widths
    right = np.minimum(left + widths, upper)
    center = (left + right) / 2
    halfwidth = (right - left) / 2
    assert np.all(np.abs(charges[indices] - center) <= halfwidth + 1e-12)
    return {"indices": indices, "center": center, "halfwidth": halfwidth,
            "largest_dimension": len(indices), "occupied_bins": len(groups),
            "safe_bin_count": int(np.prod(count, dtype=object)),
            "charge_range_lengths": upper - lower, "chosen_label": best_label,
            "charges": charges}


def shell_trajectory(rng: np.random.Generator) -> tuple[dict, list[dict]]:
    n = 8
    features = np.vstack([np.sqrt(np.arange(1, n + 1)) / math.sqrt(n),
                          np.sin(np.arange(n) + 0.37)])
    widths = np.array([0.32, 0.37])
    shell = shell_partition(features, widths)
    d = shell["largest_dimension"]
    assert d >= 2
    raw = rng.normal(size=(d, 2)) + 1j * rng.normal(size=(d, 2))
    code, _ = np.linalg.qr(raw)
    initial = np.zeros((2**n, 2, 2), complex)
    initial[shell["indices"], 0, :] = code / math.sqrt(2)
    stages = [
        (list(range(n)), 0.37, [0.53*X+0.19*Z, 0.47*Y-0.11*Z], 0.23*X),
        ([1,2,3,4,5,6,7], 0.51, [0.31*Y-0.29*Z, 0.39*X+0.21*Z], -0.17*Y),
        ([1,3,4,6,7], 0.68, [-0.43*X+0.13*Y, 0.37*Z+0.23*Y], 0.19*X+0.07*Z),
    ]
    states = bits_table(n)
    actual = initial.copy()
    comparison = initial.copy()
    exposure = np.zeros(2)
    for active, duration, couplings, hb in stages:
        exposure += duration * np.array([np.linalg.norm(c, 2) for c in couplings])
        erased = [j for j in range(n) if j not in active]
        for integer in range(2**n):
            qa = features[:, active] @ states[integer, active]
            qe = features[:, erased] @ states[integer, erased] if erased else np.zeros(2)
            h = hb + sum(qa[l] * couplings[l] for l in range(2))
            hc = hb + sum((shell["center"][l] - qe[l]) * couplings[l] for l in range(2))
            actual[integer] = expm(-1j * duration * h) @ actual[integer]
            comparison[integer] = expm(-1j * duration * hc) @ comparison[integer]
    keep = stages[-1][0] + [n + 1]
    target = reduced_pure(initial.reshape(-1), keep, n + 2)
    noisy = reduced_pure(actual.reshape(-1), keep, n + 2)
    compared = reduced_pure(comparison.reshape(-1), keep, n + 2)
    error = trace_distance(noisy, target)
    comparison_error = trace_distance(compared, target)
    bound = float(np.dot(shell["halfwidth"], exposure))
    assert comparison_error < TOL
    assert error <= min(1, bound) + TOL
    assert abs(np.vdot(actual, actual) - 1) < TOL
    tradeoff = []
    for scale in (0.5, 1, 2, 4, 8, 16, 32):
        eta = 0.25
        h = 2 * eta / (2 * scale * exposure)
        chosen = shell_partition(features, h)
        tradeoff.append({"exposure_multiplier": scale,
                        "target_shell_channel_error": eta,
                        "width_feature_1": float(h[0]), "width_feature_2": float(h[1]),
                        "largest_shell_dimension": chosen["largest_dimension"],
                        "occupied_bins": chosen["occupied_bins"],
                        "safe_product_bin_count": chosen["safe_bin_count"],
                        "log2_largest_shell_dimension": math.log2(chosen["largest_dimension"]),
                        "pigeonhole_log2_dimension_lower_bound": n-math.log2(chosen["safe_bin_count"]),
                        "interpretation": "Finite exact enumeration; inverse-exposure bin widths"})
    result = {"physical_qubits": n, "feature_values": features.tolist(),
              "requested_bin_widths": widths.tolist(), "chosen_bin": list(shell["chosen_label"]),
              "chosen_centers": shell["center"].tolist(),
              "actual_halfwidths": shell["halfwidth"].tolist(),
              "largest_shell_dimension": d, "chosen_basis_indices": shell["indices"],
              "integrated_feature_exposures": exposure.tolist(),
              "known_erased_sites": [0,2,5],
              "reference_trace_distance_to_bare_erasure": error,
              "reference_comparison_evolution_trace_distance": comparison_error,
              "proved_half_diamond_upper_bound": min(1, bound),
              "noncommuting_bath_commutator_norm": float(np.linalg.norm(
                  stages[0][2][0]@stages[0][2][1]-stages[0][2][1]@stages[0][2][0], 2))}
    return result, tradeoff


def choi(kraus: list[np.ndarray]) -> np.ndarray:
    vectors = [k.reshape(-1, order="F") for k in kraus]
    return sum((np.outer(v, v.conj()) for v in vectors),
               np.zeros((len(vectors[0]), len(vectors[0])), complex))


def cp_dyson_checks() -> list[dict]:
    """Full Choi PSD test for approximate CP maps; maps need not be TP."""
    n, r_sites, t_erased, bath = 3, 2, 1, 2
    d_a, d_r = 2**n, 2**r_sites
    couplings = [0.41*X+0.13*Z, 0.29*Y-0.17*Z, 0.23*Z+0.11*X]
    duration = 0.19
    h = np.zeros((d_a*bath, d_a*bath), complex)
    for a, bits in enumerate(bits_table(n)):
        h[a*bath:(a+1)*bath, a*bath:(a+1)*bath] = sum(bits[j]*couplings[j] for j in range(n))
    exact = expm(-1j*duration*h)
    a_budget = duration * sum(np.linalg.norm(c, 2) for c in couplings)
    bare = []
    for e in range(2**t_erased):
        k = np.zeros((d_r, d_a), complex)
        for r in range(d_r): k[r, r*2+e] = 1
        bare.append(k)
    sector_indices = [a for a in range(d_a) if a.bit_count() == 1]
    sector_embedding = np.eye(d_a)[:, sector_indices]
    rows = []
    for s in (0, 1, 2):
        truncated = np.eye(d_a*bath, dtype=complex)
        term = np.eye(d_a*bath, dtype=complex)
        for degree in range(1, s+1):
            term = term @ (-1j*duration*h) / degree
            truncated += term
        tau = math.exp(a_budget + (s+1)*math.log(a_budget) - gammaln(s+2))
        actual_tail = float(np.linalg.norm(exact-truncated, 2))
        assert actual_tail <= tau + TOL
        # Pure |0> bath preparation gives one column per physical input string.
        vs = truncated[:, np.arange(d_a)*bath]
        norm_vs_sq = float(np.linalg.norm(vs, 2)**2)
        assert norm_vs_sq <= (1+tau)**2 + TOL
        masks = [mask for mask in range(d_r) if mask.bit_count() <= s]
        m = len(masks)
        coefficients = np.zeros((2, bath, d_r), complex)
        for e in range(2):
            for b in range(bath):
                amplitudes = np.array([vs[(r*2+e)*bath+b, r*2+e] for r in range(d_r)])
                for mask in range(d_r):
                    coefficients[e,b,mask] = sum(amplitudes[r] * (-1)**((r&mask).bit_count())
                                                 for r in range(d_r)) / d_r
        forbidden = [mask for mask in range(d_r) if mask not in masks]
        forbidden_norm = float(np.max(np.abs(coefficients[:,:,forbidden]))) if forbidden else 0.0
        assert forbidden_norm < TOL
        gram_traces, gram_max_eigenvalues = [], []
        for e in range(2):
            c = coefficients[e][:,masks]
            gram = c.T @ c.conj()
            gram_traces.append(float(np.trace(gram).real))
            gram_max_eigenvalues.append(float(np.linalg.eigvalsh(gram)[-1]))
            assert gram_traces[-1] <= norm_vs_sq + TOL
        approx_kraus = []
        canonical = []
        for e in range(2):
            for b in range(bath):
                k = np.zeros((d_r,d_a), complex)
                for r in range(d_r): k[r,r*2+e] = vs[(r*2+e)*bath+b,r*2+e]
                approx_kraus.append(k)
            for mask in masks:
                phase = np.diag([(-1)**((r&mask).bit_count()) for r in range(d_r)])
                canonical.append(phase @ bare[e] / math.sqrt(m))
        domination = m*(1+tau)**2
        values = {}
        for name, embedding in [("full_input",np.eye(d_a)), ("weight_one_input",sector_embedding)]:
            jpsi = choi([k@embedding for k in approx_kraus])
            jphi = choi([k@embedding for k in canonical])
            diff = domination*jphi-jpsi
            smallest = float(np.linalg.eigvalsh((diff+diff.conj().T)/2)[0])
            assert smallest >= -TOL
            values[name+"_minimum_Choi_domination_eigenvalue"] = smallest
        rows.append({"physical_qubits":n,"surviving_qubits":r_sites,"erased_qubits":t_erased,
                     "truncation_order":s,"a_integrated_norm_budget":float(a_budget),
                     "tail_bound_tau":tau,"actual_joint_unitary_tail_norm":actual_tail,
                     "phase_support_count_M":m,"CP_domination_factor":domination,
                     "approximate_amplitude_operator_norm_squared":norm_vs_sq,
                     "Gram_traces_by_erasure_basis":gram_traces,
                     "Gram_maximum_eigenvalues_by_erasure_basis":gram_max_eigenvalues,
                     "forbidden_phase_coefficient_maximum":forbidden_norm,
                     "canonical_channel": "bare erasure followed by uniform Z masks of weight <=s",
                     "Choi_normalization": "unnormalized column-stacked Kraus Choi",
                     **values})
    return rows


def h2(x: float) -> float:
    if x <= 0 or x >= 1: return 0.0
    return -x*math.log2(x)-(1-x)*math.log2(1-x)


def support_tail_rows() -> list[dict]:
    rows = []
    for nu in (1,2,3):
        for beta in (0.25,0.5,1.0):
            for exponent in (3,4,5,6,8,10,12):
                n = 10**exponent
                cell = max(2, int(math.ceil(math.log(n)**2)))
                epsilon = min(1.0, (cell/n)**(beta/nu))
                a = n*epsilon
                s = int(math.ceil(math.e**2*a + 4*math.log(n)))
                fraction = min(1.0, s/n)
                logtau = a+(s+1)*math.log(a)-gammaln(s+2)
                log_m_bound = n*h2(fraction) if fraction <= .5 else n
                # Exact finite support count is checked only at small n; its
                # entropy upper envelope is evaluated at the large n above.
                rows.append({"N":n,"spatial_dimension_nu":nu,"Holder_beta":beta,
                             "cell_qubits_b":cell,"per_site_integrated_residual_epsilon":epsilon,
                             "a_integrated_total_budget":a,"support_cutoff_s":s,
                             "support_fraction_s_over_N":s/n,
                             "log_safe_Dyson_tail_bound":float(logtau),
                             "log2_phase_support_count_upper_bound":log_m_bound,
                             "normalized_log2_support_count_upper_bound":log_m_bound/n,
                             "interpretation":"Dyson-tail and support-entropy envelope, not achieved finite code rate"})
                assert logtau < 0
    for n in (8,16,32,64):
        for s in range(0,n//2+1):
            exact = sum(math.comb(n,w) for w in range(s+1))
            assert math.log2(exact) <= n*h2(s/n)+1e-10
    return rows


def shell_rate_rows() -> list[dict]:
    rows = []
    for n in [2**k for k in range(4,27)]:
        for rank in (1,2,4,8):
            for exposure_exponent in (0,1,2):
                exposure = n**exposure_exponent
                target = 1/n
                width = 2*target/(rank*exposure)
                bins_per_feature = max(1, math.ceil(n/width))
                deficit = rank*math.log2(bins_per_feature)
                rows.append({"N":n,"feature_count_r":rank,"exposure_exponent":exposure_exponent,
                             "per_feature_exposure":exposure,"target_shell_error":target,
                             "bin_width":width,"safe_label_deficit_qubits":deficit,
                             "normalized_label_deficit":deficit/n,"erasure_probability_p":.1,
                             "dimension_based_rate_threshold":max(0.0,.8-deficit/n),
                             "interpretation":"Dimension threshold before finite erasure coding slack; feature ranges <=N"})
    return rows


def continuous_rate_certificates() -> list[dict]:
    """Evaluate the manuscript's sufficient C0 finite-error certificate.

    The geometry-dependent input is an asserted per-site residual budget
    epsilon=0.01*(b/N)^(beta/nu); the numerical curves do not establish that
    budget for a particular device. All entropy/sector estimates are upper or
    lower envelopes in the safe direction specified by the theorem.
    """
    rows=[]
    p,target,amplitude=.1,.01,.01
    for nu in (1,2,3):
        for beta in (.25,.5,1.0):
            for exponent in range(4,13):
                n=10**exponent
                b=max(2,int(math.ceil(math.log(n)**2)))
                cells=math.ceil(n/b)
                logd_lower=n-cells*math.log2(1+n/cells)
                epsilon=amplitude*(b/n)**(beta/nu)
                a=n*epsilon
                s=int(math.ceil(math.e**2*a+4*math.log(n)))
                logtau=a+(s+1)*math.log(a)-gammaln(s+2)
                tau=math.exp(logtau) if logtau>-745 else 0.0
                log_tail_error=logtau+math.log(2+tau)
                tail_ok=log_tail_error<=math.log(target/4)
                eta=math.sqrt(math.log(4/target)/(2*n))
                cutoff_ok=s<=n/2
                logm=n*h2(s/n) if cutoff_ok else float(n)
                # The root theorem uses 3 log M, not a guessed asymptotic
                # proxy: (1+tau)^2 2^[(ell+2N(p+eta)+3logM-logD)/2]<=target/2.
                correction=2*math.log2(target/(2*(1+tau)**2))
                ell_bound=logd_lower-2*n*(p+eta)-3*logm+correction
                logical=max(0,int(math.floor(ell_bound))-16) if tail_ok and cutoff_ok else 0
                if logical:
                    log_middle=2*math.log1p(tau)+math.log(2)*(logical+2*n*(p+eta)+3*logm-logd_lower)/2
                    assert log_middle<=math.log(target/2)+1e-9
                rows.append({"N":n,"nu":nu,"Holder_beta":beta,"p":p,
                             "target_entanglement_infidelity":target,"residual_amplitude":amplitude,
                             "cell_qubits_b":b,"cell_count_C":cells,
                             "log2_sector_dimension_lower_bound":logd_lower,
                             "per_site_residual_epsilon":epsilon,"support_cutoff_s":s,
                             "support_fraction":s/n,"log_Dyson_tail_bound":float(logtau),
                             "log_tail_infidelity_bound":float(log_tail_error),
                             "tail_budget_certified":bool(tail_ok),"entropy_bound_applicable":bool(cutoff_ok),
                             "erasure_slack_eta":eta,"log2_support_count_upper_bound":logm,
                             "logical_qubits_certified":logical,"certified_rate":logical/n,
                             "interpretation":"Sufficient finite-error certificate from proved envelopes; no implemented decoder"})
    return rows


def write_csv(path: Path, rows: list[dict]) -> None:
    with path.open("w",newline="") as f:
        writer=csv.DictWriter(f,fieldnames=list(rows[0]));writer.writeheader();writer.writerows(rows)


def make_plots(output: Path, shells: list[dict], rates: list[dict], tails: list[dict], certificates: list[dict]) -> 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})
    fig,ax=plt.subplots(figsize=(7,4.3),layout="constrained")
    for rank,color in [(1,"#267882"),(2,"#517fa7"),(4,"#9174b3"),(8,"#ad6b59")]:
        chosen=[r for r in rates if r["feature_count_r"]==rank and r["exposure_exponent"]==1]
        ax.plot([r["N"] for r in chosen],[r["dimension_based_rate_threshold"] for r in chosen],
                label=f"{rank} real-valued feature"+("s" if rank != 1 else ""),color=color)
    ax.axhline(.8,color="#354052",linestyle="--",label="Erasure limit, p=0.1")
    ax.set(xscale="log",xlabel="Physical qubits N",ylabel="Dimension-based rate threshold",
           title="Real-charge shells: exposure N, target field error 1/N",ylim=(-.02,.83))
    ax.text(.03,.06,"Excludes finite erasure-code slack; profile charge ranges ≤ N",transform=ax.transAxes,fontsize=8)
    ax.legend(frameon=False,fontsize=8);ax.grid(alpha=.16)
    for ext in ("png","pdf"):fig.savefig(output/f"real_shell_rate_bounds.{ext}",dpi=220)
    plt.close(fig)
    fig,axes=plt.subplots(1,2,figsize=(9,3.8),layout="constrained")
    axes[0].plot([r["exposure_multiplier"] for r in shells],
                 [r["largest_shell_dimension"] for r in shells],marker="o",color="#267882")
    axes[0].set_xscale("log",base=2)
    axes[0].set(xlabel="Exposure multiplier",ylabel="Largest shell dimension",
                title="Eight-site exact enumeration")
    for nu,color in [(1,"#267882"),(2,"#9174b3"),(3,"#ad6b59")]:
        chosen=[r for r in tails if r["spatial_dimension_nu"]==nu and r["Holder_beta"]==.5]
        axes[1].plot([r["N"] for r in chosen],
                     [r["normalized_log2_support_count_upper_bound"] for r in chosen],
                     marker="o",color=color,label=f"Spatial dimension {nu}")
    axes[1].set(xscale="log",xlabel="Physical qubits N",ylabel="Upper bound on log₂ M / N",
                title="Dyson support envelope, Hölder β=1/2",ylim=(-.02,1.03))
    axes[1].legend(frameon=False,fontsize=8)
    for ax in axes:ax.grid(alpha=.16)
    fig.suptitle("Bound and enumeration diagnostics; no measured hardware rates",fontsize=10)
    for ext in ("png","pdf"):fig.savefig(output/f"shell_and_Dyson_diagnostics.{ext}",dpi=220)
    plt.close(fig)
    fig,axes=plt.subplots(1,2,figsize=(9,3.8),layout="constrained")
    for nu,color in [(1,"#267882"),(2,"#9174b3"),(3,"#ad6b59")]:
        chosen=[r for r in certificates if r["nu"]==nu and r["Holder_beta"]==.5]
        axes[0].plot([r["N"] for r in chosen],[r["certified_rate"] for r in chosen],
                     marker="o",color=color,label=f"Dimension {nu}")
    for beta,color in [(.25,"#ad6b59"),(.5,"#9174b3"),(1.0,"#267882")]:
        chosen=[r for r in certificates if r["nu"]==2 and r["Holder_beta"]==beta]
        axes[1].plot([r["N"] for r in chosen],[r["certified_rate"] for r in chosen],
                     marker="o",color=color,label=f"Hölder β={beta:g}")
    for ax in axes:
        ax.axhline(.8,color="#354052",linestyle="--",linewidth=1)
        ax.set(xscale="log",xlabel="Physical qubits N",ylabel="Sufficient certified rate",ylim=(-.02,.83))
        ax.legend(frameon=False,fontsize=8);ax.grid(alpha=.16)
    axes[0].set_title("Hölder β=1/2")
    axes[1].set_title("Spatial dimension 2")
    fig.suptitle("Finite-error bound: p=0.1, target error=0.01, residual amplitude=0.01",fontsize=10)
    for ext in ("png","pdf"):fig.savefig(output/f"continuous_field_certificates.{ext}",dpi=220)
    plt.close(fig)


def main() -> None:
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--output-dir",type=Path,default=Path(__file__).resolve().parents[1]/"results"/"broad")
    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)
    trajectory,shells=shell_trajectory(rng)
    cp=cp_dyson_checks();tails=support_tail_rows();rates=shell_rate_rows();certificates=continuous_rate_certificates()
    summary={"seed":SEED,"numerical_tolerance":TOL,
             "status":"Deterministic numerical checks and analytic envelopes, not novelty certification",
             "real_charge_shell_trajectory":trajectory,"finite_shell_exposure_tradeoff":shells,
             "Dyson_CP_domination_checks":cp,"Dyson_support_tail_envelopes":tails,
             "real_charge_shell_rate_envelopes":rates,"continuous_field_rate_certificates":certificates}
    (args.output_dir/"broad_verification.json").write_text(json.dumps(summary,indent=2)+"\n")
    write_csv(args.output_dir/"finite_shell_tradeoff.csv",shells)
    write_csv(args.output_dir/"Dyson_CP_checks.csv",cp)
    write_csv(args.output_dir/"Dyson_support_envelopes.csv",tails)
    write_csv(args.output_dir/"real_shell_rate_envelopes.csv",rates)
    write_csv(args.output_dir/"continuous_field_certificates.csv",certificates)
    if not args.no_plot:make_plots(args.output_dir,shells,rates,tails,certificates)
    print(json.dumps({"all_assertions_passed":True,
                      "shell_reference_error":trajectory["reference_trace_distance_to_bare_erasure"],
                      "shell_proved_bound":trajectory["proved_half_diamond_upper_bound"],
                      "comparison_evolution_error":trajectory["reference_comparison_evolution_trace_distance"],
                      "smallest_CP_domination_eigenvalue":min(r["full_input_minimum_Choi_domination_eigenvalue"] for r in cp),
                      "rows":{"CP":len(cp),"tails":len(tails),"rates":len(rates),"finite_certificates":len(certificates)}},indent=2))


if __name__=="__main__":main()