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 | |
| """Finite nonabelian operator-module checks and conservative coding certificates. | |
| All matrix tests are finite-dimensional illustrations of the accompanying | |
| proofs. Certificate plots evaluate stated sufficient bounds for explicitly | |
| chosen norm budgets; they are not device measurements or decoder benchmarks. | |
| Requires Python 3.10+, NumPy, SciPy, Matplotlib. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import csv | |
| import itertools | |
| import json | |
| import math | |
| from pathlib import Path | |
| import numpy as np | |
| from scipy.linalg import expm, svd | |
| from scipy.special import gammaln | |
| SEED=20261104 | |
| TOL=3e-10 | |
| 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) | |
| SINGLE=[I2,X,Y,Z] | |
| def kron(ops:list[np.ndarray])->np.ndarray: | |
| a=np.ones((1,1),complex) | |
| for op in ops:a=np.kron(a,op) | |
| return a | |
| def onsite(op:np.ndarray,j:int,n:int)->np.ndarray: | |
| return kron([op if k==j else I2 for k in range(n)]) | |
| def paulis(n:int)->list[tuple[tuple[int,...],int,np.ndarray]]: | |
| return [(label,sum(a!=0 for a in label),kron([SINGLE[a] for a in label])) | |
| for label in itertools.product(range(4),repeat=n)] | |
| def collective_algebra(n:int)->list[np.ndarray]: | |
| """Permutation-invariant Pauli sums form a basis of collective SU(2) algebra.""" | |
| groups={} | |
| for label,weight,op in paulis(n): | |
| counts=tuple(label.count(j) for j in (1,2,3)) | |
| groups[counts]=groups.get(counts,np.zeros_like(op))+op | |
| answer=[op/np.linalg.norm(op,'fro') for op in groups.values()] | |
| assert len(answer)==math.comb(n+3,3) | |
| gram=np.array([[np.vdot(a,b) for b in answer] for a in answer]) | |
| assert np.linalg.norm(gram-np.eye(len(answer)))<TOL | |
| return answer | |
| def orthogonal_module_basis(n:int,s:int)->np.ndarray: | |
| algebra=collective_algebra(n) | |
| columns=np.column_stack([(p@a).reshape(-1) for label,w,p in paulis(n) if w<=s | |
| for a in algebra]) | |
| u,singular,_=svd(columns,full_matrices=False) | |
| rank=int(np.sum(singular>1e-10*singular[0])) | |
| return u[:,:rank] | |
| def model_hamiltonians(r:int)->tuple[np.ndarray,np.ndarray,float]: | |
| """r survivors, one erased physical qubit, then a shared bath qubit.""" | |
| n=r+1 | |
| j=[sum((onsite(op/2,k,n) for k in range(n)),np.zeros((2**n,2**n),complex)) | |
| for op in (X,Y,Z)] | |
| h0=.71*np.kron(j[0],X)+.53*np.kron(j[1],Z)+.39*np.kron(j[2],Y) | |
| h0+=np.kron(np.eye(2**n),.21*X-.17*Y+.13*Z) | |
| # An explicit erased-site flip demonstrates that E is not assumed inert. | |
| h0+=.27*np.kron(onsite(X,r,n),Y)+.19*np.kron(onsite(Z,r,n),X) | |
| h1=np.zeros_like(h0) | |
| budget=0.0 | |
| for k in range(r): | |
| amplitude=.018*(k+1)/r | |
| bath=(.43+.03*k)*SINGLE[1+k%3]+.17*SINGLE[1+(k+1)%3] | |
| term=amplitude*np.kron(onsite(SINGLE[1+k%3],k,n),bath) | |
| h1+=term | |
| budget+=amplitude*np.linalg.norm(bath,2) | |
| assert np.linalg.norm(h0-h0.conj().T)<TOL | |
| assert np.linalg.norm(h1-h1.conj().T)<TOL | |
| return h0,h1,float(budget) | |
| def dyson_coefficients(h0:np.ndarray,h1:np.ndarray,duration:float,order:int)->list[np.ndarray]: | |
| """Exact constant-H interaction-Dyson coefficients via block exponential. | |
| The (0,k) block of exp(I tensor A + shift tensor B) is the coefficient | |
| of lambda^k in exp(A+lambda B), with A=-itH0 and B=-itH1. | |
| """ | |
| d=len(h0) | |
| shift=np.diag(np.ones(order),1) | |
| generator=np.kron(np.eye(order+1),-1j*duration*h0) | |
| generator+=np.kron(shift,-1j*duration*h1) | |
| big=expm(generator) | |
| return [big[:d,k*d:(k+1)*d] for k in range(order+1)] | |
| def coefficient_blocks(op:np.ndarray,d_r:int,d_eb:int)->np.ndarray: | |
| return op.reshape(d_r,d_eb,d_r,d_eb).transpose(0,2,1,3).reshape(d_r*d_r,d_eb*d_eb) | |
| def projection_checks()->tuple[list[dict],list[np.ndarray],float,float]: | |
| r=4 | |
| h0,h1,local_budget=model_hamiltonians(r) | |
| duration=.83 | |
| exact=expm(-1j*duration*(h0+h1)) | |
| coeff=dyson_coefficients(h0,h1,duration,2) | |
| d_r,d_eb=2**r,4 | |
| rows=[] | |
| approximations=[] | |
| a=duration*local_budget | |
| for s in (0,1,2): | |
| approximation=sum(coeff[:s+1],np.zeros_like(h0)) | |
| approximations.append(approximation) | |
| blocks=coefficient_blocks(approximation,d_r,d_eb) | |
| q=orthogonal_module_basis(r,s) | |
| module_error=np.linalg.norm(blocks-q@(q.conj().T@blocks),'fro')/np.linalg.norm(blocks,'fro') | |
| raw=np.column_stack([p.reshape(-1)/math.sqrt(d_r) for _,w,p in paulis(r) if w<=s]) | |
| raw_error=np.linalg.norm(blocks-raw@(raw.conj().T@blocks),'fro')/np.linalg.norm(blocks,'fro') | |
| tau=math.exp(a+(s+1)*math.log(a)-gammaln(s+2)) | |
| actual_tail=float(np.linalg.norm(exact-approximation,2)) | |
| assert module_error<TOL | |
| assert actual_tail<=tau+TOL | |
| # Baseline collectively couples survivors; raw low-weight Pauli support | |
| # already grows even though the collective module remains invariant. | |
| assert raw_error>1e-3 | |
| rows.append({"surviving_qubits":r,"erased_qubits":1,"bath_dimension":2, | |
| "joint_dimension":len(h0),"Dyson_order_s":s, | |
| "collective_algebra_dimension":math.comb(r+3,3), | |
| "module_dimension_numerical":q.shape[1], | |
| "module_dimension_upper_bound":sum(math.comb(r,w)*3**w for w in range(s+1))*math.comb(r+3,3), | |
| "relative_Frobenius_module_projection_error":float(module_error), | |
| "relative_Frobenius_raw_Pauli_projection_error":float(raw_error), | |
| "actual_operator_tail_norm":actual_tail,"safe_Dyson_tail_tau":tau, | |
| "integrated_residual_budget_a":a, | |
| "erased_site_flip_in_baseline":True}) | |
| return rows,approximations,a,duration | |
| def choi(kraus:list[np.ndarray])->np.ndarray: | |
| size=kraus[0].size | |
| out=np.zeros((size,size),complex) | |
| for k in kraus: | |
| v=k.reshape(-1,order='F') | |
| out+=np.outer(v,v.conj()) | |
| return out | |
| def psd_sqrt(a:np.ndarray)->np.ndarray: | |
| eig,u=np.linalg.eigh((a+a.conj().T)/2) | |
| assert eig[0]>=-TOL | |
| return (u*np.sqrt(np.maximum(eig,0)))@u.conj().T | |
| def amplitude_kraus(joint:np.ndarray,r:int)->tuple[list[np.ndarray],np.ndarray]: | |
| """Bath initially |0>; E input unrestricted; E output and bath discarded.""" | |
| d_r,d_a=2**r,2**(r+1) | |
| v=joint[:,np.arange(d_a)*2] | |
| ks=[] | |
| for e_out in range(2): | |
| for b in range(2): | |
| ks.append(v[(np.arange(d_r)*2+e_out)*2+b,:]) | |
| return ks,v | |
| def canonical_kraus(dictionary:list[np.ndarray],r:int,complete:bool)->list[np.ndarray]: | |
| d_r,d_a,m=2**r,2**(r+1),len(dictionary) | |
| erase=[] | |
| for e in range(2): | |
| k=np.zeros((d_r,d_a),complex) | |
| for a in range(d_r):k[a,a*2+e]=1 | |
| erase.append(k) | |
| result=[a@k/math.sqrt(m) for a in dictionary for k in erase] | |
| if complete: | |
| deficit=np.eye(d_r)-sum((a.conj().T@a for a in dictionary),np.zeros((d_r,d_r),complex))/m | |
| completion=psd_sqrt(deficit) | |
| result.extend(completion@k for k in erase) | |
| trace=sum((k.conj().T@k for k in result),np.zeros((d_a,d_a),complex)) | |
| assert np.linalg.norm(trace-np.eye(d_a))<TOL | |
| return result | |
| def dual_coordinate_norm(dictionary:list[np.ndarray])->tuple[float,float]: | |
| matrix=np.column_stack([a.reshape(-1,order='F') for a in dictionary]) | |
| inverse=np.linalg.inv(matrix) | |
| duals=[inverse[i].conj().reshape(dictionary[0].shape,order='F') for i in range(len(dictionary))] | |
| gram=np.array([[np.trace(d.conj().T@a) for a in dictionary] for d in duals]) | |
| assert np.linalg.norm(gram-np.eye(len(dictionary)))<TOL | |
| norm=max(float(np.linalg.svd(d,compute_uv=False).sum()) for d in duals) | |
| offdiag=matrix.conj().T@matrix | |
| offdiag-=np.diag(np.diag(offdiag)) | |
| return norm,float(np.linalg.norm(offdiag,'fro')) | |
| def cp_domination_checks()->list[dict]: | |
| r=2 | |
| d=2**r | |
| h0,h1,budget=model_hamiltonians(r) | |
| duration=.71 | |
| coefficients=dyson_coefficients(h0,h1,duration,1) | |
| approximate=coefficients[0]+coefficients[1] | |
| exact=expm(-1j*duration*(h0+h1)) | |
| a=duration*budget | |
| tau=math.exp(a+2*math.log(a)-gammaln(3)) | |
| assert np.linalg.norm(exact-approximate,2)<=tau+TOL | |
| approx_ks,v=amplitude_kraus(approximate,r) | |
| vnorm=float(np.linalg.norm(v,2)) | |
| assert vnorm<=1+tau+TOL | |
| jpsi=choi(approx_ks) | |
| pauli=[p for _,_,p in paulis(r)] | |
| units=[] | |
| for aindex in range(d): | |
| for bindex in range(d): | |
| e=np.zeros((d,d),complex);e[aindex,bindex]=1;units.append(e) | |
| nonorthogonal=[] | |
| for i,p in enumerate(pauli): | |
| aop=p+.21*pauli[(i+1)%len(pauli)] | |
| nonorthogonal.append(aop/np.linalg.norm(aop,2)) | |
| cases=[('orthonormal_unitary_Paulis',pauli,False,'m*v^2'), | |
| ('matrix_unit_Auerbach_basis',units,True,'m^2*c^2*v^2'), | |
| ('nonorthogonal_contraction_dictionary',nonorthogonal,True,'m^2*c^2*v^2')] | |
| rows=[] | |
| for name,dictionary,complete,formula in cases: | |
| m=len(dictionary) | |
| c,offdiag=dual_coordinate_norm(dictionary) | |
| if name!='nonorthogonal_contraction_dictionary':assert abs(c-1)<TOL | |
| else:assert c>1 and offdiag>1 | |
| canonical=canonical_kraus(dictionary,r,complete) | |
| jphi=choi(canonical) | |
| factor=m*vnorm**2 if formula=='m*v^2' else m*m*c*c*vnorm**2 | |
| diff=factor*jphi-jpsi | |
| minimum=float(np.linalg.eigvalsh((diff+diff.conj().T)/2)[0]) | |
| assert minimum>=-TOL | |
| safe_factor=m*(1+tau)**2 if formula=='m*v^2' else m*m*c*c*(1+tau)**2 | |
| rows.append({"dictionary":name,"surviving_qubits":r,"input_physical_qubits":r+1, | |
| "dictionary_size_m":m,"maximum_basis_operator_norm":max(float(np.linalg.norm(op,2)) for op in dictionary), | |
| "maximum_dual_coordinate_norm_c":c,"HS_offdiagonal_Gram_norm":offdiag, | |
| "approximate_amplitude_operator_norm_v":vnorm,"safe_tail_tau":tau, | |
| "CP_domination_formula":formula,"tested_CP_domination_factor":factor, | |
| "safe_factor_using_1_plus_tau":safe_factor, | |
| "minimum_unnormalized_Choi_domination_eigenvalue":minimum, | |
| "canonical_channel_completed":complete,"Choi_dimension":len(jpsi), | |
| "arbitrary_erased_site_flip_present":True}) | |
| return rows | |
| def h2(q:float)->float: | |
| if q<=0 or q>=1:return 0.0 | |
| return -q*math.log2(q)-(1-q)*math.log2(1-q) | |
| def log_collective_algebra_dimension(n:int,b:int)->float: | |
| full,rem=divmod(n,b) | |
| out=full*math.log2(math.comb(b+3,3)) | |
| if rem:out+=math.log2(math.comb(rem+3,3)) | |
| return out | |
| def log2_one_plus_exp2(x:float)->float: | |
| if x>50:return x+math.log1p(2**(-x))/math.log(2) | |
| return math.log2(1+2**x) | |
| def finite_certificate_rows()->list[dict]: | |
| """Conservative m^2 CP bound, full input dimension 2^N. | |
| User-facing curves assert only the assumed per-site residual budget; | |
| they do not measure or infer it for an experimental platform. | |
| """ | |
| rows=[] | |
| p,target=.1,.01 | |
| for nu in (1,2,3): | |
| for beta in (.25,.5,1.): | |
| for amplitude in (.001,.01): | |
| for exponent in range(4,13): | |
| n=10**exponent | |
| b=max(2,int(math.ceil(math.sqrt(n)))) | |
| 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 | |
| tail_error_log=logtau+math.log(2+tau) | |
| tail_ok=tail_error_log<=math.log(target/4) | |
| cutoff_ok=s<=n/2 | |
| q=s/n | |
| pauli_log=n*h2(q)+s*math.log2(3) if cutoff_ok else 2*n | |
| alg_log=log_collective_algebra_dimension(n,b) | |
| logm=pauli_log+alg_log | |
| # Using the upper dimension estimate is conservative even | |
| # when it exceeds the full operator-space dimension. | |
| eta=math.sqrt(math.log(4/target)/(2*n)) | |
| u=n*(p+eta) | |
| logm1=log2_one_plus_exp2(logm) | |
| correction=2*math.log2(target/(2*(1+tau)**2)) | |
| logical_bound=n-2*u-4*logm-logm1-1+correction | |
| logical=max(0,int(math.floor(logical_bound))-32) if tail_ok and cutoff_ok else 0 | |
| if logical: | |
| logcoding=(2*logm+u+.5*(1+logical+logm1-n))*math.log(2)+2*math.log1p(tau) | |
| assert logcoding<=math.log(target/2)+1e-9 | |
| rows.append({"N":n,"nu":nu,"Holder_beta":beta,"residual_amplitude":amplitude, | |
| "cell_qubits_b":b,"erasure_probability_p":p,"target_error":target, | |
| "per_site_residual_epsilon":epsilon,"Dyson_order_s":s, | |
| "support_fraction_s_over_N":q,"log_safe_tail_tau":float(logtau), | |
| "tail_budget_passes":bool(tail_ok),"entropy_envelope_applicable":bool(cutoff_ok), | |
| "log2_Pauli_ball_upper_bound":pauli_log, | |
| "log2_collective_algebra_dimension":alg_log, | |
| "log2_operator_module_dimension_upper_bound":logm, | |
| "erasure_slack_eta":eta,"erasure_cutoff_u":u, | |
| "logical_qubits_certified":logical,"certified_rate":logical/n, | |
| "interpretation":"Sufficient bound for an assumed residual norm budget; no implemented decoder"}) | |
| # Independent small-size verification of both exact dimension counts. | |
| for n in (4,8,16,32): | |
| for s in range(n//2+1): | |
| exact=sum(math.comb(n,w)*3**w for w in range(s+1)) | |
| assert math.log2(exact)<=n*h2(s/n)+s*math.log2(3)+TOL | |
| 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 plots(output:Path,projection: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,axes=plt.subplots(1,2,figsize=(9,3.8),layout='constrained') | |
| orders=[r['Dyson_order_s'] for r in projection] | |
| axes[0].semilogy(orders,[max(r['relative_Frobenius_module_projection_error'],1e-17) for r in projection], | |
| marker='o',color='#267882',label='Collective operator module') | |
| axes[0].semilogy(orders,[r['relative_Frobenius_raw_Pauli_projection_error'] for r in projection], | |
| marker='o',color='#a66c55',label='Raw weight ≤s Pauli span') | |
| axes[0].set(xlabel='Interaction-Dyson order s',ylabel='Relative projection residual', | |
| title='Four survivors, one erased site, shared bath',xticks=orders) | |
| axes[0].legend(frameon=False,fontsize=8) | |
| axes[1].semilogy(orders,[r['actual_operator_tail_norm'] for r in projection],marker='o', | |
| color='#267882',label='Exact unitary minus truncation') | |
| axes[1].semilogy(orders,[r['safe_Dyson_tail_tau'] for r in projection],marker='o', | |
| color='#9174b3',label='Proved tail upper bound') | |
| axes[1].set(xlabel='Interaction-Dyson order s',ylabel='Operator norm',title='Finite matrix tail check',xticks=orders) | |
| axes[1].legend(frameon=False,fontsize=8) | |
| for ax in axes:ax.grid(alpha=.16) | |
| for ext in ('png','pdf'):fig.savefig(output/f'nonabelian_module_checks.{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,'#a66c55')]: | |
| chosen=[r for r in certificates if r['nu']==nu and r['Holder_beta']==.5 and r['residual_amplitude']==.001] | |
| 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,'#a66c55'),(.5,'#9174b3'),(1.,'#267882')]: | |
| chosen=[r for r in certificates if r['nu']==2 and r['Holder_beta']==beta and r['residual_amplitude']==.001] | |
| 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('Generic nonabelian bound: p=0.1, target error=0.01, residual amplitude=0.001',fontsize=10) | |
| for ext in ('png','pdf'):fig.savefig(output/f'nonabelian_finite_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'/'nonabelian') | |
| parser.add_argument('--no-plot',action='store_true') | |
| args=parser.parse_args();args.output_dir.mkdir(parents=True,exist_ok=True) | |
| projection,_,_,_=projection_checks() | |
| cp=cp_domination_checks();certificates=finite_certificate_rows() | |
| result={'seed':SEED,'numerical_tolerance':TOL, | |
| 'status':'Finite matrix checks and analytic certificate evaluations, not proofs or novelty certification', | |
| 'Dyson_operator_module_checks':projection,'generic_CP_domination_checks':cp, | |
| 'finite_nonabelian_rate_certificates':certificates} | |
| (args.output_dir/'nonabelian_verification.json').write_text(json.dumps(result,indent=2)+'\n') | |
| write_csv(args.output_dir/'Dyson_module_checks.csv',projection) | |
| write_csv(args.output_dir/'generic_CP_checks.csv',cp) | |
| write_csv(args.output_dir/'finite_certificates.csv',certificates) | |
| if not args.no_plot:plots(args.output_dir,projection,certificates) | |
| print(json.dumps({'all_assertions_passed':True, | |
| 'module_dimensions':[r['module_dimension_numerical'] for r in projection], | |
| 'maximum_module_projection_residual':max(r['relative_Frobenius_module_projection_error'] for r in projection), | |
| 'raw_Pauli_projection_residuals':[r['relative_Frobenius_raw_Pauli_projection_error'] for r in projection], | |
| 'minimum_CP_domination_eigenvalue':min(r['minimum_unnormalized_Choi_domination_eigenvalue'] for r in cp), | |
| 'certificate_rows':len(certificates),'positive_certificates':sum(r['logical_qubits_certified']>0 for r in certificates)},indent=2)) | |
| if __name__=='__main__':main() | |