Quantum Error Correction: An Introductory Guide

TL;DR

This paper provides an introductory overview of quantum error correction, covering fundamental concepts, simple examples, and the surface code, emphasizing its importance for quantum computing development.

Contribution

It offers a beginner-friendly guide to quantum error correction codes, including construction, operation, and practical implementation issues, with a focus on the surface code.

Findings

Fundamental concepts explained with simple examples

Surface code described as the leading error correction protocol

Discussion of practical implementation challenges

Abstract

Quantum error correction protocols will play a central role in the realisation of quantum computing; the choice of error correction code will influence the full quantum computing stack, from the layout of qubits at the physical level to gate compilation strategies at the software level. As such, familiarity with quantum coding is an essential prerequisite for the understanding of current and future quantum computing architectures. In this review, we provide an introductory guide to the theory and implementation of quantum error correction codes. Where possible, fundamental concepts are described using the simplest examples of detection and correction codes, the working of which can be verified by hand. We outline the construction and operation of the surface code, the most widely pursued error correction protocol for experiment. Finally, we discuss issues that arise in the practical implementation of the surface code and other quantum error correction codes.

Equations

$$\mathcal{B}=\{0,1\}\stackrel{three-bitencoding}{\to }{C}_3=\{000,111\},$$

$$d=2t+1.$$

$$|\psi ⟩=\alpha |0⟩+\beta |1⟩,$$

$$|\psi ⟩=\cos \frac{\theta }{2}|0⟩+e^{i\varphi }\sin \frac{\theta }{2}|1⟩,$$

$$U(\delta \theta ,\delta \varphi )|\psi ⟩=\cos \frac{\theta +\delta \theta }{2}|0⟩+e^{i(\varphi +\delta \varphi )}\sin \frac{\theta +\delta \theta }{2}|1⟩,$$

$$\text{leavevmode}11=\left(\begin{array}{cc}1& 0\\ 0& 1\end{array}\right),X=\left(\begin{array}{cc}0& 1\\ 1& 0\end{array}\right),Y=\left(\begin{array}{cc}0& -\mathrm{i}\\ \mathrm{i}& 0\end{array}\right),Z=\left(\begin{array}{cc}1& 0\\ 0& -1\end{array}\right).$$

$$U(\delta \theta ,\delta \varphi )|\psi ⟩={\alpha }_I\text{leavevmode}11|\psi ⟩+{\alpha }_{X}X|\psi ⟩+{\alpha }_{Z}Z|\psi ⟩+{\alpha }_{Y}Y|\psi ⟩$$

$$U(\delta \theta ,\delta \varphi )|\psi ⟩={\alpha }_I\text{leavevmode}11|\psi ⟩+{\alpha }_{X}X|\psi ⟩+{\alpha }_{Z}Z|\psi ⟩+{\alpha }_{XZ}XZ|\psi ⟩.$$

$$X|\psi ⟩=\alpha X|0⟩+\beta X|1⟩=\alpha |1⟩+\beta |0⟩.$$

$$Z|\psi ⟩=\alpha Z|0⟩+\beta Z|1⟩=\alpha |0⟩-\beta |1⟩.$$

$$U_{\mathrm{clone}}(|\psi ⟩\otimes |0⟩)\to |\psi ⟩\otimes |\psi ⟩,$$

$$|\psi ⟩=\alpha |0⟩+\beta |1⟩\stackrel{\text{two-qubit encoder}}{\to }{|\psi ⟩}_L=\alpha |00⟩+\beta |11⟩=\alpha {|0⟩}_L+\beta {|1⟩}_L,$$

$${|\psi ⟩}_L=\alpha |00⟩+\beta |11⟩\ne |\psi ⟩\otimes |\psi ⟩.$$

$$|\psi ⟩\in {\mathcal{H}}_4=\text{span}\{|00⟩,|01⟩,|10⟩,|11⟩\}.$$

$${|\psi ⟩}_L\in \mathcal{C}=\mathrm{span}\{|00⟩,|11⟩\}\subset {\mathcal{H}}_4,$$

$$X_1{|\psi ⟩}_L=\alpha |10⟩+\beta |01⟩,$$

$$X_1{|\psi ⟩}_L\in \mathcal{F}\subset {\mathcal{H}}_4,$$

$$Z_1{Z}_2{|\psi ⟩}_L=Z_1{Z}_2(\alpha |00⟩+\beta |11⟩)=(+1){|\psi ⟩}_L.$$

$$E{|\psi ⟩}_L{|0⟩}_A\stackrel{\text{syndrome extraction}}{\to }\frac{1}{2}(\text{leavevmode}11_1\text{leavevmode}11_2+Z_1{Z}_2)E{|\psi ⟩}_L{|0⟩}_A+\frac{1}{2}(\text{leavevmode}11_1\text{leavevmode}11_2-Z_1{Z}_2)E{|\psi ⟩}_L{|1⟩}_A,$$

$$\mathcal{E}={\alpha }_I\text{leavevmode}11+{\alpha }_{X}X,$$

$$E={\mathcal{E}}_1\otimes {\mathcal{E}}_2={\alpha }_I^2\text{leavevmode}11_1\text{leavevmode}11_2+{\alpha }_I{\alpha }_X(X_1+X_2)+{\alpha }_X^2{X}_1{X}_2.$$

$$E{|\psi ⟩}_L{|0⟩}_A\stackrel{\text{syndrome extraction}}{\to }({\alpha }_I^2\text{leavevmode}11_1\text{leavevmode}11_2+{\alpha }_X^2{X}_1{X}_2){|\psi ⟩}_L{|0⟩}_A+{\alpha }_I{\alpha }_X(X_1+X_2){|\psi ⟩}_L{|1⟩}_A.$$

$$\frac{({\alpha }_I^2\text{leavevmode}11_1\text{leavevmode}11_2+{\alpha }_X^2{X}_1{X}_2)}{\sqrt{|{\alpha }_I^2{|}^2+|{\alpha }_X^2{|}^2}}{|\psi ⟩}_L{|0⟩}_A,$$

$$p_L={\left|\frac{{\alpha }_X^2}{\sqrt{|{\alpha }_I^2{|}^2+|{\alpha }_X^2{|}^2}}\right|}^2=\frac{p_x^2}{(1-p_x{)}^2+p_x^2}\approx p_x^2$$

$$\begin{array}{rl}& \mathcal{C}=\mathrm{span}\{|000⟩,|111⟩\},{\mathcal{F}}_1=\mathrm{span}\{|100⟩,|110⟩\},\\ & {\mathcal{F}}_2=\mathrm{span}\{|010⟩,|101⟩\},{\mathcal{F}}_3=\mathrm{span}\{|001⟩,|110⟩\},\end{array}$$

$$\bar{X}{|0⟩}_L={|1⟩}_L\mathrm{and}\bar{X}{|1⟩}_L={|0⟩}_L,$$

$$|+⟩=\frac{1}{\sqrt{2}}(|0⟩+|1⟩)\text{and}|-⟩=\frac{1}{\sqrt{2}}(|0⟩-|1⟩).$$

$${|+⟩}_L=\frac{1}{\sqrt{2}}(|000⟩+|111⟩)\text{and}{|-⟩}_L=\frac{1}{\sqrt{2}}(|000⟩-|111⟩).$$

$$E{|\psi ⟩}_L{|0⟩}_{A_i}\stackrel{\text{syndrome extraction}}{\to }\frac{1}{2}(\text{leavevmode}11^{\otimes n}+P_i)E{|\psi ⟩}_L{|0⟩}_{A_i}+\frac{1}{2}(\text{leavevmode}11^{\otimes n}-P_i)E{|\psi ⟩}_L{|1⟩}_{A_i}.$$

$$\mathcal{S}=\{P_i\in {\mathcal{G}}_n|P_i{|\psi ⟩}_L=(+1){|\psi ⟩}_L\forall {|\psi ⟩}_L\wedge [P_i,P_j]=0\forall (i,j)\}.$$

Full text

1 Introduction

In place of the bits in traditional computers, quantum computers work by controlling and manipulating quantum bits (qubits). Through the precise control of quantum phenomena such as entanglement, it is in principle possible for such qubit-based devices to outperform their classical counterparts. To this end, efficient quantum computing algorithms have been developed with applications such as integer factorisation [1], search [2], optimisation [3] and quantum chemistry [4].

There is currently no preferred qubit technology; a variety of physical systems are being explored for use as qubits, including photons [5, 6], trapped ions [7, 8, 9, 10], superconducting circuits [11, 12, 13] and spins in semiconductors [14, 15, 16]. A shortcoming shared by all of these approaches is that it is difficult to sufficiently isolate the qubits from the effects of external noise, meaning errors during quantum computation are inevitable. In contrast, bits in a classical computer are typically realised as the robust on/off states of transistor switches which are differentiated by billions of electrons. This provides classical bits with high error margins that near-eradicate failures at the physical level. For quantum computers, where qubits are realised as fragile quantum systems, there is no such security against errors. As such, any circuit-model quantum computer based on current and future qubit technologies will require some sort of active error correction.

Driven by the demands of high-performance communication networks and the Internet, there is a well-developed theory of classical error correction [17, 18, 19]. However, adapting existing classical methods for quantum error correction is not straightforward. Qubits are subject to the no-cloning theorem [20], meaning quantum information cannot be duplicated in the same way as classical information. Furthermore, it is not possible to perform arbitrary measurements on a qubit register due to the problem of wavefunction collapse. It was initially feared that these constraints would pose an insurmountable challenge to the viability of quantum computing. However, a breakthrough was reached in 1995 by Peter Shor with a paper proposing the first quantum error correction scheme [21]. Shor’s method demonstrated how quantum information can be redundantly encoded by entangling it across an expanded system of qubits. Subsequent results then demonstrated that extensions to this technique can in principle be used to arbitrarily suppress the quantum error rate, provided certain physical conditions on the qubits themselves are met [22, 23, 24, 25, 26]. It was with these developments in quantum error correction that the field of quantum computing moved from a theoretical curiosity to a practical possibility.

Many reviews have been written covering quantum error correction and its associated subfields [27, 28, 29, 30, 31, 32, 33]. This work is intended as an introductory guide where we describe the essential concepts behind quantum error correction codes through the use of simple examples. The ultimate aim is to provide the reader with sufficient background to understand the construction and operating principles behind the surface code, the most widely pursued error correction scheme for experimental implementation [34]. Crucially, our descriptions of the surface code do not rely upon terminology from topology and homology, as is the case with many of the original sources. Whilst this review does not require prior knowledge of coding theory or error correction, we do assume an understanding of elementary quantum mechanics and the circuit model of quantum computing. The reader should be comfortable with quantum circuit notation, as seen for example in [35], and be familiar with standard gates such as the Hadamard gate ($H$), the controlled-NOT gate (CNOT) and measurement operations in the computational basis. A brief outline of these gates, as well as the conventions we adopt for labelling quantum states and operators, can be found in appendices A-C.

In section 2, we begin by explaining the differences between bits and qubits, before describing the principal challenges in designing quantum error correction codes. Section 3 outlines how quantum information is redundantly encoded, and explains how errors can be detected by performing projective measurements. In section 4, we introduce the stabilizer framework which allows for the construction a large class of quantum error correction codes. Following this, the surface code is described in section 5. Finally, in section 6, we discuss some of the practical issues that arise when considering the implementation of quantum error correction codes on realistic hardware.

2 From classical to quantum error correction

Classical information technologies employ binary encodings in which data is represented as sequences of bits takings values ‘[math]’ or ‘$1$’. The basic principle behind error correction is that the number of bits used to encode a given amount of information is increased. The exact way in which this redundant encoding is achieved is specified by a set of instructions known as an error correction code [18, 19].

The simplest example of an error correction code is the three-bit repetition code, the encoder for which duplicates each bit value $0\rightarrow 000$ and $1\rightarrow 111$. More formally, we can define the three-bit encoder as a mapping from a ‘raw’ binary alphabet $\mathcal{B}$ to a code alphabet $C_{3}$

[TABLE]

where the encoded bit-strings ‘$000$’ and ‘$111$’ are referred to as the logical codewords of the code $C_{3}$. As an example, consider the simple case where we wish to communicate a single-bit message ‘[math]’ to a recipient in a different location. Using the three bit encoding, the message that we would send would be the ‘$000$’ codeword.

Now, imagine that the message is subject to a single bit-flip error during transmission so that the bit-string the recipient receives is ‘$010$’. In this scenario, the recipient will be able to infer that the intended codeword is ‘$000$’ via a majority vote. The same will be true for all cases where the codeword is subject to only a single error. However, if the codeword is subject to two bit-flip errors, the majority vote will lead to the incorrect codeword. The final scenario to consider is when all three bits are flipped so that the codeword ‘$000$’ becomes ‘$111$’. In this case, the corrupted message is also a codeword: the recipient will therefore have no way of knowing an error has occurred. The distance of a code is defined as the minimum number of errors that will change one codeword to another in this way. We can relate the distance $d$ of a code to the number of errors it can correct as follows

[TABLE]

where $t$ is the number of errors the code can correct. It is clear that the above equation is satisfied for the three-bit code where $t=1$ and $d=3$.

In general, error correction codes are described in terms of the $[n,k,d]$ notation, where $n$ is the total number of bits per codeword, $k$ is the number of encoded bits (the length of the original bit-string) and $d$ is the code distance. Under this notation, the three-bit repetition code is labelled $[3,1,3]$.

2.1 From bits to qubits

In place of bits in classical systems, the fundamental unit of quantum information is the qubit. The general qubit state can be written as follows

[TABLE]

where $\alpha$ and $\beta$ are complex numbers that satisfy the condition $|\alpha|^{2}+|\beta|^{2}=1$. Details regarding the notation we use to represent quantum states can be found in appendix A. Qubits can encode information in a superposition of their basis states, meaning quantum computers have access to a computational space that scales as $2^{n}$ where $n$ is the total number of qubits [35]. It is by exploiting superposition, in combination with other quantum effects such as entanglement, that it is possible to construct algorithms that provide a quantum advantage [1, 2]. However, if such algorithms are ever to be realised on current or future quantum hardware, it will be necessary for the qubits to be error corrected.

2.2 The digitisation of quantum errors

In classical information, bits are either in the ‘0’ or ‘1’ state. Therefore, the only error-type to be considered is the bit-flip that takes $0\rightarrow 1$ and vice-versa. In contrast, the general qubit state defined in equation (3) can assume a continuum of values between its basis states. From the perspective of developing error correction codes, this property is problematic as it means the qubit is subject to an infinite number of errors. To illustrate this more clearly, it is useful to rewrite the general qubit state in terms of a geometric representation given by

[TABLE]

where the probability amplitudes maintain the condition that $|\cos{\frac{\theta}{2}}|^{2}+|e^{i\phi}\sin{\frac{\theta}{2}}|^{2}=1$. In this form, the qubit state corresponds to a point, specified by the angles $\theta$ and $\phi$, on the surface of a so-called Bloch sphere. An example state in this representation is shown in figure 1.

Qubit errors can occur by a variety of physical processes. The simplest case to examine are errors which cause the qubit to coherently rotate from one point on the Bloch sphere to another. Such qubit errors could, for example, arise from systematic control faults in the hardware with which the qubits are realised. Mathematically, coherent errors are described by a unitary operation $U(\delta\theta,\delta\phi)$ which evolves the qubit state as follows

[TABLE]

where $\theta+\delta\theta$ and $\phi+\delta\phi$ are the new coordinates on the Bloch sphere. From this, we see that qubits are susceptible to a continuum of coherent errors obtained by varying the parameters $\delta\theta$ and $\delta\phi$. It would therefore seem, at first glance, that quantum error correction protocols should have to be based on techniques from classical analogue computation for which the theory of error correction is not well developed. Luckily, however, it turns out that quantum errors can be digitised so that the ability to correct for a finite set of errors is sufficient to correct for any error [36]. To see how this is possible, we first note that coherent noise processes are described by matrices that can be expanded terms of a Pauli basis.111For a more detailed definition of the Pauli group, and details of the Pauli notation used in this review, see appendix B. For example, the Pauli basis for two-dimensional matrices is given by

[TABLE]

The single-qubit coherent error process described in equation (5) can be expanded in the above basis as follows

[TABLE]

where $\alpha_{I,X,Y,Z}$ are the expansion coefficients. By noting that the Pauli $Y$-matrix is equivalent (up to a phase) to the product $XZ$, this expression can be further simplified to

[TABLE]

The above expression shows that any coherent error process can be decomposed into a sum from the Pauli set $\{\leavevmode\hbox{\small 1\normalsize\kern-3.30002pt1},X,Z,XZ\}$. In the following sections, we will see that the error correction process itself involves performing projective measurements that cause the above superposition to collapse to a subset of its terms. As a result, a quantum error correction code with the ability to correct errors described the by the $X$- and $Z$-Pauli matrices will be able to correct any coherent error. This effect, referred to as the digitisation of the error, is crucial to the success of quantum error correction codes.

2.3 Quantum error-types

As a result of the digitisation of the error there are two fundamental quantum error-types that need to be accounted for by quantum codes. Pauli $X$-type errors can be thought of as quantum bit-flips that map $X\ket{0}=\ket{1}$ and $X\ket{1}=\ket{0}$. The action of an $X$-error on the general qubit state is

[TABLE]

The second quantum error type, the $Z$-error, is often referred to as a phase-flip and has no classical analogue. Phase-flips map the qubit basis states $Z\ket{0}=\ket{0}$ and $Z\ket{1}=-\ket{1}$, and therefore have the following action on the general qubit state

[TABLE]

So far, for simplicity, I have restricted discussion to coherent errors acting on single-qubits. However, the digitisation of the error result generalises to arbitrary quantum error processes, including those that describe incoherent evolution of the quantum state as a result of the qubits’ interaction with their environment [36].

2.4 The challenges of quantum error correction

The digitisation of quantum errors means it is possible to reuse certain techniques from classical coding theory in quantum error correction. However, there remain a number of complications that prevent the straight-forward translation of classical codes to quantum codes. The first complication is the no-cloning theorem for quantum states [20], which asserts that it is not possible to construct a unitary operator $U_{\rm clone}$ which performs the following operation

[TABLE]

where $\ket{\psi}$ is the state to be cloned. In contrast, classical codes work under the assumption that data can be arbitrarily duplicated. For quantum coding, it is therefore necessary to find alternative ways of adding redundancy to the system.

The second complication in quantum coding arises from the fact that qubits are susceptible to both bit-flips ($X$-errors) and phase-flips ($Z$-errors). Quantum error correction codes must therefore be designed with the ability to detect both error-types simultaneously. In contrast, in classical coding, only bit-flip errors need to be considered.

The final complication specific to quantum error correction is the problem of wavefunction collapse. In a classical system, it is possible to measure arbitrary properties of the bit register without risk of compromising the encoded information. For quantum codes, however, any measurements of the qubits performed as part of the error correction procedure must be carefully chosen so as not to cause the wavefunction to collapse and erase the encoded information. In the next section, we will see how this is achieved through the use of a special type of projective measurement referred to as a stabilizer measurement [37].

3 Quantum redundancy & stabilizer measurement

As outlined in the previous section, quantum error correction is complicated by the no-cloning theorem, wavefunction collapse and the existence of a uniquely quantum error-type, the phase-flip. So, faced with these challenges, how is redundancy added to a quantum system to allow errors to be detected in real time? Classical repetition codes work by increasing the resources used to encode the data beyond the theoretical minimum. Analogously, in quantum codes redundancy is added by expanding the Hilbert space in which the qubits are encoded [21]. To see how this is achieved in practice, we now describe the two-qubit code, a prototypical quantum code designed to detect a single-bit flip error. The encode stage of the two-qubit code, acting on the general state $\ket{\psi}$, has the following action

[TABLE]

where after encoding the logical codewords are $\ket{0}_{L}=\ket{00}$ and $\ket{1}_{L}=\ket{11}$. Note that this does not correspond to cloning the state as

[TABLE]

The effect of the encoding operation is to distribute the quantum information in the initial state $\ket{\psi}$ across the entangled two-party logical state $\ket{\psi}_{L}$. This introduces redundancy to the encoding that can be exploited for error detection. To understand exactly how this works, it is instructive to consider the computational Hilbert spaces before and after encoding. Prior to encoding, the single qubit is parametrised within a two-dimensional Hilbert space $\ket{\psi}\in\mathcal{H}_{2}=\text{span}\{\ket{0},\ket{1}\}$. After encoding the logical qubit occupies a four-dimensional Hilbert space

[TABLE]

More specifically the logical qubit is defined within a two-dimensional subspace of this expanded Hilbert space

[TABLE]

where $\mathcal{C}$ is called the codespace. Now, imagine that the logical qubit is subject a bit-flip error on the first qubit resulting in the state

[TABLE]

where $X_{1}$ is a bit-flip error acting on the first qubit. The resultant state is rotated into a new subspace

[TABLE]

where we call $\mathcal{F}$ the error subspace. Notice that an $X_{2}$-error will also rotate the logical state into the $\mathcal{F}$ subspace. If the logical state $\ket{\psi}_{L}$ is uncorrupted, it occupies the codespace $\mathcal{C}$, whereas if it has been subject to a single-qubit bit-flip, it occupies the error space $\mathcal{F}$. As the $\mathcal{C}$ and $\mathcal{F}$ subspaces are mutually orthogonal, it is possible to distinguish which subspace the logical qubit occupies via a projective measurement without compromising the encoded quantum information. In the context of quantum coding, measurements of this type are called stabilizer measurements.

For the purposes of differentiating between the codespace $\mathcal{C}$ and the error space $\mathcal{F}$, a projective measurement of the form $Z_{1}Z_{2}$ is performed. The $Z_{1}Z_{2}$ operator yields a $(+1)$ eigenvalue when applied to the logical state

[TABLE]

The $Z_{1}Z_{2}$ operator is said to stabilize the logical qubit $\ket{\psi}_{L}$ as it leaves it unchanged [28]. Conversely, the $Z_{1}Z_{2}$ operator projects the errored states, $X_{1}\ket{\psi}_{L}$ and $X_{2}\ket{\psi}_{L}$, onto the $(-1)$ eigenspace. Notice that for either outcome, the information encoded in the $\alpha$ and $\beta$ coefficients of the logical state remains undisturbed.

Figure 2 shows the circuit implementation of the two-qubit code. In the encode stage, a CNOT gate is used to entangle the $\ket{\psi}$ state with a redundancy qubit to create the logical state $\ket{\psi}_{L}$. Following this, we assume the logical qubit is subject to a bit-flip error $E$, applied during the stage of the circuit labelled ‘E’. Following the error stage, an ancilla qubit $\ket{0}_{A}$ is introduced to perform the measurement of the $Z_{1}Z_{2}$ stabilizer. The syndrome extraction stage of the circuit transforms the quantum state as follows

[TABLE]

where $E$ is an error from the set $\{\leavevmode\hbox{\small 1\normalsize\kern-3.30002pt1},X_{1},X_{2},X_{1}X_{2}\}$. Now, consider the case where $E=X_{1}$ so that the logical state occupies the error space $E\ket{\psi}_{L}\in\mathcal{F}$. In this scenario, it can be seen that the first term in equation (19) goes to zero. The ancilla qubit is therefore measured deterministically as ‘1’. Considering the other error patterns, we see that if the logical state is in the codespace (i.e., if $E=\{\leavevmode\hbox{\small 1\normalsize\kern-3.30002pt1},X_{1}X_{2}\}$) then the ancilla is measured as ‘0’. Likewise, if the logical state is in the error subspace (i.e., if $E=\{X_{1},X_{2}\}$) then the ancilla is measured as ‘1’. The outcome of the ancilla qubit measurement is referred to as a syndrome, and tells us whether or not the logical state has been subject to an error. The syndromes for all bit-flip error types in the two-qubit code are shown in table 3.

Up to this point, we have assumed that the error introduced by the circuit element labelled ‘$E$’ is deterministic. We now demonstrate how the two qubit code works under a more general probabilistic error of the type discussed in section 2.2. For the purposes of this example, we will assume that each qubit in the two-qubit code is subject to a coherent error of the form

[TABLE]

where $|\alpha_{I}|^{2}+|\alpha_{X}|^{2}=1$. Here we see that $|\alpha_{X}|^{2}=p_{X}$ is the probability of an $X$-error occurring on the qubit. The probability of no-error occurring is therefore equal to $|\alpha_{I}|^{2}=1-p_{X}$. The combined action of the error operator $\mathcal{E}$ acting on both qubits is given by

[TABLE]

With the above error operator $E$, the syndrome extraction stage in figure 2 stage transforms the quantum state as follows

[TABLE]

If the syndrome is measured as ‘[math]’, the state collapses to a subset of its terms

[TABLE]

where the the denominator ensures normalisation. By calculating the square-norm in the first term in the above, we can calculate the probability $p_{L}$ that the logical state is subject to an error

[TABLE]

where the above approximation is made under the assumption that $p_{x}$ is small. For the single qubit $\ket{\psi}$, the probability of error is $p_{x}$ when it is subject to the error operator $\mathcal{E}$. For the logical qubit $\ket{\psi}_{L}$ subject to the error operator $\mathcal{E}_{1}\otimes\mathcal{E}_{2}$, the logical error rate is $p_{L}=p_{x}^{2}$. From this, we see that the two-qubit code suppresses the error rate relative to the un-encoded case.

3.1 The three-qubit error correction code

The syndrome produced by the two-qubit code informs us of the presence of an error, but does not provide enough information to allow us to infer which qubit the error occurred on. It is therefore a detection code. In order to create an error correction code with the ability to both detect and localise errors, multiple stabilizer measurements need to be performed.

We now describe the three-qubit code, the natural extension of the two-qubit code in which the encoding operation distributes the quantum information across an entangled three-party state to give a logical state of the form $\ket{\psi}_{L}=\alpha\ket{000}+\beta\ket{111}$. This logical state occupies an eight-dimensional Hilbert space that can be partitioned into four two-dimensional subspaces as follows

[TABLE]

where $\mathcal{C}$ is the logical code space, and $\mathcal{F}_{\{1,2,3\}}$ are the logical error spaces. We see that each single-qubit error from the set $E=\{X_{1},X_{2},X_{3}\}$ will rotate the codespace to a unique error space so that $X_{i}\ket{\psi}_{L}\in\mathcal{F}_{i}$. In order to differentiate between these subspaces, we perform two stabilizer measurements $Z_{1}Z_{2}$ and $Z_{2}Z_{3}$ via the circuit shown in figure 3. The resultant syndrome table for single-qubit errors is given in table 3.2. From this we see that each single-qubit error produces a unique two-bit syndrome $S=s_{1}s_{2}$, enabling us to choose a suitable recovery operation.

3.2 Quantum code distance

As is the case for classical codes, the distance of a quantum code is defined as the minimum size error that will go undetected. Alternatively, this minimum size error can be viewed as a logical Pauli operator that transforms one codeword state to another. For the three-qubit code described in section 3.1, we see that the logical Pauli-$X$ operator is given by $\bar{X}=X_{1}X_{2}X_{3}$, so that

[TABLE]

where $\ket{0}_{L}=\ket{000}$ and $\ket{1}_{L}=\ket{111}$ are the logical codewords for the three-qubit code. If it were the case that qubits were only susceptible to $X$-errors, then the three-qubit code would have distance $d=3$. However, as qubits are also susceptible to phase-flip errors, it is also necessary to consider the logical Pauli-$Z$ operator $\bar{Z}$ when determining the code distance. To do this, it is useful to switch from the computational basis, $\{\ket{0},\ket{1}\}$, to the conjugate basis, $\{\ket{+},\ket{-}\}$, where we define

[TABLE]

A $Z$-error maps the conjugate basis states as follows $Z\ket{+}=\ket{-}$ and $Z\ket{-}=\ket{+}$. Now, encoding the conjugate basis states with the three-qubit code gives the logical states

[TABLE]

A weight-one logical Pauli-Z operator $\bar{Z}=Z_{1}$ will transform $Z\ket{+}_{L}=\ket{-}_{L}$, meaning the code is unable to detect the presence of single-qubit $Z$-errors. As a result, the three-qubit code has a quantum distance $d=1$. In the next section, we outline the construction of general stabilizer codes capable of detecting both $X$- and $Z$-errors.

4 Stabilizer codes

The three-qubit code works by de-localising the information in a single-qubit across three qubits. The resultant logical state is then encoded in a two-dimensional subspace (the codespace) of the expanded Hilbert space. The three-qubit code is designed such that if an $X$-error occurs, the logical state is rotated to an orthogonal error space, an event that can be detected via a sequence of two stabilizer measurements. This section describes how the procedure to can be generalised to create $[[n,k,d]]$ stabilizer codes, where $n$ is the total number of qubits, $k$ is the number of logical qubits and $d$ is the code distance. Note the use of double brackets to differentiate quantum codes from classical codes which are labelled with single brackets.

The circuit in figure 4 shows the basic structure of an $[[n,k,d]]$ stabilizer code. A register of $k$ data qubits, $\ket{\psi}_{D}$, is entangled with $m=n-k$ redundancy qubits $\ket{0}_{R}$ via an encoding operation to create a logical qubit $\ket{\psi}_{L}$. At this stage, the data previously stored solely in $\ket{\psi}_{D}$ is distributed across the expanded Hilbert space. Errors can then be detected by performing $m$ stabilizer measurements $P_{i}$ as shown to the right of figure 4.

In the circuit in figure 4, each of the stabilizers is measured using the same syndrome extraction method that was used for the two-qubit code in figure 2. For each stabilizer $P_{i}$, the syndrome extraction circuit maps the logical state as follows

[TABLE]

From the above, we see that if the stabilizer $P_{i}$ commutes with an error $E$ the measurement of ancilla qubit $A_{i}$ returns ‘0’. If the stabilizer $P_{i}$ anti-commutes with an error $E$ the measurement returns ‘1’. The task of constructing a good code therefore involves finding stabilizers that anti-commute with the errors to be detected. In general, two Pauli operators will commute with one another if they intersect non-trivially on an even number of qubits, and anti-commute if otherwise. For specific examples of Pauli commutation relations, see appendix D.

The results of the $m$ stabilizer measurements are combined to give an $m$-bit syndrome. For a well designed code, the syndrome allows us to deduce the best recovery operation to restore the logical state to the codespace.

4.1 Properties of the code stabilizers

The stabilizers $P_{i}$ of an $[[n,k,d]]$ code must satisfy the following properties:

They must be Pauli-group elements, $P_{i}\in\mathcal{G}_{n}$. Here $\mathcal{G}_{n}$ is the Pauli Group over $n$-qubits (see appendix B for the definition of the Pauli Group). 2. 2.

They must stabilize all logical states $\ket{\psi}_{L}$ of the code. This means that each $P_{i}$ has the action $P_{i}\ket{\psi}_{L}=(+1)$ for all possible values of $\ket{\psi}_{L}$. 3. 3.

All the stabilizers of a code must commute with one another, so that $[P_{i},P_{j}]=0$ for all $i$ and $j$. This property is necessary so that the stabilizers can be measured simultaneously (or in a way independent of their ordering) as depicted in figure 4.

In the language of group theory, the stabilizers $P_{i}$ of an $[[n,k,d]]$ code form an Abelian subgroup $\mathcal{S}$ of the Pauli Group. The stabilizer requirements listed above are incorporated into the definition of $\mathcal{S}$ as follows

[TABLE]

An important point to note is that any product of the stabilizers $P_{i}P_{j}$ will also be a stabilizer as $P_{i}P_{j}\ket{\psi}_{L}=P_{i}(+1)\ket{\psi}_{L}=(+1)\ket{\psi}_{L}$. Given this, it is import to ensure that the set of $m=n-k$ stabilizers that are actually measured in the syndrome extraction process form a minimal set of the stabilizer group

[TABLE]

In a minimal set it is not possible to obtain one stabilizer $G_{i}$ as a product of any of the other elements $G_{j}$. As a simple example, consider the following set of stabilizers for the three-qubit code $\mathcal{S}=\{Z_{1}Z_{2},Z_{2}Z_{3},Z_{1}Z_{3}\}$. This is not a minimal set, as it is possible to obtain the third stabilizer as a product of the first two. A possible minimal set is $S=\langle Z_{1}Z_{2},Z_{2}Z_{3}\rangle$, which are the two stabilizers measured in the example in section 3.1.

4.2 The logical operators of stabilizer codes

An $[[n,k,d]]$ stabilizer code has $2k$ logical Pauli operators that allow for logical states to be modified without having to decode then re-encode. For each logical qubit $i$, there is a logical Pauli-$X$ operator $\bar{X}_{i}$ and a logical Pauli-$Z$ operator $\bar{Z}_{i}$. Each pair of logical operators, $\bar{X}_{i}$ and $\bar{Z}_{i}$, satisfy the following properties

They commute with all the code stabilizers in $\mathcal{S}$. 2. 2.

They anti-commute with one another, so that $[\bar{X}_{i},\bar{Z}_{i}]_{+}=\bar{X}_{i}\bar{Z}_{i}+\bar{Z}_{i}\bar{X}_{i}=0$ for all qubits $i$.

Any product of a logical operator $\bar{L}_{i}$ and stabilizer $P_{j}$ will also be a logical operator. This is clear from the fact that the stabilizer maps the logical state onto its $(+1)$ eigenspace. Any product $\bar{L_{i}}P_{j}$ therefore has the following action on the logical state $\bar{L}_{i}P_{j}\ket{\psi}_{L}=\bar{L}_{i}\ket{\psi}_{L}$.

4.3 Example: The [[4,2,2]] detection code

The $[[4,2,2]]$ detection code is the smallest stabilizer code to offer protection against a quantum noise model in which the qubits are susceptible to both $X$- and $Z$-errors [38, 39]. As such, it provides a useful demonstration of the structure and properties of a stabilizer code.

An encoder for the $[[4,2,2]]$ code is shown in figure 5. A two-qubit register $\ket{\psi}_{1}\ket{\psi}_{2}$ is entangled across four qubits to give the code state $\ket{\psi_{1}\psi_{2}}_{L}$. As there are two encoded logical qubits in the $[[4,2,2]]$ code, its codespace is four-dimensional and is spanned by

[TABLE]

The stabilizers of the above logical basis states are $\mathcal{S}_{[[4,2,2]]}=\langle X_{1}X_{2}X_{3}X_{4},Z_{1}Z_{2}Z_{3}Z_{4}\rangle$. It is clear that these stabilizers commute with one another, as required by the definition in equation (30). These stabilizers can be measured using the syndrome extraction circuit shown to the right of figure 5. From equation (29), we know that for a syndrome measurement to be non-zero, the error $E$ has to anti-commute with the stabilizer being measured. Considering first the single-qubit $X$-errors ($E=\{X_{1},X_{2},X_{3},X_{4}\}$), we see that they all anti-commute with the $Z_{1}Z_{2}Z_{3}Z_{4}$ stabilizer. Likewise, the single-qubit $Z$-errors $(E=\{Z_{1},Z_{2},Z_{3},Z_{4}\}$) anti-commute with the $X_{1}X_{2}X_{3}X_{4}$ stabilizer. Any single-qubit error on the $[[4,2,2]]$ code will therefore trigger a non-zero syndrome. The syndrome table for all single-qubit errors in the $[[4,2,2]]$ code is shown in table 4.3. For completeness, table 4.3 also includes the syndromes for single-qubit $Y$-errors, which are equivalent to the simultaneous occurrence of an $X$- and $Z$-error.

The $[[4,2,2]]$ code has Pauli-$X$ and Pauli-$Z$ logical operators for each of its encoded logical qubits. A possible choice of these logical operators is given by

[TABLE]

Each logical operators commutes with the two stabilizers of the code so that $\left[L_{i},P_{i}\right]=0$ for all $L_{i}\in\mathcal{L}_{[[4,2,2]]}$ and $P_{i}\in\mathcal{S}$. Furthermore, it can be checked that the requirement $\left[\bar{X}_{i},\bar{Z}_{i}\right]_{+}=0$ is satisfied for each pair of logical operators. The minimum weight logical operator in $\mathcal{L}_{[[4,2,2]]}$ is two, which sets the code distance to $d=2$. As the distance of the $[[4,2,2]]$ code is less than three, it is a detection code rather than a full correction code. In section 4.6, we introduce the Shor $[[9,1,3]]$ code as an example of a code capable of both detecting and correcting errors.

4.4 A general encoding circuit for stabilizer codes

The quantum codes presented this review have included bespoke encoding circuits to prepare the logical states. Special methods exist for constructing such circuits given a set of stabilizers [40, 41]. In this section we describe a general method for preparing the logical states of stabilizer code using the same circuits that are used for syndrome extraction.

The $\ket{0}_{L}$ codeword of any $[[n,k,d]]$ stabilizer can be obtained via a projection onto the $(+1)$ eigenspace of all of its stabilizers

[TABLE]

where $\langle\mathcal{S}\rangle$ is the minimal set of the code stabilizers and the $1/N$ term is a factor that ensures normalisation. For example, the $\ket{00}_{L}$ codeword of the four-qubit code defined in section 4.3 is given by

[TABLE]

The remaining codewords of the code can be obtained by applying logical operators to the $\ket{0}_{L}$ codeword.

The $\ket{0}_{L}$ codeword of any stabilizer code can be prepared via the projection in equation (34) by applying the general syndrome extraction circuit (shown on the right-hand-side of figure 4) to a $\ket{0}^{\otimes n}$ state. As an example, consider the case where we apply the syndrome extraction circuit to the state $\ket{0}^{\otimes 4}$ to prepare the $\ket{0}_{L}$ codeword of the four-qubit code. The intermediary state immediately after the extraction of the $X_{1}X_{2}X_{3}X_{4}$ stabilizer is given by

[TABLE]

When the ancilla is measured, the above state collapses to either the $(+1)$ or $(-1)$ projection with equal probability. In the case where the ‘$1$’ syndrome is measured, a correction needs to be applied to transform the state back onto the $(+1)$ eigenspace of the stabilizer. Repeating this procedure for the remaining stabilizers leads to the preparation of the $\ket{0}_{L}$ codeword.

4.5 Quantum error correction with stabilizer codes

As is the case for classical codes, the distance of a quantum code is related to the number of correctable errors $t$ via the relation $d=2t+1$. As a result, stabilizer codes with $d\geq 3$ are error correction codes for which active recovery operations can be applied. In contrast, detection protocols such as the $[[4,2,2]]$ code require a repeat-until-success approach.

Figure 6 shows the general error correction procedure for a single cycle of an $[[n,k,d\geq 3]]$ stabilizer code. The encoded logical state $\ket{\psi}_{L}$ is subject to an error process described by the circuit-element $E$. Next, the code stabilizers are measured (using the syndrome extraction method illustrated in figure 4), and the results copied to a register of $m=n-k$ ancilla qubits $\ket{A}^{\otimes m}$. The ancilla qubits are then read out to give an $m$-bit syndrome $S$.

The next step in the error correction procedure is referred to as decoding, and involves processing the syndrome to determine the best unitary operation $\mathcal{R}$ to return the logical state to the codespace. After this recovery operation has been applied, the output of the code-cycle is given by $\mathcal{R}E\ket{\psi}_{L}\in\mathcal{C}_{[[n,k,d]]}$. The decoding step is a success if the combined action of $\mathcal{R}E$ on the code state is as follows

[TABLE]

The above condition is trivially satisfied if $\mathcal{R}=E^{\dagger}$ so that $\mathcal{R}E=\leavevmode\hbox{\small 1\normalsize\kern-3.30002pt1}$. However, this is not the only solution. Equation (37) is also satisfied for any product $\mathcal{R}E$ that is an element of the code stabilizer such that $\mathcal{R}E=P\in\mathcal{S}$. In section 4.6, we will see that the fact that the solution for $\mathcal{R}$ is not unique means it is possible to design degenerate quantum codes for which multiple errors can map to the same syndrome.

The decoding step fails if the recovery operation maps the code state as follows

[TABLE]

where $L$ is a logical operator of the code. In this case, the state is returned to the codespace, but the recovery operation leads to a change in the encoded information.

4.6 Example: The Shor [[9,1,3]] code

The Shor nine-qubit code was the first quantum error correction scheme to be proposed. It is an example of a distance-three degenerate code for which it is possible to apply a successful recovery operation for any single-qubit error [21]. We now outline how the Shor code can be constructed via a method known as code concatenation.

Code concatenation involves embedding the output of one code into the input of another. In the construction of the Shor nine-qubit code, the two codes that are concatenated are the three-qubit code for bit-flips and the three-qubit code for phase-flips [32]. The three-qubit code for bit-flips $\mathcal{C}_{\rm 3b}$ was described in section 3.1 and is defined as follows

[TABLE]

where $\mathcal{S}_{\rm 3b}$ are the code stabilizers. Similarly, the three-qubit code for phase-flips $\mathcal{C}_{\rm 3p}$ is defined

[TABLE]

To construct the nine-qubit code, the bit-flip code is embedded into the codewords of the phase-flip code. This concatenation maps the $\ket{0}_{\rm 3p}$ codeword of the phase-flip code to a nine-qubit codeword $\ket{0}_{9}$ as follows

[TABLE]

where $\ket{+}_{\rm 3b}=\dfrac{1}{\sqrt{2}}(\ket{000}+\ket{111})$ is a logical state of the bit-flip code. Similarly, the concatenation maps the $\ket{1}_{\rm 3p}$ codeword of the phase-flip code to

[TABLE]

where $\ket{-}_{\rm 3b}=\dfrac{1}{\sqrt{2}}(\ket{000}-\ket{111})$. The code defined by the codewords $\ket{0}_{9}$ and $\ket{1}_{9}$ is the nine-qubit Shor code with paramaters $[[9,1,3]]$. Rewriting the right-hand-sides of Equations 41 and 42 in the computational basis, we get the following codespace for the Shor code

[TABLE]

The stabilizers of the above code are given by

[TABLE]

The first six terms are the stabilizers of the bit-flip codes in the three-blocks of the code. The final two stabilizers derive from the stabilizers of the phase-flip code.

Table 4.6 shows the syndromes for all single-qubit errors in the nine-qubit code. Each of the $X$-errors produce unique syndromes. In contrast, $Z$-errors that occur in the same block of the code have the same syndrome. Fortunately, this degeneracy in the code syndromes does not reduce the code distance. To see why this is the case, consider the single-qubit errors $Z_{1}$ and $Z_{2}$, both of which map to the syndrome ‘$00000010$’. The decoder therefore has insufficient information to differentiate between the two errors, and will output the same recovery operation for either. For the purposes of this example, we will assume that the recovery operation the decoder outputs is $\mathcal{R}=Z_{1}$. For the case where the error is $E=Z_{1}$, the recovery operation trivially restores the logical state as $\mathcal{R}E\ket{\psi}_{9}=Z_{1}Z_{1}\ket{\psi}_{9}=\ket{\psi}_{9}$. In the event where $E=Z_{2}$, the recovery operation still restores the logical state as $\mathcal{R}E=Z_{1}Z_{2}$ is in the stabilizer of $\mathcal{C}_{[[9,1,3]]}$, and therefore acts on the logical state as follows $Z_{1}Z_{2}\ket{\psi}_{9}=\ket{\psi}_{9}$. The same arguments can be applied to the remaining degenerate errors of the code. As a result, the nine-qubit code has the ability to correct all single-qubit errors and has distance $d=3$.

5 The surface code

The challenge in creating quantum error correction codes lies in finding commuting sets of stabilizers that enable errors to be detected without disturbing the encoded information. Finding such sets is non-trivial, and special code constructions are required to find stabilizers with the desired properties. In section 4.6 we saw how a code can be constructed by concatenating two smaller codes. Other constructions include methods for repurposing classical codes to obtain commuting stabilizer checks [42, 43, 44, 45]. In this section, we outline a construction known as the surface code [46, 47].

The realisation of a surface code logical qubit is key goal for many quantum computing hardware efforts [48, 49, 50, 51, 52]. Surface codes belong to a broader family of so-called topological codes [53]. The general design principle behind topological codes is that the code is built up by ‘patching’ together repeated elements. We will see that this modular approach ensures that the surface code can be straight-forwardly scaled in size whilst ensuring stabilizer commutativity. In terms of actual implementation, the specific advantage of surface code for current hardware platforms is that it requires only nearest-neighbour interactions. This is advantageous as many quantum computing platforms are unable to perform high-fidelity long-range interactions between qubits.

5.1 The surface code four-cycle

For surface codes it is beneficial to adopt a pictorial representation of the code qubits in place of the circuit notation we have used up to this point. Figure 7a shows a surface code four-cycle, the fundamental building block around which surface codes are constructed. The circles in figure 7a represent the code qubits and the squares the ancilla qubits. The red edges represent controlled-$X$ gates, each controlled on an ancilla qubit $A$ and acting on a data qubit $D$. Likewise, the blue edges represent controlled-$Z$ operations, each controlled by an an ancilla qubit and acting on a data qubit. These controlled operations are the gates with which the stabilizers of the four-cycle are measured. Ancilla qubit $A_{1}$ connects to data qubits $D_{1}$ and $D_{2}$ via red edges, and therefore measures the stabilizer $X_{D_{1}}X_{D_{2}}$. Likewise, ancilla qubit $A_{2}$ measures the stabilizer $Z_{D_{1}}Z_{D_{2}}$. For comparison, the four-cycle is shown in quantum circuit notation in figure 7b.

The stabilizers of the four-cycle, $X_{D_{1}}X_{D_{2}}$ and $Z_{D_{1}}Z_{D_{2}}$, commute with one another as they intersect non-trivially on an even number of code qubits. This can easily be verified by inspection of figure 7b.

The $\ket{0}_{L}$ codeword of the four-cycle can be prepared by setting the initial state of the code qubits to $\ket{D_{1}D_{2}}=\ket{00}$, and following the general encoding procedure outlined in section 4.4. However, as the four-cycle has two code qubits $n=2$ and two stabilizers $m=2$, the number of logical qubits it encodes is equal to $k=n-m=0$. As a result, the four-cycle is not in itself a useful code. However, we will see that working detection and correction codes can be formed by tiling together multiple four-cycles to form square lattices.

5.2 The $[[5,1,2]]$ surface code

Figure 8a shows the five-qubit surface code formed by tiling together four four-cycles in a square lattice [54]. By inspecting which data qubits each ancilla qubit connects to, the stabilizers of the code in figure 8 can be read off to give

[TABLE]

The first term in the above is the stabilizer measured by ancilla qubit $A_{1}$, the second by ancilla $A_{2}$ etc. The stabilizers in $\mathcal{S}_{\rm[[5,1,2]]}$ commute with one another, as the $X$- and $Z$-type stabilizers all intersect on an even number of code qubits. From figure 8, we see that there are five code qubits and four stabilizers meaning the code encodes one logical qubit.

Figure 7b shows two examples of errors on the surface code and how they are detected. The $Z_{D_{1}}$-error on qubit $D_{1}$ anti-commutes with the $X_{D_{1}}X_{D_{2}}X_{D_{3}}$ stabilizer, and therefore triggers a ‘1’ syndrome. This is depicted by the red filling in the ancilla qubit $A_{1}$. Likewise, the $X_{D_{5}}$-error anti-commutes with the $Z_{D_{2}}Z_{D_{3}}Z_{D_{5}}$ stabilizer and triggers a ‘1’ syndrome measurement in ancilla qubit $A_{4}$.

From figure 7 it can be seen that the surface code is a square lattice with two types of boundaries. The vertical boundaries are formed of blue edges representing $Z$-type stabilizer measurements. The horizontal boundaries are formed of red-edges representing $X$-type stabilizer measurements. The logical operators of the surface code can be defined as chains of Pauli operators along the edges of these boundaries.

Figure 9a shows a two-qubit Pauli chain $X_{D_{1}}X_{D_{4}}$ along the left-hand boundary of the five-qubit surface code. The $X_{D_{1}}X_{D_{4}}$ operator commutes with all the stabilizers in $\mathcal{S}_{[[5,1,2]]}$, in particular the stabilizer $Z_{D_{1}}Z_{D_{3}}Z_{D_{4}}$ with which is shares two qubits. Similarly, figure 9b shows an operator $Z_{D_{1}}Z_{D_{2}}$ which acts across the top of the lattice. It can easily be checked that this operator also commutes with all the code stabilizers. Finally, we note that the operators $X_{D_{1}}X_{D_{4}}$ and $Z_{D_{1}}Z_{D_{2}}$ anti-commute. As outlined in section 4.2, the Pauli-$X$ and Pauli-$Z$ logical operators for each encoded qubit are pairs of operators that commute with all the code stabilizers but anti-commute with one another. A suitable choice for the logical operators of the $[[5,1,2]]$ surface code would therefore be

[TABLE]

From the above we see that the minimum weight of the logical operators is $2$, meaning the $[[5,1,2]]$ code is a detection code with $d=2$.

5.3 Scaling the surface code

The distance of a surface code can be increased simply by scaling the size of lattice. In general, a surface code with distance $d=\lambda$ will encode a single logical qubit and have code parameters given by

[TABLE]

For example, the distance-three $[[13,1,3]]$ surface code is depicted in figure 10. The Pauli-$X$ logical operator of a surface code can be defined as a chain of $X$-Pauli operators along the boundary of the code along which the $Z$-stabilizers are applied (the blue boundary in our pictorial representation). Likewise, the $Z$-Pauli logical operator can be defined as a chain of $Z$-operators across the adjacent boundary along which the $X$-type stabilizers are applied (the red edges in our pictorial representation). For the distance-three code, a choice of logical operators would be $\bar{X}=X_{D_{1}}X_{D_{6}}X_{D_{11}}$ and $\bar{Z}=Z_{D_{1}}Z_{D_{2}}Z_{D_{3}}$. The $[[13,1,3]]$ code is the smallest surface code capable of detecting and correcting errors.

6 Practical considerations for quantum error correction

Up to this point, we have described stabilizer codes in an idealised, theoretical setting. In this section, we outline some of the practical issues that arise when considering the implementation of quantum error correction codes on actual hardware.

6.1 Efficient decoding algorithms

Given a code syndrome $S$, the role of the decoder is to find the best recovery operation $\mathcal{R}$ to restore the encoded quantum information to the codespace. Measuring the stabilizers of an $[[n,k,d]]$ code will produce an $m$-bit syndrome where $m=n-k$. As a result, there are $2^{m}$ possible syndromes for each code. For the small code examples described in this review, it is possible to compute lookup-tables that exhaustively list the best recovery operation for each of the $2^{m}$ syndromes. However, such a decoding strategy rapidly becomes impractical as the code size is increased. As an example, consider the distance-five surface code which has parameters $[[41,1,5]]$. This code produces syndromes of length $m=40$, and would therefore need a lookup table of size $2^{40}\approx 10^{12}$.

In place of lookup tables, large-scale quantum error correction codes use approximate inference techniques to determine the most likely error to have occurred given a certain syndrome $S$. Such methods allow for recovery operations to be chosen and applied in real-time between successive stabilizer code cycles. Unfortunately, there is no known universal decoder that can be efficiently applied to all quantum error correction codes. Instead, bespoke decoding algorithms need to be developed that are designed for specific code constructions. For surface codes, a technique known as minimum weight perfect matching (MWPM) can be used for decoding, which works by identifying error chains between positive syndrome measurements [55, 56].

As outlined in section 4.5, the decode stage of an error correction cycle fails when $\mathcal{R}E=L$, where $\mathcal{R}$ is the recovery operation output by the decoder, $E$ is the error and $L$ is a logical operator of the code. The frequency with which the decoder fails in this way gives a logical error rate $p_{L}$. As decoding algorithms are based on approximate inference techniques, some perform better than others. As such, the logical error rate of a quantum error correction code will depend heavily on the decoder used. The logical error rate can be determined by simulating stabilizer code cycles with errors sampled from a noise model. The specifics of the noise model are motivated by the physical device on which the code is to be run.

6.2 Code thresholds

A code construction provides a method for building a set of codes with a shared underlying structure. An example are the surface codes, for which the code distance can be increased by expanding the size of the qubit lattice. Given the increase in qubit overhead, scaling the code in this way is only ‘worthwhile’ if the resultant larger code has a lower logical error rate.

The threshold theorem for stabilizer codes states that increasing the distance of a code will result in a corresponding reduction in the logical error rate $p_{L}$, provided the physical error rate $p$ of the individual code qubits is below a threshold $p<p_{th}$. The significance of this theorem is that it means that quantum error correction codes can in principle be used to arbitrarily suppress the logical error rate [22, 23, 24, 25, 26]. Conversely, if the physical error rate is above the threshold, the process of quantum encoding becomes self defeating. The threshold of a code therefore provides a minimum experimental benchmark that quantum computing experiments must reach before quantum error correction becomes viable.

Upper bounds on the threshold $p_{th}$ for a code under a given noise model can be obtained using methods from statistical mechanics. Alternatively, more realistic thresholds can be numerically estimated by simulating code cycles and decoding using efficient inference algorithms as discussed in section 6.1. For the surface code, assuming $X$- and $Z$-errors are treated independently, the upper bound on the threshold is $\approx 10.9\%$ [57]. In practice, decoders based on the MWPM algorithm can achieve thresholds as high as $\approx 10.3\%$ [58].

6.3 Fault tolerance

In the discussion of quantum error correction codes so far, we have assumed that errors only occur in certain locations in the circuit. For example, in the circuit diagram for the two-qubit code shown in figure 2, errors are the restricted to the region labelled ‘$E$’. In doing this, we assume that all of the apparatus associated with encoding and syndrome extraction operates without error. However, in practice this is not the case. In fact, for many quantum computing technologies two-qubit gates, as well as measurement operations, can be dominant sources of error. As such, it is unrealistic to assume that any part of the circuit is error free.

A quantum error correction code is said to be fault tolerant if it can account for errors (of size up to the code distance) that occur at any location in the circuit [26, 59]. Various techniques exist for modifying quantum circuits to make them fault tolerant [60, 61, 62]. In the simplest terms, these methods ensure that small sub-distance errors do not spread uncontrollably through the circuit.

Modifying a quantum error correction circuit for fault tolerance can add considerable overhead in terms of the total number of additional ancilla qubits required. For example, a fault tolerant syndrome extraction procedure proposed by Shor requires $\lambda$ ancilla qubits to measure each stabilizer, where $\lambda$ is the number of non-identity elements in the stabilizer [60]. Under this scheme, eight ancilla qubits would be required to measure the two stabilizers of the four-qubit code depicted in figure 5. More efficient schemes exist [63], but a fault tolerant version of a code will always have increased overhead relative to the original circuit.

For a quantum circuit with noisy ancilla measurements, it is not always possible to decode the error correction code in a single round of syndrome extraction. To illustrate this, consider the case where the $S=10$ syndrome is measured in the three-qubit code outlined in section 3.1. From table 3.2, we see that this syndrome is triggered by an $X_{1}$ error. However, if the ancillas themselves are subject to error, then the same syndrome could equally have resulted from an error on ancilla qubit $A_{1}$. To differentiate between these two possibilities, it is necessary to perform two (or more) rounds of stabilizer measurements and compare the syndromes over time. It should be noted that decoding over time in this way, in addition to any other modifications required for fault tolerance, will reduce the threshold for the code. For example, the threshold for the surface code with noisy ancilla measurements is $\approx 1\%$, compared to $\approx 10\%$ in the ideal case [64, 34].

6.4 Encoded computation

A universal quantum computer is a device that can perform any unitary operation $U$ that evolves a qubit register from one state to another $U\ket{\psi}=\ket{\psi^{\prime}}$. It has been shown that any such operation $U$ can be efficiently compiled from a finite set of elementary gates [65]. An example of a universal gate set is $\langle\mathcal{U}\rangle=\langle X,Z,Y,H,\leavevmode\hbox{\footnotesize{CNOT}},T\rangle$, where $T={\rm diag}(1,e^{\rm i\pi/4})$.

In this review, we have seen how Pauli logical $\bar{X}$ and $\bar{Z}$ operators can be defined for a variety of stabilizer codes. These gates allow computation to be performed directly on the encoded logical states, removing the need to decode then re-encode every time the state is to be evolved. However, the $\bar{X}$ and $\bar{Z}$ logical gates do not alone form a universal set, and additional logical operators need to be defined to achieve arbitrary computation on encoded states.

The major challenge in constructing a universal encoded gate set is to find ways in which the relevant gates can be performed fault tolerantly. For many codes, it is possible to fault tolerantly implement a subset of the gates in $\langle\mathcal{U}\rangle$ without having to introduce additional qubits. This is achieved by defining the logical operators with a property known as tranversality that guarantees errors will not spread uncontrollably through the circuit. However, a no-go theorem exists that prohibits the implementation of a full universal gate set in this way on a quantum computer [66]. As such, alternative techniques are required to perform universal encoded logic. Various methods have been proposed [67, 68, 69, 70], but these typically impose a high cost in terms of the number of additional qubits required. To put this into context, it has proposed that the surface code could realise a universal gate set using a method called magic state injection [67]. However, estimates suggest that the fault tolerant implementation of this technique could result in an order-of-magnitude increase in the total number of qubits required in the quantum computer [33].

6.5 Experimental implementations of quantum error correction

The realisation of the first fault tolerant logical qubit will mark an important milestone in the journey to build a quantum computer. To this end, laboratories at places such as Google [49], IBM Research [71, 72] and TU Delft [73] are currently building superconducting devices with the long-term goal of realising a surface code logical qubit. Other efforts are currently underway pursuing qubit architectures based on ion-trap trap technology [48] and quantum optics [6].

The threshold for the surface code under a realistic noise assumptions is approximately $1\%$ [64]. State-of-the-art qubit hardware has already been demonstrated with error rates below this level [11, 74]. However, suppressing the logical error rate to the point where the logical qubit outperforms an un-encoded qubit will require levels of scaleability that are not yet possible with current experiments. It is predicted that the first fault tolerant surface code logical qubits will require a lattice with over a thousand qubits [34]. To put the scale of the challenge that remains into context, the largest quantum computers to date have less than one hundred qubits. Furthermore, achieving this goal will only be the first step: a quantum computer with only a single logical qubit will be no more powerful than an abacus with one bead. In fact, it is currently estimated that a fault tolerant surface code quantum computer with the ability to outperform a classical device for a useful task will require over a million qubits in total [75, 33].

The first quantum protocols to achieve fault tolerance will likely be quantum detection codes. As the smallest code capable of protecting against a quantum error model, the $[[4,2,2]]$ code is a promising candidate. Several proof-of-concept implementations of the $[[4,2,2]]$ code have already been demonstrated in [76, 77, 41, 78]. Repetition codes (from the same family as the two- and three-qubit codes outlined in this review) have also been implemented on qubit hardware [79]. Over the past couple of years, several quantum computing hardware projects have developed cloud platforms to allow the public to program their devices. This makes it is possible for interested readers to test some of the early proof-of-concept quantum codes. For example, a tutorial showing how a repetition code can be implemented on the IBM Q device can be found in the supplementary material of [79].

7 Outlook & Summary

A major hurdle in the realisation of a full-scale quantum computer stems from the challenge of controlling qubits in an error free way. Quantum error correction protocols offer a solution to this problem, in principle allowing for arbitrary suppression of the logical error rate provided certain threshold conditions on the physical qubits are met. However, there is a trade-off: quantum error correction protocols require large number of qubits to operate effectively. This will significantly increase the overheads associated with quantum computing.

Developing quantum codes is not straightforward. Complications arise due the no-cloning theorem, the problem of wavefunction collapse and necessity to deal with multiple error types. Stabilizer codes provide a formalism that allow quantum error correction codes to be constructed within these constraints. For stabilizer codes, quantum redundancy is achieved by entangling the quantum information in the initial register across an expanded space of qubits. Errors can then be detected by performing a series of projective stabilizer measurements, and the results interpreted to determine the best recovery operation to restore the quantum information to its intended state.

The surface code is currently the most widely pursued quantum error correction scheme for experiment. This is due to its comparatively high threshold combined with the fact it requires only nearest-neighbour interactions. However, there are drawbacks to the surface code, most notably its poor encoding density. The distance of the surface code can be increased simply by scaling the size of the qubit lattice, but this results in a vanishing code rate, where the rate is defined as the ratio of encoded qubits to physical qubits $R=k/n$. Another disadvantage to the surface code is that resource intensive methods are required to obtain a universal encoded gate set.

Alternatives to the surface code have been proposed based on different tilings of the qubit lattice [80], as well as extensions to higher dimensions [81, 70]. These constructions typically have lower thresholds, but offer other advantages such as (potentially) easier access to universal encoded gate sets [70]. Efforts are also in progress to develop code constructions with non-vanishing rates based on principles from high-performance classical codes [59, 45]. However, for these codes, it is often necessary to perform arbitrary long range interactions between the code qubits.

In the quest to build a circuit model quantum computer there are many challenges to be overcome. At the hardware level, methods for the realisation and control of qubits need to be improved. In addition to this, a major theoretical challenge lies in finding better ways to achieve fault tolerant error correction. These two problems will have to be approached in parallel, with advances in either influencing the direction of the other.

Acknowledgement(s)

JR acknowledges the support of the QCDA project which has received funding from the QuantERA ERA-NET Cofund in Quantum Technologies implemented within the European Union’s Horizon 2020 Programme. Many thanks to Viv Kendon for useful discussions and help preparing and checking the manuscript. Special thanks to Benjamin Jones and Armanda Ottaviano Quintavalle for reading through eary versions of the manuscript and providing valuable suggestions for improvement. Thanks also to Earl Campbell and Yingkai Ouyang for useful discussions, as well as to Jasminder Sidhu for helping with tikz drawings. The quantum circuit diagrams in this review were drawn using the QPIC package [82].

Notes on contributor(s)

Joschka Roffe studied MPhys physics at The University Manchester, graduating in 2015. Following this, he studied a PhD in Quantum Computing at Durham University under the supervision of Viv Kendon. He now works as a research associate at the The University of Sheffield as part of the Quantum Codes Designs and Architectures (QCDA) project.

Appendix A Notation for quantum states

In this review quantum states are represented using Dirac bra-ket notation. Unless otherwise stated, we use the computational basis, given by $\{\ket{0},\ket{1}\}$ in the single-qubit case. For example, the general qubit state is written

[TABLE]

For multi-qubit systems, we adopt a labelling convention whereby qubits are implicitly labelled $1,..,n$ from left-to-right, where $n$ is the total number of qubits. For example, the three-qubit basis element $\ket{010}$ is equivalent to $\ket{0}_{1}\otimes\ket{1}_{2}\otimes\ket{0}_{3}$ in its full tensor product form.

Appendix B Pauli operator notation

The Pauli group on a single-qubit, $\mathcal{G}_{1}$, is defined as the set of Pauli operators

[TABLE]

where the $\pm 1$ and $\pm\text{i}$ terms are included to ensure $\mathcal{G}_{1}$ is closed under multiplication and thus forms a legitimate group. In matrix form, the four Pauli operators are given by

[TABLE]

The general Pauli group, $\mathcal{G}$, consists of the set of all operators that are formed from tensor products of the matrices in $\mathcal{G}_{1}$. For example, the operator

[TABLE]

is an element of the four-qubit Pauli group. The support of a Pauli operator is given by the list of its non-identity elements. For example, the support of the Pauli operator in equation (51) is $X_{2}Y_{4}$ where the indices point to the qubit each element acts on. In this review, Pauli errors are always written in terms of their support. As an example, we would say that the bit-flip error $X_{2}$ acts on the two-qubit basis element $\ket{00}$ as follows $X_{2}\ket{00}=\ket{01}$.

Appendix C Quantum circuit notation

Quantum circuit notation provides a useful way of representing quantum algorithms. This appendix introduces the basic elements of quantum circuit notation necessary to understand quantum error correction circuits.

C.1 Single qubit gates

In quantum circuit representation of quantum algorithms each qubit in the quantum register is assigned a wire. These wires are labelled with quantum gates from left-to-right in the order in which they are applied during the quantum computation. As an example, consider the quantum computation described by the application of the unitary operation $U=X_{1}Z_{1}$ to a general qubit state,

[TABLE]

The quantum circuit for the above computation on a single-qubit is shown below

[TABLE]

where the input state is on the left and the output on the right. Note that the $Z$-gate is placed before the $X$-gate as it is applied first.

An important single-qubit gate for quantum error correction (and quantum algorithms in general) is the Hadamard gate which is defined in matrix-form as

[TABLE]

The Hadamard gate has the following effect on the computational basis states

[TABLE]

C.2 Multi-qubit gates

A gate spanning two wires in a quantum circuit represents a multi-qubit operation. As an example, the quantum circuit for the operation $U=X_{1}X_{2}$ applied the state $\ket{\psi}=\ket{00}$ is given by

[TABLE]

C.3 Controlled-gates

A controlled gate is a gate whose action is conditional on the value of a ‘control’ qubit. In general, controlled gates are represented as follows in quantum circuit notation

[TABLE]

In the above circuit, the top qubit $C$ is the control and the lower qubit $T$ is the target. The single-qubit $G$-gate is applied to the target if the control qubit is set to $\ket{C}=\ket{1}$. If the control qubit is set to $\ket{C}=0$, the $G$-gate is not applied to the target.

A commonly occurring gate in quantum error correction is the controlled-NOT (CNOT ) gate. In this review, we use the two equivalent symbols for the CNOT gate

[TABLE]

C.4 Measurement in the computation basis

In all the circuits in this review measurement is performed in the computation basis. As an example, consider the following quantum circuit for generating random numbers (the ‘Hello World’ of quantum computing)

[TABLE]

where the computational basis measurement is depicted by the gate to the right. The above circuit outputs ‘0’ or ‘1’ with equal probability. The double lines at the end of the circuit indicate that the output is classical information.

Appendix D Commutation properties for Pauli operators

The elements of the Pauli group have eigenvalues $\{\pm 1,\pm\text{i}\}$. As a result, Pauli errors either commute or anti-commute with one another. In this appendix, we outline how to determine whether Pauli operators commute with one another.

First, recall that two operators, $F_{i}$ and $F_{j}$, commute if $F_{i}F_{j}=F_{j}F_{i}$, and anti-commute if $F_{i}F_{j}=(-1)F_{j}F_{i}$. For single-qubit Pauli-operators, we see that all pairs of distinct operators anti-commute

[TABLE]

Now consider the operators $Z_{1}Z_{2}$ and $X_{1}X_{2}$. These multi-qubit operators commute as

[TABLE]

In general, two Pauli operators will commute with one another if they intersect non-trivially on an even number of qubits as above. Conversely, if the number of non-trivial intersections is odd, then the two operators anti-commute. As an example, consider the two operators $X_{1}Z_{2}Z_{3}Z_{5}X_{7}$ and $X_{1}X_{2}X_{5}Z_{7}$. These operators intersect on the qubits $1$, $2$, $5$ and $7$. However, the intersection on qubit $1$ is trivial as both operators apply the same $X$-gate to that qubit. The number of non-trivial intersections that remain is therefore three. As the two operators intersect non-trivially an odd number of times, the two operators anti-commute.