File size: 4,236 Bytes
347a3de | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | """Independent numerical sanity checks for the computation section.
These verify specified finite-dimensional examples, not hardware or novelty.
Run from any directory; output is written alongside this source.
"""
from pathlib import Path
import json
import math
import numpy as np
from scipy.integrate import quad
def stable_f(u):
if abs(u) < 1e-3:
return sum((-1.0) ** k * u ** k / math.factorial(k)
for k in range(2, 12))
return u + math.expm1(-u)
def spectral_variance(lam, horizon, theta):
return 2 * theta * stable_f(lam * horizon) / (horizon ** 2 * lam ** 3)
cases = []
for lam in (0.01, 0.7, 1.0, 8.0):
for horizon in (1e-3, 0.3, 10.0):
theta = 0.4
formula = spectral_variance(lam, horizon, theta)
integral = quad(lambda s: 2 * theta * (horizon - s)
* math.exp(-lam * s) / (horizon ** 2 * lam),
0, horizon, epsabs=1e-12, epsrel=1e-11)[0]
error = abs(formula - integral) / max(abs(integral), 1e-15)
assert error < 1e-8, (lam, horizon, error)
assert formula > 0
assert formula <= theta / lam * (1 + 1e-10)
assert formula <= 2 * theta / (horizon * lam ** 2) * (1 + 1e-10)
cases.append({"lambda": lam, "T": horizon, "theta": theta,
"closed_form_variance": formula,
"independent_quadrature_variance": integral,
"relative_difference": error})
rng = np.random.default_rng(173)
calibration = []
for d in (2, 5, 11):
Q, _ = np.linalg.qr(rng.normal(size=(d, d)))
A_half = Q @ np.diag(np.sqrt(np.geomspace(.08, 5, d))) @ Q.T
A = A_half @ A_half
R, _ = np.linalg.qr(rng.normal(size=(d, d)))
eps = .08
E = R @ np.diag(np.linspace(-eps, eps, d)) @ R.T
A_implemented = A + A_half @ E @ A_half
covariance = np.linalg.inv(A_implemented)
observed_error = np.linalg.norm(A_half @ covariance @ A_half
- np.eye(d), ord=2)
bound = eps / (1 - eps)
assert observed_error <= bound * (1 + 1e-10)
calibration.append({"dimension": d, "relative_perturbation_limit": eps,
"whitened_covariance_error": observed_error,
"bound": bound})
dephasing = []
for gamma_t in (.01, .1, 1, 10):
observed = -math.expm1(-gamma_t) / 2
bound = min(1, gamma_t / 2)
assert observed <= bound
dephasing.append({"gamma_times_T": gamma_t,
"plus_state_trace_distance": observed,
"half_diamond_distance": observed,
"generator_bound": bound,
"braid_error": 0})
# sigma_1^2 has exponent sum two and hence is not the identity braid,
# but its population endpoint permutation is exactly identity.
labels = [0, 1]
for _ in range(2):
labels[0], labels[1] = labels[1], labels[0]
assert labels == [0, 1]
# Bit-flip channel: all errors point along the same channel difference,
# so the input-independent mixture certificate is attained.
p, delta = .1, .05
bitflip_error = p + (1 - p) * delta
assert abs(bitflip_error - .145) < 1e-15
result = {
"status": "passed",
"scope": "finite-dimensional analytical examples and numerical quadrature",
"hardware_claims": False,
"novelty_claims": False,
"stationary_averaging_cases": cases,
"calibration_cases": calibration,
"same_braid_dephasing_counterexamples": dephasing,
"pure_braid_counterexample": {"word": "sigma_1^2", "exponent_sum": 2,
"permutation": labels},
"mixture_tight_example": {"bad_event_probability": p,
"good_channel_distance": delta,
"actual_distance": bitflip_error,
"certified_bound": bitflip_error},
}
out = Path(__file__).resolve().parents[1] / "results" / "computation_verification.json"
out.parent.mkdir(parents=True, exist_ok=True)
out.write_text(json.dumps(result, indent=2) + "\n")
print(f"Passed {len(cases)} quadrature comparisons, {len(calibration)} matrix "
f"calibration cases, {len(dephasing)} coherence counterexamples; "
"pure-braid and tight mixture examples.")
|