Erasure-tolerance scheme for the surface codes on neutral atom quantum computers

TL;DR

The paper addresses erasure and leakage challenges in surface-code quantum error correction for dense neutral-atom quantum computers, where erasures accumulate over time and undermine fault tolerance. It introduces a k-shift erasure recovery scheme that uses code deformation to relocate a logical qubit from a faulty array to a pristine one, effectively refreshing erasures while keeping logical coherence intact. Through circuit-based Monte Carlo simulations, the authors show that accumulated erasures destroy longer codes under conventional repetition, but 2-shift recovery can substantially reduce the logical failure rate relative to single-array operation, yielding a practical path to fault-tolerant operation. This approach decouples erasure repair from ongoing Pauli-error correction, enabling more aggressive array maintenance strategies and advancing the feasibility of scalable neutral-atom quantum computing with surface codes.

Abstract

Neutral atom arrays manipulated with optical tweezers are promising candidates for fault-tolerant quantum computers due to their advantageous properties, such as scalability, long coherence times, and optical accessibility for communication. A significant challenge to overcome is the presence of non-Pauli errors, specifically erasure errors and leakage errors. Previous work has shown that leakage errors can be converted into erasure errors; however, these (converted) erasure errors continuously occur and accumulate over time. Prior proposals have involved transporting atoms directly from a reservoir area--where spare atoms are stored--to the computational area--where computation and error correction are performed--to correct atom loss. While coherent transport is promising, it may not address all challenges--particularly its effectiveness in dense arrays and alternative methods must help. In this study, we evaluate the effects of erasure errors on the surface code using circuit-based Monte Carlo simulations that incorporate depolarizing and accumulated erasure errors. We propose a new scheme to mitigate this problem: a k-shift erasure recovery scheme. Our scheme employs code deformation to repeatedly transfer the logical qubit from an imperfect array with accumulated erased qubits to a perfect array, thereby tolerating many accumulated erasures. Furthermore, our scheme corrects erasure errors in the atom arrays while the logical qubits are evacuated from the area being corrected; thus, manipulating optical tweezers for erasure correction does not disturb the qubits that constitute the logical data. Our scheme provides a practical pathway for neutral atom quantum computers to achieve feasible fault tolerance.

Figures (7)

• Figure 1: (a) Illustration of the stabilizer generators $\mathcal{\tilde{G}}$ of the surface code. The large white circles represent data qubits. The orange (blue) squares represent stabilizer generators of $XXXX$ ($ZZZZ$) for star (plaquette) operators. The small orange (blue) circles are ancilla qubits for syndrome measurements. Suppose a data qubit indicated by a circle with diagonal lines disappears; in that case, the stabilizer generators around it are merged. Then, a super star (plaquette) operator of a large orange (blue) polygon is added as a new stabilizer generator to maintain the functionality as an error-correcting code. (b) An example of the time evolution of a qubit array encoded by the surface code with distance $5$. The bottom layer illustrates the situation before the syndrome measurement, with no erased qubits. The vertical axis represents time, showing how the erased qubits (circles with diagonal lines) increase as time progresses. (c) A circuit diagram of syndrome measurements for the surface code. The shaded regions in blue and orange represent syndrome measurements of $X^{\otimes 4}$ and $Z^{\otimes 4}$, respectively.
• Figure 2: A surface code of code distance $d=5$ with erasure errors, which include shortened logical operators due to super stabilizers. The blue and red lines represent the shortest $X$ and $Z$ logical operators, $X_L$ and $Z_L$. The $X_L$ is shortened to $d=3$, and the $Z_L$ is shortened to $d=2$ because super stabilizers adapt to erasure errors. The $Z_L$ of $d=2$ no longer has tolerance against $Z$ errors.
• Figure 3: The logical failure rate after $d$-rounds of syndrome measurements for each erasure error rate $p_{\textrm{e}}$. Each colored line represents a logical failure rate (vertical axis) vs. the depolarizing error rate per gate operation $p_{\textrm{dep}}$ (horizontal axis) for code distances $3$, $5$, $7$, $9$, $11$, and $13$. Each graph has a fixed erasure error rate $p_{\textrm{e}}$. The black dashed line is the break-even line, where the error correction suppresses errors below the depolarizing error rate. Each inset is a zoom-in to the cross-point around $p_{\text{dep}}=10^{-2}$.
• Figure 4: This plot shows the decrease in effective code distances with increasing rounds of the syndrome measurements. The horizontal axis $r$ is the repetition number of syndrome measurements normalized by the code distance $d$, i.e., performing the syndrome measurement cycles $dr$ times. Each box plot is obtained from $10^4$ circuit samples with $p_{\textrm{e}} = 1.0 \times 10^{-3}$. The detector error model of every circuit provides the effective code distance as the “shortest graph-like error” in Stim gidney2021stim. Each thick black line is the median, and each white triangle is the average of the effective code distance. The whiskers of each box represent the maximum and minimum of the samples. Effective code distances of longer initial code distances decrease rapidly because they are more exposed to accumulated erasure errors due to $d$-repetitions.
• Figure 5: (a) The process of transferring a logical qubit via code deformation. (b) The timeline of the 3-shift erasure recovery process. The horizontal axis represents the indexing of three arrays used to store the information of the logical qubit. The orange blocks indicate the location of the logical qubit, while the shaded blue blocks denote the measurement of data qubits performed to contract the extended logical qubit. The red blocks indicate the relocation of an array to the position where it will be utilized in the next step, depending on the geometric configuration of the tweezer arrays. Initially, the logical qubit is allocated to $\mathcal{A}_1$. Subsequently, the logical qubit is expanded to span $\mathcal{A}_1$ and $\mathcal{A}_2$. Following this, the logical qubit is contracted to $\mathcal{A}_2$ by measuring the data qubits on $\mathcal{A}_1$. Finally, $\mathcal{A}_1$ is shifted to the adjacent to $\mathcal{A}_3$, as $\mathcal{A}_1$ will receive the logical qubit from $\mathcal{A}_3$ in the subsequent step.