Datasets:
Formats:
csv
Languages:
English
Size:
< 1K
Tags:
quantum-information
quantum-error-correction
quantum-memory
quantum-capacity
quantum-erasure-channel
non-markovian-noise
| #!/usr/bin/env python3 | |
| """Reproducible finite checks for spectral shells and diagonal Dyson truncation. | |
| The calculations illustrate stated theorems. They do not certify scientific | |
| priority or replace the proofs. Requires Python 3.10+, numpy, scipy, matplotlib. | |
| Run from any directory: python3 verify_broad.py --output-dir ../results/broad | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import csv | |
| import json | |
| import math | |
| from pathlib import Path | |
| import numpy as np | |
| from scipy.linalg import expm | |
| from scipy.special import gammaln | |
| SEED = 20261103 | |
| TOL = 2e-11 | |
| I2 = np.eye(2, dtype=complex) | |
| X = np.array([[0, 1], [1, 0]], complex) | |
| Y = np.array([[0, -1j], [1j, 0]], complex) | |
| Z = np.diag([1, -1]).astype(complex) | |
| def bits_table(n: int) -> np.ndarray: | |
| return np.array([[(a >> (n - 1 - j)) & 1 for j in range(n)] | |
| for a in range(2**n)], dtype=int) | |
| def reduced_pure(psi: np.ndarray, keep: list[int], n: int) -> np.ndarray: | |
| discard = [j for j in range(n) if j not in keep] | |
| matrix = psi.reshape([2] * n).transpose(keep + discard).reshape(2**len(keep), -1) | |
| return matrix @ matrix.conj().T | |
| def trace_distance(a: np.ndarray, b: np.ndarray) -> float: | |
| d = (a - b + (a - b).conj().T) / 2 | |
| return float(np.abs(np.linalg.eigvalsh(d)).sum() / 2) | |
| def shell_partition(features: np.ndarray, widths: np.ndarray) -> dict: | |
| """Partition every basis string into product charge bins; exact floating inputs.""" | |
| n = features.shape[1] | |
| charges = bits_table(n) @ features.T | |
| lower = np.minimum(features, 0).sum(axis=1) | |
| upper = np.maximum(features, 0).sum(axis=1) | |
| labels = np.floor((charges - lower) / widths).astype(int) | |
| # An exact endpoint at a range boundary belongs to the final half-open bin. | |
| count = np.maximum(1, np.ceil((upper - lower) / widths).astype(int)) | |
| labels = np.maximum(0, np.minimum(labels, count - 1)) | |
| groups: dict[tuple[int, ...], list[int]] = {} | |
| for integer, label in enumerate(labels): | |
| groups.setdefault(tuple(int(v) for v in label), []).append(integer) | |
| best_label, indices = min(groups.items(), key=lambda item: (-len(item[1]), item[0])) | |
| left = lower + np.array(best_label) * widths | |
| right = np.minimum(left + widths, upper) | |
| center = (left + right) / 2 | |
| halfwidth = (right - left) / 2 | |
| assert np.all(np.abs(charges[indices] - center) <= halfwidth + 1e-12) | |
| return {"indices": indices, "center": center, "halfwidth": halfwidth, | |
| "largest_dimension": len(indices), "occupied_bins": len(groups), | |
| "safe_bin_count": int(np.prod(count, dtype=object)), | |
| "charge_range_lengths": upper - lower, "chosen_label": best_label, | |
| "charges": charges} | |
| def shell_trajectory(rng: np.random.Generator) -> tuple[dict, list[dict]]: | |
| n = 8 | |
| features = np.vstack([np.sqrt(np.arange(1, n + 1)) / math.sqrt(n), | |
| np.sin(np.arange(n) + 0.37)]) | |
| widths = np.array([0.32, 0.37]) | |
| shell = shell_partition(features, widths) | |
| d = shell["largest_dimension"] | |
| assert d >= 2 | |
| raw = rng.normal(size=(d, 2)) + 1j * rng.normal(size=(d, 2)) | |
| code, _ = np.linalg.qr(raw) | |
| initial = np.zeros((2**n, 2, 2), complex) | |
| initial[shell["indices"], 0, :] = code / math.sqrt(2) | |
| stages = [ | |
| (list(range(n)), 0.37, [0.53*X+0.19*Z, 0.47*Y-0.11*Z], 0.23*X), | |
| ([1,2,3,4,5,6,7], 0.51, [0.31*Y-0.29*Z, 0.39*X+0.21*Z], -0.17*Y), | |
| ([1,3,4,6,7], 0.68, [-0.43*X+0.13*Y, 0.37*Z+0.23*Y], 0.19*X+0.07*Z), | |
| ] | |
| states = bits_table(n) | |
| actual = initial.copy() | |
| comparison = initial.copy() | |
| exposure = np.zeros(2) | |
| for active, duration, couplings, hb in stages: | |
| exposure += duration * np.array([np.linalg.norm(c, 2) for c in couplings]) | |
| erased = [j for j in range(n) if j not in active] | |
| for integer in range(2**n): | |
| qa = features[:, active] @ states[integer, active] | |
| qe = features[:, erased] @ states[integer, erased] if erased else np.zeros(2) | |
| h = hb + sum(qa[l] * couplings[l] for l in range(2)) | |
| hc = hb + sum((shell["center"][l] - qe[l]) * couplings[l] for l in range(2)) | |
| actual[integer] = expm(-1j * duration * h) @ actual[integer] | |
| comparison[integer] = expm(-1j * duration * hc) @ comparison[integer] | |
| keep = stages[-1][0] + [n + 1] | |
| target = reduced_pure(initial.reshape(-1), keep, n + 2) | |
| noisy = reduced_pure(actual.reshape(-1), keep, n + 2) | |
| compared = reduced_pure(comparison.reshape(-1), keep, n + 2) | |
| error = trace_distance(noisy, target) | |
| comparison_error = trace_distance(compared, target) | |
| bound = float(np.dot(shell["halfwidth"], exposure)) | |
| assert comparison_error < TOL | |
| assert error <= min(1, bound) + TOL | |
| assert abs(np.vdot(actual, actual) - 1) < TOL | |
| tradeoff = [] | |
| for scale in (0.5, 1, 2, 4, 8, 16, 32): | |
| eta = 0.25 | |
| h = 2 * eta / (2 * scale * exposure) | |
| chosen = shell_partition(features, h) | |
| tradeoff.append({"exposure_multiplier": scale, | |
| "target_shell_channel_error": eta, | |
| "width_feature_1": float(h[0]), "width_feature_2": float(h[1]), | |
| "largest_shell_dimension": chosen["largest_dimension"], | |
| "occupied_bins": chosen["occupied_bins"], | |
| "safe_product_bin_count": chosen["safe_bin_count"], | |
| "log2_largest_shell_dimension": math.log2(chosen["largest_dimension"]), | |
| "pigeonhole_log2_dimension_lower_bound": n-math.log2(chosen["safe_bin_count"]), | |
| "interpretation": "Finite exact enumeration; inverse-exposure bin widths"}) | |
| result = {"physical_qubits": n, "feature_values": features.tolist(), | |
| "requested_bin_widths": widths.tolist(), "chosen_bin": list(shell["chosen_label"]), | |
| "chosen_centers": shell["center"].tolist(), | |
| "actual_halfwidths": shell["halfwidth"].tolist(), | |
| "largest_shell_dimension": d, "chosen_basis_indices": shell["indices"], | |
| "integrated_feature_exposures": exposure.tolist(), | |
| "known_erased_sites": [0,2,5], | |
| "reference_trace_distance_to_bare_erasure": error, | |
| "reference_comparison_evolution_trace_distance": comparison_error, | |
| "proved_half_diamond_upper_bound": min(1, bound), | |
| "noncommuting_bath_commutator_norm": float(np.linalg.norm( | |
| stages[0][2][0]@stages[0][2][1]-stages[0][2][1]@stages[0][2][0], 2))} | |
| return result, tradeoff | |
| def choi(kraus: list[np.ndarray]) -> np.ndarray: | |
| vectors = [k.reshape(-1, order="F") for k in kraus] | |
| return sum((np.outer(v, v.conj()) for v in vectors), | |
| np.zeros((len(vectors[0]), len(vectors[0])), complex)) | |
| def cp_dyson_checks() -> list[dict]: | |
| """Full Choi PSD test for approximate CP maps; maps need not be TP.""" | |
| n, r_sites, t_erased, bath = 3, 2, 1, 2 | |
| d_a, d_r = 2**n, 2**r_sites | |
| couplings = [0.41*X+0.13*Z, 0.29*Y-0.17*Z, 0.23*Z+0.11*X] | |
| duration = 0.19 | |
| h = np.zeros((d_a*bath, d_a*bath), complex) | |
| for a, bits in enumerate(bits_table(n)): | |
| h[a*bath:(a+1)*bath, a*bath:(a+1)*bath] = sum(bits[j]*couplings[j] for j in range(n)) | |
| exact = expm(-1j*duration*h) | |
| a_budget = duration * sum(np.linalg.norm(c, 2) for c in couplings) | |
| bare = [] | |
| for e in range(2**t_erased): | |
| k = np.zeros((d_r, d_a), complex) | |
| for r in range(d_r): k[r, r*2+e] = 1 | |
| bare.append(k) | |
| sector_indices = [a for a in range(d_a) if a.bit_count() == 1] | |
| sector_embedding = np.eye(d_a)[:, sector_indices] | |
| rows = [] | |
| for s in (0, 1, 2): | |
| truncated = np.eye(d_a*bath, dtype=complex) | |
| term = np.eye(d_a*bath, dtype=complex) | |
| for degree in range(1, s+1): | |
| term = term @ (-1j*duration*h) / degree | |
| truncated += term | |
| tau = math.exp(a_budget + (s+1)*math.log(a_budget) - gammaln(s+2)) | |
| actual_tail = float(np.linalg.norm(exact-truncated, 2)) | |
| assert actual_tail <= tau + TOL | |
| # Pure |0> bath preparation gives one column per physical input string. | |
| vs = truncated[:, np.arange(d_a)*bath] | |
| norm_vs_sq = float(np.linalg.norm(vs, 2)**2) | |
| assert norm_vs_sq <= (1+tau)**2 + TOL | |
| masks = [mask for mask in range(d_r) if mask.bit_count() <= s] | |
| m = len(masks) | |
| coefficients = np.zeros((2, bath, d_r), complex) | |
| for e in range(2): | |
| for b in range(bath): | |
| amplitudes = np.array([vs[(r*2+e)*bath+b, r*2+e] for r in range(d_r)]) | |
| for mask in range(d_r): | |
| coefficients[e,b,mask] = sum(amplitudes[r] * (-1)**((r&mask).bit_count()) | |
| for r in range(d_r)) / d_r | |
| forbidden = [mask for mask in range(d_r) if mask not in masks] | |
| forbidden_norm = float(np.max(np.abs(coefficients[:,:,forbidden]))) if forbidden else 0.0 | |
| assert forbidden_norm < TOL | |
| gram_traces, gram_max_eigenvalues = [], [] | |
| for e in range(2): | |
| c = coefficients[e][:,masks] | |
| gram = c.T @ c.conj() | |
| gram_traces.append(float(np.trace(gram).real)) | |
| gram_max_eigenvalues.append(float(np.linalg.eigvalsh(gram)[-1])) | |
| assert gram_traces[-1] <= norm_vs_sq + TOL | |
| approx_kraus = [] | |
| canonical = [] | |
| for e in range(2): | |
| for b in range(bath): | |
| k = np.zeros((d_r,d_a), complex) | |
| for r in range(d_r): k[r,r*2+e] = vs[(r*2+e)*bath+b,r*2+e] | |
| approx_kraus.append(k) | |
| for mask in masks: | |
| phase = np.diag([(-1)**((r&mask).bit_count()) for r in range(d_r)]) | |
| canonical.append(phase @ bare[e] / math.sqrt(m)) | |
| domination = m*(1+tau)**2 | |
| values = {} | |
| for name, embedding in [("full_input",np.eye(d_a)), ("weight_one_input",sector_embedding)]: | |
| jpsi = choi([k@embedding for k in approx_kraus]) | |
| jphi = choi([k@embedding for k in canonical]) | |
| diff = domination*jphi-jpsi | |
| smallest = float(np.linalg.eigvalsh((diff+diff.conj().T)/2)[0]) | |
| assert smallest >= -TOL | |
| values[name+"_minimum_Choi_domination_eigenvalue"] = smallest | |
| rows.append({"physical_qubits":n,"surviving_qubits":r_sites,"erased_qubits":t_erased, | |
| "truncation_order":s,"a_integrated_norm_budget":float(a_budget), | |
| "tail_bound_tau":tau,"actual_joint_unitary_tail_norm":actual_tail, | |
| "phase_support_count_M":m,"CP_domination_factor":domination, | |
| "approximate_amplitude_operator_norm_squared":norm_vs_sq, | |
| "Gram_traces_by_erasure_basis":gram_traces, | |
| "Gram_maximum_eigenvalues_by_erasure_basis":gram_max_eigenvalues, | |
| "forbidden_phase_coefficient_maximum":forbidden_norm, | |
| "canonical_channel": "bare erasure followed by uniform Z masks of weight <=s", | |
| "Choi_normalization": "unnormalized column-stacked Kraus Choi", | |
| **values}) | |
| return rows | |
| def h2(x: float) -> float: | |
| if x <= 0 or x >= 1: return 0.0 | |
| return -x*math.log2(x)-(1-x)*math.log2(1-x) | |
| def support_tail_rows() -> list[dict]: | |
| rows = [] | |
| for nu in (1,2,3): | |
| for beta in (0.25,0.5,1.0): | |
| for exponent in (3,4,5,6,8,10,12): | |
| n = 10**exponent | |
| cell = max(2, int(math.ceil(math.log(n)**2))) | |
| epsilon = min(1.0, (cell/n)**(beta/nu)) | |
| a = n*epsilon | |
| s = int(math.ceil(math.e**2*a + 4*math.log(n))) | |
| fraction = min(1.0, s/n) | |
| logtau = a+(s+1)*math.log(a)-gammaln(s+2) | |
| log_m_bound = n*h2(fraction) if fraction <= .5 else n | |
| # Exact finite support count is checked only at small n; its | |
| # entropy upper envelope is evaluated at the large n above. | |
| rows.append({"N":n,"spatial_dimension_nu":nu,"Holder_beta":beta, | |
| "cell_qubits_b":cell,"per_site_integrated_residual_epsilon":epsilon, | |
| "a_integrated_total_budget":a,"support_cutoff_s":s, | |
| "support_fraction_s_over_N":s/n, | |
| "log_safe_Dyson_tail_bound":float(logtau), | |
| "log2_phase_support_count_upper_bound":log_m_bound, | |
| "normalized_log2_support_count_upper_bound":log_m_bound/n, | |
| "interpretation":"Dyson-tail and support-entropy envelope, not achieved finite code rate"}) | |
| assert logtau < 0 | |
| for n in (8,16,32,64): | |
| for s in range(0,n//2+1): | |
| exact = sum(math.comb(n,w) for w in range(s+1)) | |
| assert math.log2(exact) <= n*h2(s/n)+1e-10 | |
| return rows | |
| def shell_rate_rows() -> list[dict]: | |
| rows = [] | |
| for n in [2**k for k in range(4,27)]: | |
| for rank in (1,2,4,8): | |
| for exposure_exponent in (0,1,2): | |
| exposure = n**exposure_exponent | |
| target = 1/n | |
| width = 2*target/(rank*exposure) | |
| bins_per_feature = max(1, math.ceil(n/width)) | |
| deficit = rank*math.log2(bins_per_feature) | |
| rows.append({"N":n,"feature_count_r":rank,"exposure_exponent":exposure_exponent, | |
| "per_feature_exposure":exposure,"target_shell_error":target, | |
| "bin_width":width,"safe_label_deficit_qubits":deficit, | |
| "normalized_label_deficit":deficit/n,"erasure_probability_p":.1, | |
| "dimension_based_rate_threshold":max(0.0,.8-deficit/n), | |
| "interpretation":"Dimension threshold before finite erasure coding slack; feature ranges <=N"}) | |
| return rows | |
| def continuous_rate_certificates() -> list[dict]: | |
| """Evaluate the manuscript's sufficient C0 finite-error certificate. | |
| The geometry-dependent input is an asserted per-site residual budget | |
| epsilon=0.01*(b/N)^(beta/nu); the numerical curves do not establish that | |
| budget for a particular device. All entropy/sector estimates are upper or | |
| lower envelopes in the safe direction specified by the theorem. | |
| """ | |
| rows=[] | |
| p,target,amplitude=.1,.01,.01 | |
| for nu in (1,2,3): | |
| for beta in (.25,.5,1.0): | |
| for exponent in range(4,13): | |
| n=10**exponent | |
| b=max(2,int(math.ceil(math.log(n)**2))) | |
| cells=math.ceil(n/b) | |
| logd_lower=n-cells*math.log2(1+n/cells) | |
| epsilon=amplitude*(b/n)**(beta/nu) | |
| a=n*epsilon | |
| s=int(math.ceil(math.e**2*a+4*math.log(n))) | |
| logtau=a+(s+1)*math.log(a)-gammaln(s+2) | |
| tau=math.exp(logtau) if logtau>-745 else 0.0 | |
| log_tail_error=logtau+math.log(2+tau) | |
| tail_ok=log_tail_error<=math.log(target/4) | |
| eta=math.sqrt(math.log(4/target)/(2*n)) | |
| cutoff_ok=s<=n/2 | |
| logm=n*h2(s/n) if cutoff_ok else float(n) | |
| # The root theorem uses 3 log M, not a guessed asymptotic | |
| # proxy: (1+tau)^2 2^[(ell+2N(p+eta)+3logM-logD)/2]<=target/2. | |
| correction=2*math.log2(target/(2*(1+tau)**2)) | |
| ell_bound=logd_lower-2*n*(p+eta)-3*logm+correction | |
| logical=max(0,int(math.floor(ell_bound))-16) if tail_ok and cutoff_ok else 0 | |
| if logical: | |
| log_middle=2*math.log1p(tau)+math.log(2)*(logical+2*n*(p+eta)+3*logm-logd_lower)/2 | |
| assert log_middle<=math.log(target/2)+1e-9 | |
| rows.append({"N":n,"nu":nu,"Holder_beta":beta,"p":p, | |
| "target_entanglement_infidelity":target,"residual_amplitude":amplitude, | |
| "cell_qubits_b":b,"cell_count_C":cells, | |
| "log2_sector_dimension_lower_bound":logd_lower, | |
| "per_site_residual_epsilon":epsilon,"support_cutoff_s":s, | |
| "support_fraction":s/n,"log_Dyson_tail_bound":float(logtau), | |
| "log_tail_infidelity_bound":float(log_tail_error), | |
| "tail_budget_certified":bool(tail_ok),"entropy_bound_applicable":bool(cutoff_ok), | |
| "erasure_slack_eta":eta,"log2_support_count_upper_bound":logm, | |
| "logical_qubits_certified":logical,"certified_rate":logical/n, | |
| "interpretation":"Sufficient finite-error certificate from proved envelopes; no implemented decoder"}) | |
| return rows | |
| def write_csv(path: Path, rows: list[dict]) -> None: | |
| with path.open("w",newline="") as f: | |
| writer=csv.DictWriter(f,fieldnames=list(rows[0]));writer.writeheader();writer.writerows(rows) | |
| def make_plots(output: Path, shells: list[dict], rates: list[dict], tails: list[dict], certificates: list[dict]) -> None: | |
| import matplotlib | |
| matplotlib.use("Agg") | |
| import matplotlib.pyplot as plt | |
| plt.rcParams.update({"font.size":10,"axes.spines.top":False,"axes.spines.right":False}) | |
| fig,ax=plt.subplots(figsize=(7,4.3),layout="constrained") | |
| for rank,color in [(1,"#267882"),(2,"#517fa7"),(4,"#9174b3"),(8,"#ad6b59")]: | |
| chosen=[r for r in rates if r["feature_count_r"]==rank and r["exposure_exponent"]==1] | |
| ax.plot([r["N"] for r in chosen],[r["dimension_based_rate_threshold"] for r in chosen], | |
| label=f"{rank} real-valued feature"+("s" if rank != 1 else ""),color=color) | |
| ax.axhline(.8,color="#354052",linestyle="--",label="Erasure limit, p=0.1") | |
| ax.set(xscale="log",xlabel="Physical qubits N",ylabel="Dimension-based rate threshold", | |
| title="Real-charge shells: exposure N, target field error 1/N",ylim=(-.02,.83)) | |
| ax.text(.03,.06,"Excludes finite erasure-code slack; profile charge ranges ≤ N",transform=ax.transAxes,fontsize=8) | |
| ax.legend(frameon=False,fontsize=8);ax.grid(alpha=.16) | |
| for ext in ("png","pdf"):fig.savefig(output/f"real_shell_rate_bounds.{ext}",dpi=220) | |
| plt.close(fig) | |
| fig,axes=plt.subplots(1,2,figsize=(9,3.8),layout="constrained") | |
| axes[0].plot([r["exposure_multiplier"] for r in shells], | |
| [r["largest_shell_dimension"] for r in shells],marker="o",color="#267882") | |
| axes[0].set_xscale("log",base=2) | |
| axes[0].set(xlabel="Exposure multiplier",ylabel="Largest shell dimension", | |
| title="Eight-site exact enumeration") | |
| for nu,color in [(1,"#267882"),(2,"#9174b3"),(3,"#ad6b59")]: | |
| chosen=[r for r in tails if r["spatial_dimension_nu"]==nu and r["Holder_beta"]==.5] | |
| axes[1].plot([r["N"] for r in chosen], | |
| [r["normalized_log2_support_count_upper_bound"] for r in chosen], | |
| marker="o",color=color,label=f"Spatial dimension {nu}") | |
| axes[1].set(xscale="log",xlabel="Physical qubits N",ylabel="Upper bound on log₂ M / N", | |
| title="Dyson support envelope, Hölder β=1/2",ylim=(-.02,1.03)) | |
| axes[1].legend(frameon=False,fontsize=8) | |
| for ax in axes:ax.grid(alpha=.16) | |
| fig.suptitle("Bound and enumeration diagnostics; no measured hardware rates",fontsize=10) | |
| for ext in ("png","pdf"):fig.savefig(output/f"shell_and_Dyson_diagnostics.{ext}",dpi=220) | |
| plt.close(fig) | |
| fig,axes=plt.subplots(1,2,figsize=(9,3.8),layout="constrained") | |
| for nu,color in [(1,"#267882"),(2,"#9174b3"),(3,"#ad6b59")]: | |
| chosen=[r for r in certificates if r["nu"]==nu and r["Holder_beta"]==.5] | |
| axes[0].plot([r["N"] for r in chosen],[r["certified_rate"] for r in chosen], | |
| marker="o",color=color,label=f"Dimension {nu}") | |
| for beta,color in [(.25,"#ad6b59"),(.5,"#9174b3"),(1.0,"#267882")]: | |
| chosen=[r for r in certificates if r["nu"]==2 and r["Holder_beta"]==beta] | |
| axes[1].plot([r["N"] for r in chosen],[r["certified_rate"] for r in chosen], | |
| marker="o",color=color,label=f"Hölder β={beta:g}") | |
| for ax in axes: | |
| ax.axhline(.8,color="#354052",linestyle="--",linewidth=1) | |
| ax.set(xscale="log",xlabel="Physical qubits N",ylabel="Sufficient certified rate",ylim=(-.02,.83)) | |
| ax.legend(frameon=False,fontsize=8);ax.grid(alpha=.16) | |
| axes[0].set_title("Hölder β=1/2") | |
| axes[1].set_title("Spatial dimension 2") | |
| fig.suptitle("Finite-error bound: p=0.1, target error=0.01, residual amplitude=0.01",fontsize=10) | |
| for ext in ("png","pdf"):fig.savefig(output/f"continuous_field_certificates.{ext}",dpi=220) | |
| plt.close(fig) | |
| def main() -> None: | |
| parser=argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("--output-dir",type=Path,default=Path(__file__).resolve().parents[1]/"results"/"broad") | |
| parser.add_argument("--no-plot",action="store_true") | |
| args=parser.parse_args();args.output_dir.mkdir(parents=True,exist_ok=True) | |
| rng=np.random.default_rng(SEED) | |
| trajectory,shells=shell_trajectory(rng) | |
| cp=cp_dyson_checks();tails=support_tail_rows();rates=shell_rate_rows();certificates=continuous_rate_certificates() | |
| summary={"seed":SEED,"numerical_tolerance":TOL, | |
| "status":"Deterministic numerical checks and analytic envelopes, not novelty certification", | |
| "real_charge_shell_trajectory":trajectory,"finite_shell_exposure_tradeoff":shells, | |
| "Dyson_CP_domination_checks":cp,"Dyson_support_tail_envelopes":tails, | |
| "real_charge_shell_rate_envelopes":rates,"continuous_field_rate_certificates":certificates} | |
| (args.output_dir/"broad_verification.json").write_text(json.dumps(summary,indent=2)+"\n") | |
| write_csv(args.output_dir/"finite_shell_tradeoff.csv",shells) | |
| write_csv(args.output_dir/"Dyson_CP_checks.csv",cp) | |
| write_csv(args.output_dir/"Dyson_support_envelopes.csv",tails) | |
| write_csv(args.output_dir/"real_shell_rate_envelopes.csv",rates) | |
| write_csv(args.output_dir/"continuous_field_certificates.csv",certificates) | |
| if not args.no_plot:make_plots(args.output_dir,shells,rates,tails,certificates) | |
| print(json.dumps({"all_assertions_passed":True, | |
| "shell_reference_error":trajectory["reference_trace_distance_to_bare_erasure"], | |
| "shell_proved_bound":trajectory["proved_half_diamond_upper_bound"], | |
| "comparison_evolution_error":trajectory["reference_comparison_evolution_trace_distance"], | |
| "smallest_CP_domination_eigenvalue":min(r["full_input_minimum_Choi_domination_eigenvalue"] for r in cp), | |
| "rows":{"CP":len(cp),"tails":len(tails),"rates":len(rates),"finite_certificates":len(certificates)}},indent=2)) | |
| if __name__=="__main__":main() | |