#!/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()