July 26, 2019

Quantum Error Correction: An Introductory Guide

Joschka Roffe
arXiv:1907.11157v1 [quant-ph] 25 Jul 2019

Department of Physics & Astronomy, University of Sheffield, Sheffield, S3 7RH, United Kingdom

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 comput-
ing 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.

Keywords: Quantum computing; quantum error correction; stabilizer codes; surface codes

1. Introduction

In place of the bits in traditional computers, quantum computers work by controlling and ma-
nipulating 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 classi-
cal 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–10], superconducting circuits [11–13] and
spins in semiconductors [14–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–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

CONTACT Joschka Roffe. Email: [email protected]

July 26, 2019

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–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–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 prin-
ciples 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 under-
standing 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 quan-
tum 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 se-
quences of bits takings values ‘0’ 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 → 000 and 1 → 111. More formally, we can define the three-bit
encoder as a mapping from a ‘raw’ binary alphabet B to a code alphabet C3

three−bit encoding
B = {0, 1} −−−−−−−−−−−−→ C3 = {000, 111}, (1)

where the encoded bit-strings ‘000’ and ‘111’ are referred to as the logical codewords of the code
C3 . As an example, consider the simple case where we wish to communicate a single-bit message
‘0’ 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

2
July 26, 2019

ẑ = |0i

|ψi
θ
ŷ
φ
x̂

θ θ
Figure 1. In the geometric representation, the state of a qubit |ψi = cos 2
|0i + eiφ sin 2
|1i can be represented as a point on
the surface of a Bloch sphere.

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

d = 2t + 1. (2)

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

|ψi = α |0i + β |1i , (3)

where α and β are complex numbers that satisfy the condition |α|2 + |β|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 2n 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 → 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

3
July 26, 2019

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

θ θ
|ψi = cos |0i + eiφ sin |1i , (4)
2 2

where the probability amplitudes maintain the condition that | cos θ2 |2 + |eiφ sin θ2 |2 = 1. In this
form, the qubit state corresponds to a point, specified by the angles θ and φ, 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 (δθ, δφ)
which evolves the qubit state as follows

θ + δθ θ + δθ
U (δθ, δφ) |ψi = cos |0i + ei(φ+δφ) sin |1i , (5)
2 2

where θ + δθ and φ + δφ 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 δθ and δφ.
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.1 For example, the Pauli basis for two-dimensional matrices is
given by
       
1 0 0 1 0 −i 1 0
11 = , X= , Y = , Z= . (6)
0 1 1 0 i 0 0 −1

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

U (δθ, δφ) |ψi = αI 11 |ψi + αX X |ψi + αZ Z |ψi + αY Y |ψi (7)

where α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

U (δθ, δφ) |ψi = αI 11 |ψi + αX X |ψi + αZ Z |ψi + αXZ XZ |ψi . (8)

The above expression shows that any coherent error process can be decomposed into a sum from
the Pauli set {11, 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.

1 For a more detailed definition of the Pauli group, and details of the Pauli notation used in this review, see appendix B.

4
July 26, 2019

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 |0i = |1i and X |1i = |0i. The action of an X-error on the general qubit state
is

X |ψi = αX |0i + βX |1i = α |1i + β |0i . (9)

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 |0i = |0i and Z |1i = − |1i, and therefore have
the following action on the general qubit state

Z |ψi = αZ |0i + βZ |1i = α |0i − β |1i . (10)

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 Uclone which performs the following operation

Uclone (|ψi ⊗ |0i) → |ψi ⊗ |ψi , (11)

where |ψi 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 col-
lapse. 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

5
July 26, 2019

Encoder Syndrome extraction

|ψi1
|ψiL E E |ψiL Z1 Z2 E |ψiL
|0i2

|0iA H H

Figure 2. Circuit diagram for the two qubit code. Encode stage: the information contained in |ψi1 is entangled with a re-
dundancy qubit |0i2 to create a logical state |ψiL . Error stage: during the error window (shown by the circuit element E),
the two code qubits are potentially subject to bit-flip errors. Syndrome extraction stage: the Z1 Z2 operator, controlled by
the ancilla qubit A, is applied to the code qubits. The subsequent measurement of the ancilla gives the code syndrome S.

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 |ψi, has
the following action

two-qubit encoder
|ψi = α |0i + β |1i −−−−−−−−−−−→ |ψiL = α |00i + β |11i = α |0iL + β |1iL , (12)

where after encoding the logical codewords are |0iL = |00i and |1iL = |11i. Note that this does
not correspond to cloning the state as

|ψiL = α |00i + β |11i 6= |ψi ⊗ |ψi . (13)

The effect of the encoding operation is to distribute the quantum information in the initial state
|ψi across the entangled two-party logical state |ψiL . 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 |ψi ∈ H2 = span{|0i , |1i}. After
encoding the logical qubit occupies a four-dimensional Hilbert space

|ψi ∈ H4 = span{|00i , |01i , |10i , |11i}. (14)

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

|ψiL ∈ C = span{|00i , |11i} ⊂ H4 , (15)

where 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

X1 |ψiL = α |10i + β |01i , (16)

6
July 26, 2019

Table 1. The syndrome

table for the two-qubit
code. The syndrome S is
bit a string where each
bit corresponds to the
outcome of a stabilizer
measurement.

Error Syndrome, S

I1 I2 0
X1 I 2 1
I 1 X2 1
X1 X2 0

where X1 is a bit-flip error acting on the first qubit. The resultant state is rotated into a new
subspace

X1 |ψiL ∈ F ⊂ H4 , (17)

where we call F the error subspace. Notice that an X2 -error will also rotate the logical state into
the F subspace. If the logical state |ψiL is uncorrupted, it occupies the codespace C, whereas if it
has been subject to a single-qubit bit-flip, it occupies the error space F. As the C and 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 C and the error space F, a projective
measurement of the form Z1 Z2 is performed. The Z1 Z2 operator yields a (+1) eigenvalue when
applied to the logical state

Z1 Z2 |ψiL = Z1 Z2 (α |00i + β |11i) = (+1) |ψiL . (18)

The Z1 Z2 operator is said to stabilize the logical qubit |ψiL as it leaves it unchanged [28].
Conversely, the Z1 Z2 operator projects the errored states, X1 |ψiL and X2 |ψiL , onto the (−1)
eigenspace. Notice that for either outcome, the information encoded in the α and β 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 |ψi state with a redundancy qubit to create the logical state |ψiL . 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 |0iA is introduced to perform the
measurement of the Z1 Z2 stabilizer. The syndrome extraction stage of the circuit transforms the
quantum state as follows

syndrome extraction 1 1
E |ψiL |0iA −−−−−−−−−−−−→ (111 112 + Z1 Z2 )E |ψiL |0iA + (111 112 − Z1 Z2 )E |ψiL |1iA , (19)
2 2

where E is an error from the set {11, X1 , X2 , X1 X2 }. Now, consider the case where E = X1 so that
the logical state occupies the error space E |ψiL ∈ 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 = {11, X1 X2 }) then the ancilla is measured as ‘0’. Likewise, if the logical state is in the error
subspace (i.e., if E = {X1 , X2 }) 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

7
July 26, 2019

been subject to an error. The syndromes for all bit-flip error types in the two-qubit code are shown
in table 1.
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

E = αI 11 + αX X, (20)

where |αI |2 + |αX |2 = 1. Here we see that |αX |2 = pX is the probability of an X-error occurring on
the qubit. The probability of no-error occurring is therefore equal to |αI |2 = 1 − pX . The combined
action of the error operator E acting on both qubits is given by

E = E1 ⊗ E2 = α2I 111 112 + αI αX (X1 + X2 ) + α2X X1 X2 . (21)

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

syndrome extraction
E |ψiL |0iA −−−−−−−−−−−−→ (α2I 111 112 + α2X X1 X2 ) |ψiL |0iA + αI αX (X1 + X2 ) |ψiL |1iA . (22)

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

(α2I 111 112 + α2X X1 X2 )

q |ψiL |0iA , (23)
|α2I |2 + |α2X |2

where the the denominator ensures normalisation. By calculating the square-norm in the first term
in the above, we can calculate the probability pL that the logical state is subject to an error
2
α2X p2x
pL = q = ≈ p2x (24)
|α2I |2 + |α2X |2 (1 − px )2 + p2x

where the above approximation is made under the assumption that px is small. For the single qubit
|ψi, the probability of error is px when it is subject to the error operator E. For the logical qubit
|ψiL subject to the error operator E1 ⊗ E2 , the logical error rate is pL = p2x . 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 |ψiL = α |000i + β |111i. This logical state occupies an eight-
dimensional Hilbert space that can be partitioned into four two-dimensional subspaces as follows

C = span{|000i , |111i}, F1 = span{|100i , |110i},

(25)
F2 = span{|010i , |101i}, F3 = span{|001i , |110i},

8
July 26, 2019

Encoder Syndrome extraction

|ψi1
Z1 Z2
|0i2 |ψiL E
Z2 Z3
|0i3

|0iA1 H H

|0iA2 H H

Figure 3. The circuit diagram of the three-qubit code. Encode stage: The information contained in a single qubit |ψi is
entangled with two redundancy qubits |0i2 and |0i3 to create a logical qubit |ψiL . The stabilizers Z1 Z2 and Z2 Z3 are mea-
sured on the logical qubit via two operations controlled on the ancilla qubits A1 and A2 respectively. The subsequent mea-
surement of the ancilla qubits gives a two-bit syndrome S.

Table 2. The syndrome table for all bit-flip erros on

the three qubit code. The syndrome S is a two-bit
string formed by concatenating the results of the two
stabilizer measurements.

Error Syndrome, S Error Syndrome, S

I1 I2 I3 00 X1 X2 I 3 01
X1 I 2 I 3 10 I 1 X2 X3 10
I 1 X2 I 3 11 X1 I 2 X3 11
I 1 I 2 X3 01 X1 X2 X3 00

where C is the logical code space, and F{1,2,3} are the logical error spaces. We see that each single-
qubit error from the set E = {X1 , X2 , X3 } will rotate the codespace to a unique error space so
that Xi |ψiL ∈ Fi . In order to differentiate between these subspaces, we perform two stabilizer
measurements Z1 Z2 and Z2 Z3 via the circuit shown in figure 3. The resultant syndrome table for
single-qubit errors is given in table 2. From this we see that each single-qubit error produces a
unique two-bit syndrome S = s1 s2 , 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 X̄ = X1 X2 X3 , so that

X̄ |0iL = |1iL and X̄ |1iL = |0iL , (26)

where |0iL = |000i and |1iL = |111i 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 Z̄ when determining the code distance. To do this, it is useful to switch

9
July 26, 2019

Syndrome extraction

|ψiD
Encoder |ψiL E P1 P2 ... Pn−k
|0iR

|0iA1 H H

|0iA2 H H
.. ..
. .

|0iAn−k H H

Figure 4. Circuit illustrating the structure of an [[n, k, d]] stabilizer code. A quantum data register |ψiD = |ψ1 ψ2 ...ψk i
is entangled with redundancy qubits |0iR = |01 02 ...0n−k i via an encoding operation to create a logical qubit |ψiL . After
encoding, a sequence of n − k stabilizer checks Pi are performed on the register, and each result copied to an ancilla qubit
Ai . The subsequent measurement of the ancilla qubits provides an m-bit syndrome.

from the computational basis, {|0i , |1i}, to the conjugate basis, {|+i , |−i}, where we define

1 1
|+i = √ (|0i + |1i) and |−i = √ (|0i − |1i). (27)
2 2

A Z-error maps the conjugate basis states as follows Z |+i = |−i and Z |−i = |+i. Now, encoding
the conjugate basis states with the three-qubit code gives the logical states

1 1
|+iL = √ (|000i + |111i) and |−iL = √ (|000i − |111i). (28)
2 2

A weight-one logical Pauli-Z operator Z̄ = Z1 will transform Z |+iL = |−iL , 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, |ψiD , is entangled with m = n − k redundancy qubits |0iR via an encoding operation to cre-
ate a logical qubit |ψiL . At this stage, the data previously stored solely in |ψiD is distributed across
the expanded Hilbert space. Errors can then be detected by performing m stabilizer measurements
Pi as shown to the right of figure 4.

10
July 26, 2019

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 Pi , the syndrome
extraction circuit maps the logical state as follows

syndrome extraction 1 ⊗n 1
E |ψiL |0iAi −−−−−−−−−−−−→ (11 + Pi )E |ψiL |0iAi + (11⊗n − Pi )E |ψiL |1iAi . (29)
2 2
From the above, we see that if the stabilizer Pi commutes with an error E the measurement of
ancilla qubit Ai returns ‘0’. If the stabilizer Pi 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 Pi of an [[n, k, d]] code must satisfy the following properties:
(1) They must be Pauli-group elements, Pi ∈ Gn . Here Gn is the Pauli Group over n-qubits (see
appendix B for the definition of the Pauli Group).
(2) They must stabilize all logical states |ψiL of the code. This means that each Pi has the action
Pi |ψiL = (+1) for all possible values of |ψiL .
(3) All the stabilizers of a code must commute with one another, so that [Pi , Pj ] = 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 Pi of an [[n, k, d]] code form an Abelian subgroup
S of the Pauli Group. The stabilizer requirements listed above are incorporated into the definition
of S as follows

S = {Pi ∈ Gn | Pi |ψiL = (+1) |ψiL ∀ |ψiL ∧ [Pi , Pj ] = 0 ∀ (i, j)}. (30)

An important point to note is that any product of the stabilizers Pi Pj will also be a stabilizer as
Pi Pj |ψiL = Pi (+1) |ψiL = (+1) |ψiL . 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

S = hG1 , G2 , ..., Gm i (31)

In a minimal set it is not possible to obtain one stabilizer Gi as a product of any of the other
elements Gj . As a simple example, consider the following set of stabilizers for the three-qubit code
S = {Z1 Z2 , Z2 Z3 , Z1 Z3 }. 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 = hZ1 Z2 , Z2 Z3 i, 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

11
July 26, 2019

Encoder Syndrome extraction

|ψi1
Z1 X1
|ψi2 Z2 X2
|ψ1 ψ2 iL E
|0i3 Z3 X3

|0i4 Z4 X4
H

|0iA1 H H

|0iA2 H H

Figure 5. Circuit diagram for the four-qubit code. Encode stage: the information contained in two-qubit register |ψi1 |ψi2 is
distributed across two redundancy qubits, |0i3 and |0i4 , to create a logical state |ψ1 ψ2 iL that encodes two qubits. Syndrome
extraction stage: the code stabilizers, Z1 Z2 Z3 Z4 and X1 X2 X3 X4 , are measured on the code qubits and results copied to
the ancilla qubits. The subsequent measurement of the ancilla qubits provides a two-bit syndrome S that informs of the
occurrence of an error.

X̄i and a logical Pauli-Z operator Z̄i . Each pair of logical operators, X̄i and Z̄i , satisfy the following
properties
(1) They commute with all the code stabilizers in S.
(2) They anti-commute with one another, so that [X̄i , Z̄i ]+ = X̄i Z̄i + Z̄i X̄i = 0 for all qubits i.
Any product of a logical operator L̄i and stabilizer Pj 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 L̄i Pj
therefore has the following action on the logical state L̄i Pj |ψiL = L̄i |ψiL .

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 |ψi1 |ψi2 is entangled
across four qubits to give the code state |ψ1 ψ2 iL . As there are two encoded logical qubits in the
[[4, 2, 2]] code, its codespace is four-dimensional and is spanned by

|00iL = √1 (|0000i + |1111i) 

 

 2 
|01i = √1 (|0110i + |1001i ,
 
L 2
C[[4,2,2]] = span √1 (|1010i + |0101i) 
. (32)

 |10iL = 2 
√1 (|1100i + |0011i)

 |11i = 

L 2

The stabilizers of the above logical basis states are S[[4,2,2]] = hX1 X2 X3 X4 , Z1 Z2 Z3 Z4 i. 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 = {X1 , X2 , X3 , X4 }), we see that they all anti-commute with the Z1 Z2 Z3 Z4 stabilizer. Likewise,
the single-qubit Z-errors (E = {Z1 , Z2 , Z3 , Z4 }) anti-commute with the X1 X2 X3 X4 stabilizer. Any

12
July 26, 2019

Table 3. The syndrome table for the [[4, 2, 2]] code for all single-qubit
X-, Z- and Y -errors.

Error Syndrome, S Error Syndrome, S Error Syndrome, S

X1 10 Z1 01 Y1 11
X2 10 Z2 01 Y2 11
X3 10 Z3 01 Y3 11
X4 10 Z4 01 Y4 11

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 3. For completeness, table
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
 

X̄1 = X1 X3 
Z̄1 = Z1 Z4
 
L[[4,2,2]] = . (33)

X̄2 = X2 X3 
Z̄2 = Z2 Z4
 

Each logical operators commutes with the two stabilizers of the code so that [Li , Pi ] = 0 for all
Li ∈ L[[4,2,2]] and Pi ∈ S. Furthermore, it can be checked that the requirement X̄i , Z̄i + = 0 is
satisfied for each pair of logical operators. The minimum weight logical operator in 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 |0iL codeword of any [[n, k, d]] stabilizer can be obtained via a projection onto the (+1)
eigenspace of all of its stabilizers

1 Y
|0iL = (11⊗n + Pi ) |0⊗n i , (34)
N
Pi ∈hSi

where hSi is the minimal set of the code stabilizers and the 1/N term is a factor that ensures
normalisation. For example, the |00iL codeword of the four-qubit code defined in section 4.3 is
given by

1 1
|00iL = √ (11⊗4 + X1 X2 X3 X4 )(11⊗4 + Z1 Z2 Z3 Z4 ) |0000i = √ (|0000i + |1111i). (35)
2 2

The remaining codewords of the code can be obtained by applying logical operators to the |0iL
codeword.

13
July 26, 2019

The |0iL 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 |0i⊗n state. As an example, consider the case where we apply the syndrome extraction circuit
to the state |0i⊗4 to prepare the |0iL codeword of the four-qubit code. The intermediary state
immediately after the extraction of the X1 X2 X3 X4 stabilizer is given by

1 ⊗4 1
(11 + X1 X2 X3 X4 ) |0000i |0iA + (11⊗4 − X1 X2 X3 X4 ) |0000i |1iA . (36)
2 2

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 |0iL 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 ≥ 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 ≥ 3]]
stabilizer code. The encoded logical state |ψiL 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 |Ai⊗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 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 RE |ψiL ∈
C[[n,k,d]]. The decoding step is a success if the combined action of RE on the code state is as follows

RE |ψiL = (+1) |ψiL . (37)

The above condition is trivially satisfied if R = E † so that RE = 11. However, this is not the
only solution. Equation (37) is also satisfied for any product RE that is an element of the code
stabilizer such that RE = P ∈ S. In section 4.6, we will see that the fact that the solution for 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

RE |ψiL = L |ψiL , (38)

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.

14
July 26, 2019

|ψiL E S R RE |ψiL

|Ai⊗m S Decoder

Figure 6. The general procedure for active recovery in a quantum error correction code. The logical qubit |ψiL of an
[[n, k, d]] stabilizer code is subject to an error process E. A generating set of stabilizers S are measured on the logical state to
yield an m-bit syndrome S. This syndrome is processed by a decoder to determine the best recovery operation R to return
the logical state to the codespace. After the recovery has been applied, the output of the error correction cycle is RE |ψiL .
Double lines indicate classical information flow.

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 C3b
was described in section 3.1 and is defined as follows

C3b = span{|0i3b = |000i , |1i3b = |111i}, S3b = hZ1 Z2 , Z2 Z3 i, (39)

where S3b are the code stabilizers. Similarly, the three-qubit code for phase-flips C3p is defined

C3p = span{|0i3p = |+ + +i , |1i3p = |− − −i}, S3p = hX1 X2 , X2 X3 i, (40)

To construct the nine-qubit code, the bit-flip code is embedded into the codewords of the phase-flip
code. This concatenation maps the |0i3p codeword of the phase-flip code to a nine-qubit codeword
|0i9 as follows

concatenation
|0i3p = |+ + +i −−−−−−−−→ |0i9 = |+i3b |+i3b |+i3b , (41)

1
where |+i3b = √ (|000i + |111i) is a logical state of the bit-flip code. Similarly, the concatenation
2
maps the |1i3p codeword of the phase-flip code to

concatenation
|1i3p = |− − −i −−−−−−−−→ |1i9 = |−i3b |−i3b |−i3b , (42)

1
where |−i3b = √ (|000i − |111i). The code defined by the codewords |0i9 and |1i9 is the nine-qubit
2
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
 1 
|0i9 = √ (|000i + |111i)(|000i + |111i)(|000i + |111i)
 
C[[9,1,3]] = span 8 . (43)
1
|1i9 = √ (|000i − |111i)(|000i − |111i)(|000i − |111i)
 
8

The stabilizers of the above code are given by

S[[9,3,3]] = hZ1 Z2 , Z2 Z3 , Z4 Z5 , Z5 Z6 , Z7 Z8 , Z8 Z9 ,
(44)
X1 X2 X3 X4 X5 X6 , X4 X5 X6 X7 X8 X9 i.

15
July 26, 2019

Table 4. The syndrome table for single-qubit

X- and Z-errors on the nine-qubit code. The
nine-qubit code is a degenerate code, as certain
Z-errors share the same syndrome.

Error Syndrome, S Error Syndrome, S

X1 10000000 Z1 00000010
X2 11000000 Z2 00000010
X3 01000000 Z3 00000010
X4 00100000 Z4 00000011
X5 00110000 Z5 00000011
X6 00010000 Z6 00000011
X7 00001000 Z7 00000001
X8 00001100 Z8 00000001
X9 00000100 Z9 00000001

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 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 Z1 and Z2 , 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 R = Z1 . For
the case where the error is E = Z1 , the recovery operation trivially restores the logical state as
RE |ψi9 = Z1 Z1 |ψi9 = |ψi9 . In the event where E = Z2 , the recovery operation still restores the
logical state as RE = Z1 Z2 is in the stabilizer of C[[9,1,3]], and therefore acts on the logical state as
follows Z1 Z2 |ψi9 = |ψi9 . 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 stabi-
lizers 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–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–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.

16
July 26, 2019

|D1 i X Z
D1 A1
|D2 i X Z
|0iA1 H H
A2 D2
|0iA2 H H
(a) (b)
Figure 7. The surface code four-cycle. (a) Pictorial representation. The code qubits, D1 and D2 , are represented by the cir-
cular nodes. The ancilla qubits, A1 and A2 , are represented by the square nodes. The red and blue edges depict controlled-X
and controlled-Z operations controlled on the ancilla qubits and acting on the code qubits. (b) An equivalent surface code
four-cycle in circuit notation.

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 A1 connects to data qubits D1 and D2 via red edges, and therefore
measures the stabilizer XD1 XD2 . Likewise, ancilla qubit A2 measures the stabilizer ZD1 ZD2 . For
comparison, the four-cycle is shown in quantum circuit notation in figure 7b.
The stabilizers of the four-cycle, XD1 XD2 and ZD1 ZD2 , 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 |0iL codeword of the four-cycle can be prepared by setting the initial state of the code qubits
to |D1 D2 i = |00i, 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

S[[5,1,2]] = hXD1 XD2 XD3 , ZD1 ZD3 ZD4 , ZD2 ZD3 ZD5 , XD3 XD4 XD5 i. (45)

The first term in the above is the stabilizer measured by ancilla qubit A1 , the second by ancilla
A2 etc. The stabilizers in S[[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
ZD1 -error on qubit D1 anti-commutes with the XD1 XD2 XD3 stabilizer, and therefore triggers a
‘1’ syndrome. This is depicted by the red filling in the ancilla qubit A1 . Likewise, the XD5 -error
anti-commutes with the ZD2 ZD3 ZD5 stabilizer and triggers a ‘1’ syndrome measurement in ancilla

17
July 26, 2019

D1 A1 D2 D1 A1 D2
Z

A2 D3 A3 A2 D3 A3

D4 D5 D4 D5
A4 A4
X
(a) (b)
Figure 8. (a) The [[5, 1, 2]] surface code formed by tiling together four four-cycles in a square lattice. (b) Examples of error
detection in the [[5, 1, 2]] surface code. The ZD1 error on qubit D1 anti-commutes with the stabilizer measured by ancilla
qubit A1 . The A1 qubit is coloured red to indicate it will measured as a ‘1’. Likewise, the XD5 error on qubit D5 is detected
by the stabilizer measured by ancilla qubit A3 .

D1 D2 D1 D2
A1 A1
X Z Z

A2 D3 A3 A2 D3 A3

D4 D5 D4 D5
A4 A4
X
(a) (b)
Figure 9. The logical operators of a surface code can be defined as chains of Pauli operations that act along the boundaries
of the lattice. (a) The Pauli-X logical operator X̄ = XD1 XD4 acts along the boundary along which Z-type stabilizers are
measured. (b) The Pauli-Z logical operator Z̄ = ZD1 ZD2 acts along the boundary along which X-type stabilizers are mea-
sured. The two logical operators anti-commute with one another.

qubit A4 .
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 XD1 XD4 along the left-hand boundary of the five-qubit
surface code. The XD1 XD4 operator commutes with all the stabilizers in S[[5,1,2]] , in particular
the stabilizer ZD1 ZD3 ZD4 with which is shares two qubits. Similarly, figure 9b shows an operator
ZD1 ZD2 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 XD1 XD4 and ZD1 ZD2
anti-commute. As outlined in section 4.2, the Pauli-X and Pauli-Z logical operators for each en-
coded 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

X̄ = XD1 XD4 and Z̄ = ZD1 ZD2 . (46)

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.

18
July 26, 2019

D1 A1 D2 A2 D3

A3 D4 A4 D5 A5

D6 A6 D7 A7 D8

A8 D9 A9 D10 A10

D11 A11 D12 A12 D13

Figure 10. A distance-three surface code with parameters [[13, 1, 3]]. A possible choice for the logical operators of this code
would be X̄ = XD1 XD6 XD11 and Z̄ = ZD1 ZD2 ZD3 .

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 = λ will encode a single logical qubit and have code parameters given
by

[[n = λ2 + (λ − 1)2 , k = 1, d = λ]]. (47)

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 represen-
tation). For the distance-three code, a choice of logical operators would be X̄ = XD1 XD6 XD11
and Z̄ = ZD1 ZD2 ZD3 . 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 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 2m 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 2m syndromes.
However, such a decoding strategy rapidly becomes impractical as the code size is increased. As

19
July 26, 2019

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 240 ≈ 1012 .
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 RE = L,
where 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 pL .
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 struc-
ture. 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 pL , provided the physical error rate p of the
individual code qubits is below a threshold p < pth . 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–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 pth 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 ≈ 10.9% [57]. In practice, decoders based on the MWPM algorithm can
achieve thresholds as high as ≈ 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

20
July 26, 2019

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–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 λ ancilla qubits to measure each stabi-
lizer, where λ 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 2, we see that this syndrome is triggered by an X1 error. However, if the ancillas themselves
are subject to error, then the same syndrome could equally have resulted from an error on ancilla
qubit A1 . 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 ≈ 1%, compared to ≈ 10% in the ideal case [34,64].

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 |ψi = |ψ ′ i. 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 hU i = hX, Z, Y, H, CNOT, T i, where T = diag(1, eiπ/4 ).
In this review, we have seen how Pauli logical X̄ and 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 X̄ and 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 hU i 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–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-

21
July 26, 2019

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 exper-
iments. 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 [33,75].
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 [41,76–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 theo-
rem, 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 in-
formation 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 [70,81]. 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 [45,59]. However, for these codes, it is often

22
July 26, 2019

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 Quan-
tERA ERA-NET Cofund in Quantum Technologies implemented within the European Unions
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 Quin-
tavalle 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.

References

[1] Shor PW. Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum
computer. SIAM Journal on Computing. 1997;26(5):1484–1509.
[2] Grover LK. A fast quantum mechanical algorithm for database search. In: STOC; 1996.
[3] Schuld M, Sinayskiy I, Petruccione F. An introduction to quantum machine learning. Contemporary
Physics. 2014;56(2):172–185. Available from: https://doi.org/10.1080/00107514.2014.964942.
[4] Aspuru-Guzik A, Dutoi AD, Love PJ, et al. Simulated quantum computa-
tion of molecular energies. Science. 2005;309(5741):1704–1707. Available from:
https://science.sciencemag.org/content/309/5741/1704.
[5] Wang XL, Chen LK, Li W, et al. Experimental ten-photon entanglement. Physical Review Letters.
2016;117(21). Available from: https://doi.org/10.1103/physrevlett.117.210502.
[6] Qiang X, Zhou X, Wang J, et al. Large-scale silicon quantum photonics implement-
ing arbitrary two-qubit processing. Nature Photonics. 2018;12(9):534–539. Available from:
https://doi.org/10.1038/s41566-018-0236-y.
[7] Randall J, Weidt S, Standing ED, et al. Efficient preparation and detection of microwave dressed-state
qubits and qutrits with trapped ions. Physical Review A. 2015;91(1).
[8] Ballance C, Harty T, Linke N, et al. High-fidelity quantum logic gates using trapped-ion hyperfine
qubits. Physical Review Letters. 2016;117(6).
[9] Brandl MF, van Mourik MW, Postler L, et al. Cryogenic setup for trapped ion quantum computing.
Review of Scientific Instruments. 2016;87(11):113103.
[10] Debnath S, Linke NM, Figgatt C, et al. Demonstration of a small programmable quantum computer
with atomic qubits. Nature. 2016;536(7614):63.
[11] Chow JM, Gambetta JM, Córcoles AD, et al. Universal quantum gate set approaching fault-

23
July 26, 2019

tolerant thresholds with superconducting qubits. Physical Review Letters. 2012;109(6). Available from:
https://doi.org/10.1103/physrevlett.109.060501.
[12] Chen Y, Neill C, Roushan P, et al. Qubit architecture with high coher-
ence and fast tunable coupling. Phys Rev Lett. 2014;113:220502. Available from:
https://link.aps.org/doi/10.1103/PhysRevLett.113.220502.
[13] Wendin G. Quantum information processing with superconducting circuits: a
review. Reports on Progress in Physics. 2017;80(10):106001. Available from:
https://doi.org/10.1088/1361-6633/aa7e1a.
[14] Kane BE. A silicon-based nuclear spin quantum computer. Nature. 1998;393(6681):133–137. Available
from: https://doi.org/10.1038/30156.
[15] Hill CD, Peretz E, Hile SJ, et al. A surface code quantum computer in silicon. Science Advances. 2015;
1(9):e1500707. Available from: https://doi.org/10.1126/sciadv.1500707.
[16] van der Heijden J, Kobayashi T, House MG, et al. Readout and control of the spin-orbit states of two
coupled acceptor atoms in a silicon transistor. Science Advances. 2018;4(12):eaat9199. Available from:
https://doi.org/10.1126/sciadv.aat9199.
[17] Shannon CE. A mathematical theory of communication. University of Illinois Press; 1949.
[18] Hamming RW. Error detecting and error correcting codes. Bell System Technical Journal. 1950;
29(2):147–160. Available from: https://doi.org/10.1002/j.1538-7305.1950.tb00463.x.
[19] MacKay DJ. Information theory, inference and learning algorithms. Cambridge University Press; 2003.
[20] Wootters WK, Zurek WH. A single quantum cannot be cloned. Nature. 1982;299(5886):802–803.
[21] Shor PW. Scheme for reducing decoherence in quantum computer memory. Phys Rev A. 1995;52:R2493.
[22] Preskill J. Reliable quantum computers. Proceedings of the Royal Society of London
A: Mathematical, Physical and Engineering Sciences. 1998;454(1969):385–410. Available from:
http://rspa.royalsocietypublishing.org/content/454/1969/385.
[23] Kitaev AY. Quantum computations: algorithms and error correction. Russian Mathematical Surveys.
1997;52(6):1191–1249. Available from: https://doi.org/10.1070/rm1997v052n06abeh002155.
[24] Aharonov D, Ben-Or M. Fault-tolerant quantum computation with constant error. In: Proceedings of
the Twenty-ninth Annual ACM Symposium on Theory of Computing; New York, NY, USA. ACM;
1997. p. 176–188; STOC ’97. Available from: http://doi.acm.org/10.1145/258533.258579.
[25] Knill E. Resilient quantum computation. Science. 1998;279(5349):342–345. Available from:
https://doi.org/10.1126/science.279.5349.342.
[26] Gottesman D. Theory of fault-tolerant quantum computation. Physical Review A. 1998;57(1):127.
[27] Gaitan F. Quantum error correction and fault tolerant quantum computing. CRC Press; 2008.
[28] Gottesman D. An introduction to quantum error correction and fault-tolerant quantum computation.
arXiv:09042557. 2009;.
[29] Quantum information processing and quantum error correction: An engineering approach. Elsevier;
2012. Available from: https://doi.org/10.1016/c2010-0-66917-3.
[30] Devitt SJ, Munro WJ, Nemoto K. Quantum error correction for beginners. Reports on Progress in
Physics. 2013;76(7):076001. Available from: https://doi.org/10.1088/0034-4885/76/7/076001.
[31] Lidar D, Brun T. Quantum error correction. Cambridge University Press; 2013.
[32] Terhal BM. Quantum error correction for quantum memories. Reviews of Modern Physics. 2015;
87(2):307–346. Available from: https://doi.org/10.1103/revmodphys.87.307.
[33] Campbell ET, Terhal BM, Vuillot C. Roads towards fault-tolerant universal quantum computation.
Nature. 2017;549(7671):172–179. Available from: https://doi.org/10.1038/nature23460.
[34] Fowler AG, Mariantoni M, Martinis JM, et al. Surface codes: Towards practi-
cal large-scale quantum computation. Physical Review A. 2012;86(3). Available from:
https://doi.org/10.1103/physreva.86.032324.
[35] Nielsen M, Chuang I. Quantum computation and quantum information: 10th anniversary edition. Cam-
bridge University Press, Cambridge, United Kingdom; 2010.
[36] Knill E, Laflamme R. Theory of quantum error-correcting codes. Physical Review A. 1997;55(2):900–
911.
[37] Gottesman D. The Heisenberg representation of quantum computers. Group22: Proceedings of the
XXII International Colloquium on Group Theoretical Methods in Physics, pp 32-43, Cambridge, MA,
International Press. 1999;.
[38] Vaidman L, Goldenberg L, Wiesner S. Error prevention scheme with four particles. Physical Review A.

24
July 26, 2019

1996;54(3):R1745–R1748.
[39] Grassl M, Beth T, Pellizzari T. Codes for the quantum erasure channel. Physical Review A. 1997;
56(1):33–38.
[40] Gottesman DE. Stabilizer codes and quantum error correction [dissertation]; 1997. Available from:
http://resolver.caltech.edu/CaltechETD:etd-07162004-113028.
[41] Roffe J, Headley D, Chancellor N, et al. Protecting quantum memories using coherent parity check
codes. Quantum Science and Technology. 2018;3(3):035010.
[42] Calderbank AR, Shor PW. Good quantum error-correcting codes exist. Phys Rev A. 1996;54:1098–1106.
[43] Steane A. Error correcting codes in quantum theory. Phys Rev Lett. 1996;77:793–797.
[44] Kovalev AA, Pryadko LP. Quantum kronecker sum-product low-density parity-
check codes with finite rate. Physical Review A. 2013;88(1). Available from:
https://doi.org/10.1103/physreva.88.012311.
[45] Tillich JP, Zemor G. Quantum LDPC codes with positive rate and minimum distance proportional to
the square root of the blocklength. IEEE Transactions on Information Theory. 2014;60(2):1193.
[46] Bravyi SB, Kitaev AY. Quantum codes on a lattice with boundary. arXiv:quant-ph/9811052. 1998;.
[47] Freedman MH, Meyer DA. Projective plane and planar quantum codes ; 1998.
[48] Nickerson NH, Fitzsimons JF, Benjamin SC. Freely scalable quantum technologies using cells of 5-to-50
qubits with very lossy and noisy photonic links. Physical Review X. 2014;4(4):041041.
[49] Kelly J, Barends R, Fowler AG, et al. Scalablein situqubit calibration during repetitive error detection.
Physical Review A. 2016;94(3).
[50] Sete EA, Zeng WJ, Rigetti CT. A functional architecture for scalable quantum computing. In: 2016
IEEE International Conference on Rebooting Computing (ICRC). IEEE; 2016.
[51] O’Gorman J, Nickerson NH, Ross P, et al. A silicon-based surface code quantum computer. npj Quan-
tum Information. 2016;2(1). Available from: https://doi.org/10.1038/npjqi.2015.19.
[52] Takita M, Cross AW, Córcoles A, et al. Experimental demonstration of fault-tolerant state preparation
with superconducting qubits. Physical Review Letters. 2017;119(18).
[53] Kitaev A. Fault-tolerant quantum computation by anyons. Annals of Physics. 2003;303(1):2–30. Avail-
able from: https://doi.org/10.1016/s0003-4916(02)00018-0.
[54] Horsman C, Fowler A, Devitt S, et al. Surface code quantum computing by lattice surgery. New Journal
of Physics. 2012;14(12):123011.
[55] Edmonds J. Paths, trees, and flowers. Canadian Journal of Mathematics. 1965;17:449–467.
[56] Kolmogorov V. Blossom v: a new implementation of a minimum cost perfect matching algorithm.
Mathematical Programming Computation. 2009;1(1):43–67.
[57] Dennis E, Kitaev A, Landahl A, et al. Topological quantum memory. Journal of Mathematical Physics.
2002;43(9):4452–4505.
[58] Criger B, Ashraf I. Multi-path Summation for Decoding 2D Topological Codes. Quantum. 2018;2:102.
Available from: https://doi.org/10.22331/q-2018-10-19-102.
[59] Gottesman D. Fault-tolerant quantum computation with constant overhead. Quantum Info Comput.
2014;14(15-16):1338–1372. Available from: http://dl.acm.org/citation.cfm?id=2685179.2685184.
[60] Shor P. Fault-tolerant quantum computation. In: Proceedings of 37th Conference on
Foundations of Computer Science. IEEE Comput. Soc. Press; ???? Available from:
https://doi.org/10.1109/sfcs.1996.548464.
[61] Steane AM. Active stabilization, quantum computation, and quantum state synthesis. Physical Review
Letters. 1997;78(11):2252.
[62] DiVincenzo DP, Aliferis P. Effective fault-tolerant quantum computation with
slow measurements. Physical Review Letters. 2007;98(2). Available from:
https://doi.org/10.1103/physrevlett.98.020501.
[63] Chao R, Reichardt BW. Quantum error correction with only two extra qubits. Physical Review Letters.
2018;121(5). Available from: https://doi.org/10.1103/physrevlett.121.050502.
[64] Wang DS, Fowler AG, Stephens AM, et al. Threshold error rates for the toric
and planar codes. Quantum Info Comput. 2010;10(5):456–469. Available from:
http://dl.acm.org/citation.cfm?id=2011362.2011368.
[65] Dawson CM, Nielsen MA. The solovay-kitaev algorithm. 2005;.
[66] Eastin B, Knill E. Restrictions on transversal encoded quantum gate sets. Physical Review Letters.
2009;102(11). Available from: https://doi.org/10.1103/physrevlett.102.110502.

25
July 26, 2019

[67] Bravyi S, Kitaev A. Universal quantum computation with ideal clifford gates and noisy ancillas. Physical
Review A. 2005;71(2). Available from: https://doi.org/10.1103/physreva.71.022316.
[68] Landahl AJ, Ryan-Anderson C. Quantum computing by color-code lattice surgery ; 2014.
[69] Yoder TJ. Universal fault-tolerant quantum computation with bacon-shor codes. arXiv:170501686. 2017;
.
[70] Vasmer M, Browne DE. Universal quantum computing with 3d surface codes. arXiv:180104255. 2018;.
[71] Gambetta JM, Chow JM, Steffen M. Building logical qubits in a superconduct-
ing quantum computing system. npj Quantum Information. 2017;3(1). Available from:
https://doi.org/10.1038/s41534-016-0004-0.
[72] Takita M, Cross AW, Córcoles A, et al. Experimental demonstration of fault-tolerant state preparation
with superconducting qubits. Physical Review Letters. 2017;119(18).
[73] Ristè D, Poletto S, Huang MZ, et al. Detecting bit-flip errors in a logical qubit using stabilizer measure-
ments. Nature Communications. 2015;6(1). Available from: https://doi.org/10.1038/ncomms7983.
[74] Harty T, Allcock D, Ballance C, et al. High-fidelity preparation, gates, memory, and readout of a
trapped-ion quantum bit. Physical Review Letters. 2014;113(22).
[75] O’Gorman J, Campbell ET. Quantum computation with realistic magic-state factories. Physical Review
A. 2017;95(3). Available from: https://doi.org/10.1103/physreva.95.032338.
[76] Linke NM, Gutierrez M, Landsman KA, et al. Fault-tolerant quantum error detection. Science Advances.
2017;3(10):e1701074. Available from: https://doi.org/10.1126/sciadv.1701074.
[77] Vuillot C. Is error detection helpful on IBM 5q chips? Quantum Information and Computation. 2018;,
Vol. 18, No. 11-12:0949–0964.
[78] Harper R, Flammia ST. Fault-tolerant logical gates in the IBM quantum experience. Phys Rev Lett.
2019;122:080504. Available from: https://link.aps.org/doi/10.1103/PhysRevLett.122.080504.
[79] Wootton JR, Loss D. Repetition code of 15 qubits. Physical Review A. 2018;97(5). Available from:
https://doi.org/10.1103/physreva.97.052313.
[80] Bombin H, Martin-Delgado MA. Optimal resources for topological two-dimensional
stabilizer codes: Comparative study. Physical Review A. 2007;76(1). Available from:
https://doi.org/10.1103/physreva.76.012305.
[81] Breuckmann NP, Terhal BM. Constructions and noise threshold of hyperbolic surface codes. IEEE
Transactions on Information Theory. 2016;62(6):3731.
[82] Draper T, Kutin S. QPIC: Quantum circuit diagrams in LaTeX. ????;Available from:
https://github.com/qpic/qpic.

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 {|0i , |1i} in the single-qubit case. For example, the general
qubit state is written

|ψi = α |0i + β |1i . (A1)

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 |010i is equivalent to |0i1 ⊗ |1i2 ⊗ |0i3 in its full tensor product form.

Appendix B. Pauli operator notation

The Pauli group on a single-qubit, G1 , is defined as the set of Pauli operators

G1 = {±11, ±i11, ±X, ±iX, ±Y, ±iY, ±Z, ±iZ}, (B1)

26
July 26, 2019

where the ±1 and ±i terms are included to ensure G1 is closed under multiplication and thus forms
a legitimate group. In matrix form, the four Pauli operators are given by
       
1 0 0 1 0 −i 1 0
11 = , X= , Y = , Z= . (B2)
0 1 1 0 i 0 0 −1

The general Pauli group, G, consists of the set of all operators that are formed from tensor products
of the matrices in G1 . For example, the operator

11 ⊗ X ⊗ 11 ⊗ Y ∈ G (B3)

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 (B3) is X2 Y4
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 X2 acts on
the two-qubit basis element |00i as follows X2 |00i = |01i.

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 = X1 Z1 to a general qubit
state,

U =X Z
|ψi = α |0i + β |1i −−−−1−→
1
X1 Z1 |ψi = α |1i − β |0i . (C1)

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

|ψi Z X XZ |ψi ,

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
 
1 1
H= . (C2)
1 −1

27
July 26, 2019

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

1
H |0i = √ (|0i + |1i),
2
(C3)
1
H |1i = √ (|0i − |1i).
2

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 = X1 X2 applied the state |ψi = |00i is given by

|0i |1i
X1 X2 .
|0i |1i

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

|Ci
.
|T i G

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 |Ci = |1i. If the control qubit is
set to |Ci = 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

= .
X

C.4. Measurement in the computation basis

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

|0i H .

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.

28
July 26, 2019

Appendix D. Commutation properties for Pauli operators

The elements of the Pauli group have eigenvalues {±1, ±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, Fi and Fj , commute if Fi Fj = Fj Fi , and anti-commute if Fi Fj =
(−1)Fj Fi . For single-qubit Pauli-operators, we see that all pairs of distinct operators anti-commute

X1 Z1 = −Z1 X1 , X1 Y1 = −Y1 X1 , Z1 Y1 = −Y1 Z1 . (D1)

Now consider the operators Z1 Z2 and X1 X2 . These multi-qubit operators commute as

Z1 Z2 X1 X2 = Z1 X1 Z2 X2 = (−1)X1 Z1 (−1)X2 Z2 = X1 X2 Z1 Z2 . (D2)

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 X1 Z2 Z3 Z5 X7
and X1 X2 X5 Z7 . 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.

29