Blame for research/code/verify_spatial.py

#!/usr/bin/env python3
"""Checks for spatial moment sectors, smooth longitudinal fields, and decoupling.

This script is separate from verify.py and leaves the earlier verification
unchanged. Numerical checks illustrate claims; they do not certify novelty or
replace proofs. Run: python3 verify_spatial.py --output-dir spatial_results
Requires Python 3.10+, NumPy, SciPy, Matplotlib.
"""
from __future__ import annotations

import argparse
import csv
from functools import lru_cache
import json
import math
from pathlib import Path
import random

import numpy as np
from scipy.linalg import expm

from verify import I2, X, Y, Z, reduced_density, reduced_pure, trace_distance

SEED = 20261102
ATOL = 4e-11


def joint_sector_counts(n: int) -> dict[tuple[int, int], int]:
    """Exact DP for Hamming weight and dipole sum using positions 0,...,n-1."""
    counts = {(0, 0): 1}
    for position in range(n):
        updated = dict(counts)
        for (weight, dipole), multiplicity in counts.items():
            key = weight + 1, dipole + position
            updated[key] = updated.get(key, 0) + multiplicity
        counts = updated
    assert sum(counts.values()) == 2**n
    return counts


class MomentSectorEncoder:
    """Exact lexicographic rank/unrank encoder for a joint (Q0,Q1) sector.

    Rank is an integer label, not a claim of an efficient coherent gate circuit.
    Completion counts use arbitrary precision Python integers.
    """

    def __init__(self, n: int, weight: int, dipole: int):
        self.n, self.weight, self.dipole = n, weight, dipole

        @lru_cache(maxsize=None)
        def completions(position: int, weight_left: int, dipole_left: int) -> int:
            available = n - position
            if weight_left < 0 or weight_left > available:
                return 0
            minimum = weight_left * (2 * position + weight_left - 1) // 2
            maximum = weight_left * (2 * n - weight_left - 1) // 2
            if dipole_left < minimum or dipole_left > maximum:
                return 0
            if position == n:
                return int(weight_left == 0 and dipole_left == 0)
            return (completions(position + 1, weight_left, dipole_left)
                    + completions(position + 1, weight_left - 1, dipole_left - position))

        self._completions = completions
        self.dimension = completions(0, weight, dipole)
        if not self.dimension:
            raise ValueError("The requested moment sector is empty")

    def unrank(self, rank: int) -> str:
        if not 0 <= rank < self.dimension:
            raise ValueError("Rank lies outside the sector")
        weight_left, dipole_left = self.weight, self.dipole
        bits = []
        for position in range(self.n):
            zeros = self._completions(position + 1, weight_left, dipole_left)
            if rank < zeros:
                bits.append("0")
            else:
                bits.append("1")
                rank -= zeros
                weight_left -= 1
                dipole_left -= position
        assert rank == 0 and weight_left == 0 and dipole_left == 0
        return "".join(bits)

    def rank(self, bitstring: str) -> int:
        if len(bitstring) != self.n or any(bit not in "01" for bit in bitstring):
            raise ValueError("Expected an n-character binary string")
        if sum(map(int, bitstring)) != self.weight:
            raise ValueError("Incorrect Q0 moment")
        if sum(j * int(bit) for j, bit in enumerate(bitstring)) != self.dipole:
            raise ValueError("Incorrect Q1 moment")
        result = 0
        weight_left, dipole_left = self.weight, self.dipole
        for position, bit in enumerate(bitstring):
            if bit == "1":
                result += self._completions(position + 1, weight_left, dipole_left)
                weight_left -= 1
                dipole_left -= position
        return result


def sector_dp_checks() -> list[dict]:
    rng = random.Random(SEED)
    rows = []
    for n in (4, 8, 12, 16, 24, 32, 64):
        counts = joint_sector_counts(n)
        sector, dimension = min(counts.items(), key=lambda item: (-item[1], item[0]))
        weight, dipole = sector
        encoder = MomentSectorEncoder(n, weight, dipole)
        assert encoder.dimension == dimension
        test_ranks = set([0, dimension - 1, dimension // 2])
        test_ranks.update(rng.randrange(dimension) for _ in range(min(30, dimension)))
        if dimension <= 1000:
            test_ranks.update(range(dimension))
        for rank in test_ranks:
            assert encoder.rank(encoder.unrank(rank)) == rank
        pigeonhole_lower = 2**n / ((n + 1) * (n * (n - 1) // 2 + 1))
        requested_safe_lower = 2**n / ((n + 1) * (n * (n + 1) // 2 + 1))
        assert dimension >= pigeonhole_lower
        rows.append({
            "cell_qubits": n, "Q0": weight, "Q1_zero_based": dipole,
            "Q1_one_based": dipole + weight,
            "largest_sector_dimension_exact": dimension,
            "sector_count": len(counts), "total_strings_exact": sum(counts.values()),
            "log2_largest_sector_dimension": math.log2(dimension),
            "largest_sector_fraction_log2": math.log2(dimension) - n,
            "pigeonhole_dimension_lower_bound": pigeonhole_lower,
            "stated_safe_dimension_lower_bound": requested_safe_lower,
            "rank_unrank_roundtrips": len(test_ranks),
            "first_bitstring": encoder.unrank(0),
            "last_bitstring": encoder.unrank(dimension - 1),
        })
    return rows


def random_reference_state(n: int, indices: list[int], rng: np.random.Generator) -> np.ndarray:
    raw = rng.normal(size=(len(indices), 2)) + 1j * rng.normal(size=(len(indices), 2))
    code, _ = np.linalg.qr(raw)
    state = np.zeros((2**n, 2, 2), complex)
    state[indices, 0, 0] = code[:, 0] / math.sqrt(2)
    state[indices, 0, 1] = code[:, 1] / math.sqrt(2)
    return state


def conditional_evolve(state: np.ndarray, active: list[int], coordinates: np.ndarray,
                       b0: np.ndarray, b1: np.ndarray, b2: np.ndarray,
                       curvature: float, bath_h: np.ndarray, duration: float) -> np.ndarray:
    """Exact longitudinal evolution using one 2x2 bath unitary per bitstring."""
    n = len(coordinates)
    result = np.empty_like(state)
    for integer in range(2**n):
        occupied = [j for j in active if (integer >> (n - 1 - j)) & 1]
        h = bath_h.copy()
        for j in occupied:
            x = coordinates[j]
            h += b0 + x * b1 + curvature * (x * x / 2) * b2
        result[integer] = expm(-1j * duration * h) @ state[integer]
    return result


def spatial_field_checks(rng: np.random.Generator) -> dict:
    n, span = 8, 1.0
    counts = joint_sector_counts(n)
    (weight, dipole), dimension = min(counts.items(), key=lambda item: (-item[1], item[0]))
    encoder = MomentSectorEncoder(n, weight, dipole)
    indices = [int(encoder.unrank(rank), 2) for rank in range(dimension)]
    coordinates = (np.arange(n) - (n - 1) / 2) * span / n
    initial = random_reference_state(n, indices, rng)
    charge_indices = [integer for integer in range(2**n) if integer.bit_count() == weight]
    charge_only_initial = random_reference_state(n, charge_indices, rng)
    # Erased registers are kept as inert environmental registers in this dilation.
    stages = [
        {"active": list(range(n)), "duration": 0.41,
         "b0": 0.67 * X + 0.21 * Z, "b1": 1.19 * Z + 0.31 * Y,
         "b2": X, "bath_h": 0.37 * Y},
        {"active": [1, 2, 3, 4, 5, 6, 7], "duration": 0.63,
         "b0": -0.43 * Y + 0.39 * Z, "b1": 0.89 * X - 0.61 * Z,
         "b2": Y, "bath_h": 0.23 * X + 0.31 * Z},
        {"active": [1, 3, 4, 6, 7], "duration": 0.79,
         "b0": 0.57 * X - 0.47 * Z, "b1": -0.99 * Y + 0.73 * Z,
         "b2": Z, "bath_h": -0.29 * X + 0.41 * Y},
    ]
    final_survivors = stages[-1]["active"]
    keep = final_survivors + [n + 1]
    target = reduced_pure(initial.reshape(-1), keep, n + 2)
    charge_target = reduced_pure(charge_only_initial.reshape(-1), keep, n + 2)

    def run(state: np.ndarray, curvature: float) -> np.ndarray:
        for stage in stages:
            state = conditional_evolve(state, stage["active"], coordinates,
                                       stage["b0"], stage["b1"], stage["b2"],
                                       curvature, stage["bath_h"], stage["duration"])
        return state

    affine = run(initial, 0.0)
    affine_output = reduced_pure(affine.reshape(-1), keep, n + 2)
    affine_error = trace_distance(affine_output, target)
    assert affine_error < ATOL
    charge_output = reduced_pure(run(charge_only_initial, 0.0).reshape(-1), keep, n + 2)
    charge_only_error = trace_distance(charge_output, charge_target)
    assert charge_only_error > 1e-3
    curvature_rows = []
    for curvature in (0.03, 0.1, 0.3):
        actual_output = reduced_pure(run(initial, curvature).reshape(-1), keep, n + 2)
        actual_error = trace_distance(actual_output, target)
        # Each quadratic residual has positive scalar coefficients multiplying
        # one norm-one bath Pauli in this piecewise-constant example.
        integrated_residual_norm = sum(stage["duration"] * curvature *
                                       sum(coordinates[j]**2 / 2 for j in stage["active"])
                                       for stage in stages)
        a2 = curvature * sum(stage["duration"] for stage in stages)
        theorem_bound = span**2 * a2 * (n*n - 1) / (24 * n)
        assert actual_error <= min(1.0, integrated_residual_norm) + ATOL
        assert integrated_residual_norm <= theorem_bound + ATOL
        curvature_rows.append({
            "curvature_norm": curvature, "integrated_curvature_A2": a2,
            "reference_state_trace_distance": actual_error,
            "exact_integrated_residual_norm": integrated_residual_norm,
            "theorem_half_diamond_upper_bound": min(1.0, theorem_bound),
            "unclipped_theorem_bound": theorem_bound,
        })
    return {
        "physical_qubits": n, "span_a": span, "coordinates": coordinates.tolist(),
        "coordinate_convention": "spacing a/N, centered cell; occupied extent a*(N-1)/N",
        "Q0": weight, "Q1_zero_based": dipole, "sector_dimension": dimension,
        "bath_dimension": 2, "reference_dimension": 2,
        "final_survivors_zero_based": final_survivors,
        "known_erased_positions": [0, 2, 5],
        "affine_field_reference_state_trace_distance": affine_error,
        "charge_only_gradient_counterexample_trace_distance": charge_only_error,
        "noncommuting_field_operator_commutator_norm_example": float(np.linalg.norm(
            stages[0]["b0"] @ stages[0]["b1"] - stages[0]["b1"] @ stages[0]["b0"], 2)),
        "curvature_checks": curvature_rows,
    }


def haar_isometry(rows: int, columns: int, rng: np.random.Generator) -> np.ndarray:
    a = rng.normal(size=(rows, columns)) + 1j * rng.normal(size=(rows, columns))
    q, r = np.linalg.qr(a)
    phase = np.diag(r) / np.abs(np.diag(r))
    return q * phase.conj()[None, :]


def decoupling_monte_carlo(rng: np.random.Generator, samples: int) -> list[dict]:
    n, k = 4, 2
    rows = []
    families = {
        "weight_two_sector": [integer for integer in range(16) if integer.bit_count() == 2],
        "full_four_qubit_space": list(range(16)),
    }
    for family, basis in families.items():
        d = len(basis)
        omega = np.zeros((16, 16), complex)
        omega[basis, basis] = 1 / d
        for erased in ([0], [0, 1]):
            kept = [j for j in range(n) if j not in erased]
            de = 2**len(erased)
            omega_e = reduced_density(omega, erased, n)
            omega_r = reduced_density(omega, kept, n)
            purity_e = float(np.trace(omega_e @ omega_e).real)
            purity_r = float(np.trace(omega_r @ omega_r).real)
            predicted_hs = ((d * k - 1) / (k * (d*d - 1))) * (d * purity_r - purity_e)
            hs_values, trace_norms = [], []
            for _ in range(samples):
                isometry = haar_isometry(d, k, rng)
                state = np.zeros((16, k), complex)
                state[basis] = isometry / math.sqrt(k)
                # Reorder qubits to (reference, erased sites, retained sites).
                rho_le = reduced_pure(state.reshape(-1), [n] + erased, n + 1)
                delta = rho_le - np.kron(I2 / k, omega_e)
                hs_values.append(float(np.trace(delta @ delta).real))
                trace_norms.append(float(np.abs(np.linalg.eigvalsh(delta)).sum()))
            hs_mean = float(np.mean(hs_values))
            hs_se = float(np.std(hs_values, ddof=1) / math.sqrt(samples))
            mean_trace = float(np.mean(trace_norms))
            zscore = abs(hs_mean - predicted_hs) / hs_se if hs_se else 0.0
            # Statistical reporting, not a brittle assertion on a sample mean.
            assert abs(predicted_hs) > 0
            rows.append({
                "subspace": family, "physical_qubits": n, "D": d, "K": k,
                "erased_qubits": len(erased), "d_E": de, "samples": samples,
                "Omega_E_purity": purity_e, "Omega_R_purity": purity_r,
                "predicted_mean_HS_squared": predicted_hs,
                "empirical_mean_HS_squared": hs_mean,
                "empirical_HS_standard_error": hs_se,
                "standard_errors_from_prediction": zscore,
                "empirical_mean_trace_norm": mean_trace,
                "HS_Cauchy_bound_for_mean_trace_norm": math.sqrt(k * de * predicted_hs),
                "simple_mean_trace_norm_upper_bound": math.sqrt(k * de**2 / d),
                "delta_definition": "rho_reference,E - I_reference/K tensor Omega_E",
            })
    return rows


def dimension_cost(n: int, cell_size: int) -> float:
    """Log2 product-sector dimension lower bound, exact for cell partition sizes."""
    full, remainder = divmod(n, cell_size)
    def penalty(length: int) -> float:
        return math.log2((length + 1) * (length * (length - 1) / 2 + 1))
    cost = full * penalty(cell_size) + (penalty(remainder) if remainder else 0)
    return n - cost


def tradeoff_rows() -> list[dict]:
    n, p, span, a2 = 1_000_000, 0.1, 1.0, 1.0
    rows = []
    for b in sorted(set([4, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256,
                         384, 512, 768, 1024])):
        logd = dimension_cost(n, b)
        rows.append({
            "physical_qubits_N": n, "cell_max_qubits_b": b,
            "erasure_probability_p": p, "span_a": span, "integrated_curvature_A2": a2,
            "log2_product_sector_dimension_lower_bound": logd,
            "sector_dimension_lower_bound_per_qubit": logd / n,
            "sufficient_asymptotic_rate_threshold_from_dimension_bound": max(0.0, logd / n - 2*p),
            "unclipped_dimension_rate_expression": logd / n - 2*p,
            "curvature_half_diamond_upper_bound": min(1.0, span**2 * a2 * b*b / (24*n)),
            "unclipped_curvature_bound": span**2 * a2 * b*b / (24*n),
            "interpretation": "Analytic dimension/rate bounds, not finite-block achieved coding rates",
        })
    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 analytic_horizon_checks() -> list[dict]:
    """Check finite degree selection in log space; no huge time is exponentiated."""
    rows = []
    ratio = 0.25
    for n in (10_000, 1_000_000, 100_000_000, 1_000_000_000_000):
        for gamma in (0.2, 0.4):
            log_lambda = n ** gamma
            log_target = -2 * math.log(n)
            degree_plus_one = max(1, math.ceil(
                (math.log(n) + log_lambda - log_target - math.log1p(-ratio)) / abs(math.log(ratio))))
            log_bound = math.log(n) + log_lambda + degree_plus_one * math.log(ratio) - math.log1p(-ratio)
            assert log_bound <= log_target + 1e-9
            redundancy = degree_plus_one + degree_plus_one * (degree_plus_one + 1) * math.log2(n) / 2
            rows.append({
                "physical_qubits_N": n, "gamma": gamma,
                "log_integrated_amplitude_Lambda": log_lambda,
                "geometric_ratio": ratio, "degree": degree_plus_one - 1,
                "log_target_field_error": log_target,
                "log_proved_field_error_bound": log_bound,
                "sector_redundancy_upper_bound_qubits": redundancy,
                "redundancy_bound_per_physical_qubit": redundancy / n,
                "interpretation": "Analytic model bounds; growing horizon assumes zero losses or fixed endpoint p<1/2",
            })
    return rows


def plot_tradeoff(path: Path, rows: 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, axes = plt.subplots(1, 2, figsize=(9.1, 3.9), layout="constrained")
    bs = [row["cell_max_qubits_b"] for row in rows]
    rates = [row["sufficient_asymptotic_rate_threshold_from_dimension_bound"] for row in rows]
    errors = [row["unclipped_curvature_bound"] for row in rows]
    axes[0].semilogx(bs, rates, base=2, color="#276d83", marker="o", markersize=3)
    axes[0].axhline(0.8, color="#46505f", linestyle="--", linewidth=1,
                    label="Unrestricted asymptotic limit: 0.8")
    axes[0].set(xlabel="Maximum qubits per cell b", ylabel="Sufficient asymptotic rate threshold",
                title="Counting bound improves with cell size", ylim=(-0.05, 0.85))
    axes[0].legend(frameon=False, fontsize=8, loc="lower right")
    axes[1].loglog(bs, errors, base=2, color="#9356a0", marker="o", markersize=3)
    axes[1].set(xlabel="Maximum qubits per cell b", ylabel="Curvature error upper bound",
                title="Smooth-field error grows with cell size")
    for ax in axes:
        ax.grid(alpha=0.18)
    fig.suptitle("Analytic bounds: N=10^6, p=0.1, a=1, integrated curvature A2=1", fontsize=11)
    fig.savefig(path / "spatial_tradeoff.png", dpi=220)
    fig.savefig(path / "spatial_tradeoff.pdf")
    plt.close(fig)


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--output-dir", type=Path,
                        default=Path(__file__).resolve().parent / "spatial_results")
    parser.add_argument("--samples", type=int, default=2000)
    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)
    dp = sector_dp_checks()
    field = spatial_field_checks(rng)
    decoupling = decoupling_monte_carlo(rng, args.samples)
    tradeoff = tradeoff_rows()
    horizons = analytic_horizon_checks()
    summary = {
        "seed": SEED, "numerical_tolerance": ATOL,
        "status": "Numerical illustrations and exact integer enumeration; not novelty certification",
        "joint_moment_sector_DP": dp,
        "spatial_field_trajectory_checks": field,
        "random_subspace_decoupling_checks": decoupling,
        "analytic_tradeoff_bounds": tradeoff,
        "analytic_horizon_degree_checks": horizons,
    }
    with (args.output_dir / "spatial_verification.json").open("w") as f:
        json.dump(summary, f, indent=2)
        f.write("\n")
    write_csv(args.output_dir / "moment_sector_counts.csv", dp)
    write_csv(args.output_dir / "decoupling_monte_carlo.csv", decoupling)
    write_csv(args.output_dir / "analytic_tradeoff.csv", tradeoff)
    write_csv(args.output_dir / "analytic_horizon.csv", horizons)
    if not args.no_plot:
        plot_tradeoff(args.output_dir, tradeoff)
    print(json.dumps({
        "all_deterministic_assertions_passed": True,
        "largest_sector_n64": dp[-1],
        "affine_field_error": field["affine_field_reference_state_trace_distance"],
        "charge_only_gradient_counterexample_error": field["charge_only_gradient_counterexample_trace_distance"],
        "curvature_checks": field["curvature_checks"],
        "MC_max_standard_errors_from_prediction": max(
            row["standard_errors_from_prediction"] for row in decoupling),
    }, indent=2))


if __name__ == "__main__":
    main()