††thanks: Present address: Department of Physics, ETH Zurich, Zurich,
Switzerland

# Scalable quantum error correction code on a ring topology of qubits

Ilya. A. Simakov<EMAIL_ADDRESS>Russian Quantum Center, 143025
Skolkovo, Moscow, Russia  National University of Science and Technology
“MISIS”, 119049 Moscow, Russia  Moscow Institute of Physics and Technology,
141701 Dolgoprudny, Russia  Ilya. S. Besedin  Russian Quantum Center, 143025
Skolkovo, Moscow, Russia  National University of Science and Technology
“MISIS”, 119049 Moscow, Russia

###### Abstract

Quantum error correction is an important ingredient for scalable quantum
computing. Stabilizer codes are one of the most promising and straightforward
ways to correct quantum errors, since they do not require excessive complexity
of physical qubits, are convenient for logical operations, and improve
performance with increasing the involved qubits number. Here, we propose a
linear scalable code of the permutative stabilizers for small distances on the
ring architecture, which takes into account the topological features of the
superconducting platform. We present the way to construct the quantum circuit
of the code and provide numerical simulation that demonstrate the exponential
logical error rate suppression.

##  I Introduction

Large error rates of about $10^{-3}$ Foxen et al. (2020); Rol et al. (2019);
Huang et al. (2019); Wu et al. (2021); Moskalenko et al. (2022) are a major
obstacle towards practical application of quantum computing. Therefore,
quantum error correction (QEC) is expected to be a significant and unavoidable
part of a fault-tolerant quantum computer Peres (1985); Shor (1995);
Calderbank and Shor (1996); Knill et al. (1996). One of the most promising
methods for correcting quantum errors is considered to be stabilizer codes,
for which logical qubits are encoded in an entangled state of a large number
of physical qubits. By measuring $X$ or $Z$ parity operators (syndromes) one
can identify the occurrence of errors in the underlying physical qubits
DiVincenzo and Shor (1996); Steane (1996); Gottesman (1998). A variety of such
codes has been developed and simulated under plausible error conditions Tomita
and Svore (2014); Trout et al. (2018); Li et al. (2017a); Bonilla Ataides et
al. (2021); Bravyi et al. (2017); O’Brien et al. (2017); Chamberland et al.
(2022); Li et al. (2017b).

Experimental implementation of correction codes is a difficult task that
requires a larger number of qubits and high-precision operations on them. At
the same time, especially in large devices, the topology of the code should
map onto the underlying qubits and their connections, so that the amount of
operations per code size remains low. For example, for superconducting
systems, high-fidelity two-qubit gates can be typically realized only between
adjacent qubits. When choosing a correction code, this aspect should be
necessarily taken into account. Among the recent experimental demonstrations
we highlight the repetition code AI (2021), surface code AI (2022); Marques et
al. (2021); Zhao et al. (2022); Andersen et al. (2020), and color code Ryan-
Anderson et al. (2021) implemented on various platforms.

Yet another important property of the correction codes is scalability, here
meaning the ability to correct more physical errors by increasing the number
of involved data qubits Nielsen and Chuang (2011). The milestone experiments
demonstrating the error suppression are presented in works AI (2021, 2022).

The smallest possible code that corrects an arbitrary single-qubit error is
the perfect five-qubit code Laflamme et al. (1996). Its stabilizers can be
generated as cyclic permutation of a basic stabilizer $XZZXI$. The five-qubit
code implementation with the iSWAP gates on a ring topology was proposed in
Schuch and Siewert (2003) and thoroughly simulated in Simakov et al. (2022);
Antipov et al. (2022). Furthermore, there is the tailored $XZZX$ code Xu et
al. (2022); Kovalev and Pryadko (2012), that can be considered as a scaling of
the five-qubit code.

In this paper, we describe a set of linear scalable low-distance QEC codes,
for which the stabilizers are generated by cyclic permutations of the basic
stabilizer, similar to the five-qubit code. For a practical implementation, we
propose a quantum circuit consisting of alternating ancillary and data qubits
forming a ring, with natural two-qubit iSWAP and SWAP gates available between
any neighboring qubits. We study the efficiency of the code with the respect
to the errors occurring during and between correction cycles and compare them
with the tailored $XZZX$ code. The proposed code required reasonably low
hardware overhead and is affordable in near-term demonstration experiments.

##  II Code construction

Figure 1: The schematic layout of the 13-qubit code on the ring topology and a
part of the quantum circuit. The red and aquamarine circles mark data and
ancillary qubits correspondingly. The full quantum circuit can be
reconstructed by translation of the shown segment. The major part of the
scheme are the six series of the two-qubit gates applied to the neighboring
qubits. We highlight the path of the computational state of the first
ancillary qubit and show the data qubits with which it interacts during the
correction cycle. Also, we stress that in the end of the cycle the
computational states of data qubits are shifted.

A correction code encoding one logical qubit into $n$ physical qubits can be
described by $n-1$ syndrome generators. Below we give the basic syndrome for
the codes with distances $3,$ $5,$ $7$, $9$ and $11$, respectively:

$\displaystyle d=3,\;n=5:\;g_{0}=ZXXZI$ (1) $\displaystyle
d=5,\;n=13:\;g_{0}=ZIXXIZ\underbrace{I...I}_{7}$ $\displaystyle
d=7,\;n=21:\;g_{0}=ZIIXXXXIIZ\underbrace{I...I}_{11}$ $\displaystyle
d=9,\;n=29:\;g_{0}=ZXXIIXIIXIIXXZ\underbrace{I...I}_{15},$ $\displaystyle
d=11,\;n=37:\;g_{0}=ZXXXIIIXIIXIIIXXXZ\underbrace{I...I}_{19},$

where $X$, $Y$, $Z$, $I$ are the Pauli operators, and we assume tensor product
sign $\otimes$ between each of them. The remaining $n-2$ generators can be
obtained from $g_{0}$ by sequentially rolling beyond the last position and re-
introducing at the first. The logical operators of the codes can be written by
the following single-qubit operators:

$X_{L}=X^{\otimes n},\;Y_{L}=Y^{\otimes n},\;Z_{L}=Z^{\otimes n}.$ (2)

Measurement of the syndromes can be efficiently realized on a ring of
alternating $n$ ancillary and $n$ data qubits. Assuming single-qubit gates,
initialization procedure and single-shot readout available for an arbitrary
qubit, we propose a quantum circuit for QEC cycle with only iSWAP and SWAP
two-qubit gates between the neighboring qubits. We note, that the scheme
contains one extra ancilla, which corresponds to a syndrome that is not
independent, but a product of the other syndrome generators.

The code with $d=3$ is well-known as the perfect five-qubit code. Its behavior
under a realistic noise model in the ring topology of 10 series-connected
superconducting qubits has been researched in detail in Simakov et al. (2022).
Here, we focus on the codes with higher distances and explain their main
concept with the 13-qubit code example. The quantum circuit of the correction
cycle is presented in Fig. 1. It requires 26 physical qubits, half of which
keep the encoded logical state, and the rest are used to extract syndrome data
that gives information about possible errors that may have occurred during the
previous cycles. Every correction cycle starts and finishes with
initialization in the ground state and single-shot readout of all ancillary
qubits. During the correction cycle each ancilla is affected by six two-qubit
gates and as a result entangles with four data qubits in the way it is
highlighted for the first ancilla in Fig. 1.

It should be noted, that in a such circuit the computational states of
ancillary and data qubits move towards each other clockwise and
counterclockwise. The transition from the standard “fixed” ancilla $ZZ$ and
$XX$ entanglement method to the “sliding” ancilla is shown in Fig. 2. This
approach might be helpful in quantum circuits, when it is substantial for one
qubit to interact with several non-neighboring qubits.

The quantum circuits of the other codes with higher distances are constructed
by analogy.

Figure 2: Transforming the conventional quantum circuit of $ZZ$ (top) and $XX$
(bottom) stabilizer measurements to a scheme with iSWAP gates and “sliding”
ancillary qubit. The diagram has the same notations as the Fig 1.

##  III Methods

To characterize the efficiency of the correction codes, we focus on the
performance of the logical qubit as a quantum memory. In order to simulate a
state preservation experiment we need to suggest a relevant error model and a
decoding algorithm.

For the error model we choose an independent and identically distributed
standard depolarizing channel:

$\mathcal{E}(\rho)=(1-p)\rho+p_{x}X\rho X+p_{y}Y\rho Y^{\dagger}+p_{z}Z\rho
Z,$ (3)

where $p=p_{x}+p_{y}+p_{z}$ is the error probability, and $p_{x}$, $p_{y}$,
and $p_{z}$ are probabilities of $X$, $Y$, and $Z$ errors, respectively.

In order to observe the dynamics of an open quantum system properly, one need
to simulate time evolution of the density matrix as it is done in the works
Tomita and Svore (2014); O’Brien et al. (2017) for Surface-17 and in Simakov
et al. (2022) for perfect five-qubit code. However, such simulations become
intractable due to the exponentially growing Hilbert space size, and
approximate models which correspond to the experiment are generally
usedSrivastava et al. (2022); Bravyi et al. (2017). For the current research
we propose the following noise model. We consider that an independent single-
qubit $X$, $Y$, or $Z$ error might occur to any data qubit during the
correction cycle and between them. The probability of such error is
proportional to the duration of the correction cycle or measurement and
initialization procedures. The errors accumulate from cycle to cycle and
affect both the syndromes of subsequent correction cycles and the final
logical state of the system. The errors that happen between and during
correction cycles differ in that the former may not change the values of the
proper syndromes in the current cycle and fully affect only the subsequent
measurement cycles.

In practice, we generate $2n$ sequences, half of which correspond to errors
during the correction cycles with probability $p_{d}$, and the rest are for
the errors between cycles with probability $p_{b}$. With these errors we
determine the logical state of the system after each series of syndrome
measurement. Also, we generate the relevant results of the syndrome
measurements. Finally, we randomly with probability $1/2$ change measurement
results of all ancillas that interact during the correction cycle via iSWAP or
SWAP gate with a data qubit affected by an error that happened during the
current cycle.

For the decoding algorithm we choose an improved version of a lookup table
decoder for its clarity and simplicity. First, we detect all the syndrome
changes $s_{i,j}$:

$s^{i}_{j}=\begin{cases}0,&\text{if }j=1\\\
s^{i}_{j}=m^{i}_{j}-m^{i}_{j-1}\pmod{2},&\text{otherwise,}\end{cases}$ (4)

where $m^{i}_{j}$ is the result of $i=1,...,n$ ancillary qubit measurement
after cycle $j=1,...,m$, and takes the values $0$ or $1$. If there are errors
in two consecutive syndromes after the $j$ and $j+1$ cycles, we translate all
measurement results from $j$ to $j+1$ cycle and neglect the changes of the $j$
syndrome:

for $j<m$ do

if $\sum_{i}s^{i}_{j}\neq 0\ \mathbf{and}\ \sum_{i}s^{i}_{j+1}\neq 0$ then

for $i\leq n$ do

$s^{i}_{j+1}\leftarrow s^{i}_{j}+s^{i}_{j+1}\pmod{2}$

$s^{i}_{j}\leftarrow 0$

end for

end if

end for

This approach allows to detect errors that happened during the correction
cycle after the next cycle. Next, we match the obtained syndromes to the
logical qubit error as it is done in the classical lookup table decoding
algorithm, and finally, we get a correction sequence of logical operations.

##  IV Results

To estimate the efficiency of the code performance, we compare the logical
failure rate $\epsilon_{L}$ of different codes as a function of single-qubit
error rate $p$. The relation between these parameters is expected to be
described by a power low: $\epsilon_{L}\sim p^{r}$. As a QEC code with
distance $d$ detects up to the $(d-1)/2$ independent single-qubit errors, then
the probability of an uncorrectable error is proportional to $p^{(d+1)/2}$.
Thus, for an effective code we require a linear dependence of power $r$ on
distance $d$.

We simulate the state preservation experiment for the six cardinal qubit
states with different single-qubit error rate. The error model is described in
the methods section. Firstly, we choose a symmetric depolarization channel:
$p_{x}=p_{y}=p_{z}=p/3$. Secondly, as the relation between $p_{d}$ and $p_{b}$
probabilities depends on the duration of the correction cycles for codes with
different distances, we need to estimate characteristic times of single-qubit,
two-qubit gates, readout and reset procedures. Here we base on time scales
obtained in recent experiment AI (2021) and choose the duration of Hadamard
gate $T_{g1}=14$ ns, iSWAP and SWAP gates $T_{g1}=26$ ns, measurement and
initialization $T_{m}=880$ ns, $S$ and $Z$ gates are supposed to be virtual.
The relation between $p_{d}$ and $p_{b}$ can be written as
$p_{d}/p_{b}=2(n_{Q1}T_{g1}+n_{Q2}T_{g2})/T_{m}$, where $n_{Q1}$ and $n_{Q2}$
are the numbers of Hadamard and two-qubit gates and the factor $2$ takes into
account that during the cycle the errors happen with $2n$ qubits.

We run the state preservation experiment with $50$ cycles $10^{6}$ times per
each chosen value of $p_{b}$, and calculate the fidelity of the recovered
states. The obtained points we approximate with the function

$F(t)=\frac{1}{2}+\frac{1}{2}(1-2\epsilon_{L})^{t-t_{0}},$ (5)

where $\epsilon_{L}$ is the logical error rate per $1\,\mu$s, $t$ is the time
in $\mu$s. The parameters $\epsilon_{L}$ and $t_{0}$ are obtained by the least
squares method fit. We repeat the simulation for different single-qubit error
probabilities $p_{b}$ (remind that $p_{d}$ is a function of $p_{b})$ and
present the obtained dependence of the logical error rate in a logarithmic
scale in Fig 3. We fit this data with a linear function and plot the slope $r$
for different distances in Fig 4. We observe good agreement between parameter
$r$ and code distances, that shows that the proposed codes correct the
required number of errors.

Figure 3: Logical error rate plotted as a function of the physical error
probability between correction cycles $p_{b}$. The lines show the linear fit
of the simulated data in the logarithmic scale. The slope $r$ of each code
distance is given in the legend description and the errors are calculated as a
standard deviation. The crosses and dashed line refer to the cyclic code with
distance $d=7$ implemented on the ring architecture, that is provided for
comparison.

##  V Discussion

The key result of our study presented above is a quantum circuit that scales
the perfect five-qubit code linearly. The number of total qubits required for
the code is close to the Hamming bound. Today, when state-of-the-art
superconducting quantum processor generally consists of several dozens
physical qubits, the small footprint of the correction code is a significant
advantage, that allows to examine QEC experimentally. Nevertheless, we
mention, the code is not scalable in the conventional sense of the term. The
maximum number of non-identity single-qubit operators or, in other words, the
weight of the code syndromes increases with code distance. This is the main
reason why it is excessive to scale this code for higher distances.

Yet another point of the research is the comparison of the proposed code with
cyclic code $[[n,1,d]]$, that quadratically scales: $n=(d^{2}+1)/2$ Xu et al.
(2022). Its syndromes are generated with the cyclic permutation of the base
syndrome $g_{0}=ZI^{\otimes(t-1)}XXI^{\otimes(t-1)}ZI^{\otimes{(n-2t-2)}}$,
where $t=(d-1)/2$. For distances 3 and 5 the both codes are identical. Thus,
we simulate cyclic code with $d=7$ on the same ring architecture with $50$
qubits and present the obtained dependence of the logical failure rate on the
physical error rate with the dashed line in Fig. 3. Even though the cyclic
code has the shorter correction cycle, as its quantum circuit requires $8$
series of the two-qubit gates against $10$, the linear scalable code shows
better performance because it uses less physical qubits.

Finally, we highlight the decoding problem. In the current paper we use a
slightly modified lookup table decoder that is foolproof and fast. The
proposed code is not a Calderbank-Shor-Steane code Calderbank and Shor (1996);
Steane (1996), thus we cannot analyze $X$ and $Z$ errors separately and use
common minimum-weight perfect matching decoding algorithm Edmonds (1965);
Higgott (2021). However, there are other alternative promising decoding
methods, that for example use neural network approach Krastanov and Jiang
(2017); Simakov et al. (2022) or approximate matrix product state simulations
Bravyi et al. (2014), but they are usually time and memory consuming. So, the
problem of finding the optimal real-time scalable decoding is relevant and
urgent for future research.

Figure 4: The linear slope $r$ of the logarithmic logical failure rate
$\epsilon_{L}\sim p^{r}$ plotted as a function of the code distance. We
observe exponential error suppression with the code scaling and good agreement
with the linear fit (dashed line). The colors and markers of the dots
corresponds to the data in the Fig 3.

##  VI Conclusion

In conclusion, we propose a family of linear scaling codes for small distances
on a realistic superconducting circuit topology. The corresponding quantum
circuit is defined on a ring of $2n$ superconducting qubits with natural two-
qubit iSWAP and SWAP gates available between each pair of neighboring qubits.
The amount of qubits required for the realization of these codes is within the
reach of current generation hardware even for larger code distances.
Furthermore, we have studied the logical fidelity of the proposed linear code
assuming the model of independent and identically distributed error during and
between correction cycles and decoding, based on the intuitive lookup table
algorithm. Despite the inseparable by $X$ and $Z$ syndromes, the simplicity of
the decoder and an increased duration of the correction cycle, we observe
exponential reduction of the logical failure rate with the code distance. The
key challenge for further advancing these codes is the development of a
decoder suitable for more accurate error models.

## Acknowledgments

The authors acknowledge Alexey Ustinov for helpful discussions and comments on
the manuscript. We acknowledge partial support from the Ministry of Education
and Science of the Russian Federation in the framework of the Program of
Strategic Academic Leadership “Priority 2030”.

## References

  * Foxen et al. [2020] B. Foxen, C. Neill, A. Dunsworth, P. Roushan, B. Chiaro, A. Megrant, J. Kelly, Zijun Chen, K. Satzinger, R. Barends, F. Arute, K. Arya, R. Babbush, D. Bacon, J. C. Bardin, S. Boixo, D. Buell, B. Burkett, Yu Chen, R. Collins, E. Farhi, A. Fowler, C. Gidney, M. Giustina, R. Graff, M. Harrigan, T. Huang, S. V. Isakov, E. Jeffrey, Z. Jiang, D. Kafri, K. Kechedzhi, P. Klimov, A. Korotkov, F. Kostritsa, D. Landhuis, E. Lucero, J. McClean, M. McEwen, X. Mi, M. Mohseni, J. Y. Mutus, O. Naaman, M. Neeley, M. Niu, A. Petukhov, C. Quintana, N. Rubin, D. Sank, V. Smelyanskiy, A. Vainsencher, T. C. White, Z. Yao, P. Yeh, A. Zalcman, H. Neven, and J. M. Martinis.  Demonstrating a continuous set of two-qubit gates for near-term quantum algorithms.  _Phys. Rev. Lett._ , 125:120504, Sep 2020.  doi: 10.1103/PhysRevLett.125.120504.  URL https://link.aps.org/doi/10.1103/PhysRevLett.125.120504.
  * Rol et al. [2019] M. A. Rol, F. Battistel, F. K. Malinowski, C. C. Bultink, B. M. Tarasinski, R. Vollmer, N. Haider, N. Muthusubramanian, A. Bruno, B. M. Terhal, and L. DiCarlo.  Fast, high-fidelity conditional-phase gate exploiting leakage interference in weakly anharmonic superconducting qubits.  _Phys. Rev. Lett._ , 123:120502, Sep 2019.  doi: 10.1103/PhysRevLett.123.120502.  URL https://link.aps.org/doi/10.1103/PhysRevLett.123.120502.
  * Huang et al. [2019] W. Huang, C. H. Yang, K. W. Chan, T. Tanttu, B. Hensen, R. C. C. Leon, M. A. Fogarty, J. C. C. Hwang, F. E. Hudson, K. M. Itoh, A. Morello, A. Laucht, and A. S. Dzurak.  Fidelity benchmarks for two-qubit gates in silicon.  _Nature_ , 569(7757):532–536, may 2019.  doi: 10.1038/s41586-019-1197-0.  URL https://doi.org/10.1038%2Fs41586-019-1197-0.
  * Wu et al. [2021] Yulin Wu, Wan-Su Bao, Sirui Cao, Fusheng Chen, Ming-Cheng Chen, Xiawei Chen, Tung-Hsun Chung, Hui Deng, Yajie Du, Daojin Fan, Ming Gong, Cheng Guo, Chu Guo, Shaojun Guo, Lianchen Han, Linyin Hong, He-Liang Huang, Yong-Heng Huo, Liping Li, Na Li, Shaowei Li, Yuan Li, Futian Liang, Chun Lin, Jin Lin, Haoran Qian, Dan Qiao, Hao Rong, Hong Su, Lihua Sun, Liangyuan Wang, Shiyu Wang, Dachao Wu, Yu Xu, Kai Yan, Weifeng Yang, Yang Yang, Yangsen Ye, Jianghan Yin, Chong Ying, Jiale Yu, Chen Zha, Cha Zhang, Haibin Zhang, Kaili Zhang, Yiming Zhang, Han Zhao, Youwei Zhao, Liang Zhou, Qingling Zhu, Chao-Yang Lu, Cheng-Zhi Peng, Xiaobo Zhu, and Jian-Wei Pan.  Strong quantum computational advantage using a superconducting quantum processor.  _Phys. Rev. Lett._ , 127:180501, Oct 2021.  doi: 10.1103/PhysRevLett.127.180501.  URL https://link.aps.org/doi/10.1103/PhysRevLett.127.180501.
  * Moskalenko et al. [2022] Ilya N. Moskalenko, Ilya A. Simakov, Nikolay N. Abramov, Alexander A. Grigorev, Dmitry O. Moskalev, Anastasiya A. Pishchimova, Nikita S. Smirnov, Evgeniy V. Zikiy, Ilya A. Rodionov, and Ilya S. Besedin.  High fidelity two-qubit gates on fluxoniums using a tunable coupler, 2022\.  URL https://arxiv.org/abs/2203.16302.
  * Peres [1985] Asher Peres.  Reversible logic and quantum computers.  _Phys. Rev. A_ , 32:3266–3276, Dec 1985.  doi: 10.1103/PhysRevA.32.3266.  URL https://link.aps.org/doi/10.1103/PhysRevA.32.3266.
  * Shor [1995] Peter W. Shor.  Scheme for reducing decoherence in quantum computer memory.  _Phys. Rev. A_ , 52:R2493–R2496, Oct 1995.  doi: 10.1103/PhysRevA.52.R2493.  URL https://link.aps.org/doi/10.1103/PhysRevA.52.R2493.
  * Calderbank and Shor [1996] A. R. Calderbank and Peter W. Shor.  Good quantum error-correcting codes exist.  _Physical Review A_ , 54(2):1098–1105, aug 1996\.  doi: 10.1103/physreva.54.1098.  URL https://doi.org/10.1103%2Fphysreva.54.1098.
  * Knill et al. [1996] Emanuel Knill, Raymond Laflamme, and Wojciech Zurek.  Threshold accuracy for quantum computation.  _arXiv:9610011_ , 1996\.
  * DiVincenzo and Shor [1996] David P. DiVincenzo and Peter W. Shor.  Fault-tolerant error correction with efficient quantum codes.  _Phys. Rev. Lett._ , 77:3260–3263, Oct 1996.  doi: 10.1103/PhysRevLett.77.3260.
  * Steane [1996] A. M. Steane.  Error correcting codes in quantum theory.  _Phys. Rev. Lett._ , 77:793–797, Jul 1996.  doi: 10.1103/PhysRevLett.77.793.
  * Gottesman [1998] Daniel Gottesman.  Theory of fault-tolerant quantum computation.  _Phys. Rev. A_ , 57:127–137, Jan 1998.  doi: 10.1103/PhysRevA.57.127.
  * Tomita and Svore [2014] Yu Tomita and Krysta M. Svore.  Low-distance surface codes under realistic quantum noise.  _Phys. Rev. A_ , 90:062320, Dec 2014.  doi: 10.1103/PhysRevA.90.062320.
  * Trout et al. [2018] Colin J Trout, Muyuan Li, Mauricio Gutiérrez, Yukai Wu, Sheng-Tao Wang, Luming Duan, and Kenneth R Brown.  Simulating the performance of a distance-3 surface code in a linear ion trap.  _New Journal of Physics_ , 20(4):043038, apr 2018\.  doi: 10.1088/1367-2630/aab341.  URL https://doi.org/10.1088/1367-2630/aab341.
  * Li et al. [2017a] Muyuan Li, Mauricio Gutiérrez, Stanley E. David, Alonzo Hernandez, and Kenneth R. Brown.  Fault tolerance with bare ancillary qubits for a [[7,1,3]] code.  _Physical Review A_ , 96(3), Sep 2017a.  ISSN 2469-9934.  doi: 10.1103/physreva.96.032341.  URL http://dx.doi.org/10.1103/PhysRevA.96.032341.
  * Bonilla Ataides et al. [2021] Juan Pablo Bonilla Ataides, David Tuckett, Stephen Bartlett, Steven Flammia, and Benjamin Brown.  The xzzx surface code.  _Nature Communications_ , 12, 04 2021.  doi: 10.1038/s41467-021-22274-1.
  * Bravyi et al. [2017] Sergey Bravyi, Matthias Englbrecht, Robert Koenig, and Nolan Peard.  Correcting coherent errors with surface codes.  _npj Quantum Information_ , 4, 10 2017.  doi: 10.1038/s41534-018-0106-y.
  * O’Brien et al. [2017] T. E. O’Brien, B. Tarasinski, and L. DiCarlo.  Density-matrix simulation of small surface codes under current and projected experimental noise.  _npj Quantum Information_ , 3(1), Sep 2017.  ISSN 2056-6387.  doi: 10.1038/s41534-017-0039-x.
  * Chamberland et al. [2022] Christopher Chamberland, Kyungjoo Noh, Patricio Arrangoiz-Arriola, Earl T. Campbell, Connor T. Hann, Joseph Iverson, Harald Putterman, Thomas C. Bohdanowicz, Steven T. Flammia, Andrew Keller, Gil Refael, John Preskill, Liang Jiang, Amir H. Safavi-Naeini, Oskar Painter, and Fernando G. S. L. Brandão.  Building a fault-tolerant quantum computer using concatenated cat codes.  _arXiv preprint arXiv:2012.04108_ , 2022.
  * Li et al. [2017b] Linshu Li, Chang-Ling Zou, Victor V. Albert, Sreraman Muralidharan, S. M. Girvin, and Liang Jiang.  Cat codes with optimal decoherence suppression for a lossy bosonic channel.  _Physical Review Letters_ , 119(3), Jul 2017b.  ISSN 1079-7114.  doi: 10.1103/physrevlett.119.030502.  URL http://dx.doi.org/10.1103/PhysRevLett.119.030502.
  * AI [2021] Google Quantum AI.  Exponential suppression of bit or phase flip errors with repetitive error correction.  _Nature_ , 595:383–387, 7 2021.  doi: 10.1038/s41586-021-03588-y.
  * AI [2022] Google Quantum AI.  Suppressing quantum errors by scaling a surface code logical qubit, 2022\.
  * Marques et al. [2021] JF Marques, BM Varbanov, MS Moreira, Hany Ali, Nandini Muthusubramanian, Christos Zachariadis, Francesco Battistel, Marc Beekman, Nadia Haider, Wouter Vlothuizen, et al.  Logical-qubit operations in an error-detecting surface code.  _arXiv preprint arXiv:2102.13071 (2021)_ , 2021.  doi: 10.21203/rs.3.rs-380732/v1.
  * Zhao et al. [2022] Youwei Zhao, Yangsen Ye, He-Liang Huang, Yiming Zhang, Dachao Wu, Huijie Guan, Qingling Zhu, Zuolin Wei, Tan He, Sirui Cao, Fusheng Chen, Tung-Hsun Chung, Hui Deng, Daojin Fan, Ming Gong, Cheng Guo, Shaojun Guo, Lianchen Han, Na Li, Shaowei Li, Yuan Li, Futian Liang, Jin Lin, Haoran Qian, Hao Rong, Hong Su, Lihua Sun, Shiyu Wang, Yulin Wu, Yu Xu, Chong Ying, Jiale Yu, Chen Zha, Kaili Zhang, Yong-Heng Huo, Chao-Yang Lu, Cheng-Zhi Peng, Xiaobo Zhu, and Jian-Wei Pan.  Realization of an error-correcting surface code with superconducting qubits.  _Phys. Rev. Lett._ , 129:030501, Jul 2022.  doi: 10.1103/PhysRevLett.129.030501.  URL https://link.aps.org/doi/10.1103/PhysRevLett.129.030501.
  * Andersen et al. [2020] Christian Kraglund Andersen, Ants Remm, Stefania Lazar, Sebastian Krinner, Nathan Lacroix, Graham J Norris, Mihai Gabureac, Christopher Eichler, and Andreas Wallraff.  Repeated quantum error detection in a surface code.  _Nature Physics_ , 16(8):875–880, 2020.  doi: 10.1038/s41567-020-0920-y.
  * 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.  _Phys. Rev. X_ , 11:041058, Dec 2021.  doi: 10.1103/PhysRevX.11.041058.  URL https://link.aps.org/doi/10.1103/PhysRevX.11.041058.
  * Nielsen and Chuang [2011] Michael A. Nielsen and Isaac L. Chuang.  _Quantum Computation and Quantum Information: 10th Anniversary Edition_.  Cambridge University Press, USA, 10th edition, 2011.  ISBN 1107002176.
  * Laflamme et al. [1996] Raymond Laflamme, Cesar Miquel, Juan Pablo Paz, and Wojciech Hubert Zurek.  Perfect quantum error correcting code.  _Phys. Rev. Lett._ , 77:198–201, Jul 1996.  doi: 10.1103/PhysRevLett.77.198.  URL https://link.aps.org/doi/10.1103/PhysRevLett.77.198.
  * Schuch and Siewert [2003] Norbert Schuch and Jens Siewert.  Natural two-qubit gate for quantum computation using the xy interaction.  _Physical Review A_ , 67(3):032301, 2003.  doi: 10.1103/PhysRevA.67.032301.
  * Simakov et al. [2022] I. A. Simakov, I. S. Besedin, and A. V. Ustinov.  Simulation of the five-qubit quantum error correction code on superconducting qubits.  _Phys. Rev. A_ , 105:032409, Mar 2022.  doi: 10.1103/PhysRevA.105.032409.  URL https://link.aps.org/doi/10.1103/PhysRevA.105.032409.
  * Antipov et al. [2022] A. V. Antipov, E. O. Kiktenko, and A. K. Fedorov.  Realizing a class of stabilizer quantum error correction codes using a single ancilla and circular connectivity, 2022.  URL https://arxiv.org/abs/2207.13356.
  * Xu et al. [2022] Qian Xu, Nam Mannucci, Alireza Seif, Aleksander Kubica, Steven T. Flammia, and Liang Jiang.  Tailored xzzx codes for biased noise, 2022.  URL https://arxiv.org/abs/2203.16486.
  * Kovalev and Pryadko [2012] Alexey A. Kovalev and Leonid P. Pryadko.  Improved quantum hypergraph-product LDPC codes.  In _2012 IEEE International Symposium on Information Theory Proceedings_. IEEE, jul 2012.  doi: 10.1109/isit.2012.6284206.  URL https://doi.org/10.1109%2Fisit.2012.6284206.
  * Srivastava et al. [2022] Basudha Srivastava, Anton Frisk Kockum, and Mats Granath.  The XYZ2 hexagonal stabilizer code.  _Quantum_ , 6:698, April 2022.  ISSN 2521-327X.  doi: 10.22331/q-2022-04-27-698.  URL https://doi.org/10.22331/q-2022-04-27-698.
  * Edmonds [1965] Jack Edmonds.  Paths, trees, and flowers.  _Canadian Journal of Mathematics_ , 17:449–467, 1965.  doi: 10.4153/CJM-1965-045-4.
  * Higgott [2021] Oscar Higgott.  Pymatching: A python package for decoding quantum codes with minimum-weight perfect matching, 2021.  URL https://arxiv.org/abs/2105.13082.
  * Krastanov and Jiang [2017] Stefan Krastanov and Liang Jiang.  Deep neural network probabilistic decoder for stabilizer codes.  _Scientific Reports_ , 7(1), sep 2017.  doi: 10.1038/s41598-017-11266-1.  URL https://doi.org/10.1038%2Fs41598-017-11266-1.
  * Bravyi et al. [2014] Sergey Bravyi, Martin Suchara, and Alexander Vargo.  Efficient algorithms for maximum likelihood decoding in the surface code.  _Phys. Rev. A_ , 90:032326, Sep 2014.  doi: 10.1103/PhysRevA.90.032326.  URL https://link.aps.org/doi/10.1103/PhysRevA.90.032326.