PaperlayerView exact revision on arXiv

Source-linked AI summary

Correcting coherent errors with surface codes

Sergey Bravyi, Matthias Englbrecht, Robert Koenig, Nolan Peard

arXiv:1710.02270v1quant-ph

TL;DR

The paper asks how surface codes tolerate coherent unitary errors that are not captured by standard Pauli-noise analyses. It develops an efficient Majorana-fermion-based simulation approach for surface-code error-correction protocols, achieving O(n^2) runtime. Simulations reach more than one thousand physical qubits and indicate that large-distance error correction produces approximately incoherent, random-Pauli-like logical noise, although coherence can still affect sub-threshold logical error rates.

  • Problem

    Coherent unitary errors are difficult to analyze because they generally cannot be described within the stabilizer formalism underlying standard Pauli-noise studies.

  • Method

    The paper constructs O(n^2)-runtime algorithms for simulating surface-code storage and logical-state preparation under coherent errors, using a Majorana-fermion representation.

  • Results

    The simulations reach n = 2401 physical qubits; for storage, sub-threshold P L decays exponentially with code distance and the threshold agrees well with the Pauli-twirl approximation.

  • Takeaways & Limitations

    At large code distances, coherent physical noise is converted into approximately incoherent logical-level noise concentrated near logical Pauli errors.

Abstract

from arXiv · show

We study how well topological quantum codes can tolerate coherent noise caused by systematic unitary errors such as unwanted $Z$-rotations. Our main result is an efficient algorithm for simulating quantum error correction protocols based on the 2D surface code in the presence of coherent errors. The algorithm has runtime $O(n^2)$, where $n$ is the number of physical qubits. It allows us to simulate systems with more than one thousand qubits and obtain the first error threshold estimates for several toy models of coherent noise. Numerical results are reported for storage of logical states subject to $Z$-rotation errors and for logical state preparation with general $SU(2)$ errors. We observe that for large code distances the effective logical-level noise is well-approximated by random Pauli errors even though the physical-level noise is coherent. Our algorithm works by mapping the surface code to a system of Majorana fermions.

I. INTRODUCTION

The paper develops polynomial-time simulation algorithms for surface-code error correction under coherent unitary noise, addressing a gap left by Pauli-noise analyses and exponentially costly prior simulations. Numerical studies examine storage and logical-state preparation, finding threshold behavior and effective logical noise that becomes approximately incoherent at large code distances.

  • Motivation: Coherent unitary errors are difficult to analyze because they generally fall outside the stabilizer formalism used for Pauli-noise models.Systematic small rotations can arise from hardware miscalibration, motivating direct study of coherent noise.
  • Problem and approach: The paper constructs algorithms A and B that simulate surface-code storage and logical-basis-state preparation under coherent errors.The two tasks are fault-tolerant storage and fault-tolerant preparation of a logical basis state.
  • Storage results: For storage with translation-invariant Z-rotation noise, the syndrome distribution is independent of the initial logical state, while the final logical state depends on a syndrome-specific logical rotation.The logical error rate is measured using the average diamond-norm distance between the conditional logical channel and the identity.
  • Storage results: Below the threshold, P L decays exponentially with code distance, and the threshold estimate agrees well with the Pauli-twirl approximation despite coherent physical noise.The Pauli-twirl approximation nevertheless significantly underestimates P L in the sub-threshold regime.
  • Logical-noise structure: At large code distances, logical rotation angles concentrate near 0 and π/2, supporting conversion of coherent physical noise into approximately incoherent logical noise.These angles correspond to logical Pauli-type errors I and ZL.

II. METHODS

The simulation maps surface-code error-correction protocols to fermionic linear optics (FLO), enabling classical simulation through a small set of elementary Majorana operations.

  • Fermionic linear optics: The surface-code protocols decompose into O(n) elementary gates from the fermionic linear optics gate set.The relevant operations initialize Majorana pairs, apply exp(γc_pc_q), and project with (I + ic_pc_q)/2.

III. FROM QUBITS TO MAJORANA FERMIONS

The surface code is represented using four Majorana modes per physical qubit, with link and vertex operators encoding stabilizers and logical Pauli operators. This representation converts surface-code syndrome measurements and logical operators into structured Majorana products.

  • C4 encoding: Each surface-code qubit is encoded into four Majorana modes governed by a single C4 stabilizer.The logical Pauli operators are represented by products of two Majorana modes, such as X = ic_1c_2 and Z = ic_2c_3.
  • Majorana lattice: The fermionic construction distributes 4n Majorana modes over lattice edges and vertices, including paired edge modes and four unpaired corner modes.An oriented edge connecting c_p to c_q defines the link operator L_e = ic_pc_q.
  • Majorana lattice: Link operators are Hermitian, mutually commuting, and commute with the four unpaired corner modes.These properties support the reduction of stabilizer measurements to link-operator measurements.
  • Vertex encoding: Four-mode vertex clusters carry stabilizers and logical Pauli operators that reproduce the surface-code qubit algebra.The cluster stabilizer is S_u = −c_u,1c_u,2c_u,3c_u,4, while X_u and Z_u are encoded as two-mode products.
  • Stabilizer representation: Surface-code face stabilizers can be represented as products of link operators around face boundaries, with arrow orientations fixing the required signs.An odd number of clockwise-oriented arrows on each face ensures the construction works for all code distances by translation invariance.
  • Logical operators: Logical boundary operators are likewise represented using link operators on the LEFT and TOP edge sets.The construction adds logical edges and logical faces so that the same boundary-product argument applies to X_L and Z_L.
  • State preparation: A logical state can be injected into the surface-code logical subspace by tensoring unentangled edge-mode pairs and measuring vertex stabilizers.The resulting link-mode state is Gaussian, and coherent errors encoded through the C4 code preserve this Gaussian structure.

IV. LOGICAL STATE PREPARATION

Logical state preparation is simulated by encoding each input qubit into the C4 code, measuring link syndromes with FLO operations, and computing the final logical Bloch vector conditioned on the syndrome.

  • Protocol: The protocol samples a surface-code syndrome and computes the final logical state conditioned on that syndrome.The syndrome projector is P_s = 1/2(I + s_fB_f) for each face stabilizer.
  • Input preparation: Arbitrary single-qubit input states are encoded into C4 states and prepared using O(n) FLO gates.An Euler-angle decomposition supplies the single-qubit rotations before applying the C4 encoding independently to each qubit.
  • Syndrome measurement: Surface-code syndrome measurement reduces to measuring commuting link operators and classically multiplying their outcomes around each face.Each link measurement is an FLO operation, so the complete syndrome measurement uses O(n) FLO gates.
  • Logical output: FLO gates also compute the final logical Bloch vector conditioned on the measured syndrome.Logical components are obtained through additional Majorana measurements after the link-syndrome measurement.
  • Complexity: Direct simulation of the resulting circuit takes O(n^3), but disentangling measured modes reduces the active system and computational cost.The optimization removes modes after link measurements and exploits the product form of the initial state.

V. STORAGE OF A LOGICAL STATE

For storage, the protocol applies independent coherent rotations before syndrome measurement and computes the conditioned logical state. Under the modeled Z-type errors, the syndrome distribution is independent of the initial logical state and the residual operation is a logical Z rotation.

  • Storage protocol: The storage problem applies a product unitary of single-qubit rotations to an unknown logical state before syndrome measurement.The simulation samples the syndrome and computes the final logical state conditioned on it.
  • Noise model: Z-type coherent errors produce trivial syndromes for Z stabilizers, so the correction can be chosen as a Z-type Pauli.This is the model-specific restriction used in the storage analysis.
  • Storage outcome: The syndrome probability distribution is independent of the initial logical state, while the conditioned logical map is a logical Z rotation.The logical rotation angle θ_s lies in [0, π) and depends on the measured syndrome.

A. Simulating the syndrome measurement

The syndrome-measurement simulator samples measurement outcomes using FLO gates in a Majorana representation of the surface code. Removing measured and unentangled modes reduces the total runtime to O(n^2).

  • A. Simulating the syndrome measurement: Syndrome outcomes are sampled sequentially by computing conditional probabilities for single-qubit X-measurement results and then classically deriving face syndromes.The simulator orders qubits column by column and samples each outcome from its conditional distribution.
  • A. Simulating the syndrome measurement: The surface-code state and measurement updates are represented with FLO gates acting on Majorana modes.The construction uses C4 encodings and link operators so the relevant operators have the required two-mode Majorana form.
  • A. Simulating the syndrome measurement: O(n^2) runtime follows because only O(n^1/2) active modes need simulation at each of O(n) measurement steps.Measured modes are removed, while distant modes remain in unentangled pairs that need not be loaded.
  • A. Simulating the syndrome measurement: The same framework computes individual outcome probabilities up to a normalizing coefficient depending only on n.The probability of any specified measurement outcome can be evaluated in O(n^2).
  • A. Simulating the syndrome measurement: The simulator can initialize the unpaired modes in a logical-Y state through a minor modification of the syndrome-sampling procedure.The modified algorithm is otherwise the same as the logical-X initialization procedure.

B. Computing the logical rotation angle

The logical rotation angle is computed from probabilities associated with products of single-qubit Z rotations. These probabilities are evaluated with the syndrome-sampling algorithm in O(n^2) time.

  • B. Computing the logical rotation angle: The method forms U+ = CsU and U− = ZLCsU, which are products of single-qubit Z rotations after syndrome correction.Their diagonal action in the Z basis reduces the logical-angle calculation to probability evaluation.
  • B. Computing the logical rotation angle: O(n^2) time suffices to compute the probabilities p± and q± used to determine θs modulo π.These probabilities are special cases of the previously developed measurement-outcome probabilities.
  • B. Computing the logical rotation angle: The conditional logical rotation angle θs is obtained from probability ratios computed for Z-rotation products.For one initialization, tan^2(θs) = p−/p+; an alternative logical-Y initialization gives tan^2(θs − π/4) = q−/q+.

VI. NUMERICAL RESULTS

The numerical study uses translation-invariant coherent noise and surface codes with odd distances from 5 through 49. Logical error rates are estimated by Monte Carlo sampling.

  • VI. NUMERICAL RESULTS: Surface-code simulations cover distances 5 ≤ d ≤ 49 under translation-invariant coherent noise.Distance 3 is omitted because of strong finite-size effects; d = 37 is used for storage and d = 49 for state preparation.
  • VI. NUMERICAL RESULTS: At least 50,000 syndrome samples are used to estimate the logical error rate P_L.The simulations use Monte Carlo sampling of syndrome outcomes.

A. Numerical results for storage

For storage under coherent Z rotations, the logical error rate decays exponentially with code distance below threshold. Although physical Pauli twirling reproduces the threshold estimate, it underestimates sub-threshold logical error rates, while the effective logical noise becomes nearly incoherent at large distances.

  • A. Numerical results for storage: P_L is the average diamond-norm distance between the syndrome-conditioned logical channel and the identity channel.For a conditional rotation angle θs, the identity-channel distance is 2|sin θs|.
  • A. Numerical results for storage: Below threshold, P_L decays exponentially with code distance d.This behavior is observed for θ < θ0 in the storage simulations.
  • A. Numerical results for storage: The coherence ratio P_L/P_L^twirl decreases with increasing code distance and approaches one for large distances.The same trend is observed for both conditional and average logical channels.
  • A. Numerical results for storage: For the average logical channel, large code distances convert coherent physical noise into effectively incoherent logical noise.The average channel is relevant when the environment has no access to the measured syndrome.
  • A. Numerical results for storage: Physical Pauli twirling gives an accurate threshold estimate but significantly underestimates logical error probability in the sub-threshold regime.The comparison uses coherent Z rotations and their twirled dephasing channel with ϵ = sin^2(θ).

B. Numerical results for state preparation

The state-preparation protocol measures syndromes after coherent single-qubit rotations and evaluates the resulting logical error rate. Simulations suggest threshold behavior governed mainly by the Z-rotation angle, with weak dependence on the second noise parameter.

  • The protocol prepares |+L⟩ by syndrome measurements on a product state with coherent rotations exp(iϕX)exp(iθZ)|+⟩ applied to each qubit.
  • The logical error rate P_L is the average trace-norm distance between the final logical state and the target |+L⟩ state.
  • The decoder chooses a Pauli correction so the final state has nonnegative logical X expectation and is optimal among Pauli corrections under that constraint.
  • The surface-code symmetries restrict simulation to 0 ≤ θ, ϕ ≤ π/4 after invariance transformations.
  • For code distance d = 39, the data support a threshold function θ0(ϕ), with P_L tending to zero below threshold and remaining bounded positively above it.
  • The estimated threshold θ0(ϕ) has very mild, if any, dependence on ϕ, with refined simulations performed at ϕ = 0.

VII. CONCLUSIONS

The paper presents efficient simulation of coherent-noise surface-code protocols and uses it to study larger code sizes. Its results indicate reasonably high thresholds and suggest that error correction can yield approximately incoherent logical noise, while broader generality remains unresolved.

  • The algorithms efficiently simulate coherent errors and extend numerical investigation to large code sizes relevant for error-threshold estimates.
  • For the simulated models, thresholds for state preparation and storage are reasonably high, suggesting coherent noise is not as detrimental as expected from prior studies.
  • The results motivate the conjecture that error correction converts coherent physical noise into incoherent logical noise at large code sizes.
  • The simulations use translation-invariant noise models, although the algorithms also apply to more general qubit-dependent noise.

Appendix A: Proof of Lemma 4

The appendix develops the Majorana-fermion and Gaussian-state machinery used to simulate the surface-code protocols. It represents states through covariance matrices and updates them efficiently under parity measurements and rotations.

  • Appendix A: Proof of Lemma 4: The proof expands errors in the Pauli basis and uses stabilizer-subspace structure to relate syndrome probabilities to quantities independent of the logical input state.
  • Appendix A: Proof of Lemma 4: The construction separates even- and odd-weight contributions, yielding real and imaginary components whose squared magnitudes determine the syndrome probability.
  • Gaussian-state simulation: Majorana operators and monomials provide an operator basis, while Gaussian states are characterized by real antisymmetric covariance matrices and Wick-theorem expectations.
  • Gaussian-state simulation: Gaussian states remain efficiently simulable under two-mode parity measurements, rotations, and tensor products through covariance-matrix updates.
  • Gaussian-state simulation: A parity-measurement update can be computed in O(n^2), whereas a two-mode rotation update can be computed in O(n).
Loading 1710.02270v1…