# Optimized measurement-free and fault-tolerant quantum error correction
for neutral atoms

Stefano Veroni<EMAIL_ADDRESS>PlanQC GmbH, Münchener Str. 34, 85748
Garching, Germany  Markus Müller  Institute for Quantum Information, RWTH
Aachen University, D-52056 Aachen, Germany  Peter Grünberg Institute,
Theoretical Nanoelectronics, Forschungszentrum Jülich, D-52425 Jülich, Germany
Giacomo Giudice  PlanQC GmbH, Münchener Str. 34, 85748 Garching, Germany

(August 31, 2024)

###### Abstract

A major challenge in performing quantum error correction (QEC) is implementing
reliable measurements and conditional feed-forward operations. In quantum
computing platforms supporting unconditional qubit resets, or a constant
supply of fresh qubits, alternative schemes which do not require measurements
are possible. In such schemes, the error correction is realized via crafted
coherent quantum feedback. We propose implementations of small measurement-
free QEC schemes, which are fault-tolerant to circuit-level noise. These
implementations are guided by several heuristics to achieve fault-tolerance:
redundant syndrome information is extracted, and additional single-shot flag
qubits are used. By carefully designing the circuit, the additional overhead
of these measurement-free schemes is moderate compared to their conventional
measurement-and-feed-forward counterparts. We highlight how this alternative
approach paves the way towards implementing resource-efficient measurement-
free QEC on neutral-atom arrays.

##  I Introduction

Large-scale quantum computers will require _quantum error correction_ (QEC) to
perform quantum information processing [1, 2]. By carefully designing the
physical system one can counteract the propagation of faults, arising from
fundamentally noisy hardware. The logical information is encoded in a small
subspace of the physical Hilbert space of the whole system, in a typically
non-local way: this _redundant_ encoding is then robust against local errors.
The redundancy however introduces a significant overhead in the resources
required to implement QEC. Therefore, the choice of the specific error-
correction scheme should be tailored to a given quantum computer, in order to
minimize this overhead and take advantage of the features of a given physical
platform. Despite the technical challenges, we are currently witnessing
exciting progress in the field of QEC, as highlighted by recent experimental
advances [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17].

\begin{overpic}[width=433.62pt]{tweezers.pdf} \put(6.0,65.0){(a)}
\put(52.0,65.0){(b)} \put(6.0,25.0){(c)} \end{overpic}

((a))

((b))

((c))

Figure 1:  (a) Optical tweezer arrays allow for the manipulation of individual
atoms in space. By placing atoms nearby, one can exploit Rydberg interactions
to perform entangling gates. Such gates can then be used to extract stabilizer
information from the system. For example, the ancillary qubit highlighted in
red can be used to extract the stabilizer
$S_{1}^{X}=X_{1}X_{2}X_{3}X_{4}X_{5}X_{6}$ of the Bacon-Shor code. (b) The
Bacon-Shor codespace is generated by four six-body stabilizers: two
$X$-stabilizers in the vertical direction and two $Z$-stabilizers in the
horizontal direction. (c) General circuit layout for fault-tolerant
measurement-free QEC. It uses three registers of qubits: data
$\ket{\psi}_{L}$, flags $\ket{f}$, ancillae $\ket{a}$. Fault-tolerance is
achieved via two main ingredients: syndrome redundancy and single-shot flags.
The circuit coherently maps syndrome information of a redundant number $m$ of
stabilizers on ancilla qubits, with $m$ larger than the size of the generating
set of stabilizers (orange). Each extraction is aided by flags, which detect
errors occurring during the coherent mapping of the stabilizers. The flag
pattern is then used to correct these errors on data qubits (purple). After
the extraction of each stabilizer, the qubits in the intermediary register are
reset to $\ket{0}$ or, alternatively, replaced by fresh qubits in $\ket{0}$
($R$ gate). Finally, the correction is applied coherently based on the
syndrome information contained in the quantum state of the ancillae (green).
Arrows represent the flow of information.

Neutral atom arrays are a promising candidate for large-scale quantum
information processors [18]. Atoms can be manipulated in large numbers using
optical tweezers, cf. Fig. 1(a), enabling reconfigurable geometries as well as
the physical transport of individual atoms while preserving quantum
information [19]. The quantum information is stored in different atomic
levels, exhibiting long coherence times of the order of seconds. Single-qubit
gates can be realized with controlled sequences of microwave or laser pulses,
which can be performed in times of the order of
$0.5\text{\,}\mathrm{\SIUnitSymbolMicro s}$ [20, 21, 22, 23]. Multi-qubit
entangling gates are realized via Rydberg interactions between neighboring
qubits. By engineering pulses that drive the atoms to their Rydberg states and
back [24, 25], high-fidelity controlled-$Z$ gates ($CZ$) have been realized
with rubidium [26], strontium [27, 28], and ytterbium [29]. Furthermore, these
gates can be slightly faster than single-qubit gates. One can generalize this
mechanism to natively realize multi-controlled gates as well, such as
$C^{m}Z$, which were demonstrated experimentally [25, 26]. This is
particularly interesting from an algorithmic point of view, as this enables
fast Toffoli ($CCX$) gates, which can be constructed from $CCZ$ and local
Hadamard ($H$) gates.

One limitation of neutral-atom platforms is state measurement, which is
typically performed by inducing fluorescence and detecting the light emitted
from the atoms. Feed-forward operations based on real-time measurements remain
challenging, despite recent demonstrations [30, 31, 32, 29, 33, 34, 14].
Measurements require times of the order of
$500\text{\,}\mathrm{\SIUnitSymbolMicro s}$, without accounting for camera
readout times and possible shuttling time of atoms to a dedicated readout zone
[35, 19, 14]. Therefore, there are around three orders of magnitude in time
difference between gates and measurements in neutral-atom platforms. Coupling
the atoms to a cavity could speed up the times required for read out [36, 37],
at the cost of a loss of parallelism for single-mode cavities.

In standard QEC protocols, some partial information of the system is measured,
the _error syndrome_. Based on this, a correction is decided upon by a
classical algorithm (decoder) and applied to the system, either by physical
feedback or in software [1]. Relatively slow measurements inhibit the fast
execution of such protocols. As an alternative, _measurement-free_ (MF) QEC
protocols have been proposed [38, 39, 40, 41], where the classical processing
is replaced with unitary dynamics. The overall dynamics are still dissipative,
since we need to remove the additional entropy introduced by faults. In MF
QEC, this is provided by reset operations, or a sufficiently large reservoir
of continuously-provided ancilla qubits [42, 43, 44].

Recent attempts have focused on rendering such MF schemes fault-tolerant (FT):
such FT constructions guarantee that the protocol is capable of lowering
failure rates provided the physical error rates are below a break-even point,
by introducing redundancies in the syndrome under a specific error model [45].
The first MF and fully FT explicit quantum circuit implementation was proposed
in Ref. [46], making use of concepts from Steane-type error correction [47]
(not to be confused with the Steane code, discussed later). There, the key is
to first copy the logical state of the to-be-corrected logical data qubit to
an auxiliary logical qubit register to avoid the uncontrolled propagation of
errors to the logical data qubit during the extraction of the error syndrome.
This additional register needs to be initialized fault-tolerantly into a
logical state to perform the coherent error copying-operation, which requires
further overhead.

In this manuscript, we develop alternative strategies to construct MF, yet
fully FT QEC circuits, which are ideally suited for application to low-
distance QEC codes such as, e.g., the 9-qubit Bacon-Shor code illustrated in
Fig. 1(b). As sketched in Fig. 1(c), these protocols involve (i) introducing
redundancies in the syndrome information, and (ii) using additional qubits to
first flag the syndrome extraction and to then apply corrections on the data
qubits in a single-shot fashion. These procedures reduce the qubit overhead,
and, simultaneously, avoid the need for faul-tolerant preparation of auxiliary
logical states. In Sec. II, we outline our strategy, and formulate some
general heuristics with which we design concrete error-correcting circuits. In
Sec. III we demonstrate the validity of our scheme by applying them to
specific distance-three QEC codes, namely the Bacon-Shor code [48, 49], Shor’s
code [50], the rotated surface code [51, 52, 53] and Steane’s code [54] as the
smallest 2D topological color code [55]. The performance of our MF QEC
protocols is then benchmarked and compared to comparable feed-forward
implementations in Sec. IV, for a general depolarizing noise model as well as
a noise model specific to neutral-atom arrays. Finally, we summarize our
results and discuss the possibilities of scaling up such approaches in Sec. V.

##  II Guidelines for fault-tolerant measurement-free QEC

A QEC code is described by the set of integers $\llbracket n,k,d\rrbracket$,
where $n$ is the number of physical qubits, $k$ is the number of logical
qubits and $d$ is the code distance, meaning the code can correct at least
$t=\left\lfloor{d/2}\right\rfloor$ errors. A protocol is said to be FT if the
following conditions are satisfied [56, 57]:

  1. 1.

If the input is a codeword with error of weight $r$ and the protocol has $s$
faults, with $r+s\leq t$, then the output is the original codeword up to a
correctable error.

  2. 2.

If the protocol has $s\leq t$ faults, independently of the errors on the
input, then the output differs from any codeword by an error of at most weight
$s$.

We consider general circuit-level error models, which correspond to some
(possibly gate-dependent) quantum channel following each operation. We
therefore aim at designing specific circuits implementing QEC protocols, which
are FT against such errors.

Recently, fault tolerance was achieved by adopting elements of Steane-type
error correction, by introducing an auxiliary register of qubits to be used as
intermediary between data and ancillae [46]. There, errors on data qubits are
copied coherently to an auxiliary register by means of a transversal
$\mathrm{CNOT}$. This auxiliary register is then manipulated during the
syndrome extraction, such that errors occurring in this register do not
propagate to the data qubits. In other words, the lack of direct communication
between data qubits and ancillae enables fault tolerance.

In this work, we suggest an alternative scheme, which allows one to use fewer
qubits and operations, as well as gates with support on fewer qubits (at most
3-qubit Toffoli-type gates), to achieve similar performances. As summarized in
Fig. 1(c), our strategy is built upon the following elements:

  1. 1.

_Syndrome redundancy_. An informationally over-complete set of stabilizer bits
is extracted [40]. This prevents that errors during the syndrome extraction
lead to erroneous corrections, corrupting the logical state. It also allows
for the application of the aforementioned heuristic to be applied in the error
correction. The order in which the stabilizers are read out needs to be chosen
carefully to satisfy certain constraints, as explained in App. A.

  2. 2.

_Single-shot flags_. Additional qubits are used to flag the syndrome
extraction [58]. Flag qubits prevent bit-flips on the ancillae from inducing
uncorrectable errors on the data. Typically, if a flag qubit is triggered,
i.e. measured in the $\ket{1}$ state, the syndrome extraction circuit is
repeated. Our use of flag qubits is single-shot [59], as they lead to
corrections on the data qubits, immediately after each stabilizer read out,
without the need for repeating theextraction circuit. Notably, we show this
can be done without measurements.

In the next section, we provide explicit examples how these guidelines are
implemented. As will be shown, they allow for single-round FT QEC, where only
one round of stabilizer measurements is required.

While the general strategy outlined above enables fault-tolerance, it does not
automatically provide FT circuit implementations. For this goal, we suggest
that a FT $d=3$ QEC protocol should avoid the following configurations
(illustrated in Fig. 2):

  1. (a)

multi-qubit gates involving more than a single data qubit;

  2. (b)

multi-qubit gates in the syndrome extraction acting on a data qubit and more
than one ancilla;

  3. (c)

certain pairs of multi-qubit gates acting on data and sharing some qubits.
Specifically, those outside of the syndrome extraction, where all the one-
control qubits 111In a controlled unitary, we define a one-control as the
qubit that leads to the application of the unitary if the control is in
$\ket{1}$. These are illustrated in the diagrams with a filled circle.  of a
later gate are also involved in an earlier one.

As illustrated in Fig. 2, these guidelines prevent the spread of errors on the
input logical qubit, under the assumption of correlated errors occurring at
first-order in probability on the qubits of a single gate. These guidelines
are neither sufficient on their own, nor strictly necessary. In fact, they
could be relaxed on a case-by-case basis, depending on the presence of
correlation or bias in the noise, additional structure of the QEC code, or the
specific syndrome redundancy. Nevertheless, they can aid in the realization of
generally FT QEC implementations.

\begin{overpic}[width=433.62pt]{rules.pdf} \put(2.0,32.0){(a)}
\put(30.0,32.0){(b)} \put(60.0,32.0){(c)} \end{overpic} Figure 2:
Configurations or circuit elements _to be avoided_ to maintain fault-tolerance
in a $d=3$ QEC protocol. (a) Gates involving more than one data qubit, as they
can introduce errors on several data qubits. (b) Gates involving a data qubit
and more than one ancilla. In fact these can immediately cause an error on the
data qubit. Additionally, multiple errors on the ancillae introduce additional
errors on the data later in the circuit. In contrast, single errors on the
ancillae can be tolerated by imposing a minimal syndrome redundancy, discussed
in the main text. (c) Multi-controlled gates acting on data qubits with common
one-controls can cause errors on multiple data qubits. This can occur if all
one-controls of the later gate are shared with the earlier gate.  Figure 3:
Measurement-free fault-tolerant QEC implementation for the Bacon-Shor code. It
coherently reads out three $X$-type and $Z$-type stabilizers rather than only
two. This redundant syndrome information allows for fault-tolerant
measurement-free error correction via coherent quantum feedback, here by
Toffoli-type three-qubit gate operations. The left half of the circuit detects
and corrects $Z$-errors; the right half, after the reset $R$ of the ancillae
to the $\ket{0}$ state, detects and corrects $X$-errors.

##  III Fault-Tolerant Measurement-Free Protocols

In this section, we outline the FT circuit implementation for the Bacon-Shor
code and Shor’s code. These will illustrate our guidelines presented in Sec.
II.

These guidelines can be easily extended to any Calderbank-Shor-Steane (CSS)
code [61, 62]. In App. B, we provide additional circuit implementations for
the surface code and Steane’s code. In a CSS code, stabilizers are either
$X$-type or $Z$-type Pauli strings. Logical Pauli operators are transversal,
and so is the logical $\mathrm{CNOT}$. These codes allow one to treat bit and
phase flips with separate sub-circuits, referred to as $X$\- and $Z$-blocks,
and which are executed one after the other.

The general procedure for a MF implementation requires the following steps:
(i) determining the most adequate form of redundancy in the syndrome
extraction, (ii) possibly placing flag operations in stabilizers extractions,
and (iii) designing a correction circuit benefiting from the redundancy. We
expect that this strategy can be further extended to any stabilizer code,
albeit with a higher overhead.

###  III.1 Bacon-Shor Code

The smallest Bacon-Shor code [48, 49] encodes 1 logical qubit in 9 physical
qubits. Its codespace is the joint $+1$ eigenspace of the following set of
mutually commuting stabilizers generators

$\displaystyle S_{1}^{X}$ $\displaystyle=X_{1}X_{2}X_{3}X_{4}X_{5}X_{6},\quad
S_{1}^{Z}$ $\displaystyle=Z_{1}Z_{2}Z_{4}Z_{5}Z_{7}Z_{8},$ (1) $\displaystyle
S_{2}^{X}$ $\displaystyle=X_{4}X_{5}X_{6}X_{7}X_{8}X_{9},\quad S_{2}^{Z}$
$\displaystyle=Z_{2}Z_{3}Z_{5}Z_{6}Z_{8}Z_{9},$

as shown in Fig. 1(b). Its logical operators can be chosen to be
$X_{L}=X_{1}X_{2}X_{3}$ and $Z_{L}=Z_{1}Z_{4}Z_{7}$. The code supports a
transversal logical Hadamard gate up to a qubit permutation [49], and can be
fault-tolerantly encoded with no additional overhead [59].

In the Bacon-Shor code, which is a subsystem code [1], multiple states can
correspond to the same codeword. These states are equivalent up to gauge
operators, which commute with both the logical operators and the stabilizers,
and as such do not affect the logical information. The group of gauge
operators is generated by the stabilizer generators and the pairs $X_{i}X_{j}$
($Z_{i}Z_{j}$) of elements $i,j$ in the same row (column) as of Fig. 1(b). As
the gauge is allowed to change, multiple pairs of operations $X_{i}X_{j}$ and
$Z_{i}Z_{j}$ do not constitute an error.

The addition of syndrome redundancy is straightforward. Besides the
stabilizers in Eq. 1, we also extract the eigenvalues of

$\displaystyle S_{3}^{X}$
$\displaystyle=S_{1}^{X}S_{2}^{X}=X_{1}X_{2}X_{3}X_{7}X_{8}X_{9},$ (2)
$\displaystyle S_{3}^{Z}$
$\displaystyle=S_{1}^{Z}S_{2}^{Z}=Z_{1}Z_{3}Z_{4}Z_{6}Z_{7}Z_{9}.$

These preserve the separation between $X$\- and $Z$-blocks. Due to the
resilience of the code to multiple higher-weight errors, the extraction of
stabilizers does not require flag qubits.

Finally, the correction blocks use Toffoli gates to apply corrections on data
qubits, as shown in the circuit in Fig. 3. Each Toffoli is activated by the
pair of faulty syndromes associated with that particular error. The
positioning of the gates is done in accordance with the heuristics outlined in
the previous section. In particular, the redundancy in the syndromes allows
the gates to avoid a full overlap of controls. In turn, this prevents single
faults on the ancillae leading to erroneous correction operations, and hence
uncorrectable errors.

###  III.2 Shor’s Code

\begin{overpic}[width=433.62pt]{shor_combined.pdf} \put(2.0,43.0){(a)}
\put(25.0,43.0){(b)} \put(2.0,23.0){(c)} \end{overpic}

((a))

((b))

((c))

Figure 4:  Measurement-free fault-tolerant QEC implementation for the 9-qubit
Shor code. (a) Stabilizers of the Shor’s code. The $S^{Z}$ stabilizers can be
grouped into pairs acting on different triplets of qubits (a pair for each
column). (b) Circuit for the correction of bit flips. Note how the syndrome
extraction and correction occur separately for each triplet of qubits having
separate $S^{Z}$ stabilizers. (c) Circuit for the correction of phase flips.
Operations acting on flags are depicted in red. The two flag operations at the
end of each stabilizer measurement (a CNOT and a Toffoli) apply corrections on
the data, preventing uncorrectable errors from spreading.

Shor’s code [50] is a concatenation of the bit-flip and phase-flip codes. It
encodes 1 logical qubit in 9 physical qubits. Its codespace is the joint $+1$
eigenspace of the following stabilizer generators

$\begin{aligned} S_{1}^{X}&=X_{1}X_{2}X_{3}X_{4}X_{5}X_{6},\\\
S_{2}^{X}&=X_{4}X_{5}X_{6}X_{7}X_{8}X_{9},\\\ S_{a1}^{Z}&=Z_{1}Z_{2},\\\
S_{a2}^{Z}&=Z_{2}Z_{3},\end{aligned}\qquad\;\begin{aligned}
S_{b1}^{Z}&=Z_{4}Z_{5},\\\ S_{b2}^{Z}&=Z_{5}Z_{6},\\\
S_{c1}^{Z}&=Z_{7}Z_{8},\\\ S_{c2}^{Z}&=Z_{8}Z_{9},\end{aligned}$ (3)

as shown in Fig. 4(a). Its logical operators can be chosen to be
$X_{L}=X_{1}X_{2}X_{3}$ and $Z_{L}=Z_{1}Z_{4}Z_{7}$. As for the Bacon-Shor
code, its encoding is trivially FT. As evident in Fig. 4(a), the $S^{Z}$
stabilizers can be grouped into pairs acting on separate triplets of qubits
(labeled in Eq. 3 by letters $a,b,c$). Therefore, they can be read out
independently, allowing one to correct single bit-flip errors acting on
different triplets of qubits, e.g. $X_{2}X_{5}$ or $X_{1}X_{4}X_{9}$.

The most adequate syndrome redundancy is the one preserving the structure of
the code. In order to maintain the separation between $X$\- and $Z$-blocks,
and between the triplets with different $S^{Z}$ stabilizers, we also extract
the following stabilizers

$\begin{aligned} S_{3}^{X}&=X_{1}X_{2}X_{3}X_{7}X_{8}X_{9},\\\
S_{a3}^{Z}&=Z_{1}Z_{3},\end{aligned}\qquad\;\begin{aligned}
S_{b3}^{Z}&=Z_{4}Z_{6},\\\ S_{c3}^{Z}&=Z_{7}Z_{9},\end{aligned}$ (4)

Read-out of weight-two stabilizers does not require flags. Instead, the read-
out of weight-six stabilizers is made FT by the addition of two flag qubits.
As illustrated in Fig. 4(c), these flags detect bit-flips on the ancilla.
Then, gates controlled on the flags and acting on the data prevent said bit-
flips from becoming unrecoverable errors, in a FT way. In contrast to
conventional flagged circuits [58], this design does not require measurements,
as the same extraction circuit is run independently of the values of the
flags. This deterministic scheme resembles that in Ref. [59], but is
simplified and implemented without measurements and feed-forward operations.
It requires fewer gates at the price of allowing multiple, yet correctable,
bit-flips to propagate. This is not problematic as they can be corrected.

Finally, the correction blocks closely resemble those of the Bacon-Shor code.
The full circuit of our implementation is shown in Fig. 4.

##  IV Performance

In this section we benchmark our protocols against hardware-agnostic
depolarizing noise (Sec. IV.1), and a noise model tailored to neutral atom
arrays (Sec. IV.2). Details of the models are given in the relevant
subsections.

We simulate our circuits, which heavily use non-Clifford gates, with
statevector simulations using cirq [63]. First, we confirm the fault-tolerance
of the protocols by simulation of all possible single faults. To compute the
logical failure probability, we perform a Monte Carlo simulation, by sampling
Kraus operators at each error location according to the chosen noise model.
Because of fault-tolerance, we only simulate circuits with two or more errors.
The logical failure probability is then estimated as

$p_{\mathrm{log}}=p_{\mathrm{log}}^{2+}\cdot p_{\mathrm{err}}^{2+},$ (5)

where $p_{\mathrm{log}}^{2+}$ is the average failure probability associated to
having two or more errors in the circuit, and $p_{\mathrm{err}}^{2+}$ is the
probability two or more errors occurring. This is given by

$p_{\mathrm{err}}^{2+}=1-p_{\mathrm{err}}^{0}-p_{\mathrm{err}}^{1},$ (6)

with

$p_{\mathrm{err}}^{0}=\prod_{i}(1-p_{i})^{N_{i}},\quad
p_{\mathrm{err}}^{1}=p_{\mathrm{err}}^{0}\sum_{i}\frac{N_{i}p_{i}}{1-p_{i}},$
(7)

where $p_{i}$ is the probability that a gate of type $i$ is faulty, and
$N_{i}$ is the number of such gates. The averaging is performed over $60\,000$
simulations, with inputs equally distributed among $\ket{0}_{L}$,
$\ket{+}_{L}$ and $\ket{i}_{L}$ 222This corresponds to a Haar-uniform sampling
over initial logical states. .

###  IV.1 Depolarizing Noise

\begin{overpic}[width=433.62pt]{plog_FDN.pdf} \put(0.0,37.0){(a)}
\put(40.0,37.0){(b)} \put(77.0,37.0){(c)} \end{overpic}

((a))

((b))

((c))

Figure 5: Logical qubit error rate vs. physical one, under symmetric
depolarizing noise of Eq. 8, for the (a) measurement-free and (b) feed-forward
implementation. Solid lines correspond to the numerical fits used to estimate
the pseudo-thresholds. The fit is performed with a polynomial of the form
$p_{\mathrm{log}}=c_{2}p_{\mathrm{phys}}^{2}+c_{3}p_{\mathrm{phys}}^{3}+c_{4}p_{\mathrm{phys}}^{4}$.
Since single-qubit errors are correctable due to the FT character of the
protocols, the zero-th and first order are vanishing, while terms beyond the
fourth degree are negligible at the considered physical error rates. (c)
Numerical estimates of the pseudo-thresholds.

We consider the hardware-agnostic _depolarizing channel_. Given the set of
Pauli strings of length $\ell$, i.e.
$\mathcal{P}_{\ell}=\\{I,X,Y,Z\\}^{\otimes\ell}$, it is defined as

$\mathcal{E}(\rho)=(1-p)\rho+\frac{p}{|\mathcal{P_{\ell}}|-1}\sum_{\mathclap{\begin{subarray}{c}P\in\mathcal{P}_{\ell}\\\
P\neq I^{\otimes\ell}\end{subarray}}}{P\rho P^{\dagger}},$ (8)

where $p$ is the probability of an error occurring. In other words, after each
gate we apply with probability $p$ an operator sampled uniformly from all non-
trivial Pauli strings.

The depolarizing channel is a fairly general error model, and is a standard
benchmark of QEC protocols. We study both a MF and feed-forward (FF) version
of our QEC protocols. In the latter, flags and ancillae are measured, and the
correction circuit is substituted by conventional correction operations, which
are only applied if required. Initialization operations, measurements and
correction operations have the same error rate $p_{\mathrm{phys}}=p$ as other
operations, whereas idling errors are neglected. The set of required gates
$\\{X,H,CX,CZ,CCX,CCZ\\}$ is assumed to be natively supported.

The logical performance of each protocol is shown in Fig. 5; their pseudo-
thresholds and resource overhead are summarized in Table 1. The pseudo-
threshold is directly connected to the number of gates and the correction
capabilities of each implementation. It is not surprising that the
implementations which are both shorter and resilient to higher weight
errors—such as of the Bacon-Shor or Shor’s code—lead to the best performance.
On the other hand, Steane’s code cannot correct higher weight errors.
Furthermore, the logic in its correction step is more involved and has the
largest number of Toffoli gates. As such, this protocol performs worse than
other codes. It is worth noting that both the correction capabilities and the
resources overhead of a protocol can in part be inferred from the structure of
the stabilizers. In fact, codes with stabilizers generators having fewer
common qubits, as in Shor’s and the surface code, generally have lower logical
error rates.

Compared to the single-shot FF implementations, it is not surprising that the
MF approach, which has considerably deeper circuits, returns a higher logical
error rate at same physical error rate. However, it is remarkable that the MF
overhead consistently lowers the pseudo-threshold only by a factor of
approximately two. This suggests that MF QEC represents a valuable alternative
for architectures in which measurements are technically challenging or come
with a large time overhead. This will be explored in the next subsection.

We may also ask what is the performance of our single-shot FF implementations
compared to conventional flag-based implementations in the literature. For the
Bacon-Shor code, Shor’s code, and Steane’s code, we consider the
implementation with parallel flags outlined in Ref. [65]. Again, we stress
that in this scheme, the flags are not single-shot, i.e. after they signal the
presence of an error, a new circuit is run. Overall, similar performance is
achieved, since the pseudo-thresholds they obtained are
$0.86\text{\,}\mathrm{\char 37\relax}$, $0.98\text{\,}\mathrm{\char
37\relax}$, and $0.13\text{\,}\mathrm{\char 37\relax}$ respectively (c.f.
Table 1). Regarding the rotated surface code, we compare our scheme with the
recent results from Ref. [66, 67], where corrections are applied after the
decoding of $d$ rounds of syndrome measurements, achieving thresholds of
$0.55\text{\,}\mathrm{\char 37\relax}0.94\text{\,}\mathrm{\char 37\relax}$,
depending on the decoding technique used 333We note that the thresholds
claimed are for a single logical basis state different than $\ket{i}_{L}$,
which in our simulations lowers the logical performance.. Our implementation
achieves a comparable pseudo-threshold (c.f. Table 1) by measuring half as
many stabilizers. Moreover, as comparing pseudo-threshold with threshold
values can be misleading, we observe that our protocol achieves lower logical
error rates at same physical rates. A full comparison, which would require the
use of similar decoding techniques, is beyond the scope of this article.

Protocol |  # qubits |  # gates ($R$, $G_{1}$, $G_{2}$, $G_{3}$, $M$) |  $p_{\mathrm{th}}[\%]$
---|---|---|---
Bacon-Shor (MF) | 12 |  6 6 36 6 0 | 0.56
Bacon-Shor (FF) | 10 |  6 6 36 0 6 | 0.76
Shor (MF) | 14 | 18 6 51 15 0 | 0.36
Shor (FF) | 12 | 18 6 48 0 18 | 0.64
Surface (MF) | 17 | 20 24 40 22 0 | 0.30
Surface (FF) | 10 | 12 12 40 0 12 | 0.62
Steane (MF) | 14 | 38 26 90 32 0 | 0.07
Steane (FF) | 10 | 30 20 90 0 30 | 0.15
Table 1: Comparison of measurement-free and feed-forward implementations, when
natively supporting any required gate. The number of qubits refers to the
_minimal_ number required by the implementation, since each reset can be
replaced by an additional qubit. The gate count is divided into
initialization/reset, 1-, 2-, 3-qubit gates, and measurements. For FF
approaches, this does not count the Pauli corrections applied after the
decoding of the measurements, as their number varies between runs. The pseudo-
threshold $p_{\mathrm{th}}$ is computed under symmetric depolarizing noise in
absence of idling errors.

###  IV.2 Noise model for neutral atoms

\begin{overpic}[width=212.47617pt]{plogs_vs_pidle_Steane.pdf}
\put(-99.0,77.0){(a)} \put(1.0,77.0){(b)} \end{overpic}

Figure 6:  Logical vs. physical error rate of our protocols for the (a) Bacon-
Shor code, and (b) Steane’s code, under the simplified noise model for
Rydberg-atom arrays described in Sec. IV.2. The MF protocol is compared
against FF implementations with varying idling error rates
$p_{\mathrm{idle}}$. Datapoints of the FF protocol correspond to $15\,000$
simulations. First, we note there is a regime above a critical idling rate
$\sim 10^{-2}$ where the logical error rate is always higher than the physical
one. Secondly, for low gate error rates, idling errors dominate, and the MF
approach, which under the described noise model is not affected, outperforms
the FF protocol. The inset shows the regimes at which MF and FF
implementations are advantageous as a function of $p_{2}$ and
$p_{\mathrm{idle}}$. Data points are numerical estimates of noise rates at
which the protocols yield equivalent performances, matching the prediction in
Eq. 14.

In neutral-atom architectures, the large difference between gate times and
measurement times [35, 14] means that idling errors on data qubits _during_
measurements cannot be neglected (cf. Sec. C.3). Therefore, in this
subsection, we compare the behavior of MF and FF protocols under a noise model
which, albeit simplified, reproduces key features of neutral atom arrays.

For single-qubit gates, we consider _quasi-static fluctuations_ in the driving
parameters. In other words, we assume these fluctuations are slow enough
compared to gate times, such that they can be considered static coherent
errors for a single gate. By averaging over independent realizations of such
fluctuations, and performing the _Pauli twirling approximation_ (PTA) [69, 70,
71, 72, 73], we obtain the following effective channels for the $X$ and $H$
gates

$\displaystyle\mathcal{E}_{X}(\rho)$
$\displaystyle=\left(1-p_{1}\right)\rho+\frac{p_{1}}{2}X\rho
X+\frac{p_{1}}{2}Z\rho Z,$ (9a) $\displaystyle\mathcal{E}_{H}(\rho)$
$\displaystyle=\left(1-\frac{3p_{1}}{4}\right)\rho+\frac{3p_{1}}{8}X\rho
X+\frac{3p_{1}}{8}Z\rho Z.$ (9b)

The details of the derivation are provided in App. C.

The only native multi-qubit gates are $C^{m}Z$ gates. Their main source of
infidelity is given by the decay from Rydberg states, which are auxiliary
states with strong interatomic interactions used during the gate protocol to
create entanglement between nearby atoms. By performing the PTA, this results
in the noise channel (cf. App. C)

$\mathcal{E}_{C^{\ell-1}Z}(\rho)=\left(1-p_{\ell}\right)\rho+\frac{p_{\ell}}{2^{\ell}-1}\sum_{\mathclap{\begin{subarray}{c}P\in\\{I,Z\\}^{\otimes\ell}\\\
P\neq I^{\otimes\ell}\end{subarray}}}P\rho P^{\dagger},$ (10)

i.e. controlled phase gates are only affected by $Z$-type gates. For example,
the Kraus operators for the $CZ$ gate are $\sqrt{p_{2}/3}\,Z_{1}$,
$\sqrt{p_{2}/3}\,Z_{2}$, $\sqrt{p_{2}/3}\,Z_{1}Z_{2}$. We note that, under
this biased noise, flags are superfluous and some constraints from Sec. II
could be relaxed. Nevertheless, our noise model might be too simplistic;
hence, for a fair comparison, we decided to run the generally FT circuits
outlined in Sec. III.

We simulate our implementations of the Bacon-Shor code in presence of such
noise. We varied $p_{2}$, while fixing $p_{1}=p_{2}/5$ and $p_{3}=4p_{2}$.
Furthermore, initializations and measurements were subject to bit-flips with
respective rates $p_{i}=p_{1}/2$ and $p_{m}=p_{2}/2$. These values and ratios
of error rates roughly describe recent experiments [26, 14].

We also simulate the FF protocols with varying idling error rate
$p_{\mathrm{idle}}$, with the idling noise channel

$\mathcal{E}_{\mathrm{idle}}(\rho)=(1-p_{\mathrm{idle}})\rho+p_{\mathrm{idle}}\,Z\rho
Z,$ (11)

affecting data qubits before corrections are applied. Owing to the large
difference between gate times and measurement times in neutral-atom arrays, we
ignore idling errors in the MF setting. In principle, one should take into
account additional idling errors during shuttling operations to perform non-
local gates, for both MF and FF protocols. However, for the codes considered,
the shuttling distances would be small on a 2D geometry, inducing a negligible
time overhead compared to measurements.

Results are shown in Fig. 6. Notably, the behavior of the logical error rate
in FF protocols can be categorized into three regimes. For a protocol with $n$
data qubits and $N$ gates respectively, to leading order we have

$p_{\mathrm{log}}^{\mathrm{FF}}=\begin{cases}O(N^{2}\,p_{2}^{2})&\;\mathrm{for}\;p_{2}>p_{\mathrm{idle}}\\\
O(N\,n\,p_{2}\,p_{\mathrm{idle}})&\;\mathrm{for}\;p_{2}\lesssim
p_{\mathrm{idle}}\\\ O(n^{2}\,p_{\mathrm{idle}}^{2})&\;\mathrm{for}\;p_{2}\ll
p_{\mathrm{idle}}\\\ \end{cases}.$ (12)

Idling errors are independent of the quality of gates, thus, as the latter
improves, idling errors may constitute an insurmountable limit in the
performance of FF protocols. In the first place, this implies that for some
$p_{\mathrm{idle}}$ there is only a finite region where feed-forward gives an
advantage over physical qubits. Secondly, as we considered idling errors
negligible in the MF setting, the MF protocols eventually outperform the
respective FF implementations as the quality of gates improves. Considering
that in FT MF protocols, the logical error rate scales as

$p_{\mathrm{log}}^{\mathrm{MF}}=O(N^{2}\,p_{2}^{2}),$ (13)

the protocols yield equivalent performances when

$p_{2}^{\mathrm{MF=FF}}=O\\!\left(\frac{n}{N}\right)p_{\mathrm{idle}}.$ (14)

This matches the result in the inset of Fig. 6. We estimate that for the
Bacon-Shor and Steane’s protocols, the proportionalities are $\sim 0.68$ and
$\sim 0.12$ respectively, in both cases roughly $4n/N$.

Finally, we note that current state-of-the-art experiments with neutral atoms
have achieved $p_{2}\approx 5\times 10^{-3}$ and $p_{\mathrm{idle}}\lesssim
10^{-3}$ [14]. Such estimates place this experiment in the FF regime, albeit
not far from the MF. Additional results without idling errors can be found in
App. D.

##  V Summary and outlook

In summary, we have proposed several implementations of measurement-free QEC
schemes based on syndrome redundancy and single-shot flags. The classical
logic traditionally involved in QEC schemes is moved _within_ the quantum
circuit and is performed using quantum gates. These implementations have been
designed with near-term quantum hardware in mind, with focus on the smallest
non-trivial CSS codes. By using the guiding principles outlined in Sec. II, we
design quantum circuits which are FT, with lower overhead than in alternative
proposals [46, 45].

The measurement-free QEC protocols for the Bacon-Shor code and Shor’s code
provide examples that we constructed using such heuristics, as discussed in
detail in Sec. III. We furthermore show that these guidelines can be extended
to any CSS code, although one needs to adapt the correction step to remain FT.
This can be achieved by using auxiliary qubits for decomposing larger multi-
controlled operations—as is discussed in the cases of the surface code and
Steane’s code in Sec. B.1 and B.2. By careful circuit design, the additional
overhead of measurement-free QEC can be kept to a minimum.

The development of such measurement-free techniques could be beneficial for
the design of more traditional feed-forward implementations as well. The
proposed redundant syndrome extraction is of interest for so-called single-
shot decoding [74], which allows for a robust protocol without repeating
extraction rounds. The overhead of repeating syndrome extraction or using
flags could be reduced, simply by extracting an overcomplete set of
stabilizers.

We have benchmarked our scheme with numerical simulations under depolarizing
noise, both for the measurement-free and feed-forward implementations, as
summarized in Table 1. The feed-forward protocols achieve performances
comparable with state-of-the-art techniques, thus they represent a competitive
single-shot alternative. Our measurement-free protocols have pseudo-thresholds
that are only about a factor of two smaller than the ones of the comparable
feed-forward implementations. Particularly interesting are the ones that can
correct the most higher-weight errors and use the fewest gates, with the
Bacon-Shor code showing the best performance overall.

Measurement-free schemes are particularly interesting in quantum-computing
platforms where measurements are a main bottleneck, such as neutral-atom
arrays. For such platforms, we have derived a simplified noise model, which
leads to improved pseudo-thresholds—within the reach of current state-of-the-
art experimental error rates [14]. Additionally, we have performed a more
realistic comparison with feed-forward QEC by adding idling errors during
measurements, and observed that, as the quality of the gates improves, idling
errors significantly drag down the performance of the protocols. In this
context, measurement-free implementations, where idling errors play less of a
role or even can become negligible, outperform the respective feed-forward
protocols.

Neutral-atom arrays have additional features particularly suited for
measurement-free QEC. Multi-controlled gates—such as the $CCZ$, necessary for
the correction step—are natively supported on the hardware. Additionally,
shuttling via optical tweezers could enable the increased connectivity
required. We emphasize that these numerical results should be taken _cum grano
salis_ : the noise model for Rydberg atoms is undoubtedly overly simplistic,
as it neglects other sources of errors, such as atom loss or leakage outside
of the computational subspace. Including these effects into a refined noise
model would increase the numerical cost, and more importantly, will require
further assumptions on the specific qubit encoding used. We leave this as a
possible direction for future work.

We emphasize that the proposed new measurement-free error correction schemes
are not solely relevant to neutral-atom arrays. The only requirement is the
availability of fast and locally addressable reset operations, or,
alternatively, of a sufficiently large reservoir of fresh ancillae. In this
case, a full or partial measurement-free scheme can be beneficial, as one can
trade measurements for quantum gates. This could lead to a faster or less
error-prone QEC implementation, depending on the hardware specifics.

Having near-term devices in mind, we have only considered $d=3$ codes. Scaling
up error-correcting capabilities is hard to achieve in a purely measurement-
free setting. For higher-distance codes, the decoding logic becomes non-
trivial and, accordingly, it becomes much more challenging to design a FT
correction circuit. Code concatenation could provide an alternative approach
for scaling to larger distances. The implementations presented in this paper
can be realized with a native gate set of $\\{H,X,CZ,CCZ\\}$. If this set can
be implemented at the logical level, then the code could be concatenated with
itself. This could possibly be achieved with Steane’s code, as it supports all
Clifford gates as well as the so-called pieceable FT $CCZ$ gates [75].
Similarly, concatenation could be achieved with codes supporting fold-
transversal gates such as the surface code or the Bacon-Shor code.
Alternatively, rather than attempting to scale up measurement-free QEC, we
believe that small measurement-free blocks could be beneficially concatenated
within conventional feed-forward protocols. In this setting, measurements
could be performed much less frequently, while the measurement-free units run
fast and autonomously. Recent experiments have demonstrated that neutral-atom
arrays are well-suited to implementing small error-correcting blocks in a
modular fashion [14]. By avoiding or minimizing measurements, the measurement-
free approach could lead to improvements in the logical qubit fidelity or, at
least, provide significant speedups of the durations of QEC cycles.

Concatenation also opens up the possibility of implementing universal quantum
computation. Steane’s code could be concatenated with a code with transversal
$T$ gates, such as 3D color codes or triorthogonal codes [76, 77, 78]. In such
constructions, code distance is traded for a larger set of transversal gates.
Incorporating measurement-free QEC into such logical gate constructions could
be key to achieving fast universal quantum computation.

###### Acknowledgements.

We acknowledge inspiring discussions with Alexandru Paler and Alexander
Glätzle. We would especially like to thank Johannes Zeiher for fruitful
discussions and insightful feedback on this manuscript. This research is part
of the Munich Quantum Valley (K-8), which is supported by the Bavarian state
government with funds from the Hightech Agenda Bayern Plus. M.M. additionally
acknowledges support by the BMBF project MUNIQC-ATOMS (Grant No. 13N16070), by
the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under
Germany’s Excellence Strategy ‘Cluster of Excellence Matter and Light for
Quantum Computing (ML4Q) EXC 2004/1’ 390534769, and from the European Union’s
Horizon Europe research and innovation programme under grant agreement No.
101114305 (“MILLENION-SGA1” EU Project) and ERC Starting Grant QNets through
Grant No. 804247.

##  Appendix A Requirements on redundant syndromes

This section defines a constraint on the order in which stabilizers are
extracted within our implementations of QEC protocols for $d=3$ codes. Error
syndromes obtained from the extraction of $m$ stabilizers are bit-strings
$\mathbf{b}=(x_{1},\,\dots,\,x_{m})$. Ideal decoding associates syndromes to
correction operations. Let us call a syndrome bit-string
$\tilde{\mathbf{b}}_{i}$ _active_ if it leads to a correction operation
different than the identity. Since the extraction of stabilizer eigenvalues is
sequential, the order matters. In particular, we require that, given the set
of active syndromes $\tilde{\mathcal{S}}=\\{\tilde{\mathbf{b}}_{i}\\}$

$\tilde{\mathbf{b}}_{i}\neq
R_{s}\big{(}\tilde{\mathbf{b}}_{j}\big{)}\quad\forall i,j,s,$ (15)

where $R_{s}\big{(}\tilde{\mathbf{b}}_{j}\big{)}$ returns
$\tilde{\mathbf{b}}_{j}$ with the first $s$ 1s turned into 0s.

This requirement stems from the fact that stabilizer extractions are prone to
errors. Assume a logical codeword is passed as input to the QEC circuit, and
that we are measuring $Z$-type stabilizers. Assume all stabilizer extractions
are fault-free except for a single one, the $s^{\mathrm{th}}$ involving the
$i^{\mathrm{th}}$ data qubit. During this extraction, a bit-flip $X_{i}$
occurs on the said data qubit. The syndrome bit-string
$\tilde{\mathbf{b}}_{i}$, leading to the correction $X_{i}$, is not observed,
as the data was fault-free in the first $s$ extractions involving data qubit
$i$. Instead,
$\tilde{\mathbf{b}}_{j}=R_{s}\big{(}\tilde{\mathbf{b}}_{i}\big{)}$ is
observed. If $\tilde{\mathbf{b}}_{j}$ leads to correcting a different data
qubit, the protocol accumulates two different errors. This would spoil fault-
tolerance. Analogous considerations hold for phase flips occurring during
extraction of $X$-type stabilizers. This is illustrated in Fig. 7 for the
Steane code—further described in Sec. B.2.

Figure 7: Circuit for detecting bit-flips in the Steane code, illustrating the
requirement for two extra syndromes to be FT. $S^{Z}_{1}$, $S^{Z}_{2}$,
$S^{Z}_{3}$, defined in Eq. 17, are the $Z$-type stabilizers generators.
$S^{Z}_{4}$ is the product of the three. All of them involve data qubit $7$.
An error $X_{7}$ occurring at the end of the $S_{2}^{Z}$ syndrome is measured
by the following stabilizers. This returns the syndrome $0011$, leading to the
correction $X_{1}$. Together with the previous error $X_{7}$, this forms an
uncorrectable weight-two error. We have exhaustively verified that no ordering
of any combination of four stabilizers can satisfy Eq. 15. An appropriate
redundancy is instead used in Fig. 9.

The requirement in Eq. 15 can be generalized to non-CSS codes by adding
additional constraints, arising from the fact that different operators are
measured on the same qubits during the syndrome extraction procedure. Thus, we
expect our strategy to be applicable for non-CSS codes, albeit with higher
overhead.

##  Appendix B Additional CSS codes

This section contains the MF implementations for the rotated surface code and
Steane’s code.

###  B.1 Surface code

The smallest error-correcting surface code $\llbracket 9,1,3\rrbracket$ [51,
52, 53] has the following stabilizer generators

$\begin{aligned} S_{1}^{X}&=X_{8}X_{9},\\\ S_{2}^{X}&=X_{5}X_{6}X_{7}X_{8},\\\
S_{3}^{X}&=X_{2}X_{3}X_{4}X_{5},\\\
S_{4}^{X}&=X_{1}X_{2},\end{aligned}\qquad\qquad\begin{aligned}
S_{1}^{Z}&=Z_{6}Z_{7},\\\ S_{2}^{Z}&=Z_{1}Z_{2}Z_{5}Z_{6},\\\
S_{3}^{Z}&=Z_{4}Z_{5}Z_{8}Z_{9},\\\ S_{4}^{Z}&=Z_{3}Z_{4},\end{aligned}$ (16)

as shown in Fig. 8(a). Its logical operators can be chosen to be
$X_{L}=X_{1}X_{6}X_{7}$ and $Z_{L}=Z_{1}Z_{2}Z_{3}$. A FT MF codeword encoding
has been introduced in [79]. Fig. 8 illustrates our FT MF design with a total
of $17$ qubits.

We notice that the code has a certain symmetry. Stabilizers come in pairs that
are specular with respect to qubit $5$, and so is the optimal decoding, which
is shown in Table 2. Therefore, we added two new syndromes,
$S_{12}=S_{1}S_{2}$ and $S_{34}=S_{3}S_{4}$, that preserve the symmetry.

The code is very modular, as stabilizers are well-localized and share only few
qubits. This makes the code capable of correcting multiple weight-two errors:
all the pairs $X_{i}X_{j}$ such that there exists no $k$ for which
$X_{L}=X_{i}X_{j}X_{k}$, and similarly for $Z$. As noted in Ref. [80], this
implies that the extraction of weight-four stabilizers does not require flags
if gates are opportunely ordered, as in Fig. 8(c). Trivially, the read-out of
weight-two stabilizers does not require flags either.

The symmetry of the code allows for a simple design of a MF correction
circuit, capable of implementing the optimal decoding of Table 2. The
correction circuit is illustrated in Fig. 8(d). Note how it uses an
intermediate register between ancillae and data qubits. The intermediary
register prevents single faults to cause errors on both ancillae and data
qubits, in a fashion similar to [46], but with fewer qubits, as well as gates
with support on fewer qubits (Toffoli-type gates, supported on three qubits).

Syndrome ($S_{1},S_{2},S_{3},S_{4}$) |  $X$-Correction |  $Z$-Correction
---|---|---
01($xy\neq$10) | $X_{2}$ | $Z_{6}$
$xy$01 | $X_{3}$ | $Z_{1}$
$xy$11 | $X_{4}$ | $Z_{2}$
0110 | $X_{5}$ | $Z_{5}$
11$xy$ | $X_{6}$ | $Z_{8}$
10$xy$ | $X_{7}$ | $Z_{9}$
($xy\neq$01)10 | $X_{8}$ | $Z_{4}$
Table 2: Optimal one-round decoding for the surface code. $xy$ denote digits
of the syndrome that are irrelevant for that specific correction. This enables
weight-two corrections: for example bit-flip syndrome $1101$ leads to
correction $X_{3}X_{6}$.

\begin{overpic}[width=433.62pt]{surface_combined.pdf} \put(0.0,80.0){(a)}
\put(33.0,80.0){(b)} \put(2.5,37.0){(c)} \put(33.0,49.0){(d)} \end{overpic}

((a))

((b))

((c))

((d))

Figure 8: Fault-tolerant MF implementation for the surface code, using a total
of 17 qubits (9 data qubits, 6 ancilla and 2 intermediary qubits). (a)
Stabilizers of the $d=3$ surface code. (b) General scheme for single-shot
correction of a bit- or phase-flip. This involves a redundant extraction of
stabilizers, and an error correction ($\mathrm{EC}$) block. (c) Syndrome
measurement of the $S_{2}^{Z}$ stabilizer. As for the other stabilizers, it
does not require any flags, as long as the first two and the last two
extracted operators constitute a weight-two correctable error, which is
allowed to propagate onto the data qubit register. (d) FT MF correction
circuit for bit-flips. The circuit for correcting phase-flips is analogous,
with $CCZ$ gates substituting the Toffoli gates acting on data qubits.

###  B.2 Steane’s code

Steane’s code $\llbracket 7,1,3\rrbracket$ [54] has the following stabilizer
generators

$\begin{aligned} S_{1}^{X}=X_{4}X_{5}X_{6}X_{7},\\\
S_{2}^{X}=X_{2}X_{3}X_{6}X_{7},\\\
S_{3}^{X}=X_{1}X_{3}X_{5}X_{7},\end{aligned}\qquad\qquad\begin{aligned}
S_{1}^{Z}=Z_{4}Z_{5}Z_{6}Z_{7},\\\ S_{2}^{Z}=Z_{2}Z_{3}Z_{6}Z_{7},\\\
S_{3}^{Z}=Z_{1}Z_{3}Z_{5}Z_{7},\end{aligned}$ (17)

as illustrated in Fig. 9(a). Its logical operators can be chosen to be
$X_{L}=X_{1}X_{2}X_{3}$ and $Z_{L}=Z_{1}Z_{2}Z_{3}$. The Steane code has the
computational advantage of providing transversal single-qubit Clifford logical
operations. A FT MF encoding of the logical states has been recently
introduced in Ref. [46]. Figure 9 illustrates our FT MF 14-qubits design.

As shown, a single extraction block (for bit- or phase-flips) measures five
stabilizers, two more than the minimum required. Besides those in Eq. 17, we
measure $S_{12}=S_{1}S_{2}$, and $S_{13}=S_{2}S_{3}$. In fact, by exhaustively
checking the possible combinations and permutations, it can be verified that
the addition of only one stabilizer is not sufficient to satisfy the
constraint outlined in App. A, and therefore fault-tolerance cannot be
achieved. A full redundancy, achievable by measuring seven syndromes as in
Refs. [40, 45], is not only unnecessary, but perhaps even detrimental as it
would largely increase both the number of qubits and the number of gates
employed.

As shown for stabilizer $S^{Z}_{1}$ in Fig. 9(c), extractions are supported by
single-shot flags. In contrast to conventional flagged circuits [58], this
design does not require measurements, as the same extraction circuit is run
independently of the values of the flags.

Finally, Fig. 9(d) outlines our FT MF correction block. As for the surface
code, it uses an intermediate register, here a single qubit, between ancillae
and data qubits to avoid single faults to spread.

\begin{overpic}[width=433.62pt]{steane_combined.pdf} \put(0.0,92.0){(a)}
\put(26.0,92.0){(b)} \put(32.0,67.0){(c)} \put(22.0,35.0){(d)} \end{overpic}

((a))

((b))

((c))

((d))

Figure 9: Fault-tolerant MF implementation of the Steane code, using 14
qubits. (a) Topology of the Steane code, the smallest color code [55]. (b)
General scheme for single-shot correction of a bit- or phase-flip. This
involves a redundant flagged extraction of stabilizers, and an error
correction ($\mathrm{EC}$) block. (c) Syndrome measurement of the $S_{1}^{Z}$
stabilizer. Single-shot flags, whose operations are highlighted in purple,
prevent uncorrectable errors from spreading. (d) Correction circuit for bit-
flips. The correction of phase-flips uses an analogous circuit, with $CCZ$
gates replacing the Toffoli gates acting on data qubits.

##  Appendix C Simplified noise model for neutral atoms

In this section, we construct a simple effective noise model to account for
imperfections in controlling neutral atoms.

###  C.1 Single-qubit gates

We begin by considering a laser-driven two-level system. The Hamiltonian
between the two computational states reads

$\displaystyle\mathcal{H}$
$\displaystyle=\frac{\Omega}{2}\left(e^{i\phi}\ket{1}\bra{0}+\mathrm{h.c.}\right)+\frac{\Delta}{2}\left(\ket{0}\bra{0}-\ket{1}\bra{1}\right)$
$\displaystyle=\frac{\Omega}{2}\left(\cos\phi X+\sin\phi
Y\right)+\frac{\Delta}{2}Z,$ (18)

where $\Omega$ is the Rabi frequency, $\phi$ is the laser phase and $\Delta$
the detuning of the laser with respect to the transition frequency. By
evolving the system for a time $t$ (assuming, for simplicity, a constant
profile for $\Omega$ and $\Delta$), we obtain the unitary
$U=\exp\left({-i\mathcal{H}t}\right)$

$U=\cos\theta-i\sin\theta\left(\frac{\Omega}{\tilde{\Omega}}\cos\phi
X+\frac{\Omega}{\tilde{\Omega}}\sin\phi
Y+\frac{\Delta}{\tilde{\Omega}}Z\right),$ (19)

where $\tilde{\Omega}=\sqrt{\Omega^{2}+\Delta^{2}}$ and
$\theta=\frac{\tilde{\Omega}t}{2}$. In the following, we consider _static_
fluctuations of the driving parameters, which is physically motivated when
these fluctuations happen over time scales much larger than the typical gate
times. We therefore average Eq. 19 over different realizations with the
driving parameters drawn from a Gaussian distribution. This generates the
channel $\Lambda(\rho)=\overline{U\rho U^{\dagger}}$, where the bar denotes
the averaging over the stochastic variable.

For example, we account for phase noise by setting $\phi=\xi$, where
$\xi\sim\mathcal{N}(0,\sigma^{2})$. This corresponds to slow fluctuations of
the laser phase during the driving. It also corresponds to a simplified model
of the momentum transfer between photons and the atom in the laser field,
which imprints a phase factor $e^{i\mathbf{k}\cdot\mathbf{x}}$ for a
wavevector $\mathbf{k}$ and the atomic center of mass $\mathbf{x}$.

Considering the noiseless gate $U_{0}$ generated by Eq. 19 at $\phi=0$, we can
then perform the average over $\xi$, and obtain the channel

$\Lambda^{\mathrm{ph}}(\rho)\simeq\left(1-\frac{\sigma^{2}}{2}\right)\\!U_{0}\rho
U_{0}^{\dagger}+\frac{\sigma^{2}}{2}\cos^{2}{\theta}\rho-i\frac{\sigma^{2}}{2}\cos{\theta}\sin{\theta}\frac{\Delta}{\tilde{\Omega}}\left(Z\rho-\rho
Z\right)+\sigma^{2}\sin^{2}{\theta}\left[-\frac{1}{2}\frac{\Omega^{2}}{\tilde{\Omega}^{2}}X\rho
X+\frac{\Omega^{2}}{\tilde{\Omega}^{2}}Y\rho
Y+\frac{1}{2}\frac{\Delta^{2}}{\tilde{\Omega}^{2}}Z\rho Z\right].$ (20)

where we have applied the following first-order approximations

$\overline{e^{i\phi}}=\overline{\cos{\phi}}=e^{-\sigma^{2}\\!/2}\simeq
1-\frac{\sigma^{2}}{2},\qquad\overline{\cos^{2}\phi}\simeq
1-\sigma^{2},\qquad\overline{\sin\phi\cos\phi}\simeq
0,\qquad\overline{\sin^{2}\phi}\simeq\sigma^{2}.$

For the case of the $X$ gate ($\Delta=0$ and $t=\pi/\Omega$) and $H$ gate
($\Delta=\Omega$ and $t=\pi/\tilde{\Omega}$), Eq. 20 reduces to

$\displaystyle\Lambda_{X}^{\mathrm{ph}}(\rho)=$
$\displaystyle\left(1-\sigma^{2}\right)X\rho X+\sigma^{2}Y\rho Y,$ (21a)
$\displaystyle\Lambda_{H}^{\mathrm{ph}}(\rho)=$
$\displaystyle\left(1-\frac{\sigma^{2}}{2}\right)H\rho H$
$\displaystyle-\frac{\sigma^{2}}{4}X\rho X+\frac{\sigma^{2}}{2}Y\rho
Y+\frac{\sigma^{2}}{4}Z\rho Z.$ (21b)

In the context of quantum error correction, we typically express the noise
operation as a channel _after_ the desired gate $U_{0}$, i.e.

$\Lambda_{U_{0}}(\rho)=\mathcal{E}_{U_{0}}\\!\left(U_{0}\rho
U_{0}^{\dagger}\right),$ (22)

For the phase noise in Eq. 21, we then obtain

$\displaystyle\mathcal{E}_{X}^{\mathrm{ph}}(\rho)=$
$\displaystyle\left(1-p_{\mathrm{ph}}\right)\rho+p_{\mathrm{ph}}Z\rho Z,$
(23a) $\displaystyle\mathcal{E}_{H}^{\mathrm{ph}}(\rho)=$
$\displaystyle\left(1-\frac{p_{\mathrm{ph}}}{2}\right)\rho-\frac{p_{\mathrm{ph}}}{4}XH\rho
HX$ $\displaystyle+\frac{p_{\mathrm{ph}}}{2}YH\rho
HY+\frac{p_{\mathrm{ph}}}{4}ZH\rho HZ,$ (23b)

where we define $p_{\mathrm{ph}}=\sigma^{2}$.

We now perform the _Pauli twirling approximation_ (PTA)

$\tilde{\mathcal{E}}(\rho)=\sum_{P\in\mathcal{P}_{\ell}}P^{\dagger}\mathcal{E}\\!\left(P\rho
P^{\dagger}\right)P,$ (24)

to approximate the channels above with the closest possible Pauli channel [69,
70, 71, 72, 73]. This can be experimentally realized by physically applying a
random Pauli string before and after the gate.

Using the PTA in Eq. 24, the latter becomes

$\tilde{\mathcal{E}}_{H}^{\mathrm{ph}}(\rho)=\left(1-\frac{p_{\mathrm{ph}}}{2}\right)\rho+\frac{p_{\mathrm{ph}}}{4}\left(X\rho
X+Z\rho Z\right).$ (25)

Similarly, we can account for fluctuations of the pulse area by setting
$\theta=\theta_{0}(1+\xi)$ in Eq. 19 where $\xi\sim\mathcal{N}(0,\sigma^{2})$.
This can be seen as an amplitude fluctuation, and fluctuations on the
amplitude can, in the case of Raman transitions, induce correlated
fluctuations on the detuning [81]. By performing similar steps to the case of
phase noise, we obtain

$\Lambda^{\mathrm{time}}(\rho)\simeq(1-2\theta_{0}^{2}\sigma^{2})U_{0}\rho
U_{0}^{\dagger}+\theta_{0}^{2}\sigma^{2}(\rho+K\rho K),$ (26)

where $K=\frac{\Omega}{\tilde{\Omega}}X+\frac{\Delta}{\tilde{\Omega}}Z$. For
the $X$ and $H$ gates this corresponds to

$\displaystyle\Lambda_{X}^{\mathrm{time}}(\rho)=$
$\displaystyle\left(1-\frac{\pi^{2}\sigma^{2}}{4}\right)X\rho
X+\frac{\pi^{2}\sigma^{2}}{4}\rho,$ (27a)
$\displaystyle\Lambda_{H}^{\mathrm{time}}(\rho)=$
$\displaystyle\left(1-\frac{\pi^{2}\sigma^{2}}{4}\right)H\rho
H+\frac{\pi^{2}\sigma^{2}}{4}\rho.$ (27b)

This leads to

$\displaystyle\mathcal{E}_{X}^{\mathrm{time}}(\rho)=$
$\displaystyle\left(1-p_{\mathrm{time}}\right)\rho+p_{\mathrm{time}}X\rho X,$
(28a) $\displaystyle\mathcal{E}_{H}^{\mathrm{time}}(\rho)=$
$\displaystyle\left(1-p_{\mathrm{time}}\right)\rho+p_{\mathrm{time}}H\rho H,$
(28b)

where we define $p_{\mathrm{time}}=\pi^{2}\sigma^{2}/4$. Performing the PTA on
the channel for the $H$ gate yields

$\tilde{\mathcal{E}}_{H}^{\mathrm{time}}(\rho)=\left(1-p_{\mathrm{time}}\right)\rho+\frac{p_{\mathrm{time}}}{2}\left(X\rho
X+Z\rho Z\right).$ (29)

Putting everything together, choosing $p_{\mathrm{ph}}=p_{\mathrm{time}}$
yields the result in the main text, cf. Eq. 9, with
$p_{1}=p_{\mathrm{ph}}+p_{\mathrm{time}}$.

\begin{overpic}[width=433.62pt]{plog_RN_local.pdf} \put(0.0,37.0){(a)}
\put(40.0,37.0){(b)} \put(77.0,37.0){(c)} \end{overpic}

((a))

((b))

((c))

Figure 10:  Logical qubit error rate vs. physical one, under the simplified
noise model for neutral atoms described in Sec. IV.2, for the (a) measurement-
free and (b) feed-forward implementation. Solid lines correspond to the
numerical fits used to estimate the pseudo-thresholds, similar to Fig. 5. (c)
Numerical estimates of the pseudo-thresholds.

###  C.2 Multi-controlled gates

An entangling gate can be realized in neutral atoms by driving the $\ket{1}$
state to an auxiliary Rydberg $\ket{r}$ state. Ideally, the $\ket{r}$ state is
completely unoccupied after the protocol has been performed. The main source
of error comes from the spontaneous decay from the $\ket{r}$ state. Here we
assume simplistically that the decay from the $\ket{r}$ state can only happen
to the $\ket{1}$ state. Such effects have been explored to mitigate errors
arising from leakage outside of the computational subspace, and are broadly
referred to as _erasure conversion_ , both in theoretical proposals [82, 83],
as well as in experimental setups [84, 29]. Here we follow a similar approach
to Ref. [83]. We assume that with perfect erasure conversion, all remaining
populations in the Rydberg state—for example due to driving imperfections—is
brought back to the $\ket{1}$ state. Importantly, we assume that the erasure
conversion can be achieved solely by incoherent repumping, and not via
measurements. We then derive the associated quantum channel.

A $C^{m}Z$ gate is supported on $\ell=m+1$ qubits. The channel is
$\mathcal{E}_{C^{m}Z}^{\mathrm{decay}}(\rho)=\sum_{\mathbf{s}}K_{\mathbf{s}}\rho
K_{\mathbf{s}}^{\dagger}$, where the Kraus operators are indexed using the
basis state $\ket{\mathbf{s}}=\ket{s_{1},s_{2},\dots,s_{\ell}}$ that is
subject to decay,

$K_{\mathbf{s}}=\begin{cases}\displaystyle\ket{\mathbf{0}}\bra{\mathbf{0}}+\sqrt{1-p}\sum_{\mathbf{s^{\prime}}\neq\mathbf{0}}\ket{\mathbf{s^{\prime}}}\bra{\mathbf{s^{\prime}}}&\mbox{if}\leavevmode\nobreak\
\mathbf{s}=\mathbf{0},\\\
\displaystyle\sqrt{p}\ket{\mathbf{s}}\bra{\mathbf{s}}&\mbox{otherwise},\end{cases}$
(30)

where we define $\ket{\mathbf{0}}=\ket{00\dots 00}$. We assume that all the
states $\mathbf{s}\neq\mathbf{0}$ are subject to the same decay probability
$p$ during the gate protocol. This is realistic, since in the blockaded regime
only one $\ket{r}$ state can be excited at a given time, so their decay
probability should be similar. Expanding to first order in $p$ we obtain

$K_{\mathbf{s}}\rho
K_{\mathbf{s}}^{\dagger}\simeq\begin{cases}\displaystyle(1-p)\rho+\frac{p}{2}\left(\ket{\mathbf{0}}\bra{\mathbf{0}}\rho+\rho\ket{\mathbf{0}}\bra{\mathbf{0}}\right)&\mbox{if}\leavevmode\nobreak\
\mathbf{s}=\mathbf{0},\\\
\displaystyle\;p\ket{\mathbf{s}}\bra{\mathbf{s}}\rho\ket{\mathbf{s}}\bra{\mathbf{s}}&\mbox{otherwise}.\end{cases}$
(31)

Using the identities $\ket{0}\bra{0}=\frac{1}{2}(I+Z)$ and
$\ket{1}\bra{1}=\frac{1}{2}(I-Z)$ we twirl each term with Eq. 24 to obtain

$\widetilde{K_{\mathbf{s}}\rho
K_{\mathbf{s}}^{\dagger}}\simeq\begin{cases}\displaystyle\left[1-\left(1-\frac{1}{2^{\ell}}\right)p\right]\rho&\mbox{if}\leavevmode\nobreak\
\mathbf{s}=\mathbf{0},\\\
\displaystyle\frac{p}{(2^{\ell})^{2}}\;\;\sum_{\mathclap{{P\in\\{I,Z\\}^{\otimes\ell}}}}P\rho
P^{\dagger}&\mbox{otherwise}.\end{cases}$ (32)

Finally, the twirled channel contains all combinations of $Z$ operators on
each qubit

$\tilde{\mathcal{E}}_{C^{\ell-1}Z}^{\mathrm{decay}}(\rho)=\left(1-\frac{(2^{\ell}-1)^{2}}{(2^{\ell})^{2}}p\right)\rho+\frac{2^{\ell}-1}{(2^{\ell})^{2}}p\sum_{\mathclap{\begin{subarray}{c}P\in\\{I,Z\\}^{\otimes\ell}\\\
P\neq I^{\otimes\ell}\end{subarray}}}P\rho P^{\dagger}.$ (33)

This result generalizes the one in Ref. [83] and is equivalent to Eq. 10 with
$p_{\ell}=(2^{\ell}-1)^{2}p/(2^{\ell})^{2}$.

This would suggest $p_{3}\approx 1.36\;p_{2}$. However, the gates have
different decay probabilities. Then, accounting for the fact that a $CCZ$ gate
is approximately twice as long as a $CZ$ gate [85], and taking into account
extra contributions from laser imperfections, we choose $p_{3}=4p_{2}$ for our
numerical simulations, matching recent experiments [26, 14].

###  C.3 Idling errors

In neutral-atom qubits, dephasing times $T_{2}$ ranging from a few to hundreds
of milliseconds have been observed. These can be extended to
$T_{2}\gtrsim$1\text{\,}\mathrm{s}$$ with dynamical decoupling [19, 31, 32,
34], with recent demonstrations achieving $T_{2}>$10\text{\,}\mathrm{s}$$ [86,
87]. Conversely, the relaxation time $T_{1}$ spans between a few and hundreds
of seconds [19, 29, 32].

As both quantum gates and shuttling over a few lattice spaces take
significantly less time, a few microseconds at most, we neglect idling errors
occurring during gates. On the other hand, midcircuit measurements require
times of the order of $1\text{\,}\mathrm{ms}20\text{\,}\mathrm{ms}$ [14, 34,
31, 33, 32, 30]. This leads to idling errors during measurements which cannot
be neglected. For the following, we assume dephasing dominates, as $T_{2}\ll
T_{1}$. Therefore, during measurements, every data qubit is subject to the
channel

$\mathcal{E}_{\mathrm{idle}}(\rho)=\left(1-p_{\mathrm{idle}}\right)\rho+p_{\mathrm{idle}}Z\rho
Z,$ (34)

with

$p_{\mathrm{idle}}=\frac{1}{2}\left(1-e^{-t/T_{2}}\right),$ (35)

where $t$ represents the time taken by measurements.

With a feed-forward time of $t\approx$0.9\text{\,}\mathrm{ms}$$ and coherence
$T_{2}>$1\text{\,}\mathrm{s}$$ from state-of-the-art QEC experiments with
rubidium atoms [14], $p_{\mathrm{idle}}\lesssim 10^{-3}$ was estimated. Very
recent results with arrays of cesium atoms observe a $T_{2}$ time that is an
order of magnitude larger [87]. With further experimental improvements, an
optimistic scenario for the future would be $t=$0.1\text{\,}\mathrm{ms}$$ and
$T_{2}=$50\text{\,}\mathrm{s}$$, leading to negligible idling rates
($p_{\mathrm{idle}}\approx 10^{-6}$).

##  Appendix D Additional numerical results

In this appendix, we report on the numerical simulations of our protocols
under the simplistic noise model derived in App. C for neutral-atom arrays, in
the absence of idling errors. This is shown in Fig. 10.

Results are qualitatively similar to the depolarizing noise (cf. Sec. IV.1),
but the pseudo-thresholds are higher. In particular, the pseudo-threshold of
multiple implementations is found to be within the reach of current state-of-
the-art experiments [14, 28], from which one can estimate a $p_{2}$ in the
range of $0.005\text{\,}0.007\text{\,}$.

## References

  * Terhal [2015] B. M. Terhal, Quantum error correction for quantum memories, Reviews of Modern Physics 87, 307 (2015), 1302.3428 .
  * Campbell  _et al._ [2017] E. T. Campbell, B. M. Terhal, and C. Vuillot, Roads towards fault-tolerant universal quantum computation, Nature 549, 172 (2017), 1612.07330 .
  * Google Quantum AI [2021] Google Quantum AI, Exponential suppression of bit or phase errors with cyclic error correction, Nature 595, 383 (2021).
  * Google Quantum AI [2023] Google Quantum AI, Suppressing quantum errors by scaling a surface code logical qubit, Nature 614, 676 (2023).
  * Ryan-Anderson  _et al._ [2021] C. Ryan-Anderson, J. G. Bohnet, K. Lee, D. Gresh, A. Hankin, J. P. Gaebler, D. Francois, A. Chernoguzov, D. Lucchetti, N. C. Brown, T. M. Gatterman, S. K. Halit, K. Gilmore, J. A. Gerber, B. Neyenhuis, D. Hayes, and R. P. Stutz, Realization of real-time fault-tolerant quantum error correction, Physical Review X 11, 041058 (2021).
  * Krinner  _et al._ [2022] S. Krinner, N. Lacroix, A. Remm, A. Di Paolo, E. Genois, C. Leroux, C. Hellings, S. Lazar, F. Swiadek, J. Herrmann, G. J. Norris, C. K. Andersen, M. Müller, A. Blais, C. Eichler, and A. Wallraff, Realizing repeated quantum error correction in a distance-three surface code, Nature 605, 669 (2022).
  * Abobeih  _et al._ [2022] M. H. Abobeih, Y. Wang, J. Randall, S. J. H. Loenen, C. E. Bradley, M. Markham, D. J. Twitchen, B. M. Terhal, and T. H. Taminiau, Fault-tolerant operation of a logical qubit in a diamond quantum processor, Nature 606, 884 (2022).
  * Zhao  _et al._ [2022] Y. Zhao, Y. Ye, H.-L. Huang, Y. Zhang, D. Wu, H. Guan, Q. Zhu, Z. Wei, T. He, S. Cao, F. Chen, T.-H. Chung, H. Deng, D. Fan, M. Gong, C. Guo, S. Guo, L. Han, N. Li, S. Li, Y. Li, F. Liang, J. Lin, H. Qian, H. Rong, H. Su, L. Sun, S. Wang, Y. Wu, Y. Xu, C. Ying, J. Yu, C. Zha, K. Zhang, Y.-H. Huo, C.-Y. Lu, C.-Z. Peng, X. Zhu, and J.-W. Pan, Realization of an error-correcting surface code with superconducting qubits, Physical Review Letters 129, 030501 (2022).
  * Wang  _et al._ [2023] Y. Wang, S. Simsek, T. M. Gatterman, J. A. Gerber, K. Gilmore, D. Gresh, N. Hewitt, C. V. Horst, M. Matheny, T. Mengle, B. Neyenhuis, and B. Criger, Fault-tolerant one-bit addition with the smallest interesting colour code (2023), arxiv:2309.09893 .
  * Gupta  _et al._ [2024] R. S. Gupta, N. Sundaresan, T. Alexander, C. J. Wood, S. T. Merkel, M. B. Healy, M. Hillenbrand, T. Jochym-O’Connor, J. R. Wootton, T. J. Yoder, A. W. Cross, M. Takita, and B. J. Brown, Encoding a magic state with beyond break-even fidelity, Nature 625, 259 (2024).
  * Hilder  _et al._ [2022] J. Hilder, D. Pijn, O. Onishchenko, A. Stahl, M. Orth, B. Lekitsch, A. Rodriguez-Blanco, M. Müller, F. Schmidt-Kaler, and U. G. Poschinger, Fault-tolerant parity readout on a shuttling-based trapped-ion quantum computer, Physical Review X 12, 011032 (2022).
  * Postler  _et al._ [2022] L. Postler, S. Heußen, I. Pogorelov, M. Rispler, T. Feldker, M. Meth, C. D. Marciniak, R. Stricker, M. Ringbauer, R. Blatt, P. Schindler, M. Müller, and T. Monz, Demonstration of fault-tolerant universal quantum gate operations, Nature 605, 675 (2022).
  * Postler  _et al._ [2023] L. Postler, F. Butt, I. Pogorelov, C. D. Marciniak, S. Heußen, R. Blatt, P. Schindler, M. Rispler, M. Müller, and T. Monz, Demonstration of fault-tolerant Steane quantum error correction (2023), arxiv:2312.09745 .
  * Bluvstein  _et al._ [2024] D. Bluvstein, S. J. Evered, A. A. Geim, S. H. Li, H. Zhou, T. Manovitz, S. Ebadi, M. Cain, M. Kalinowski, D. Hangleiter, J. P. Bonilla Ataides, N. Maskara, I. Cong, X. Gao, P. Sales Rodriguez, T. Karolyshyn, G. Semeghini, M. J. Gullans, M. Greiner, V. Vuletić, and M. D. Lukin, Logical quantum processor based on reconfigurable atom arrays, Nature 626, 58 (2024).
  * Huang  _et al._ [2023] S. Huang, K. R. Brown, and M. Cetina, Comparing Shor and Steane error correction using the Bacon-Shor code (2023), arXiv:2312.10851 .
  * Pogorelov  _et al._ [2024] I. Pogorelov, F. Butt, L. Postler, C. D. Marciniak, P. Schindler, M. Müller, and T. Monz, Experimental fault-tolerant code switching (2024), arXiv:2403.13732 .
  * da Silva  _et al._ [2024] M. P. da Silva, C. Ryan-Anderson, J. M. Bello-Rivas, A. Chernoguzov, J. M. Dreiling, C. Foltz, F. Frachon, J. P. Gaebler, T. M. Gatterman, L. Grans-Samuelsson, D. Hayes, N. Hewitt, J. Johansen, D. Lucchetti, M. Mills, S. A. Moses, B. Neyenhuis, A. Paz, J. Pino, P. Siegfried, J. Strabley, A. Sundaram, D. Tom, S. J. Wernli, M. Zanner, R. P. Stutz, and K. M. Svore, Demonstration of logical qubits and repeated error correction with better-than-physical error rates (2024), arXiv:2404.02280 .
  * Henriet  _et al._ [2020] L. Henriet, L. Beguin, A. Signoles, T. Lahaye, A. Browaeys, G.-O. Reymond, and C. Jurczak, Quantum computing with neutral atoms, Quantum 4, 327 (2020).
  * Bluvstein  _et al._ [2022] D. Bluvstein, H. Levine, G. Semeghini, T. T. Wang, S. Ebadi, M. Kalinowski, A. Keesling, N. Maskara, H. Pichler, M. Greiner, V. Vuletić, and M. D. Lukin, A quantum processor based on coherent transport of entangled atom arrays, Nature 604, 451 (2022).
  * Levine  _et al._ [2022] H. Levine, D. Bluvstein, A. Keesling, T. T. Wang, S. Ebadi, G. Semeghini, A. Omran, M. Greiner, V. Vuletić, and M. D. Lukin, Dispersive optical systems for scalable Raman driving of hyperfine qubits, Physical Review A 105, 032618 (2022).
  * Ma  _et al._ [2022] S. Ma, A. P. Burgers, G. Liu, J. Wilson, B. Zhang, and J. D. Thompson, Universal gate operations on nuclear spin qubits in an optical tweezer array of ${}^{171}\mathrm{Yb}$ atoms, Phys. Rev. X 12, 021028 (2022).
  * Unnikrishnan  _et al._ [2024] G. Unnikrishnan, P. Ilzhöfer, A. Scholz, C. Hölzl, A. Götzelmann, R. K. Gupta, J. Zhao, J. Krauter, S. Weber, N. Makki, H. P. Büchler, T. Pfau, and F. Meinert, Coherent control of the fine-structure qubit in a single alkaline-earth atom (2024), arXiv:2401.10679 .
  * Pucher  _et al._ [2024] S. Pucher, V. Klüsener, F. Spriestersbach, J. Geiger, A. Schindewolf, I. Bloch, and S. Blatt, Fine-structure qubit encoded in metastable strontium trapped in an optical lattice (2024), arXiv:2401.11054 .
  * Jaksch  _et al._ [2000] D. Jaksch, J. I. Cirac, P. Zoller, S. L. Rolston, R. Côt’e, and M. D. Lukin, Fast quantum gates for neutral atoms, Physical Review Letters 85, 2208 (2000).
  * Levine  _et al._ [2019] H. Levine, A. Keesling, G. Semeghini, A. Omran, T. T. Wang, S. Ebadi, H. Bernien, M. Greiner, V. Vuletić, H. Pichler, and M. D. Lukin, Parallel implementation of high-fidelity multiqubit gates with neutral atoms, Physical Review Letters 123, 170503 (2019).
  * Evered  _et al._ [2023] S. J. Evered, D. Bluvstein, M. Kalinowski, S. Ebadi, T. Manovitz, H. Zhou, S. H. Li, A. A. Geim, T. T. Wang, N. Maskara, H. Levine, G. Semeghini, M. Greiner, V. Vuletić, and M. D. Lukin, High-fidelity parallel entangling gates on a neutral-atom quantum computer, Nature 622, 268 (2023).
  * Cao  _et al._ [2024] A. Cao, W. J. Eckner, T. L. Yelin, A. W. Young, S. Jandura, L. Yan, K. Kim, G. Pupillo, J. Ye, N. D. Oppong, and A. M. Kaufman, Multi-qubit gates and ’Schrödinger cat’ states in an optical clock (2024), arxiv:2402.16289 .
  * Finkelstein  _et al._ [2024] R. Finkelstein, R. B.-S. Tsai, X. Sun, P. Scholl, S. Direkci, T. Gefen, J. Choi, A. L. Shaw, and M. Endres, Universal quantum operations and ancilla-based readout for tweezer clocks (2024), arXiv:2402.16220 .
  * Ma  _et al._ [2023] S. Ma, G. Liu, P. Peng, B. Zhang, S. Jandura, J. Claes, A. P. Burgers, G. Pupillo, S. Puri, and J. D. Thompson, High-fidelity gates and mid-circuit erasure conversion in an atomic qubit, Nature 622, 279 (2023).
  * Singh  _et al._ [2023] K. Singh, C. E. Bradley, S. Anand, V. Ramesh, R. White, and H. Bernien, Mid-circuit correction of correlated phase errors using an array of spectator qubits, Science 380, 1265 (2023).
  * Graham  _et al._ [2023] T. M. Graham, L. Phuttitarn, R. Chinnarasu, Y. Song, C. Poole, K. Jooya, J. Scott, A. Scott, P. Eichler, and M. Saffman, Midcircuit measurements on a single-species neutral alkali atom quantum processor, Phys. Rev. X 13, 041051 (2023).
  * Huie  _et al._ [2023] W. Huie, L. Li, N. Chen, X. Hu, Z. Jia, W. K. C. Sun, and J. P. Covey, Repetitive readout and real-time control of nuclear spin qubits in ${}^{171}\mathrm{Yb}$ atoms, PRX Quantum 4, 030337 (2023).
  * Lis  _et al._ [2023] J. W. Lis, A. Senoo, W. F. McGrew, F. Rönchen, A. Jenkins, and A. M. Kaufman, Midcircuit operations using the omg architecture in neutral atom arrays, Phys. Rev. X 13, 041035 (2023).
  * Norcia  _et al._ [2023] M. A. Norcia, W. B. Cairncross, K. Barnes, P. Battaglino, A. Brown, M. O. Brown, K. Cassella, C.-A. Chen, R. Coxe, D. Crow, J. Epstein, C. Griger, A. M. W. Jones, H. Kim, J. M. Kindem, J. King, S. S. Kondov, K. Kotru, J. Lauigan, M. Li, M. Lu, E. Megidish, J. Marjanovic, M. McDonald, T. Mittiga, J. A. Muniz, S. Narayanaswami, C. Nishiguchi, R. Notermans, T. Paule, K. A. Pawlak, L. S. Peng, A. Ryou, A. Smull, D. Stack, M. Stone, A. Sucich, M. Urbanek, R. J. M. van de Veerdonk, Z. Vendeiro, T. Wilkason, T.-Y. Wu, X. Xie, X. Zhang, and B. J. Bloom, Midcircuit qubit measurement and rearrangement in a ${}^{171}\mathrm{Yb}$ atomic array, Phys. Rev. X 13, 041034 (2023).
  * Shea  _et al._ [2020] M. E. Shea, P. M. Baker, J. A. Joseph, J. Kim, and D. J. Gauthier, Submillisecond, nondestructive, time-resolved quantum-state readout of a single, trapped neutral atom, Phys. Rev. A 102, 053101 (2020).
  * Bochmann  _et al._ [2010] J. Bochmann, M. Mücke, C. Guhl, S. Ritter, G. Rempe, and D. L. Moehring, Lossless state detection of single neutral atoms, Physical Review Letters 104, 203601 (2010).
  * Deist  _et al._ [2022] E. Deist, Y.-H. Lu, J. Ho, M. K. Pasha, J. Zeiher, Z. Yan, and D. M. Stamper-Kurn, Mid-circuit cavity measurement in a neutral atom array, Physical Review Letters 129, 203602 (2022).
  * Paz-Silva  _et al._ [2010] G. A. Paz-Silva, G. K. Brennen, and J. Twamley, Fault tolerance with noisy and slow measurements and preparation, Physical Review Letters 105, 100501 (2010).
  * Li  _et al._ [2012] C.-K. Li, M. Nakahara, Y.-T. Poon, N.-S. Sze, and H. Tomita, Recovery in quantum error correction for general noise without measurement, Quantum Inf. Comput. 12, 149 (2012).
  * Crow  _et al._ [2016] D. Crow, R. Joynt, and M. Saffman, Improved error thresholds for measurement-free error correction, Physical Review Letters 117, 130503 (2016).
  * Ercan  _et al._ [2018] H. E. Ercan, J. Ghosh, D. Crow, V. N. Premakumar, R. Joynt, M. Friesen, and S. N. Coppersmith, Measurement-free implementations of small-scale surface codes for quantum-dot qubits, Physical Review A 97, 012318 (2018).
  * Singh  _et al._ [2022] K. Singh, S. Anand, A. Pocklington, J. T. Kemp, and H. Bernien, Dual-element, two-dimensional atom array with continuous-mode operation, Physical Review X 12, 011040 (2022).
  * Norcia  _et al._ [2024] M. A. Norcia, H. Kim, W. B. Cairncross, M. Stone, A. Ryou, M. Jaffe, M. O. Brown, K. Barnes, P. Battaglino, T. C. Bohdanowicz, A. Brown, K. Cassella, C. A. Chen, R. Coxe, D. Crow, J. Epstein, C. Griger, E. Halperin, F. Hummel, A. M. W. Jones, J. M. Kindem, J. King, K. Kotru, J. Lauigan, M. Li, M. Lu, E. Megidish, J. Marjanovic, M. McDonald, T. Mittiga, J. A. Muniz, S. Narayanaswami, C. Nishiguchi, T. Paule, K. A. Pawlak, L. S. Peng, K. L. Pudenz, D. R. Perez, A. Smull, D. Stack, M. Urbanek, R. J. M. van de Veerdonk, Z. Vendeiro, L. Wadleigh, T. Wilkason, T. Y. Wu, X. Xie, E. Zalys-Geller, X. Zhang, and B. J. Bloom, Iterative assembly of ${}^{171}\mathrm{Yb}$ atom arrays in cavity-enhanced optical lattices (2024), arXiv:2401.16177 .
  * Gyger  _et al._ [2024] F. Gyger, M. Ammenwerth, R. Tao, H. Timme, S. Snigirev, I. Bloch, and J. Zeiher, Continuous operation of large-scale atom arrays in optical lattices (2024), arXiv:2402.04994 .
  * Perlin  _et al._ [2023] M. A. Perlin, V. N. Premakumar, J. Wang, M. Saffman, and R. Joynt, Fault-tolerant measurement-free quantum error correction with multiqubit gates, Phys. Rev. A 108, 062426 (2023).
  * Heußen  _et al._ [2024] S. Heußen, D. F. Locher, and M. Müller, Measurement-free fault-tolerant quantum error correction in near-term devices, PRX Quantum 5, 010333 (2024).
  * Steane [1997] A. M. Steane, Active stabilization, quantum computation, and quantum state synthesis, Phys. Rev. Lett. 78, 2252 (1997).
  * Bacon [2006] D. Bacon, Operator quantum error-correcting subsystems for self-correcting quantum memories, Phys. Rev. A 73, 012340 (2006).
  * Aliferis and Cross [2007] P. Aliferis and A. W. Cross, Subsystem fault tolerance with the Bacon-Shor code, Phys. Rev. Lett. 98, 220502 (2007).
  * Shor [1995] P. W. Shor, Scheme for reducing decoherence in quantum computer memory, Phys. Rev. A 52, R2493 (1995).
  * Bravyi and Kitaev [1998] S. B. Bravyi and A. Y. Kitaev, Quantum codes on a lattice with boundary (1998), arXiv:quant-ph/9811052 .
  * Dennis  _et al._ [2002] E. Dennis, A. Kitaev, A. Landahl, and J. Preskill, Topological quantum memory, Journal of Mathematical Physics 43, 4452 (2002).
  * Fowler  _et al._ [2012] A. G. Fowler, M. Mariantoni, J. M. Martinis, and A. N. Cleland, Surface codes: Towards practical large-scale quantum computation, Physical Review A 86, 032324 (2012).
  * Steane [1996a] A. M. Steane, Error correcting codes in quantum theory, Phys. Rev. Lett. 77, 793 (1996a).
  * Bombin and Martin-Delgado [2006] H. Bombin and M. A. Martin-Delgado, Topological quantum distillation, Phys. Rev. Lett. 97, 180501 (2006).
  * Chamberland and Beverland [2018] C. Chamberland and M. E. Beverland, Flag fault-tolerant error correction with arbitrary distance codes, Quantum 2, 53 (2018).
  * Chao and Reichardt [2020] R. Chao and B. W. Reichardt, Flag fault-tolerant error correction for any stabilizer code, PRX Quantum 1, 010302 (2020).
  * Chao and Reichardt [2018] R. Chao and B. W. Reichardt, Quantum error correction with only two extra qubits, Physical Review Letters 121, 050502 (2018).
  * Prabhu and Reichardt [2023] P. Prabhu and B. W. Reichardt, Fault-tolerant syndrome extraction and cat state preparation with fewer qubits, Quantum 7, 1154 (2023).
  * Note [1] In a controlled unitary, we define a one-control as the qubit that leads to the application of the unitary if the control is in $\mathinner{|{1}\rangle}$. These are illustrated in the diagrams with a filled circle.
  * Calderbank and Shor [1996] A. R. Calderbank and P. W. Shor, Good quantum error-correcting codes exist, Phys. Rev. A 54, 1098 (1996).
  * Steane [1996b] A. Steane, Multiple-particle interference and quantum error correction, Proceedings of the Royal Society of London. Series A: Mathematical, Physical and Engineering Sciences 452, 2551 (1996b).
  * Cirq Developers [2023] Cirq Developers, Cirq, Zenodo [Online] (2023).
  * Note [2] This corresponds to a Haar-uniform sampling over initial logical states.
  * Liou and Lai [2023] P.-H. Liou and C.-Y. Lai, Parallel syndrome extraction with shared flag qubits for Calderbank-Shor-Steane codes of distance three, Physical Review A 107, 022614 (2023).
  * Tan  _et al._ [2023] X. Tan, F. Zhang, R. Chao, Y. Shi, and J. Chen, Scalable surface-code decoders with parallelization in time, PRX Quantum 4, 040344 (2023).
  * Higgott  _et al._ [2023] O. Higgott, T. C. Bohdanowicz, A. Kubica, S. T. Flammia, and E. T. Campbell, Improved decoding of circuit noise and fragile boundaries of tailored surface codes, Phys. Rev. X 13, 031007 (2023).
  * Note [3] We note that the thresholds claimed are for a single logical basis state different than $\mathinner{|{i}\rangle}_{L}$, which in our simulations lowers the logical performance.
  * Bennett  _et al._ [1996] C. H. Bennett, G. Brassard, S. Popescu, B. Schumacher, J. A. Smolin, and W. K. Wootters, Purification of noisy entanglement and faithful teleportation via noisy channels, Phys. Rev. Lett. 76, 722 (1996).
  * Dür  _et al._ [2005] W. Dür, M. Hein, J. I. Cirac, and H.-J. Briegel, Standard forms of noisy quantum operations via depolarization, Phys. Rev. A 72, 052326 (2005).
  * Emerson  _et al._ [2007] J. Emerson, M. Silva, O. Moussa, C. Ryan, M. Laforest, J. Baugh, D. G. Cory, and R. Laflamme, Symmetrized characterization of noisy quantum processes, Science 317, 1893 (2007).
  * Silva  _et al._ [2008] M. Silva, E. Magesan, D. W. Kribs, and J. Emerson, Scalable protocol for identification of correctable codes, Phys. Rev. A 78, 012347 (2008).
  * Geller and Zhou [2013] M. R. Geller and Z. Zhou, Efficient error models for fault-tolerant architectures and the Pauli twirling approximation, Phys. Rev. A 88, 012314 (2013).
  * Bombín [2015] H. Bombín, Single-shot fault-tolerant quantum error correction, Phys. Rev. X 5, 031043 (2015).
  * Yoder  _et al._ [2016] T. J. Yoder, R. Takagi, and I. L. Chuang, Universal fault-tolerant gates on concatenated stabilizer codes, Physical Review X 6, 031039 (2016).
  * Paetznick and Reichardt [2013] A. Paetznick and B. W. Reichardt, Universal fault-tolerant quantum computation with only transversal gates and error correction, Phys. Rev. Lett. 111, 090505 (2013).
  * Jochym-O’Connor and Laflamme [2014] T. Jochym-O’Connor and R. Laflamme, Using concatenated quantum codes for universal fault-tolerant quantum gates, Physical Review Letters 112, 010505 (2014).
  * Chamberland  _et al._ [2017] C. Chamberland, T. Jochym-O’Connor, and R. Laflamme, Overhead analysis of universal concatenated quantum codes, Physical Review A 95, 022313 (2017).
  * Goto  _et al._ [2023] H. Goto, Y. Ho, and T. Kanao, Measurement-free fault-tolerant logical zero-state encoding of the distance-three nine-qubit surface code in a one-dimensional qubit array, Physical Review Research 5, 043137 (2023).
  * Tomita and Svore [2014] Y. Tomita and K. M. Svore, Low-distance surface codes under realistic quantum noise, Physical Review A 90, 062320 (2014).
  * Day  _et al._ [2022] M. L. Day, P. J. Low, B. White, R. Islam, and C. Senko, Limits on atomic qubit control from laser noise, npj Quantum Information 8, 72 (2022).
  * Cong  _et al._ [2022] I. Cong, H. Levine, A. Keesling, D. Bluvstein, S.-T. Wang, and M. D. Lukin, Hardware-efficient, fault-tolerant quantum computation with Rydberg atoms, Physical Review X 12, 021049 (2022).
  * Sahay  _et al._ [2023] K. Sahay, J. Jin, J. Claes, J. D. Thompson, and S. Puri, High-threshold codes for neutral-atom qubits with biased erasure errors, Phys. Rev. X 13, 041013 (2023).
  * Wu  _et al._ [2022] Y. Wu, S. Kolkowitz, S. Puri, and J. D. Thompson, Erasure conversion for fault-tolerant quantum computing in alkaline earth Rydberg atom arrays, Nature Communications 13, 4657 (2022).
  * Jandura and Pupillo [2022] S. Jandura and G. Pupillo, Time-optimal two- and three-qubit gates for Rydberg atoms, Quantum 6, 712 (2022).
  * Barnes  _et al._ [2022] K. Barnes, P. Battaglino, B. J. Bloom, K. Cassella, R. Coxe, N. Crisosto, J. P. King, S. S. Kondov, K. Kotru, S. C. Larsen, J. Lauigan, B. J. Lester, M. McDonald, E. Megidish, S. Narayanaswami, C. Nishiguchi, R. Notermans, L. S. Peng, A. Ryou, T.-Y. Wu, and M. Yarwood, Assembly and coherent control of a register of nuclear spin qubits, Nature Communications 13, 2779 (2022).
  * Manetsch  _et al._ [2024] H. J. Manetsch, G. Nomura, E. Bataille, K. H. Leung, X. Lv, and M. Endres, A tweezer array with 6100 highly coherent atomic qubits (2024), arXiv:2403.12021 .