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 numerical checks for antipodal erasure-code rigidity. | |
| These checks do not prove the theorem. They independently exercise the exact | |
| identities, sharp constant, phase rounding, and erasure recovery construction. | |
| Only NumPy and the Python standard library are required. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| from math import comb | |
| from pathlib import Path | |
| import numpy as np | |
| SEED = 20261102 | |
| TOLERANCE = 2.0e-9 | |
| def frobenius_squared(matrix: np.ndarray) -> float: | |
| return float(np.vdot(matrix, matrix).real) | |
| def support_data(n: int, support: list[int]) -> dict: | |
| support = sorted(set(support)) | |
| mask = (1 << n) - 1 | |
| assert len(support) >= 4 and len(support) % 2 == 0 | |
| index = {word: position for position, word in enumerate(support)} | |
| assert all((word ^ mask) in index for word in support) | |
| complements = np.array([index[word ^ mask] for word in support]) | |
| pairs = [(i, int(j)) for i, j in enumerate(complements) if i < j] | |
| signs = np.array( | |
| [[2 * ((word >> j) & 1) - 1 for j in range(n)] for word in support], | |
| dtype=float, | |
| ) | |
| delta = min( | |
| (left ^ right).bit_count() | |
| for i, left in enumerate(support) | |
| for right in support[i + 1 :] | |
| ) | |
| return { | |
| "n": n, | |
| "support": support, | |
| "signs": signs, | |
| "complements": complements, | |
| "pairs": pairs, | |
| "dimension": len(support), | |
| "rank": len(pairs), | |
| "delta": delta, | |
| } | |
| def phase_code(data: dict, phases: np.ndarray) -> np.ndarray: | |
| encoding = np.zeros((data["dimension"], data["rank"]), dtype=complex) | |
| for column, ((left, right), phase) in enumerate(zip(data["pairs"], phases)): | |
| encoding[left, column] = 1 / np.sqrt(2) | |
| encoding[right, column] = np.exp(1j * phase) / np.sqrt(2) | |
| return encoding | |
| def nearest_phase_projection(data: dict, projection: np.ndarray) -> np.ndarray: | |
| involution = np.zeros_like(projection) | |
| for left, right in data["pairs"]: | |
| entry = projection[left, right] | |
| phase = entry / abs(entry) if abs(entry) > 0 else 1.0 + 0j | |
| involution[left, right] = phase | |
| involution[right, left] = phase.conjugate() | |
| return (np.eye(data["dimension"]) + involution) / 2 | |
| def compression_metrics(data: dict, projection: np.ndarray) -> dict: | |
| dimension, rank = data["dimension"], data["rank"] | |
| involution = 2 * projection - np.eye(dimension) | |
| defect_sum = 0.0 | |
| residual_sum = 0.0 | |
| maximum_identity_error = 0.0 | |
| for j in range(data["n"]): | |
| diagonal = np.diag(data["signs"][:, j]) | |
| alpha = float(np.trace(projection @ diagonal).real / rank) | |
| centered = projection @ diagonal @ projection - alpha * projection | |
| defect_squared = frobenius_squared(centered) | |
| residual = involution @ diagonal + diagonal @ involution | |
| residual -= 2 * alpha * np.eye(dimension) | |
| residual_squared = frobenius_squared(residual) | |
| maximum_identity_error = max( | |
| maximum_identity_error, abs(residual_squared - 8 * defect_squared) | |
| ) | |
| defect_sum += defect_squared | |
| residual_sum += residual_squared | |
| comp = data["complements"] | |
| complementary_mass = float( | |
| np.sum(np.abs(involution[np.arange(dimension), comp]) ** 2) | |
| ) | |
| off_complement_mass = frobenius_squared(involution) - complementary_mass | |
| rounded = nearest_phase_projection(data, projection) | |
| distance_squared = frobenius_squared(projection - rounded) | |
| exact_nearest_formula = rank - 2 * sum( | |
| abs(projection[left, right]) for left, right in data["pairs"] | |
| ) | |
| covariance = data["signs"].T @ data["signs"] / dimension | |
| largest_covariance_eigenvalue = float(np.linalg.eigvalsh(covariance)[-1]) | |
| return { | |
| "defect_sum": defect_sum, | |
| "residual_sum": residual_sum, | |
| "identity_error": maximum_identity_error, | |
| "off_complement_mass": off_complement_mass, | |
| "distance_squared": distance_squared, | |
| "nearest_formula_error": abs(distance_squared - exact_nearest_formula), | |
| "largest_covariance_eigenvalue": largest_covariance_eigenvalue, | |
| "bound": defect_sum / data["delta"], | |
| } | |
| def assert_rigidity(data: dict, projection: np.ndarray) -> dict: | |
| metrics = compression_metrics(data, projection) | |
| assert metrics["identity_error"] < TOLERANCE | |
| assert metrics["nearest_formula_error"] < TOLERANCE | |
| assert metrics["distance_squared"] <= metrics["bound"] + TOLERANCE | |
| assert metrics["residual_sum"] + TOLERANCE >= ( | |
| 4 * data["delta"] * metrics["off_complement_mass"] | |
| ) | |
| assert 2 * metrics["distance_squared"] <= ( | |
| metrics["off_complement_mass"] + TOLERANCE | |
| ) | |
| assert metrics["largest_covariance_eigenvalue"] <= ( | |
| data["n"] - data["delta"] + TOLERANCE | |
| ) | |
| return metrics | |
| def remove_bit(word: int, position: int) -> int: | |
| return (word & ((1 << position) - 1)) | ((word >> (position + 1)) << position) | |
| def verify_erasure_recovery(data: dict, rng: np.random.Generator) -> dict: | |
| encoding = phase_code(data, rng.uniform(-np.pi, np.pi, data["rank"])) | |
| rank = data["rank"] | |
| maximum_kl_error = 0.0 | |
| maximum_completeness_error = 0.0 | |
| maximum_recovery_error = 0.0 | |
| maximum_post_erasure_phase_error = 0.0 | |
| density_seed = rng.normal(size=(rank, rank)) + 1j * rng.normal(size=(rank, rank)) | |
| density = density_seed @ density_seed.conj().T | |
| density /= np.trace(density) | |
| for position in range(data["n"]): | |
| survivor_words = sorted({remove_bit(w, position) for w in data["support"]}) | |
| assert len(survivor_words) == data["dimension"] | |
| survivor_index = {w: i for i, w in enumerate(survivor_words)} | |
| branches = [] | |
| for outcome in (0, 1): | |
| branch = np.zeros((len(survivor_words), rank), dtype=complex) | |
| for row, word in enumerate(data["support"]): | |
| if ((word >> position) & 1) == outcome: | |
| branch[survivor_index[remove_bit(word, position)], :] += encoding[row, :] | |
| branches.append(branch) | |
| for left in (0, 1): | |
| for right in (0, 1): | |
| target = np.eye(rank) / 2 if left == right else np.zeros((rank, rank)) | |
| maximum_kl_error = max( | |
| maximum_kl_error, | |
| float(np.linalg.norm(branches[left].conj().T @ branches[right] - target)), | |
| ) | |
| recovery = [np.sqrt(2) * branch.conj().T for branch in branches] | |
| completeness = sum(kraus.conj().T @ kraus for kraus in recovery) | |
| maximum_completeness_error = max( | |
| maximum_completeness_error, | |
| float(np.linalg.norm(completeness - np.eye(len(survivor_words)))), | |
| ) | |
| erased = sum(branch @ density @ branch.conj().T for branch in branches) | |
| recovered = sum(kraus @ erased @ kraus.conj().T for kraus in recovery) | |
| maximum_recovery_error = max( | |
| maximum_recovery_error, float(np.linalg.norm(recovered - density)) | |
| ) | |
| theta = float(rng.uniform(-10, 10)) | |
| phase = np.diag(np.exp(1j * theta * np.array([w.bit_count() for w in survivor_words]))) | |
| phase_erased = phase @ erased @ phase.conj().T | |
| phase_recovered = sum(kraus @ phase_erased @ kraus.conj().T for kraus in recovery) | |
| maximum_post_erasure_phase_error = max( | |
| maximum_post_erasure_phase_error, | |
| float(np.linalg.norm(phase_recovered - density)), | |
| ) | |
| assert maximum_kl_error < TOLERANCE | |
| assert maximum_completeness_error < TOLERANCE | |
| assert maximum_recovery_error < TOLERANCE | |
| assert maximum_post_erasure_phase_error < TOLERANCE | |
| return { | |
| "n": data["n"], | |
| "rank": rank, | |
| "erasure_locations_checked": data["n"], | |
| "maximum_kl_error": maximum_kl_error, | |
| "maximum_recovery_completeness_error": maximum_completeness_error, | |
| "maximum_density_recovery_error": maximum_recovery_error, | |
| "maximum_post_erasure_collective_phase_error": maximum_post_erasure_phase_error, | |
| } | |
| def run_checks() -> dict: | |
| rng = np.random.default_rng(SEED) | |
| checks = [] | |
| supports = [] | |
| for n in (4, 6, 8): | |
| supports.append((f"central_{n}", support_data(n, [w for w in range(1 << n) if w.bit_count() == n // 2]))) | |
| for n in (4, 6): | |
| supports.append((f"even_parity_{n}", support_data(n, [w for w in range(1 << n) if w.bit_count() % 2 == 0]))) | |
| for n, delta in ((4, 2), (6, 2), (6, 3), (8, 2), (8, 4)): | |
| mask, word = (1 << n) - 1, (1 << delta) - 1 | |
| supports.append((f"two_orbit_{n}_{delta}", support_data(n, [0, mask, word, word ^ mask]))) | |
| central_six = support_data(6, [w for w in range(64) if w.bit_count() == 3]) | |
| chosen = rng.choice(len(central_six["pairs"]), size=8, replace=False) | |
| subset = [central_six["support"][i] for p in chosen for i in central_six["pairs"][p]] | |
| supports.append(("paired_random_subset_6", support_data(6, subset))) | |
| for name, data in supports: | |
| assert data["delta"] >= 2 | |
| for repetition in range(3): | |
| gaussian = rng.normal(size=(data["dimension"], data["rank"])) | |
| gaussian = gaussian + 1j * rng.normal(size=gaussian.shape) | |
| encoding, _ = np.linalg.qr(gaussian, mode="reduced") | |
| projection = encoding @ encoding.conj().T | |
| metrics = assert_rigidity(data, projection) | |
| rounded = nearest_phase_projection(data, projection) | |
| for _ in range(4): | |
| alternative = phase_code(data, rng.uniform(-np.pi, np.pi, data["rank"])) | |
| candidate = alternative @ alternative.conj().T | |
| assert frobenius_squared(projection - rounded) <= ( | |
| frobenius_squared(projection - candidate) + TOLERANCE | |
| ) | |
| checks.append({"kind": "random_projection_rigidity", "support": name, "repetition": repetition, **metrics}) | |
| for n, delta in ((4, 2), (6, 2), (6, 3), (8, 4)): | |
| mask, word = (1 << n) - 1, (1 << delta) - 1 | |
| data = support_data(n, [0, mask, word, word ^ mask]) | |
| projection = np.diag([1.0 if w in (0, word) else 0.0 for w in data["support"]]).astype(complex) | |
| metrics = assert_rigidity(data, projection) | |
| assert abs(metrics["defect_sum"] - 2 * delta) < TOLERANCE | |
| assert abs(metrics["distance_squared"] - 2) < TOLERANCE | |
| assert abs(metrics["distance_squared"] - metrics["bound"]) < TOLERANCE | |
| checks.append({"kind": "sharp_constant", "n": n, "delta": delta, **metrics}) | |
| for n in (4, 6, 8): | |
| data = support_data(n, [w for w in range(1 << n) if w.bit_count() == n // 2]) | |
| checks.append({"kind": "exact_erasure_recovery", **verify_erasure_recovery(data, rng)}) | |
| for n in (4, 6, 8): | |
| data = support_data(n, [w for w in range(1 << n) if w.bit_count() == n // 2]) | |
| index = {word: row for row, word in enumerate(data["support"])} | |
| involution = np.zeros((data["dimension"], data["dimension"]), dtype=complex) | |
| mask = (1 << n) - 1 | |
| for column, word in enumerate(data["support"]): | |
| first_two_differ = (word & 1) != ((word >> 1) & 1) | |
| swapped = word ^ 3 if first_two_differ else word | |
| involution[index[swapped ^ mask], column] = 1 | |
| projection = (np.eye(data["dimension"]) + involution) / 2 | |
| metrics = assert_rigidity(data, projection) | |
| expected_mass = 2 * comb(n - 2, n // 2 - 1) | |
| assert abs(metrics["defect_sum"] - expected_mass) < TOLERANCE | |
| assert abs(metrics["off_complement_mass"] - expected_mass) < TOLERANCE | |
| assert abs(metrics["distance_squared"] - expected_mass / 2) < TOLERANCE | |
| assert abs(metrics["distance_squared"] - metrics["bound"]) < TOLERANCE | |
| checks.append({"kind": "central_sector_sharp_half_constant", "n": n, "expected_noncomplement_mass": expected_mass, **metrics}) | |
| data = support_data(4, [w for w in range(16) if w.bit_count() == 2]) | |
| zero_rows = [i for i, w in enumerate(data["support"]) if (w & 1) == 0] | |
| partner_rows = [int(data["complements"][i]) for i in zero_rows] | |
| partner_rows[0], partner_rows[1] = partner_rows[1], partner_rows[0] | |
| encoding = np.zeros((6, 3), dtype=complex) | |
| for column, (left, right) in enumerate(zip(zero_rows, partner_rows)): | |
| encoding[left, column] = encoding[right, column] = 1 / np.sqrt(2) | |
| projection = encoding @ encoding.conj().T | |
| metrics = assert_rigidity(data, projection) | |
| first_compression = encoding.conj().T @ np.diag(data["signs"][:, 0]) @ encoding | |
| assert np.linalg.norm(first_compression) < TOLERANCE | |
| assert metrics["defect_sum"] > 1.0 | |
| assert metrics["distance_squared"] > 0.5 | |
| checks.append({"kind": "central_four_noncomplement_swap_witness", **metrics}) | |
| balanced = np.array([[1, 1, 1], [-1, -1, -1], [1, -1, -1], [-1, 1, 1]], dtype=float) | |
| signature_encoding = np.zeros((4, 2), dtype=complex) | |
| signature_encoding[[0, 1], 0] = 1 / np.sqrt(2) | |
| signature_encoding[[2, 3], 1] = 1 / np.sqrt(2) | |
| maximum = max(float(np.linalg.norm(signature_encoding.conj().T @ np.diag(balanced[:, j]) @ signature_encoding)) for j in range(3)) | |
| assert maximum < TOLERANCE | |
| checks.append({"kind": "balanced_joint_signatures", "maximum_scalar_compression_error": maximum, "antipodal_pairs": 2}) | |
| imbalanced = np.array([[1, 1, 1], [1, -1, -1], [-1, 1, -1], [-1, -1, 1]], dtype=float) | |
| assert np.all(np.sum(imbalanced, axis=0) == 0) | |
| admissible_entries = sum(bool(np.all(left + right == 0)) for left in imbalanced for right in imbalanced) | |
| assert admissible_entries == 0 | |
| checks.append({"kind": "individually_balanced_but_no_antipodal_joint_signature", "anticommuting_matrix_kernel_dimension": admissible_entries, "conclusion": "No nonzero matrix anticommutes with all three signature observables; hence no rank-two zero-compression projector."}) | |
| reflection = np.array([[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]], dtype=complex) | |
| projection = (np.eye(4) + reflection) / 2 | |
| signature_defect_sum = 0.0 | |
| signature_identity_error = 0.0 | |
| for j in range(3): | |
| observable = np.diag(imbalanced[:, j]) | |
| alpha = float(np.trace(projection @ observable).real / 2) | |
| defect_squared = frobenius_squared(projection @ observable @ projection - alpha * projection) | |
| residual = reflection @ observable + observable @ reflection - 2 * alpha * np.eye(4) | |
| signature_defect_sum += defect_squared | |
| signature_identity_error = max(signature_identity_error, abs(frobenius_squared(residual) - 8 * defect_squared)) | |
| gamma = min(float(np.sum((left + right) ** 2) / 4) for left in imbalanced for right in imbalanced) | |
| signature_imbalance = 4 | |
| obstruction_lower_bound = gamma * signature_imbalance / 2 | |
| assert gamma == 1.0 | |
| assert abs(signature_defect_sum - 2) < TOLERANCE | |
| assert abs(signature_defect_sum - obstruction_lower_bound) < TOLERANCE | |
| assert signature_identity_error < TOLERANCE | |
| checks.append({"kind": "sharp_joint_signature_imbalance_obstruction", "gamma": gamma, "signature_imbalance_delta": signature_imbalance, "defect_sum": signature_defect_sum, "gamma_delta_over_two": obstruction_lower_bound, "identity_error": signature_identity_error}) | |
| identity_errors = [entry.get("identity_error", 0.0) for entry in checks] | |
| violations = [max(0.0, entry.get("distance_squared", 0.0) - entry.get("bound", float("inf"))) for entry in checks] | |
| return { | |
| "label": "Finite numerical checks; not a proof of the theorem or a novelty certificate.", | |
| "seed": SEED, | |
| "numpy_version": np.__version__, | |
| "tolerance": TOLERANCE, | |
| "all_checks_passed": True, | |
| "check_count": len(checks), | |
| "maximum_centered_identity_error": max(identity_errors), | |
| "maximum_rigidity_bound_violation": max(violations), | |
| "checks": checks, | |
| } | |
| def main() -> None: | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("--output", type=Path, default=Path(__file__).with_name("verification_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() | |