#!/usr/bin/env python3 """Finite SDP checks for minimax recovery of complex Schur channels. These floating-point checks supplement proofs and do not prove a universal theorem or certify novelty. Primal, dual, and direct diamond SDPs are solved independently. Rounded primal/dual witnesses are checked by eigenvalues; these are numerical residual checks, not interval-arithmetic certificates. """ from __future__ import annotations import argparse import json from pathlib import Path import cvxpy as cp import numpy as np SEED = 20261103 TOLERANCE = 3e-6 SOLVER_STATUS_COUNTS: dict[str, int] = {} def hermitian(matrix: np.ndarray) -> np.ndarray: return (matrix + matrix.conj().T) / 2 def minimum_eigenvalue(matrix: np.ndarray) -> float: return float(np.linalg.eigvalsh(hermitian(matrix))[0]) def solve(problem: cp.Problem) -> float: value = problem.solve(solver="CLARABEL", tol_gap_abs=2e-9, tol_gap_rel=2e-9, tol_feas=2e-9, max_iter=250) assert problem.status in (cp.OPTIMAL, cp.OPTIMAL_INACCURATE), problem.status SOLVER_STATUS_COUNTS[problem.status] = SOLVER_STATUS_COUNTS.get(problem.status, 0) + 1 return float(np.real(value)) def correlation_kraus(correlation: np.ndarray) -> list[np.ndarray]: eigenvalues, eigenvectors = np.linalg.eigh(hermitian(correlation)) coefficients = (eigenvectors * np.sqrt(np.maximum(eigenvalues, 0.0))).T kraus = [np.diag(row) for row in coefficients] assert np.linalg.norm(sum(k.conj().T @ k for k in kraus) - np.eye(len(correlation))) < 1e-9 reconstructed = sum(np.diag(k)[:, None] * np.diag(k).conj()[None, :] for k in kraus) assert np.linalg.norm(reconstructed - correlation) < 1e-9 return kraus def round_correlation(matrix: np.ndarray, ridge: float = 1e-7) -> np.ndarray: eigenvalues, eigenvectors = np.linalg.eigh(hermitian(matrix)) positive = (eigenvectors * np.maximum(eigenvalues, 0.0)) @ eigenvectors.conj().T diagonal = np.sqrt(np.maximum(np.real(np.diag(positive)), 1e-15)) positive = positive / diagonal[:, None] / diagonal[None, :] return hermitian((1 - ridge) * positive + ridge * np.eye(len(matrix))) def solve_state_cap(correlation: np.ndarray) -> dict: """Independently solve the rank-sized state cap, dual, and packing SDPs.""" dimension = len(correlation) eigenvalues, eigenvectors = np.linalg.eigh(hermitian(correlation)) active = eigenvalues > 1e-9 vectors = np.sqrt(eigenvalues[active])[:, None] * eigenvectors[:, active].conj().T assert np.linalg.norm(vectors.conj().T @ vectors - correlation) < 1e-8 rank = len(vectors) projectors = [np.outer(vectors[:, i], vectors[:, i].conj()) for i in range(dimension)] sigma = cp.Variable((rank, rank), hermitian=True) t = cp.Variable() state = cp.Problem(cp.Maximize(t), [sigma >> 0, cp.trace(sigma) == 1] + [cp.real(cp.trace(sigma @ pi)) >= t for pi in projectors]) state_value = solve(state) q = cp.Variable(dimension) z = cp.Variable() mixture = sum(q[i] * projectors[i] for i in range(dimension)) dual = cp.Problem(cp.Minimize(z), [q >= 0, cp.sum(q) == 1, z * np.eye(rank) - mixture >> 0]) state_dual = solve(dual) weights = cp.Variable(dimension) packing = cp.Problem(cp.Maximize(cp.sum(weights)), [weights >= 0, np.eye(rank) - sum(weights[i] * projectors[i] for i in range(dimension)) >> 0]) packing_value = solve(packing) assert abs(state_value - state_dual) < TOLERANCE assert abs(packing_value - 1 / state_value) < 5 * TOLERANCE sigma_eigenvalues, sigma_eigenvectors = np.linalg.eigh(hermitian(sigma.value)) sigma_rounded = ((sigma_eigenvectors * np.maximum(sigma_eigenvalues, 0)) @ sigma_eigenvectors.conj().T) sigma_rounded /= np.trace(sigma_rounded).real m = hermitian(vectors.conj().T @ sigma_rounded @ vectors) f = np.real(np.diag(m)) lower = float(np.min(f)) * (1 - 1e-9) assert lower > 0 explicit_a = lower * m.conj() / f[:, None] / f[None, :] explicit_a += np.diag(1 - lower / f) psd_violation = max(0.0, -minimum_eigenvalue(explicit_a), -minimum_eigenvalue(correlation * explicit_a - lower * np.ones((dimension, dimension)))) assert psd_violation < 1e-8 assert np.max(np.abs(np.diag(explicit_a) - 1)) < 1e-9 assert abs(state_value - lower) < TOLERANCE return { "state_cap_rank": rank, "state_cap_value": state_value, "state_cap_dual_value": state_dual, "state_cap_duality_gap": abs(state_value - state_dual), "packing_value": packing_value, "packing_reciprocity_error": abs(packing_value - 1 / state_value), "explicit_decoder_lower_value": lower, "explicit_decoder_value_gap": abs(state_value - lower), "explicit_decoder_psd_violation": psd_violation, } def solve_recovery(correlation: np.ndarray) -> dict: dimension = len(correlation) ones = np.ones((dimension, dimension)) a = cp.Variable((dimension, dimension), hermitian=True) lam = cp.Variable() primal = cp.Problem(cp.Maximize(lam), [a >> 0, cp.diag(a) == 1, cp.multiply(correlation, a) - lam * ones >> 0]) value = solve(primal) a_value = hermitian(a.value) z = cp.Variable((dimension, dimension), hermitian=True) y = cp.Variable(dimension) dual = cp.Problem(cp.Minimize(cp.sum(y)), [z >> 0, cp.real(cp.sum(z)) == 1, cp.diag(y) - cp.multiply(correlation.conj(), z) >> 0]) dual_value = solve(dual) z_value = hermitian(z.value) y_value = np.asarray(y.value, dtype=float) direct_a = cp.Variable((dimension, dimension), hermitian=True) direct_y = cp.Variable((dimension, dimension), hermitian=True) s = cp.Variable() direct = cp.Problem(cp.Minimize(2 * s), [direct_a >> 0, cp.diag(direct_a) == 1, direct_y >> 0, direct_y + cp.multiply(correlation, direct_a) - ones >> 0, cp.real(cp.diag(direct_y)) <= s]) direct_value = solve(direct) assert abs(dual_value - value) < TOLERANCE assert abs(direct_value - 2 * (1 - value)) < TOLERANCE raw_violations = [ max(0.0, -minimum_eigenvalue(a_value)), max(0.0, -minimum_eigenvalue(correlation * a_value - value * ones)), max(0.0, -minimum_eigenvalue(z_value)), max(0.0, -minimum_eigenvalue(np.diag(y_value) - correlation.conj() * z_value)), ] assert max(raw_violations) < TOLERANCE a_rounded = round_correlation(a_value) b_rounded = hermitian(correlation * a_rounded) # The ridge in A makes C o A positive definite, so this expression is stable. inverse_quadratic = float(np.real(np.ones(dimension) @ np.linalg.solve( b_rounded, np.ones(dimension)))) rounded_lower = (1 - 1e-8) / inverse_quadratic rounded_primal_violation = max(0.0, -minimum_eigenvalue( b_rounded - rounded_lower * ones)) z_eigenvalues, z_eigenvectors = np.linalg.eigh(z_value) z_rounded = (z_eigenvectors * np.maximum(z_eigenvalues, 0)) @ z_eigenvectors.conj().T z_rounded /= float(np.real(np.sum(z_rounded))) dual_slack = hermitian(np.diag(y_value) - correlation.conj() * z_rounded) y_rounded = y_value + max(0.0, -minimum_eigenvalue(dual_slack)) + 1e-8 rounded_upper = float(np.sum(y_rounded)) rounded_dual_violation = max(0.0, -minimum_eigenvalue( np.diag(y_rounded) - correlation.conj() * z_rounded)) assert rounded_lower <= rounded_upper + TOLERANCE assert rounded_upper - rounded_lower < 5e-6 assert rounded_primal_violation < 1e-9 assert rounded_dual_violation < 1e-9 recovery_kraus = correlation_kraus(a_rounded) noise_kraus = correlation_kraus(correlation) product_kraus = [r @ e for r in recovery_kraus for e in noise_kraus] gaussian = np.arange(1, dimension * dimension + 1).reshape(dimension, dimension) rho = gaussian @ gaussian.T rho = rho / np.trace(rho) recovered = sum(k @ rho @ k.conj().T for k in product_kraus) kraus_composition_error = float(np.linalg.norm(recovered - b_rounded * rho)) assert kraus_composition_error < 1e-9 state_cap = solve_state_cap(correlation) assert abs(state_cap["state_cap_value"] - value) < TOLERANCE return { "dimension": dimension, "primal_value": value, "dual_value": dual_value, "primal_dual_gap": abs(dual_value - value), "direct_diamond_value": direct_value, "diamond_formula_error": abs(direct_value - 2 * (1 - value)), "largest_raw_psd_violation": max(raw_violations), "rounded_primal_lower": float(rounded_lower), "rounded_dual_upper": rounded_upper, "rounded_gap": rounded_upper - rounded_lower, "rounded_primal_psd_violation": rounded_primal_violation, "rounded_dual_psd_violation": rounded_dual_violation, "kraus_composition_error": kraus_composition_error, "state_cap_hadamard_value_error": abs(state_cap["state_cap_value"] - value), **state_cap, "a_rounded": a_rounded, } def random_correlation(dimension: int, rank: int, rng: np.random.Generator, positive: bool = False) -> np.ndarray: coefficients = rng.uniform(0.05, 1, (rank, dimension)) if positive else ( rng.normal(size=(rank, dimension)) + 1j * rng.normal(size=(rank, dimension))) coefficients /= np.linalg.norm(coefficients, axis=0, keepdims=True) return hermitian(coefficients.T @ coefficients.conj()) def nonnegative_minimum(correlation: np.ndarray) -> float: dimension = len(correlation) q = cp.Variable(dimension) return solve(cp.Problem(cp.Minimize(cp.quad_form(q, cp.psd_wrap(correlation.real))), [q >= 0, cp.sum(q) == 1])) def minimum_entanglement_fidelity(kraus: list[np.ndarray], dimension: int) -> float: rho = cp.Variable((dimension, dimension), hermitian=True) objective = sum(cp.square(cp.abs(cp.trace(rho @ k))) for k in kraus) return solve(cp.Problem(cp.Minimize(objective), [rho >> 0, cp.trace(rho) == 1])) def run_checks() -> dict: SOLVER_STATUS_COUNTS.clear() rng = np.random.default_rng(SEED) checks = [] examples = [] for d in (2, 3, 4, 5): phases = np.exp(1j * rng.uniform(-np.pi, np.pi, d)) examples.append((f"phase_unitary_{d}", np.outer(phases, phases.conj()), 1.0)) for d in (2, 3, 4, 5): examples.append((f"complete_dephasing_{d}", np.eye(d), 1 / d)) nonnegative_examples = [] for repetition in range(4): d = 2 + repetition correlation = random_correlation(d, 3, rng, positive=True) nonnegative_examples.append(correlation) examples.append((f"nonnegative_{d}", correlation, nonnegative_minimum(correlation))) for repetition, base in enumerate(nonnegative_examples): phases = np.exp(1j * rng.uniform(-np.pi, np.pi, len(base))) correlation = np.outer(phases, phases.conj()) * base examples.append((f"gauge_positive_{repetition}", correlation, nonnegative_minimum(base))) random_examples = [] for repetition in range(8): d = 2 + repetition % 4 correlation = random_correlation(d, 2 + repetition % 3, rng) random_examples.append(correlation) examples.append((f"random_complex_{repetition}", correlation, None)) s = 1 / np.sqrt(3) g = np.array([[1, s, s, s], [s, 1, 1j * s, -1j * s], [s, -1j * s, 1, 1j * s], [s, 1j * s, -1j * s, 1]], dtype=complex) assert np.linalg.norm(g @ g - 2 * g) < 1e-12 for t in (0.0, 0.2, 0.65, 1.0): correlation = (1 - t) * np.eye(4) + t * g.conj() expected = (1 + t) / 4 z = np.ones((4, 4)) / 16 y = np.full(4, (1 + t) / 16) assert minimum_eigenvalue(correlation * g - expected * np.ones((4, 4))) > -1e-12 assert minimum_eigenvalue(np.diag(y) - correlation.conj() * z) > -1e-12 examples.append((f"sic_analytic_t_{t}", correlation, expected)) frame_dimension, frame_rank = 5, 2 harmonic_vectors = np.exp(2j * np.pi * np.arange(frame_rank)[:, None] * np.arange(frame_dimension)[None, :] / frame_dimension) harmonic_vectors /= np.sqrt(frame_rank) frame_correlation = harmonic_vectors.conj().T @ harmonic_vectors assert np.linalg.norm(frame_correlation @ frame_correlation - (frame_dimension / frame_rank) * frame_correlation) < 1e-12 for t in (0.0, 0.35, 1.0): correlation = (1 - t) * np.eye(frame_dimension) + t * frame_correlation expected = (1 - t) / frame_dimension + t / frame_rank assert minimum_eigenvalue(correlation * frame_correlation.conj() - expected * np.ones((frame_dimension, frame_dimension))) > -1e-12 examples.append((f"harmonic_tight_frame_t_{t}", correlation, expected)) solved = {} for name, correlation, expected in examples: result = solve_recovery(correlation) a = result.pop("a_rounded") if expected is not None: result["analytic_value"] = expected result["analytic_value_error"] = abs(result["primal_value"] - expected) assert result["analytic_value_error"] < TOLERANCE checks.append({"kind": "independent_primal_dual_direct_sdp", "name": name, **result}) solved[name] = (correlation, result, a) for repetition, indices in enumerate(((0, 1), (0, 2), (1, 2))): c = random_examples[indices[0]] d = random_examples[indices[1]] left = solve_recovery(c) right = solve_recovery(d) joint = solve_recovery(np.kron(c, d)) expected = left["primal_value"] * right["primal_value"] error = abs(joint["primal_value"] - expected) assert error < TOLERANCE checks.append({"kind": "complex_tensorization", "dimensions": [len(c), len(d)], "joint_value": joint["primal_value"], "product_value": expected, "tensorization_error": error, "primal_dual_gap": joint["primal_dual_gap"], "largest_raw_psd_violation": joint["largest_raw_psd_violation"], "diamond_formula_error": joint["diamond_formula_error"]}) for repetition in range(4): correlation = random_examples[repetition] dimension = len(correlation) optimal = solved[f"random_complex_{repetition}"][1]["dual_value"] gaussian = rng.normal(size=(3 * dimension, dimension)) gaussian = gaussian + 1j * rng.normal(size=gaussian.shape) isometry, _ = np.linalg.qr(gaussian, mode="reduced") recovery = [isometry[i * dimension:(i + 1) * dimension] for i in range(3)] noise = correlation_kraus(correlation) composed = [r @ e for r in recovery for e in noise] fidelity = minimum_entanglement_fidelity(composed, dimension) assert fidelity <= optimal + TOLERANCE checks.append({"kind": "arbitrary_cptp_recovery_worst_fidelity_upper_check", "dimension": dimension, "random_recovery_worst_fidelity": fidelity, "optimal_recovery_upper": optimal, "fidelity_upper_violation": max(0.0, fidelity - optimal)}) for repetition in range(4): correlation, values, rounded_a = solved[f"random_complex_{repetition}"] recovered_kraus = correlation_kraus(correlation * rounded_a) fidelity = minimum_entanglement_fidelity(recovered_kraus, len(correlation)) error = abs(fidelity - values["primal_value"]) assert error < TOLERANCE checks.append({"kind": "optimal_recovery_worst_fidelity_equality", "dimension": len(correlation), "optimized_worst_fidelity": fidelity, "sdp_value": values["primal_value"], "fidelity_equality_error": error}) phase = np.array([1, 1j]) correlation = np.outer(phase, phase.conj()) corrected = correlation * correlation.conj() assert np.linalg.norm(corrected - np.ones((2, 2))) < 1e-12 checks.append({"kind": "phase_unitary_recovery_contrast", "uncorrected_diamond_error": float(np.sqrt(2)), "optimal_corrected_diamond_error": 0.0, "recovered_correlation_residual": float(np.linalg.norm(corrected - 1))}) return { "label": "Finite floating-point SDP checks; not a universal proof or novelty certificate.", "seed": SEED, "numpy_version": np.__version__, "cvxpy_version": cp.__version__, "solver": "CLARABEL", "tolerance": TOLERANCE, "solver_status_counts": dict(SOLVER_STATUS_COUNTS), "all_checks_passed": True, "check_count": len(checks), "maximum_primal_dual_gap": max(x.get("primal_dual_gap", 0) for x in checks), "maximum_direct_diamond_formula_error": max(x.get("diamond_formula_error", 0) for x in checks), "maximum_raw_psd_violation": max(x.get("largest_raw_psd_violation", 0) for x in checks), "maximum_rounded_primal_dual_gap": max(x.get("rounded_gap", 0) for x in checks), "maximum_analytic_value_error": max(x.get("analytic_value_error", 0) for x in checks), "maximum_complex_tensorization_error": max(x.get("tensorization_error", 0) for x in checks), "maximum_optimal_recovery_fidelity_error": max(x.get("fidelity_equality_error", 0) for x in checks), "maximum_state_cap_hadamard_value_error": max(x.get("state_cap_hadamard_value_error", 0) for x in checks), "maximum_state_cap_duality_gap": max(x.get("state_cap_duality_gap", 0) for x in checks), "maximum_packing_reciprocity_error": max(x.get("packing_reciprocity_error", 0) for x in checks), "maximum_explicit_decoder_psd_violation": max(x.get("explicit_decoder_psd_violation", 0) for x in checks), "checks": checks, } def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--output", type=Path, default=Path(__file__).with_name("complex_recovery_results.json")) arguments = parser.parse_args() result = run_checks() arguments.output.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") print(json.dumps({key: value for key, value in result.items() if key != "checks"}, indent=2)) if __name__ == "__main__": main()