Quantum Science and

Technology

PAPER You may also like

- Techniques for combining fast local
Decoding small surface codes with feedforward decoders with global decoders under
circuit-level noise
neural networks Christopher Chamberland, Luis
Goncalves, Prasahnt Sivarajah et al.

- Cloud-Connected Labs of Future for

To cite this article: Savvas Varsamopoulos et al 2018 Quantum Sci. Technol. 3 015004 Green Energy Materials
Kourosh Malek

- Real-time decoding for fault-tolerant

quantum computing: progress, challenges
and outlook
View the article online for updates and enhancements. F Battistel, C Chamberland, K Johar et al.

This content was downloaded from IP address 130.192.232.231 on 22/01/2025 at 14:22

 Quantum Sci. Technol. 3 (2018) 015004 https://doi.org/10.1088/2058-9565/aa955a

PAPER

Decoding small surface codes with feedforward neural networks

RECEIVED
10 May 2017
REVISED
Savvas Varsamopoulos1,2,3 , Ben Criger1,2 and Koen Bertels1,2
17 October 2017 1
Computer Engineering, Delft University of Technology, Mekelweg 4, 2628 CD Delft, The Netherlands
2
ACCEPTED FOR PUBLICATION QuTech, Delft University of Technology, PO Box 5046, 2600 GA Delft, The Netherlands
3
23 October 2017 Author to whom any correspondence should be addressed.
PUBLISHED E-mail: [email protected], [email protected] and [email protected]
15 November 2017
Keywords: quantum error correction, fault tolerance, surface codes, artificial neural networks

Abstract
Surface codes reach high error thresholds when decoded with known algorithms, but the decoding
time will likely exceed the available time budget, especially for near-term implementations. To
decrease the decoding time, we reduce the decoding problem to a classification problem that a
feedforward neural network can solve. We investigate quantum error correction and fault tolerance at
small code distances using neural network-based decoders, demonstrating that the neural network
can generalize to inputs that were not provided during training and that they can reach similar or
better decoding performance compared to previous algorithms. We conclude by discussing the time
required by a feedforward neural network decoder in hardware.

1. Introduction

Quantum computing has emerged as a solution to accelerate various calculations using systems governed by
quantum mechanics. Such calculations are believed to take exponential time to perform using classical
computers. Initial applications where quantum computing will be useful are simulation of quantum physics [1],
cryptanalysis [2, 3] and unstructured search [4], and there is a growing set of other quantum algorithms [5].
Simple quantum algorithms have been shown to scale better than classical algorithms [6–8] for small test cases,
though larger computers are required to solve real-world problems. The main obstacle to scalability is that the
required quantum operations (state preparations, single- and two-qubit unitary gates, and measurements) are
subject to noise, therefore quantum algorithms cannot run with perfect fidelity. This requires quantum computers
to use active error correction [9, 10] to achieve scalability, which in turn requires a classical co-processor to infer
which corrections to make, given a stream of measurement results as input. If this co-processor is slow, performance
of the quantum computer may be degraded (though recent results [11] suggest that this may be mitigated).
The remainder of this paper is organized as follows. In section 2, we outline the relevant aspects of quantum
error correction (QEC) and fault tolerance (FT). We discuss the need for a fast classical co-processor in section 3.
In section 4, we give a brief summary of existing techniques to perform decoding quickly, and follow this in
section 5 with the introduction of a new technique based on feedforward neural networks. We examine the
accuracy of the proposed decoder in section 6, and conclude by discussing its speed in section 7.

2. Quantum error correction

While it is often possible to decrease the amount of noise affecting a quantum operation using advanced control
techniques [12, 13], their analogue nature suggests that some imperfection will always remain. This has driven
the development of algorithmic techniques to protect quantum states and computations from noise, which are
called QEC and FT, respectively.
Quantum error correction replaces unprotected qubit states (e.g. ∣0ñ, ∣1ñ) with specially encoded multi-qubit
states (typically called ∣0ñ ¯ ), accompanied by a set of logical operators Ū transforming states in the subspace
¯ , ∣1ñ
defined by ∣0ñ¯ and ∣1ñ¯ . Quantum codes typically ensure that random operations E acting on fewer than d qubits
cannot transform one encoded state into another (á 0¯ ∣ E∣1¯ ñ = 0), where d is called the code distance [14, 15].

© 2017 IOP Publishing Ltd

Quantum Sci. Technol. 3 (2018) 015004 S Varsamopoulos et al

Figure 1. Surface codes with distances 3, 5, and 7, respectively. Data qubits are placed at the corners of the square tiles, on which the
stabilizers are supported. White and grey squares support stabilizers of the form X Ä4 and Z Ä4 , respectively. White and grey semi-
circles support stabilizers of the form X Ä2 and Z Ä2 , respectively. Logical operators are supported on continuous paths that cross the
tiling from side to side; shorter paths form detectable errors (syndromes shown in red). Ancilla qubits placed inside the tiles can be
coupled to neighbouring data qubits and measured to effect indirect stabilizer measurement.

Typically, these random operations are taken to be Pauli operators, whose names and effects on single-qubit
states are given below:
∣0ñ  ∣1ñ ∣0ñ  ∣0ñ ∣0ñ  i∣1ñ
X: , Z: , Y:
∣1ñ  ∣0ñ ∣1ñ  - ∣1ñ ∣1ñ  - i∣0ñ. (1)

These operators form a convenient basis for the space of possible errors; codes which can correct these errors on
a subset of qubits can correct arbitrary errors on the same subset [15, chapter 2].
Often, the encoded states are chosen to be in the mutual +1 eigenspace of a set of multi-qubit Pauli
operators, called stabilizers, resulting in a stabilizer code. Projective measurements of the stabilizers result in
output bits, called syndromes, which are used by a reliable classical co-processor to determine which error has
occurred, a process called decoding. The use of stabilizer codes can effectively reduce the probability of error
from transmitting a qubit through a noisy channel (though logical errors can still occur, acting as X̄ , Z̄ , or Ȳ ).
This reduction in the probability of error is obtained when operations are perfect, however, QEC is not enough
on its own to guarantee that computation can be performed with a low probability of error when using noisy
operations.
To suppress errors from the physical operations themselves, it is necessary to design logical operations which
act directly on encoded states (i.e. without first transforming the encoded states to bare qubit states), in such a
way that random errors affecting physical operations are likely to result in correctable errors with respect to the
underlying code. Operations which have this property are called fault-tolerant [16]. Fault-tolerant syndrome
measurements can be applied repeatedly to correct time-dependent errors, which occur continuously as
computation proceeds. There are many schemes for attaining FT, based on different families of quantum codes,
and using different techniques for ensuring noise from imperfect state preparation and stabilizer measurement
remains suppressable.
Each FT scheme has a threshold error rate, beneath which there exists a code in the associated code family
which can suppress errors to exponential accuracy, using a polynomially-large number of qubits and operations
[17]. Each code in such a family also typically has a pseudo-threshold, an error rate at which encoded operations
using that specific code provide higher accuracy than is possible using bare qubits/operations. These figures of
merit are used to characterize FT schemes, and are especially important when considering near-term
implementations of these schemes.
One scheme which has a relatively high threshold error rate uses surface codes [18–21], stabilizer codes whose
stabilizers are supported on qubits which are adjacent on a 2D square tiling (see figure 1). This approach also
allows the use of exclusively planar connections between qubits, and uses at most four connections between each
qubit and its neighbours (see figure 2). These features make surface codes especially attractive for near-term
implementation.
To complete such an implementation and analyse its performance, it is also necessary to specify the method
by which surface codes are to be decoded. Syndromes obtained by measuring surface code stabilizers have a
special mathematical structure, which leads to a polynomial-time decoding algorithm. These syndromes occur
at the endpoints of continuous one-dimensional chains of errors if stabilizer measurement is performed with
perfect operations, and differences between consecutive syndromes occur at the endpoints of one-dimensional
chains of data/measurement errors if realistically noisy operations are used (see figure 3). If error rates are low,

2
Quantum Sci. Technol. 3 (2018) 015004 S Varsamopoulos et al

Figure 2. Stabilizer measurement circuit for the distance-3 surface code [22–24]. Left: measurement circuit for individual Z tiles (top)
and X tiles (bottom), including an ancilla qubit to be placed at the centre of each tile. Ancilla qubits are prepared in the +1-eigenstate
of the appropriate basis, four CNOT gates are executed, and the ancilla qubits are measured in the appropriate basis. Right: interleaving
of separate stabilizer measurements, including late preparation and early measurement for weight-two stabilizers.

Figure 3. Three consecutive rounds of surface code measurement arranged in a 2+1-dimensional lattice. Errors on data qubits result
in horizontally-separated changes in the syndrome record, measurement errors result in vertically-separated changes.

then the smallest error which conforms with the syndrome is likely a valid correction. To find it requires the
classical co-processor to minimize the sum of the lengths of chains connecting pairs of syndrome changes, a
problem known as minimum-weight perfect matching [25]. This problem can be solved using the Blossom
algorithm [26, 27]. This algorithm produces accurate corrections for the surface code, but has a complexity
which scales super-linearly with respect to d. This is an obstacle to using the Blossom algorithm for decoding
surface codes in practice, for reasons which we explain in the following section.

3. Need for fast decoding

Projective measurement of the logical qubits and classical feedforward of the measurement values are key
ingredients in universal fault-tolerant quantum computing. To calculate the bit which we feed forward, we need
to decode. Thus, it is necessary to correct errors frequently during a computation.

3
Quantum Sci. Technol. 3 (2018) 015004 S Varsamopoulos et al

While the decoding takes place at the classical co-processor, we could either continue running rounds of
syndrome measurement or stop and wait for the decoding to be concluded. If we stop the computation, errors
will build up until they become uncorrectable. This takes an amount of time which depends on the
implementation in question (~10 ms in current superconducting circuits, for example [28]). On the other hand,
if we continue measuring syndromes, we will build a backlog of data that produces a more difficult decoding
problem in the future. The ideal case would be a decoder that decodes d rounds of syndrome measurement in
less time than the time needed to perform the measurements themselves. In superconducting circuits, the time
for a single round of syndrome measurement is 800 ns [29].
There are many techniques that provide high performance decoding. In the following section, we
summarize some of them.

4. Related work

To decrease decoding time when correcting time-dependent errors, the ‘overlapping recovery’ method was
introduced in [22]. This method divides the measurement record into windows, defined as a set of ~d
consecutive error correction cycles. In the overlapping recovery technique, syndrome changes are matched
either to each other (pairwise) or to a time boundary placed immediately after the last round of syndrome
measurement. At the next window, the syndrome changes matched to the time boundary are forwarded to the
following window, in order to identify chains of errors which cross the boundary. This reduces the backlog
problem mentioned earlier, by allowing the decoding problem to be solved incrementally.
To further reduce the backlog, Fowler [30] has parallelized the Blossom algorithm, using message-passing
between local processors to replace slow subroutines. This technique produces accurate corrections, resulting in
a high threshold error rate, and is scalable to large code distances. However, in the near future, only small code
distances will be experimentally viable, so it is likely that a heuristic approach will perform well.
One such approach is taken in [24]. In this paper, the authors have designed a heuristic-based decoder that
resembles the parallelized MWPM decoding for a distance-3 Surface Code with a window of 3 error correction
cycles. The simple structure of this heuristic algorithm makes it easily programmable to hardware, decreasing
the decoding time. The main drawback of this algorithm is that it cannot easily be extended to higher code
distances, so an alternate method is required.
Currently, machine learning techniques are being explored as possible alternate decoding techniques for
both classical LDPC codes [31, 32] and quantum codes, independently of the need for high-speed decoding. One
such technique is being used in [33]. The authors of this paper use a stochastic neural network (or Boltzmann
machine) to decode stabilizer codes. They optimize the neural network to fit a dataset that includes the errors
and their respective syndromes. The network then models the probability distribution of the errors in the dataset
and generates prospective recovery error chains when a syndrome is input. Many networks are produced for a
variety of physical error probabilities p, so when an error syndrome is obtained, a random recovery chain of
errors is sampled from the distribution corresponding to the known value of p. While this method was as
accurate as MWPM decoding for simple error models, repeated sampling is required in order to produce an
error that conforms with the syndrome, which takes unknown time.
To achieve high accuracy in bounded time, we use a simpler machine learning technique, the feed-forward
neural network, which we introduce and apply to the decoding problem in the next section.

5. Neural network decoder

To apply machine learning techniques to surface code decoding, we first reduce the decoding problem to a well-
studied problem in machine learning; classification. Classification problems consist of a set of (generally high-
dimensional) inputs, each of which is associated with a (generally low-dimensional) label. The goal is to optimize
the assignment of known labels to known inputs (a process called training) so that unknown inputs can also be
correctly labelled.
To reduce the decoding problem to a classification problem, we decompose an error E into three multi-qubit
Pauli operators:
E = S · C · L, (2)

where S is a stabilizer, C is any fixed Pauli which produces the syndrome s (also known as a pure error [34]), and L
is a logical Pauli operator of the surface code, see figure 4. Any decoder which provides a correction
E ¢ = S¢ · C · L , in which the stabilizer in the correction is different from that in the actual error, does not lead to
a logical error. This implies that S can be assigned arbitrarily with no impact on decoder accuracy. Also, it is
possible to produce a pure error by parallel table look-up, since each bit of the syndrome can be assigned a

4
Quantum Sci. Technol. 3 (2018) 015004 S Varsamopoulos et al

Figure 4. Surface code error E decomposed into three components; a stabilizer S, a fixed Pauli C which produces the same syndrome as
E, and a logical operator L.

Figure 5. Graphical and functional descriptions of a feed-forward neural network. In the graphical description (left), inputs xj are
 
passed to neurons in a hidden layer, and each of these neurons outputs s (w · x + b ), where w and b are a local set of weights and a
bias, and s (x ) is a nonlinear activation function (we use s (x ) = (1 + exp (-x ))-1 for all neurons considered in this work). The final
outputs yk can be rounded to {0, 1}, and interpreted as a class label. In the functional picture, the weights and biases are assembled
into matrices and vectors, respectively, allowing the output vector to be expressed as a composition of functions acting on the input
vector.

unique pure error, independently of the other bits. We call the apparatus that produces this error the simple
decoder. Since pure errors can be determined quickly in this fashion, the neural network only has to identify L,
which can take one of four values; ̂ , X̄ , Ȳ , or Z̄ . These four values can be used as labels in a classification
problem.
To solve this problem, we use feed-forward neural networks, which are widely regarded as the simplest
machine learning technique [35]. A feed-forward neural net can be described graphically or functionally, see
figure 5. The artificial neurons which comprise the network are devices which store a length-m internal array of
   
weights w , as well as a bias b. Upon receiving a length-m input x , they calculate (1 + exp (-(w · x + b )))-1 and
either broadcast the result to a subsequent layer of neurons, or output the result directly if the neuron in question

is part of the output layer. Such output is typically denoted y , and its accuracy is measured using an approptiate
cost function.
A typical cost function, which we use in this work, is the average cross-entropy:
  
á H ( p , y )ñ µ - å
 
p · ln ( y (x )) , (3)
( p ,x )Î T

 
where T is the training set, consisting of desired (‘target’) distributions p and input values x . The cross-entropy
is a measure of the divergence between two probability (or frequency) distributions,
 differing from the
Kullback–Leibler divergence [36] only in terms that depend solely on p . To minimize the cross-entropy, we use
stochastic gradient descent, as implemented in the Tensorflow library [37]. To produce a training set, we use
direct sampling at a single physical error probability, where the Blossom algorithm produces a logical error rate
of ~25%. This physical error probability is chosen so that a large variety of error syndromes can be produced
while still ensuring that correction is possible. For small surface codes, it is possible to sample the entire set of
possible syndromes, we limit the size of the training set to at most 106 samples for larger codes. This training set
size provides relatively fast training and high accuracy, as seen in section 6.

5
Quantum Sci. Technol. 3 (2018) 015004 S Varsamopoulos et al

Table 1. Layer sizes for the neural networks used throughout this work.
The number of input nodes is determined by the number of syndromes in
the quantum error correction scenario, using only X (or Z) syndrome bits
for independent X/Z errors, and all syndrome bits for depolarizing errors.
For fault tolerance error models, d rounds of measurement are followed
by readout of the data qubits, and calculated stabilizer eigenvalues are
included in the input. The output layer is restricted to two nodes for
independent X/Z errors, since logical X/Z errors are also independent. In
all other scenarios, four nodes are used to discriminate between ̂ , X̄ , Ȳ ,
and Z̄ . The number of nodes in the hidden layer is determined by
analysing the performance of the resulting decoder empirically.

QEC error models

Code capacity noise

Code distance Input nodes Hidden nodes Output nodes

3 4 10 2
5 12 90 2
7 24 512 2

Depolarizing noise

3 8 128 4
5 24 660 4
7 48 256 4

FT error models

Phenomenological noise

Code distance Input nodes Hidden nodes Output nodes

3 16 768 4

Depolarizing and measurement noise

3 32 768 4

Circuit noise

3 32 704 4

In the following section, we compare the performance of our decoder to the performance of Blossom and the
performance of the partial lookup table (PLUT), which contains the error syndromes and corrections from the
training set. In the event that the input syndrome is not in the training set, the PLUT decoder multiplies the
correction from the simple decoder by the most frequent logical operator, ̂ . The comparison in terms of
performance is based on the logical error rate of each decoder for specific code distances and error models.

6. Results

In the proposed decoder, we provide the error syndrome to both the simple decoder and the neural network. As
presented in table 1, the size of the input for the neural network is equal to the number of required syndrome
bits, depending on the error model, and only one hidden layer was used for all networks. The number of nodes in
the hidden layer was decided based on the performance of the neural network during training and testing.
We test the proposed decoder against Blossom and the PLUT decoder for two classes of error models, called
QEC and FT. QEC error models approximate noise only on data qubits and FT error models approximate noise
on all qubits, gates and operations, therefore requiring multiple rounds of measurement to find all errors. The
code capacity model inserts only X or only Z errors with probability p in the data qubits. The depolarizing model
places X/Y/Z errors with equal probability, p 3, on the data qubits. For these error models only one cycle of
error correction is required to find all errors.
For FT error models, the probability of an error occurring on a qubit and the probability of a measurement
error is the same, therefore the minimum number of rounds of measurement is taken to be d. Instead of data
qubit and measurement errors, the circuit noise model assumes that all operations and gates are noisy. Each
single-qubit gate is followed by depolarizing noise with probability p 3 and each two-qubit gate is followed by a
two-bit depolarizing map where each non- ˆ Ä ˆ two-bit Pauli has probability p 15. Preparation and

6
Quantum Sci. Technol. 3 (2018) 015004 S Varsamopoulos et al

Figure 6. Code capacity error model without measurement errors for Surface Code distances 3, 5 and 7. Performance comparison of
the neural network decoder (blue) to the MWPM algorithm (orange) partial look-up table (green), and un-encoded qubit (black
dashed line).

measurement locations fail with probability p, resulting in a prepared −1-eigenstate or measurement error,
respectively.
In our simulations, more than 106 error correction cycles were run per point, and each point has a
confidence interval of 99.9%. The percentage of the most frequent error syndromes that were used as training
cases for the QEC error models were 100% (d = 3), 72.46% (d = 5), 2.75% (d = 7), see figure 6, and 100%
(d = 3), 0.98% (d = 5), 3 ´ 10-7% (d = 7), see figure 7, for code capacity and depolarizing models
respectively. The percentage of the most frequent error syndromes that were used as training cases for the FT
error models were 30.09%, 0.022% and 0.01% for the code capacity (see figure 8 top), the depolarizing (see
figure 8 middle), and the circuit model (see figure 8 bottom), respectively. The performance of our decoder was
compared to the Blossom algorithm and the PLUT decoder.
In the QEC error models, see figures 6 and 7, we observe a clear trend. In both error models, as the distance
increases the performance of our decoder remains similar to Blossom, and becomes much better than the
PLUT-based decoder. This demonstrates that the neural networks of our decoder can successfully correct error
syndromes that were not included in training. At small code distances, almost all possible error syndromes were
used in training, resulting in identical performance from both the PLUT and our decoder. However, going to

7
Quantum Sci. Technol. 3 (2018) 015004 S Varsamopoulos et al

Figure 7. Depolarizing error model without measurement errors for Surface Code distances 3, 5 and 7. Performance comparison of
the neural network decoder (blue) to the MWPM algorithm (orange) partial look-up table (green), and un-encoded qubit (black
dashed line).

larger distances while using a small set of error syndromes for training, leads to sub-optimal decoding by the
PLUT decoder.
It is known that, for the code capacity error model, Blossom can reach near-optimal accuracy, therefore it is
sufficient for our decoder to reach similar accuracy. There are correctable errors (with weight 3) in distance 7
that are not included in the training set and the neural network is not generalizing correctly. Therefore, the
performance is ~1% worse than Blossom’s. However, for the depolarizing error model, Blossom is known to
misidentify Y errors, since it performs the decoding for X and Z errors separately, treating a Y error as two
distinct errors. Thus, if we train our decoder to take Y errors into account as weight-1 errors, the performance
will be better than Blossom’s. In the depolarizing model, there are still a few weight 3 errors that are being mis-
identified, however the existence of higher weight errors in the training set, that are being corrected properly,
account for the sligthly better performance compared to the Blossom decoder.
In the FT scenario, see figure 8, due to the small code distance, all decoders reach a similar level of
performance. Specifically, for the code capacity and the depolarizing error model, only a small amount of error
syndromes was necessary to reach Blossom’s performance. The circuit metric required more syndromes,
however slightly better performance was achieved in this case as well.

8
Quantum Sci. Technol. 3 (2018) 015004 S Varsamopoulos et al

Figure 8. Code capacity error model with measurement errors for Surface Code distance 3 (top). Depolarizing error model with
measurement errors for Surface Code distance 3 (middle). Circuit error model for Surface Code distance 3 (bottom). Performance
comparison of the neural network decoder (blue) to the MWPM algorithm (orange) partial look-up table (green), and un-encoded
qubit (black dashed line).

It is encouraging that the neural network based decoder can achieve similar performance to Blossom.
However, the main reason that such a design is proposed is to accelerate the decoding time. In the following
section, we provide an estimation of the speed of the neural network based decoder in hardware, and discuss the
implications for future research.

7. Discussion and conclusion

To estimate runtime scaling of a neural network decoder of the type introduced above, we first note that the
runtime is dictated by the sizes of the input, hidden and output layers. The input layer grows quadratically with
the distance of the surface code in question, and the size of the output layer is constant. The size of the hidden
layer, however, is selected through trial and error, so it cannot be predicted a priori.
Given a hidden layer size, we can estimate the required runtime, using the graphical description of neural
networks (see figure 5). Firstly, the output of each neuron can be evaluated independently, so the runtime is
dominated by the time needed to take an inner product between the weight vector and an intermediate state in the
network. Each multiplication can be performed independently, and summation requires a logarithmic-depth

9
Quantum Sci. Technol. 3 (2018) 015004 S Varsamopoulos et al

circuit composed of adders, arranged in a tree-like structure. This implies that any sub-exponential growth in the
size of the hidden layer will result in sub-linear growth in the required decoding time.
To get a better idea of how these scaling arguments function in practice, we can bound the performance of a
neural network decoder, and compare with similar bounds using the Blossom algorithm, running on a CPU. We
consider an average instance of the decoding problem for the d=3 rotated surface code correcting circuit noise,
in which three syndrome differences occur during repeated measurement, leading to a graph with 6 vertices and
9 edges. We also neglect the runtime of the simple decoder, since, for the distance-3 code, it can be reduced to a
simple look-up table.
To lower-bound the time required for the Blossom algorithm, we hard-code the relevant graph data into a C
programme and calculate the matching. This requires ∼500 ns, indicating that the Blossom algorithm can
compute a correction on the timescale required for the distance-3 code. However, this neglects the time required
to translate syndrome data from experimental hardware into the data structure required by the algorithm. To
upper-bound this time, we write a second programme which reads the graph data from a file, resulting in a
runtime of ~6 ms , slightly too slow to be compatible with an 800 ns syndrome measurement time.
To lower-bound the runtime of the neural network, we make the assumption that each arithmetic operation
will require one clock cycle of the appropriate FPGA, typically 1–5 ns [38]. The network which corrects errors
from the circuit model requires two multiplications (one for the hidden layer, and one for the output layer), 15
addition steps (⎡⎢ log 2(32) ⎤⎥ + ⎡⎢ log 2(704) ⎤⎥), and two evaluations of the sigmoid function, for a total of 19 serial
steps, requiring 19–95 ns. To obtain an upper bound, we estimate the number of clock cycles required using a
high-level synthesis tool [39], which permits hardware-synthesizable code to be generated from C, but does not
ensure that the resulting code is optimized for speed. This results in an estimate of ∼3600 clock cycles, requiring
∼3.6–18 ms, again slightly too slow to be compatible with an 800 ns syndrome measurement time. Either
decoder would require only minor optimization to attain compatibility at distance 3, an ideal topic for
immediate future work.
In concert with this, we can extend the proposed decoder to the case where syndromes from a finite window
are fed forward, as in [22]. In addition, we can begin testing the applicability of feedforward neural networks to
surface codes with larger distance, as well as to alternate topological codes for which existing decoders do not
attain high accuracy and speed simultaneously [40–42].
If feedforward neural networks can efficiently decode a large range of topological codes, it will also be
interesting to determine the scope of their applicability. There are known families of sparse and/or high-rate
stabilizer codes [43–45] for which fast and accurate decoders are not known. Aside from concatenated codes,
which can be optimally decoded by fast message passing [34], neural networks provide an interesting avenue to
quickly test the performance of small codes, with ∼50 stabilizer measurements.
In conclusion, feedforward neural networks provide a fast and accurate method to decode small surface
codes, both for performing QEC, as well as fault-tolerant operations. Given that the hardware requirements and
anticipated runtime are relatively low, we expect feedfoward neural network decoders to be usable in the
near term.

Acknowledgments

We thank Tom O’Brien, Paul Baireuther and Brian Tarasinski for useful discussions, and Imran Ashraf for his
timely and invaluable assistance with high-level synthesis tools for FPGA programming. We acknowledge
financial support from Intel in the context of the QuTech-Intel collaboration.

ORCID iDs

Savvas Varsamopoulos https://orcid.org/0000-0002-5277-8768

References
[1] Georgescu I M, Ashhab S and Nori F 2014 Quantum simulation Rev. Mod. Phys. 86 153
[2] Shor P W 1997 Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer SIAM J. Comput.
26 1484–509
[3] Monz T, Nigg D, Martinez E A, Brandl M F, Schindler P, Rines R, Wang S X, Chuang I L and Blatt R 2016 Realization of a scalable Shor
algorithm Science 351 1068–70
[4] Grover L K 1997 Quantum mechanics helps in searching for a needle in a haystack Phys. Rev. Lett. 79 325–8
[5] Jordan S 2016 Quantum algorithms http://math.nist.gov/quantum/zoo/
[6] Wu Z, Li J, Zheng W, Luo J, Feng M and Peng X 2011 Experimental demonstration of the Deutsch–Jozsa algorithm in homonuclear
multispin systems Phys. Rev. A 84 042312

10
Quantum Sci. Technol. 3 (2018) 015004 S Varsamopoulos et al

[7] Liu Y and Zhang F 2015 First experimental demonstration of an exact quantum search algorithm in nuclear magnetic resonance system
Sci. China Phys., Mech. Astron. 58 1–6
[8] Peruzzo A, McClean J, Shadbolt P, Yung M-H, Zhou X-Q, Love P J, Aspuru-Guzik A and O’Brien J L 2014 A variational eigenvalue
solver on a photonic quantum processor Nat. Commun. 5 4213
[9] DiCarlo L et al 2009 Demonstration of two-qubit algorithms with a superconducting quantum processor Nature 460 240–4
[10] Shor P W 1995 Scheme for reducing decoherence in quantum computer memory Phys. Rev. A 52 R2493
[11] Chamberland C, Iyer P and Poulin D 2017 Fault-tolerant quantum computing in the pauli or clifford frame with slow error diagnostics
arXiv:1704.06662
[12] Khodjasteh K, Lidar D A and Viola L 2010 Arbitrarily accurate dynamical control in open quantum systems Phys. Rev. Lett. 104 090501
[13] Motzoi F, Gambetta J M, Rebentrost P and Wilhelm F K 2009 Simple pulses for elimination of leakage in weakly nonlinear qubits Phys.
Rev. Lett. 103 110501
[14] Gottesman D 1997 Stabilizer codes and quantum error correction PhD Thesis California Institute of Technology
[15] Lidar D A and Brun T A 2013 Quantum Error Correction (Cambridge: Cambridge University Press)
[16] Shor P W 1996 Fault-tolerant quantum computation Proc., 37th Annual Symp. on Foundations of Computer Science, 1996 (Piscataway,
NJ: IEEE) pp 56–65
[17] Preskill J 1998 Reliable quantum computers Proc. R. Soc. A 385–410
[18] Kitaev A Y 2003 Fault-tolerant quantum computation by anyons Ann. Phys., NY 303 2–30
[19] Freedman M H and Meyer D A 2001 Projective plane and planar quantum codes Found. Comput. Math. 1 325–32
[20] Bravyi S B and Kitaev A Y 1998 Quantum codes on a lattice with boundary arXiv:9811052
[21] Bombin H and Martin-Delgado M A 2007 Optimal resources for topological two-dimensional stabilizer codes: comparative study
Phys. Rev. A 76 012305
[22] Dennis E, Kitaev A, Landahl A and Preskill J 2002 Topological quantum memory J. Math. Phys. 43 4452–505
[23] Fowler A G, Stephens A M and Groszkowski P 2009 High-threshold universal quantum computation on the surface code Phys. Rev. A
80 052312
[24] Tomita Y and Svore K M 2014 Low-distance surface codes under realistic quantum noise Phys. Rev. A 90 062320
[25] Schrijver A 2003 Combinatorial Optimization: Polyhedra and Efficiency (Algorithms and Combinatorics vol 1) (Berlin: Springer)
[26] Edmonds J 1965 Paths, trees, and flowers Can. J. Math. 17 449–67
[27] Kolmogorov V 2009 Blossom V: a new implementation of a minimum cost perfect matching algorithm Math. Program. Comput. 1
43–67
[28] O’Brien T E, Tarasinski B and DiCarlo L 2017 Density-matrix simulation of small surface codes under current and projected
experimental noise npj Quantum Information 3 39
[29] Versluis R, Poletto S, Khammassi N, Haider N, Michalak D J, Bruno A, Bertels K and DiCarlo L 2016 Scalable quantum circuit and
control for a superconducting surface code Phys. Rev. Applied 8 034021
[30] Fowler A G 2015 Minimum weight perfect matching of fault-tolerant topological quantum error correction in average o (1) parallel
time Quantum Inf. Comput. 15 145–58
[31] Nachmani E, Be’ery Y and Burshtein D 2016 Learning to decode linear codes using deep learning 2016 54th Annual Allerton Conf. on
Communication, Control, and Computing (Allerton) (Piscataway, NJ: IEEE) pp 341–6
[32] Nachmani E, Marciano E, Burshtein D and Y Be’ery 2017 RNN decoding of linear block codes arXiv:1702.07560
[33] Torlai G and Melko R G 2016 A neural decoder for topological codes Phys. Rev. Lett. 119 030501
[34] Poulin D 2006 Optimal and efficient decoding of concatenated quantum block codes Phys. Rev. A 74 052333
[35] MacKay D J C 2003 Information Theory, Inference and Learning Algorithms (Cambridge: Cambridge University Press)
[36] Kullback S and Leibler R A 1951 On information and sufficiency Ann. Math. Stat. 22 79–86
[37] Abadi M et al 2015 TensorFlow: large-scale machine learning on heterogeneous systems http://tensorflow.org/. Software
tensorflow.org
[38] Virtex UltraScale FPGAs Datasheet : DC and AC switching characteristics, March 2017
[39] Liang Y, Rupnow K, Li Y, Min D, Do M N and Chen D 2012 High-level synthesis: productivity, performance, and software constraints
J. Electr. Comput. Eng. 2012 1
[40] Bombin H and Martin-Delgado M A 2006 Topological quantum distillation Phys. Rev. Lett. 97 180501
[41] Landahl A J, Anderson J T and Rice P R 2011 Fault-tolerant quantum computing with color codes arXiv:1108.5738
[42] Bombin H, Duclos-Cianci G and Poulin D 2012 universal topological phase of two-dimensional stabilizer codes New J. Phys. 14 073048
[43] Tillich J-P and Zémor G 2014 Quantum LDPC codes with positive rate and minimum distance proportional to the square root of the
blocklength IEEE Trans. Inf. Theory 60 1193–202
[44] Couvreur A, Delfosse N and Zémor G 2013 A construction of quantum LDPC codes from Cayley graphs IEEE Trans. Inf. Theory 59
6087–98
[45] Bacon D, Flammia S T, Harrow A W and Shi J 2017 Sparse quantum codes from quantum circuits IEEE Trans. Inf. Theory 63 2464–79

11