Datasets:
Modalities:
Text
Formats:
json
Languages:
English
Size:
< 1K
Tags:
mathematics
quantum-information
quantum-error-correction
schur-channels
semidefinite-programming
research-artifact
| #!/usr/bin/env python3 | |
| """Finite checks of exact minimax recovery for nonnegative Schur channels. | |
| These computations supplement the mathematical proofs. They do not establish | |
| the theorem or certify novelty. Only NumPy, SciPy, and the standard library are | |
| required. No semidefinite optimizer or recovery-search claim is used. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| from pathlib import Path | |
| import numpy as np | |
| from scipy.optimize import minimize | |
| import scipy | |
| SEED = 20261102 | |
| TOLERANCE = 5.0e-7 | |
| def trace_norm_hermitian(matrix: np.ndarray) -> float: | |
| matrix = (matrix + matrix.conj().T) / 2 | |
| return float(np.sum(np.abs(np.linalg.eigvalsh(matrix)))) | |
| def solve_simplex(correlation: np.ndarray) -> dict: | |
| """Return a feasible primal vector and a rigorous-form dual certificate. | |
| The certificate expressions are mathematically valid for an exact feasible | |
| vector; their floating-point evaluation is subject to roundoff. The optimizer | |
| is never treated as a proof of optimality. | |
| """ | |
| dimension = len(correlation) | |
| result = minimize( | |
| lambda q: float(q @ correlation @ q), | |
| np.full(dimension, 1.0 / dimension), | |
| jac=lambda q: 2 * correlation @ q, | |
| method="SLSQP", | |
| bounds=[(0.0, 1.0)] * dimension, | |
| constraints=[{"type": "eq", "fun": lambda q: float(np.sum(q) - 1), | |
| "jac": lambda q: np.ones(dimension)}], | |
| options={"ftol": 1e-14, "maxiter": 2000}, | |
| ) | |
| assert result.success, result.message | |
| q = np.maximum(result.x, 0.0) | |
| q /= np.sum(q) | |
| upper = float(q @ correlation @ q) | |
| lower = float(2 * np.min(correlation @ q) - upper) | |
| gap = max(0.0, upper - lower) | |
| assert gap < TOLERANCE | |
| return {"q": q, "upper": upper, "lower": lower, "duality_gap": gap} | |
| def random_recovery(dimension: int, input_dimension: int, | |
| rng: np.random.Generator) -> list[np.ndarray]: | |
| kraus_count = max(3, (input_dimension + dimension - 1) // dimension + 1) | |
| gaussian = rng.normal(size=(kraus_count * dimension, input_dimension)) | |
| gaussian = gaussian + 1j * rng.normal(size=gaussian.shape) | |
| isometry, _ = np.linalg.qr(gaussian, mode="reduced") | |
| kraus = [isometry[i * dimension:(i + 1) * dimension, :] | |
| for i in range(kraus_count)] | |
| assert np.linalg.norm(sum(r.conj().T @ r for r in kraus) | |
| - np.eye(input_dimension)) < 1e-10 | |
| return kraus | |
| def random_recovery_fidelity(correlation: np.ndarray, q: np.ndarray, | |
| rng: np.random.Generator) -> float: | |
| dimension = len(correlation) | |
| recovery = random_recovery(dimension, dimension, rng) | |
| diagonals = np.array([np.diag(kraus) for kraus in recovery]) | |
| diagonal_gram = diagonals.T @ diagonals.conj() | |
| fidelity = float(np.real(q @ (correlation * diagonal_gram) @ q)) | |
| return fidelity | |
| def positive_correlation(dimension: int, branches: int, | |
| rng: np.random.Generator) -> np.ndarray: | |
| vectors = rng.uniform(0.001, 1.0, (branches, dimension)) | |
| vectors /= np.linalg.norm(vectors, axis=0, keepdims=True) | |
| return vectors.T @ vectors | |
| def verify_channel(correlation: np.ndarray, rng: np.random.Generator, | |
| name: str, require_nonnegative: bool = True) -> dict: | |
| dimension = len(correlation) | |
| assert np.max(np.abs(correlation - correlation.T)) < 1e-12 | |
| assert np.max(np.abs(np.diag(correlation) - 1)) < 1e-12 | |
| assert np.linalg.eigvalsh(correlation)[0] > -1e-10 | |
| if require_nonnegative: | |
| assert np.min(correlation) > -1e-12 | |
| solution = solve_simplex(correlation) | |
| q, upper, lower = solution["q"], solution["upper"], solution["lower"] | |
| difference_kernel = np.ones_like(correlation) - correlation | |
| worst_weighted_excess = 0.0 | |
| for _ in range(16): | |
| p = rng.dirichlet(np.ones(dimension)) | |
| weighted = np.sqrt(p)[:, None] * difference_kernel * np.sqrt(p)[None, :] | |
| norm = trace_norm_hermitian(weighted) | |
| worst_weighted_excess = max(worst_weighted_excess, norm - 2 * (1 - lower)) | |
| assert norm <= 2 * (1 - lower) + TOLERANCE | |
| assert np.count_nonzero(np.linalg.eigvalsh(weighted) > 1e-10) <= 1 | |
| weighted = np.sqrt(q)[:, None] * difference_kernel * np.sqrt(q)[None, :] | |
| extremal_error = abs(trace_norm_hermitian(weighted) - 2 * (1 - upper)) | |
| assert extremal_error < TOLERANCE | |
| fidelity_excess = 0.0 | |
| if require_nonnegative: | |
| for _ in range(4): | |
| fidelity = random_recovery_fidelity(correlation, q, rng) | |
| fidelity_excess = max(fidelity_excess, fidelity - upper) | |
| assert fidelity <= upper + TOLERANCE | |
| return { | |
| "kind": "nonnegative_schur" if require_nonnegative else "real_schur_fixed_channel_only", | |
| "name": name, "dimension": dimension, | |
| "simplex_minimum_upper": upper, "simplex_minimum_lower": lower, | |
| "duality_gap": solution["duality_gap"], | |
| "extremal_trace_norm_identity_error": extremal_error, | |
| "maximum_random_input_bound_excess": max(0.0, worst_weighted_excess), | |
| "maximum_random_recovery_fidelity_excess": max(0.0, fidelity_excess), | |
| } | |
| def verify_flagged(dimension: int, branches: int, | |
| rng: np.random.Generator) -> dict: | |
| probabilities = rng.uniform(0.0, 1.0, (branches, dimension)) | |
| probabilities /= np.sum(probabilities, axis=0, keepdims=True) | |
| roots = np.sqrt(probabilities) | |
| correlation = roots.T @ roots | |
| solution = solve_simplex(correlation) | |
| q = solution["q"] | |
| noise, polar_recovery = [], [] | |
| for b in range(branches): | |
| embedding = np.zeros((branches * dimension, dimension), dtype=complex) | |
| embedding[b * dimension:(b + 1) * dimension, :] = np.eye(dimension) | |
| noise.append(embedding @ np.diag(roots[b])) | |
| polar_recovery.append(embedding.conj().T) | |
| assert np.linalg.norm(sum(e.conj().T @ e for e in noise) - np.eye(dimension)) < 1e-10 | |
| assert np.linalg.norm(sum(r.conj().T @ r for r in polar_recovery) | |
| - np.eye(branches * dimension)) < 1e-10 | |
| seed = rng.normal(size=(dimension, dimension)) + 1j * rng.normal(size=(dimension, dimension)) | |
| rho = seed @ seed.conj().T | |
| rho /= np.trace(rho) | |
| noisy = sum(e @ rho @ e.conj().T for e in noise) | |
| recovered = sum(r @ noisy @ r.conj().T for r in polar_recovery) | |
| polar_channel_error = float(np.linalg.norm(recovered - correlation * rho)) | |
| assert polar_channel_error < 1e-10 | |
| maximum_fidelity_excess = 0.0 | |
| for _ in range(4): | |
| recovery = random_recovery(dimension, branches * dimension, rng) | |
| fidelity = sum(abs(np.trace(np.diag(q) @ r @ e)) ** 2 | |
| for r in recovery for e in noise) | |
| maximum_fidelity_excess = max(maximum_fidelity_excess, | |
| float(fidelity - solution["upper"])) | |
| assert fidelity <= solution["upper"] + TOLERANCE | |
| return {"kind": "orthogonal_flagged_commuting_channel", "dimension": dimension, | |
| "branches": branches, "duality_gap": solution["duality_gap"], | |
| "polar_channel_identity_error": polar_channel_error, | |
| "maximum_random_recovery_fidelity_excess": max(0.0, maximum_fidelity_excess)} | |
| def verify_binary(dimension: int, rng: np.random.Generator) -> dict: | |
| a, b = sorted(rng.uniform(-1, 1, 2)) | |
| lambdas = np.concatenate(([a, b], rng.uniform(a, b, dimension - 2))) | |
| roots = np.sqrt(np.vstack(((1 - lambdas) / 2, (1 + lambdas) / 2))) | |
| correlation = roots.T @ roots | |
| solution = solve_simplex(correlation) | |
| fidelity = 0.5 * (np.sqrt((1 + a) * (1 + b)) | |
| + np.sqrt((1 - a) * (1 - b))) | |
| exact_error = 1 - fidelity | |
| qp_error = 2 * (1 - solution["upper"]) | |
| assert abs(qp_error - exact_error) < TOLERANCE | |
| return {"kind": "binary_closed_formula", "dimension": dimension, | |
| "minimum_eigenvalue": float(a), "maximum_eigenvalue": float(b), | |
| "closed_form_diamond_error": float(exact_error), | |
| "closed_formula_error": abs(qp_error - exact_error), | |
| "duality_gap": solution["duality_gap"]} | |
| def verify_tensor(rng: np.random.Generator) -> dict: | |
| first = positive_correlation(3, 4, rng) | |
| second = positive_correlation(4, 3, rng) | |
| left, right = solve_simplex(first), solve_simplex(second) | |
| product = np.kron(first, second) | |
| joint = solve_simplex(product) | |
| q_product = np.kron(left["q"], right["q"]) | |
| expected = left["upper"] * right["upper"] | |
| tensor_error = abs(joint["upper"] - expected) | |
| assert tensor_error < TOLERANCE | |
| assert abs(q_product @ product @ q_product - expected) < 1e-12 | |
| product_gap = max(0.0, 2 * (q_product @ product @ q_product | |
| - np.min(product @ q_product))) | |
| assert product_gap < TOLERANCE | |
| return {"kind": "tensorization", "dimensions": [3, 4], | |
| "joint_simplex_minimum": joint["upper"], | |
| "product_of_simplex_minima": expected, | |
| "tensorization_error": tensor_error, | |
| "product_witness_duality_gap": float(product_gap), | |
| "duality_gap": joint["duality_gap"]} | |
| def run_checks() -> dict: | |
| rng = np.random.default_rng(SEED) | |
| checks = [] | |
| for d in (2, 3, 5, 8): | |
| checks.append(verify_channel(np.eye(d), rng, f"complete_dephasing_{d}")) | |
| checks.append(verify_channel(np.ones((5, 5)), rng, "identity_channel")) | |
| for d, p in ((3, 0.15), (4, 0.5), (6, 0.8), (7, 1.0)): | |
| correlation = (1 - p) * np.ones((d, d)) + p * np.eye(d) | |
| record = verify_channel(correlation, rng, f"equicorrelation_{d}_{p}") | |
| exact = 1 - p + p / d | |
| assert abs(record["simplex_minimum_upper"] - exact) < 1e-12 | |
| checks.append(record) | |
| for repetition in range(7): | |
| d, branches = 3 + repetition % 4, 2 + repetition % 5 | |
| checks.append(verify_channel(positive_correlation(d, branches, rng), | |
| rng, f"positive_gram_{repetition}")) | |
| for repetition in range(3): | |
| points = rng.normal(size=(6, 2)) | |
| squared = np.sum((points[:, None, :] - points[None, :, :]) ** 2, axis=2) | |
| correlation = np.exp(-(0.2 + repetition) * squared) | |
| checks.append(verify_channel(correlation, rng, f"gaussian_phase_kernel_{repetition}")) | |
| cycle = np.eye(5) | |
| for i in range(5): | |
| cycle[i, (i + 1) % 5] = cycle[(i + 1) % 5, i] = 0.6 | |
| checks.append(verify_channel(cycle, rng, "nonnegative_five_cycle_correlation")) | |
| for repetition in range(8): | |
| checks.append(verify_binary(2 + repetition % 5, rng)) | |
| for repetition in range(8): | |
| checks.append(verify_flagged(2 + repetition % 4, 2 + repetition % 3, rng)) | |
| for _ in range(8): | |
| checks.append(verify_tensor(rng)) | |
| for repetition in range(4): | |
| vectors = rng.normal(size=(3, 4)) | |
| vectors /= np.linalg.norm(vectors, axis=0, keepdims=True) | |
| checks.append(verify_channel(vectors.T @ vectors, rng, | |
| f"signed_real_gram_{repetition}", False)) | |
| negative_phase = np.array([[1.0, -1.0], [-1.0, 1.0]]) | |
| solution = solve_simplex(negative_phase) | |
| assert abs(solution["upper"]) < 1e-12 | |
| assert np.linalg.norm(negative_phase * negative_phase - np.ones((2, 2))) < 1e-12 | |
| checks.append({"kind": "negative_phase_counterexample_to_identity_optimality", | |
| "fixed_channel_diamond_error": 2.0, | |
| "phase_unitary_corrected_diamond_error": 0.0}) | |
| complex_phase = np.array([[1, 1j], [-1j, 1]], dtype=complex) | |
| p = np.array([0.5, 0.5]) | |
| weighted = np.sqrt(p)[:, None] * (np.ones((2, 2)) - complex_phase) * np.sqrt(p)[None, :] | |
| measured = trace_norm_hermitian(weighted) | |
| wrong_real_extension = 2 * (1 - float(np.real(p @ complex_phase @ p))) | |
| assert abs(measured - np.sqrt(2)) < 1e-12 | |
| assert abs(measured - wrong_real_extension) > 0.4 | |
| checks.append({"kind": "complex_phase_counterexample_to_real_distance_formula", | |
| "fixed_channel_diamond_error": measured, | |
| "invalid_real_formula_value": wrong_real_extension}) | |
| return { | |
| "label": "Finite numerical checks; not a proof of universal optimality or a novelty certificate.", | |
| "seed": SEED, "numpy_version": np.__version__, "scipy_version": scipy.__version__, | |
| "tolerance": TOLERANCE, "all_checks_passed": True, | |
| "check_count": len(checks), | |
| "maximum_simplex_duality_gap": max(entry.get("duality_gap", 0.0) for entry in checks), | |
| "maximum_extremal_trace_norm_identity_error": max(entry.get("extremal_trace_norm_identity_error", 0.0) for entry in checks), | |
| "maximum_binary_closed_formula_error": max(entry.get("closed_formula_error", 0.0) for entry in checks), | |
| "maximum_tensorization_error": max(entry.get("tensorization_error", 0.0) for entry in checks), | |
| "checks": checks, | |
| } | |
| def main() -> None: | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("--output", type=Path, | |
| default=Path(__file__).with_name("minimax_results.json")) | |
| arguments = parser.parse_args() | |
| results = run_checks() | |
| arguments.output.write_text(json.dumps(results, indent=2) + "\n", encoding="utf-8") | |
| print(json.dumps({key: value for key, value in results.items() if key != "checks"}, indent=2)) | |
| if __name__ == "__main__": | |
| main() | |