PreprintPDF Available

Simulation and performance analysis of quantum error correction with a rotated surface code under a realistic noise model

Preprints and early-stage research may not have been peer reviewed yet.

Abstract and Figures

The demonstration of quantum error correction (QEC) is one of the most important milestones in the realization of fully-fledged quantum computers. Toward this, QEC experiments using the surface codes have recently been actively conducted. However, it has not yet been realized to protect logical quantum information beyond the physical coherence time. In this work, we performed a full simulation of QEC for the rotated surface codes with a code distance 5, which employs 49 qubits and is within reach of the current state-of-the-art quantum computers. In particular, we evaluate the logical error probability in a realistic noise model that incorporates not only stochastic Pauli errors but also coherent errors due to a systematic control error or unintended interactions. While a straightforward simulation of 49 qubits is not tractable within a reasonable computational time, we reduced the number of qubits required to 26 qubits by delaying the syndrome measurement in simulation. This and a fast quantum computer simulator, Qulacs, implemented on GPU allows us to simulate full QEC with an arbitrary local noise within reasonable simulation time. Based on the numerical results, we also construct and verify an effective model to incorporate the effect of the coherent error into a stochastic noise model. This allows us to understand what the effect coherent error has on the logical error probability on a large scale without full simulation based on the detailed full simulation of a small scale. The present simulation framework and effective model, which can handle arbitrary local noise, will play a vital role in clarifying the physical parameters that future experimental QEC should target.
Content may be subject to copyright.
Simulation and performance analysis of quantum error correction with a rotated
surface code under a realistic noise model
Mitsuki Katsuda,1, Kosuke Mitarai,1, 2, 3, and Keisuke Fujii1, 2, 4, 5,
1Graduate School of Engineering Science, Osaka University,
1-3 Machikaneyama, Toyonaka, Osaka 560-8531, Japan
2Center for Quantum Information and Quantum Biology,
Osaka University, 1-2 Machikaneyama, Toyonaka 560-0043, Japan
3JST, PRESTO, 4-1-8 Honcho, Kawaguchi, Saitama 332-0012, Japan
4RIKEN Center for Quantum Computing (RQC), Hirosawa 2-1, Wako, Saitama 351-0198, Japan
5Fujitsu Quantum Computing Joint Research Division at QIQB,
Osaka University, 1-2 Machikaneyama, Toyonaka 560-0043, Japan
(Dated: April 26, 2022)
The demonstration of quantum error correction (QEC) is one of the most important milestones
in the realization of fully-fledged quantum computers. Toward this, QEC experiments using the
surface codes have recently been actively conducted. However, it has not yet been realized to protect
logical quantum information beyond the physical coherence time. In this work, we performed a full
simulation of QEC for the rotated surface codes with a code distance 5, which employs 49 qubits
and is within reach of the current state-of-the-art quantum computers. In particular, we evaluate
the logical error probability in a realistic noise model that incorporates not only stochastic Pauli
errors but also coherent errors due to a systematic control error or unintended interactions. While
a straightforward simulation of 49 qubits is not tractable within a reasonable computational time,
we reduced the number of qubits required to 26 qubits by delaying the syndrome measurement in
simulation. This and a fast quantum computer simulator, Qulacs, implemented on GPU allows
us to simulate full QEC with an arbitrary local noise within reasonable simulation time. Based
on the numerical results, we also construct and verify an effective model to incorporate the effect
of the coherent error into a stochastic noise model. This allows us to understand what the effect
coherent error has on the logical error probability on a large scale without full simulation based on
the detailed full simulation of a small scale. The present simulation framework and effective model,
which can handle arbitrary local noise, will play a vital role in clarifying the physical parameters
that future experimental QEC should target.
Quantum error correction (QEC) is essential for the re-
alization of quantum computers because physical qubits
suffer from errors due to decoherence caused by undesir-
able interactions with the environment. QEC protects
them from such errors by encoding logical information of
qubits on many physical qubits [1]. With the progress
of quantum hardware, it is becoming possible to pre-
cisely control tens to a hundred qubits, leading to ex-
perimental demonstrations of simple QEC codes on a va-
riety of physical systems [27]. Surface codes proposed
by Kitaev [8] has attracted much attention as a method
to implement an error correction with superconducting
qubits due to their relatively high threshold for local er-
rors and their implementability using a two-dimensional
lattice of qubits. By using the rotated surface code [9],
we can make one logical qubit with code distance dus-
ing only 2d21 qubits. This means that we can im-
plement d= 3 and d= 5 surface codes with 17 and
49 physical qubits, respectively. Currently available de-
vices such as the ones presented in [10,11] can handle
qubits of this scale. Experimental efforts are underway
to demonstrate QEC with the surface codes using the su-
perconducting qubits. Ref. [7] has achieved exponential
suppression of the logical error probability with the one-
dimensional repetitive code, which is a one-dimensional
substructure of the surface code. Moreover, Refs. [12
14] have implemented all of the operations necessary for
the implementation of QEC in a two-dimensional surface
code with d= 3, while they do not achieve the break-even
point, that is, the logical error probability is smaller than
the physical error probability.
To demonstrate that QEC can actually achieve a logi-
cal error probability lower than the physical one, it is es-
sential to implement a surface code with a code distance
of d= 5 that can correct up to two errors. This is because
two-qubit operations inevitably introduce two-qubit cor-
related errors on physical qubits. However, successful
experimental realizations of surface codes [7,1215] are
still up to d= 3 [1214] possibly due to the limited fi-
delity of gates and readouts in present quantum devices.
To clarify what ultimately limits the experimental im-
plementation of the error correction, detailed numerical
analyses are required; we need to determine how much
performance is necessary for which parameters, and how
much the logical error probability can be reduced if they
are achieved.
Numerical experiments of surface codes have been car-
arXiv:2204.11404v1 [quant-ph] 25 Apr 2022
ried out under various noise models. The simplest, albeit
not truly realistic, model is the stochastic Pauli errors
where Pauli operators act on the qubits probabilistically.
In this case, the Gottesman-Knill theorem [16] allows us
to simulate even large systems efficiently. In real exper-
imental systems, unfortunately, there is a noise that has
coherence and cannot be described by stochastic Pauli er-
rors originating from, for example, over-rotation with a
systematic control error, global external fields, cross-talk
and so on.
Simulating QEC with these noises is as difficult as sim-
ulating a universal quantum computer in general. How-
ever, in certain limited cases, it is possible to numeri-
cally evaluate their performance. For example, a mixture
of coherent and incoherent noise on the one-dimensional
repetition code has been analysed in detail by making
use of its exact solvability mapping it to free-fermionic
dynamics [17]. The d= 3 rotated surface code with am-
plitude damping and dephasing [18] has been analysed
by exact simulation of the system, which is possible due
to its small number of qubits. A sophisticated technique
for contraction of 2D tensor networks has been used to
simulate surface codes with arbitrary local noise on the
data qubits, while the syndrome measurements are as-
sumed to be ideal [19]. It is not clear if this method can
be extended to simulate circuit-level noise, where each
elementary operation is subject to noise. More recently,
quasiprobability decomposition of non-Clifford channels
into Clifford channels is utilized to simulate surface codes
with a small coherent noise [20]. This method is, how-
ever, not applicable to arbitrary noise because the coher-
ence of the noise increases its sampling overhead expo-
nentially. Given the finite precision of control systems
in actual experiments, the existence of coherent errors
is inevitable. A detailed simulation of the surface code
with d= 5, which is the near-term milestone of QEC, is
still challenging for classical computers. A framework to
realize such simulations and to obtain knowledge on the
impact of a coherent error on QEC is highly demanded.
In this work, we fully simulate the QEC under a realis-
tic noise model, including incoherent and coherent noise,
in the d= 5 rotated surface code with 49 physical qubits,
and analyzed the effect of coherent errors on the logical
error probability. The main obstacle to its analysis is
that a straightforward simulation of 49 qubits would re-
quire a complex vector of dimension 249. This prevents us
from simulating the dynamics with a realistic computa-
tional resource. We overcome this obstacle by exploiting
the structure of the syndrome measurement and reusing
the measured qubits in the simulation. This allows us
to achieve a full simulation of the d= 5 rotated surface
code by simulating only 26 qubits, thus making it feasi-
ble to analyze the effects of arbitrary local noise models
on this QEC code. In particular, assuming its implemen-
tation on superconducting qubits, we use a realistic gate
set and noise model, such as coherent errors in one-qubit
operations and cross resonance gates in addition to naive
stochastic Pauli errors. Moreover, we develop an effective
model of physical error probability for incorporating the
effects of coherent errors in rotated surface codes com-
bining the simulation results and the previous analysis
of coherent errors in 1D repetitive codes [17]. Using this
model, we investigate the possible regime of coherence
time, gate time, coherent error ratio, etc., required for
maintaining the quantum information of a logical qubit
beyond the coherence time of a physical qubit. The re-
sults show that if the ratio of gate operation time to
coherence time is below 0.005, the lifetime of the logical
qubit exceeds that of the physical qubit, even if coherent
errors occur with the same magnitude as their incoherent
counterparts. On the other hand, it was also found that
if the magnitude of the coherent error can be reduced to
20% of the incoherent one, the ratio of gate operation
time to coherence time is acceptable up to 0.007. The
present simulation framework for QEC would provide an
important guideline for future experimental demonstra-
tions of QEC to extend the lifetime of logical qubits.
A. Circuits for syndrome measurements
The d= 5 rotated surface code, which is the target
in this work, is shown in FIG.1a. White circles and
black circles in Fig. 1a represent data qubits and ancilla
qubits for the sydrome measurements, respectively. The
list of stabilizers of this code is summarized in Table I.
In this table, Xi, Zimean Pauli operators acting on the
i-th data qubit. These stabilizers are also illustrated in
Fig. 1a.X-type stabilizers correspond to yellow plaque-
ttes, and Z-type stabilizers do to ocher ones. These sta-
bilizers are measured with the circuits shown in Figs. 1b
and 1c, respectively.
The order of CNOT gates is important to determine
the minimum depth of the syndrome measurement cir-
cuit. In this work, we choose the following order. In
the case of X-type stabilizers, they are applied clockwise
from the bottom right, while in the case of Z-type it is
TABLE I. List of stabilizers of the d= 5 rotated surface code
Index X-stabilizer Z-stabilizer
3X2X3X7X8Z11Z12 Z16Z17
4X4X5X9X10 Z1Z2Z6Z7
5X6X7X11X12 Z17 Z18Z22 Z23
6X8X9X13X14 Z7Z8Z12 Z13
7X12X13 X17X18 Z13 Z14 Z18Z19
8X14X15 X19X20 Z3Z4Z8Z9
9X16X17 X21X22 Z19 Z20 Z24Z25
10 X18X19 X23X24 Z9Z10 Z14 Z15
11 X22X23 Z15 Z20
12 X24X25 Z5Z10
123 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
16 320 4 24
14 518 6 22
15 719 8 23
13 917 10 21
11 12
|ψXi |0iH H
|ψZi |0i
FIG. 1. (a)The d= 5 rotated surface codes. Yellow faces( )
corresponds to X-type stabilizer and ocher ones( ) cor-
responds to Z-type stabilizer.White circles( ) means data
qubits with their index, and black circles( ) means ancilla
qubits used for measurement and the order in which the mea-
surement circuits are run. (b)Circuit for the X-type stabi-
lizer measurement (c)Circuit for the Z-type stabilizer mea-
clockwise from the top right. For example, if Z1Z2Z6Z7
is to be measured, we apply CNOT gates with the or-
der of 2,7,6,1. We have to make a special treatment for
the measurement qubits on the boundary as they have
fewer CNOT gates than the other measurement qubits.
In this work, we make them “wait” if their target data
qubit doesn’t exist. While “waiting“, one-qubit noise is
applied. For example, the sequence for measuring X1X2
is “2, 1, wait, wait”, and for measuring X22X23 is “wait,
wait, 22, 23”.
FIG. 2. A method to reduce the number of qubits in sim-
ulation in the case of the one-dimensional repetition code.
(left) The original syndrome measurement circuit. (right) A
time-shifted version of the original one.
B. Reducing the number of qubits for simulation
If we straightforwardly simulate 49 qubits, we need to
reserve a 249-dimensional complex vector on a classical
memory. It prohibits us to simulate the error correction
procedure with a practical computational resource. To
overcome this obstacle, we reduce the number of qubits
that have to be simulated by reusing the measured qubits.
As an illustrative example of this, we show the case for
the one-dimensional repetition code in FIG.2. While in
the actual experiment, the syndrome measurements are
done in parallel for each measurement qubit, we delay
them so that one syndrome measurement runs at a time.
This strategy allows us to reuse one measurement qubit
for multiple stabiliser measurements without changing
the system to be simulated. Note that the same effect can
be obtained by analytically calculating a set of POVM
operators corresponding to each syndrome measurement
and applying them with appropriate probabilities. How-
ever, the circuit-based noise model with coherent error
considered here is somewhat complicated and hence we
avoid this approach.
When applying the proposed method to surface codes,
we have to take care of the order of the two-qubit gates
in the three-dimensional arrangement so that each syn-
drome measurement circuit can be delayed without any
collision. A three-dimensional unit block corresponding
to the syndrome measurements for X- and Z-type sta-
bilizers is shown in FIG. 3a. The unit block consists of
two types of rectangular blocks stacked on a time axis.
The rectangle block of 1 ×1×1 represents a one-qubit
gate applied to a measurement qubit and the rectangle
block of 2 ×1×1 represents a two-qubit gate between a
measurement qubits and an adjacent data qubit. Using
these 3D blocks, we construct a syndrome measurement
circuit for the whole surface code as in FIG. 3b. As you
can see, the blocks are assembled in such a way that they
can be delayed without any collision. This indicates that
the measurement qubits can be reused as same as the
one-dimensional case by delaying the syndrome measure-
ments appropriately. Specifically, the numbers written in
black circles in FIG. 1a correspond to the order in which
the measurements are to be executed.
|0 |0
FIG. 3. (a) Left and right blocks represent the syndrome mea-
surement circuits for X- and Z-stabilizers, respectively. (b)
Each syndrome measurement circuit is complied for parallel
X- and Z-type syndrome measurements on the surface codes.
Note that each syndrome measurement circuit can be delayed
without any collision following the order shown in each block
so that the syndrome measurements are done sequentially to
reduce the number of qubits in simulation.
A. Simulated system
The simulation method in Sec. II allows us to effec-
tively perform the full-vector simulation of d= 5 rotated
surface code, and therefore to evaluate its performance
under any local noise model. We consider a situation
where two types of noise, incoherent and coherent, act
on physical qubits in a syndrome measurement circuit.
Here, we describe the concrete gateset and noise model
that are used in the simulation.
To conduct a realistic simulation, we consider a
hardware-native gateset common to the superconducting
devices and compile the syndrome measurement circuit
with those gates. More concretely, we use a gate-
set {Rx(π/2), R
x(π/2), Rzx (π/2), R
zx(π/2), Rz(π/2)},
Rx(π/2) = eiπX/4,(1)
Rz(π/2) = eiπZ/4,(2)
Rzx(π/2) = eiπX Z/4,(3)
to perform the syndrome measurements. This gateset
is commonly used in the superconducting qubits with
cross resonance gate [21,22]. With these gate sets, the
syndrome measurement circuit can be rewritten as in
FIG. 4, where three changes are made from the circuit
shown in FIG.1b and FIG.1c. Firstly, we replace CNOT
gates in FIG.1c with Rzx(π/2) gates. Second, for the
two Hadamard gates in the circuit of FIG. 1b, we re-
placed the former one by the R
x(π/2) gate and the lat-
ter one by the Rx(π/2) gate. Finally, we apply Rx(π/2)
gates to the data qubits after the circuit shown in FIG.1b
and Rz(π/2) gates to the data qubits after the circuit in
FIG.1c. These one-qubit rotation gates restore the errors
transformed to Yerror by Rzx(π/2) gates.
Next, let us define the noise model used in the simu-
lation and see how incoherent noise is incorporated. We
assume that the single-qubit depolarizing noise,
E1(ρ) = (1 p)ρ+p
A∈{X, Y, Z }
AρA, (4)
acts on every qubit at each step of the measurement cir-
cuit in FIG. 4. Same noise occurs in the “waiting” qubit
where the gate does not act. For the two qubits after the
cross-resonance gates, we apply the two-qubit depolariz-
ing noise:
E2(ρ) = (1 p)ρ+p
15 X
A,B∈{I ,X,Y,Z }
We call the parameter pthe physical error probability.
In this paper, the probability of each Pauli error is set
to be equal, but it is not difficult to reflect the actual
distribution of stochastic errors.
FIG. 4. A syndrome measurement circuit for the rotated surface codes consisting of cross resonance gates and Virtual-Z gates.
The grey rectangle ( ) represents a cross resonance gate acting with another qubit. The rotation angle of the Rx, Rz, Rz x
gates is π/2 and that of the R
xgate is π/2.
Next, we describe coherent noise. The coherent noise
was modelled as an (unintentional) increase in the rota-
tion angle of each rotation gate. This increase is referred
to as an over-rotation error. Since this is associated with
the rotation gate, it does not act on the “waiting” data
qubit. In this study, we want to model the error probabil-
ity with the single parameter p. To this end, we introduce
a coherent error ratio cand set the over-rotation angle
to be θ= 2cp. In other words, for a rotation gate gen-
erated by a Pauli operator A, we add the coherent noise
channel in the form of:
Ec(ρ) = eicpAρeicpA .(6)
The reason why we set θ= 2cpis as follows. Consider
the expectation value of P1=|1ih1|when Rx(θ) = eiθ
is applied to |0i. It is calculated as,
x(θ)P1Rx(θ)|0i= sin2θ
Since θ1, the bit-flip probability pflip associated with
this over-rotation is,
pflip =c2p. (8)
Or equivalently, if the coherence of noise is destroyed
at each step, for example, by using the twirling opera-
tion, then such a decohered noise map corresponds to
a probabilistic Pauli error with probability c2p. If the
coherent errors experience constructive or destructive in-
terferences, then the effect of the coherent error would
be increased or decreased against c2p. The parameter c
controls the magnitude of the coherent error compared
to the incoherent one.
B. Numerical simulation
We employ one of the fastest classical simulators of
quantum circuits, Qulacs [23]. In the simulation, all data
qubits are first initialised to |0iand projected to the sur-
face code state by performing noise-free syndrome mea-
surements with zero outcomes. Next, we run syndrome
measurement circuits with circuit-level noise as explained
above for five rounds. After completing five rounds of
measurements, all data qubits were subjected to projec-
tive measurements in the Pauli Zbasis. The above pro-
cedure was repeated 10000 times. In decoding, as usual,
we took the XOR of the syndrome of the adjacent rounds
to determine the position where the syndrome is flipped.
With this information, we estimated the error positions
using the minimum weight perfect matching (MWPM)
algorithm implemented in NetworkX [24]. After apply-
ing the recovery operation using the estimated errors,
we finally calculate the eigenvalue of the logical Pauli Z
operator ZL=Z1Z7Z13Z19Z25 from the final projective
measurement. The logical error probability pLis esti-
mated by dividing the number of ZL= 1 occurrences by
10000. We varied pfrom 103to 7.0×102and cfrom
0.0 to 1.0 by 0.25. For each parameter pair (p, c), the cal-
culation took 18 hours in the absence of coherent errors
and up to 80 hours in their presence using an NVIDIA
A100 GPU.
The obtained pLis shown in FIG. 5. For psmaller than
about 3.0×103, we can see that pLdecreases if pis de-
creased. Furthermore, pLsatisfies pL=Apξat any value
of cwithin the statistical error. By fitting the numerical
values of pLat c= 0 for p= 1.0×103to 3.0×103
with pL=Apξusing two parameters (A, ξ), we obtain
A= 6.5×105and ξ= 2.92. The value of ξis consistent
with the expectation that it should be d+1
2= 3. One
might think that the contribution of the coherent error
is small because such a small angle rotation can be frozen
by repetitive projections for the syndrome measurements.
However, even for a small ratio c= 0.25, it has a negli-
gible contribution to the logical error probability. This
result clearly shows that the effect of the coherence error
is important to estimate the experimentally achievable
logical error probability accurately.
FIG. 5. The logical error probability is plotted as a function
of the physical error probability pwith coherent-noise param-
eters c= 0,0.25,0.5,0.75,1.0. The dotted lines correspond to
the results of the fitting.
FIG. 6. The ratio peff /p is plotted as a function of the coher-
ence parameter c. The dotted curve represents 1 + αc2with
the fitted value α= 0.872.
C. Effective model incorporating the coherent
In order to understand the effect of coherent noise on
pL, we consider how to effectively incorporate the effect
of coherent error as a leading order correction to the in-
coherent error p. Since we expect that the leading-order
contribution of the coherent error to the effective error
peff is proportional to c2p, we model peff as,
peff =1 + αc2p. (9)
This is because while the probability amplitude for the
coherent error is cp, such an error becomes a de-
tectable event if and only if such an error occurs twice
on either ket or bra spaces in the density operator pic-
ture [17]. The coefficient αtakes into account the fact
that the coherent errors can interfere with each other and
therefore their contribution to peff can be not exactly c2p.
As mentioned before, if the coherence is destroyed at each
step, then αshould be a unit.
Then, we assume that the logical error probability un-
der the coherent error is given by replacing the physical
probability pin the case of c= 0 with peff . More pre-
cisely, the logical error probability pLshould be obtained
by replacing pin Eq. (9) with peff :
pL=A·1 + αc2·pξ,(10)
where Aand ξare thought to be the same as those with
c= 0. The validity of this model is confirmed by detailed
numerical calculations carried out on the 1D repetition
codes in the previous study [17]. To test this assumption
for the two-dimensional case, we estimate the value of α
by the following procedure. First, we fit pLobtained at
various c’s in the range of p= 1.0×103to 3.0×103
with pL=A(Bp)ξusing Bas the fitting parameter while
using the fixed Aand ξobtained at c= 0. Then, we fit
Bwith 1 + αc2. As a result we obtain α= 0.872 and the
ratio peff /p shown in FIG. 6implies that this fitting goes
well supporting our assumption. Another interesting fact
is the coefficient α= 0.872 is smaller than a unit meaning
the coherent error interferes in a destructive way. This
implies that the coherent error modelled in this work is
not so damaging for QEC, since the logical error prob-
ability is increased when the coherence is destroyed at
each step by twirling.
Since this behaviour of the leading order contribution
of the coherent error is a local property of the noise, the
effective model obtained here is expected to be valid not
only when pis reduced for d= 5, but also when the code
distance dis further increased. If this is true, we can
estimate the logical error probability under the coherent
error by combining a limited size of full simulation and a
large size of simulation with stochastic Pauli noise.
D. Experimental consideration
As a concrete usage of this model, here we argue in
what situation an experimental QEC can achive a longer
lifetime tLof logical quantum information against a phys-
ical coherence time tcby calculating tL/tc. First, we
rewrite the error probability pusing the coherence time
tcand time tgrequired for each gate operation. For clar-
ity, we assume that the error probability is well approxi-
mated by:
This is the situation where a quantum gate is well-
calibrated and the coherence-time-limited fidelity is
achieved. Second, we rewrite the logical lifetime tLusing
the logical error probability pL. Letting Nsteps = 11 be
the number of steps in one cycle of the syndrome mea-
surement (see Fig. 4), it takes physical time dNstepstgto
conduct dcycles of syndrome measurements. Since the
logical error occurs with probabilty pLin this time, the
logical lifetime is roughly given by
FIG. 7. The lifetime tLof a logical qubit, calculated from
the coherent noise parameter c, the gate operation time tg
and the coherent time tcof the physical qubit, divided by
tc. The upper graph is a three-dimensional representation of
tL/tc, while the lower graph shows the relationship between
tg/tcand cin more detail. The red area in the upper graph
and the shaded area in the lower graph show the area where
tL< tc.
Finally, combining Eqs. (10)-(12), we obtain the follow-
ing relation:
A·hβ(1 + αc2)·1etg
A graph plotting tL/tcas a function of cand tg/tcis
shown in the FIG. 7. The part of the graph marked in
red is the parameter region where tL/tcis below 1. In
this region, the error correction procedure itself damages
the lifetime and therefore is meaningless for protecting
the quantum information. To achieve tL/tc>1, the gate
and coherence time ratio tg/tcdepends on the amount of
coherent error and ranges from 0.005 to 0.007. If the ra-
tio is reduced to tg/tc= 0.001, the lifetime of the logical
qubit is improved by a factor of tens against the coher-
ence time even in the presence of the coherence error with
c= 1. In this case, the over-rotation angle is θ0.06,
which would be experimentally detectable and hopefully
can be calibrated [25].
Finally, let us discuss the experiments on the rotated
surface code with code distance 3 carried out by different
research groups in 2021 [12,13]. The main parameters
of each experimental system are given in TABLE II. For
p1Q, p2Qin the table, Krinner’s group evaluated it by
Interleaved Randomized Benchmarking (Interleaved RB)
and Zhao’s group evaluated it by Cross Entropy Bench-
marking (XEB). Note that while these are great progress
toward experimental QEC, neither group has succeeded
in QEC in a strict sense. Krinner’s group has imple-
mented a QEC protocol, but was unable to make the
lifetime of the logical qubit T1,L longer than the lifetime
of the physical one T1. Zhao’s group has only imple-
mented the error detection and postselection. The main
reason for the lack of successful error correction would
be the short code distance. The distance 3 code can-
not correct two-qubit errors that occur during two-qubit
Let us see whether or not a successful QEC is reach-
able if the code distance is increased to 5 and con-
sider what elements should be improved if it is not the
case. Since p2Qis 1.5 %,1.035 %, which is outside the
region where pL=Apd+1
2holds in Figure 5, QEC is ex-
pected to fail even if the code distance is increased to 5.
The ratios of the two-qubit gate and coherence time are
Tg,2/T1= 0.003 and = 0.001 for Krinners’ and Zhaos’
groups, respectively. This is sufficiently small from our
analysis. However, p2Qare, respectively, given by 1.5 %
and 1.035 %, which is much higher than those limited
by the coherence time. This implies that this infidelity
caused by a systematic control error or cross-talk result-
ing in coherent errors. Therefore, by improving their
control strategies, there would be a great possibility to
achieve a breakeven point by experimental QEC in the
near future; at least the coherence time does not become
the main obstacle for it.
TABLE II. Parameters of experiments which are implemented
by two different groups.
Parameter Krinner [12] Zhao [13]
1Q gate duration Tg,1(ns) 40 25
2Q gate duration Tg,2(ns) 98 32
Lifetime T1(µs) 32.5 26.1
Coherence Time T
2(µs) 37.5 3.6
1Q gate error p1Q(%) 0.09 0.098
2Q gate error p2Q(%) 1.5 1.035
Measurement duration TM(ns) 300 1500
Measurement error pM(%) 0.9 4.752
Logical Lifetime T1,L(µs) 16.4 64.4
Logical Coherence Time T
2,L(µs) 18.2 69.0
In this study, we constructed a framework to fully sim-
ulate QEC on the distance 5 rotated surface code un-
der an arbitrary local noise. Furthermore, we have con-
structed an effective model that explains the behaviour
of the logical error probability under the coherent errors
within the stochastic Pauli noise model with an appro-
priate modification. Therefore, combining our numerical
result and the effective model, we can analyse the be-
haviour of the logical error probability with smaller a
physical error probability or larger code distance. While
we only modelled the over-rotation caused by a system-
atic control error, there are plenty of sources of coher-
ent errors such as unintended interactions in Hamilto-
nian, cross-talk, global fields and so on. These sources of
noise would be straightforwardly incorporated into our
framework. The performance analysis under a realistic
noise model is becoming increasingly important, and our
framework will provide a vital guideline for future im-
provements on experimental sides.
[1] P. Shor, Fault-tolerant quantum computation, in Pro-
ceedings of 37th Conference on Foundations of Computer
Science (1996) pp. 56–65.
[2] J. Zhang, R. Laflamme, and D. Suter, Experimental im-
plementation of encoded logical qubit operations in a
perfect quantum error correcting code, Physical review
letters 109, 100503 (2012).
[3] M. Abobeih, Y. Wang, J. Randall, S. Loenen, C. Bradley,
M. Markham, D. Twitchen, B. Terhal, and T. Taminiau,
Fault-tolerant operation of a logical qubit in a diamond
quantum processor, arXiv preprint arXiv:2108.01646
[4] L. Egan, D. M. Debroy, C. Noel, A. Risinger, D. Zhu,
D. Biswas, M. Newman, M. Li, K. R. Brown, M. Cetina,
et al., Fault-tolerant control of an error-corrected qubit,
Nature 598, 281 (2021).
[5] Y.-H. Luo, M.-C. Chen, M. Erhard, H.-S. Zhong, D. Wu,
H.-Y. Tang, Q. Zhao, X.-L. Wang, K. Fujii, L. Li, et al.,
Quantum teleportation of physical qubits into logical
code spaces, Proceedings of the National Academy of Sci-
ences 118 (2021).
[6] C. K. Andersen, A. Remm, S. Lazar, S. Krinner,
N. Lacroix, G. J. Norris, M. Gabureac, C. Eichler, and
A. Wallraff, Repeated quantum error detection in a sur-
face code, Nature Physics 16, 875 (2020).
[7] G. Q. AI, Exponential suppression of bit or phase errors
with cyclic error correction, Nature 595, 383 (2021).
[8] E. Dennis, A. Kitaev, A. Landahl, and J. Preskill,
Topological quantum memory, Journal of Mathematical
Physics 43, 4452 (2002).
[9] C. Horsman, A. G. Fowler, S. Devitt, and R. Van Meter,
Surface code quantum computing by lattice surgery, New
Journal of Physics 14, 123011 (2012).
[10] F. Arute, K. Arya, R. Babbush, D. Bacon, J. C.
Bardin, R. Barends, R. Biswas, S. Boixo, F. G. S. L.
Brandao, D. A. Buell, B. Burkett, Y. Chen, Z. Chen,
B. Chiaro, R. Collins, W. Courtney, A. Dunsworth,
E. Farhi, B. Foxen, A. Fowler, C. Gidney, M. Giustina,
R. Graff, K. Guerin, S. Habegger, M. P. Harrigan,
M. J. Hartmann, A. Ho, M. Hoffmann, T. Huang,
T. S. Humble, S. V. Isakov, E. Jeffrey, Z. Jiang,
D. Kafri, K. Kechedzhi, J. Kelly, P. V. Klimov, S. Knysh,
A. Korotkov, F. Kostritsa, D. Landhuis, M. Lind-
mark, E. Lucero, D. Lyakh, S. Mandr`a, J. R. Mc-
Clean, M. McEwen, A. Megrant, X. Mi, K. Michielsen,
M. Mohseni, J. Mutus, O. Naaman, M. Neeley, C. Neill,
M. Y. Niu, E. Ostby, A. Petukhov, J. C. Platt, C. Quin-
tana, E. G. Rieffel, P. Roushan, N. C. Rubin, D. Sank,
K. J. Satzinger, V. Smelyanskiy, K. J. Sung, M. D. Tre-
vithick, A. Vainsencher, B. Villalonga, T. White, Z. J.
Yao, P. Yeh, A. Zalcman, H. Neven, and J. M. Marti-
nis, Quantum supremacy using a programmable super-
conducting processor, Nature 574, 505 (2019).
[11] Y. Wu, W.-S. Bao, S. Cao, F. Chen, M.-C. Chen,
X. Chen, T.-H. Chung, H. Deng, Y. Du, D. Fan, M. Gong,
C. Guo, C. Guo, S. Guo, L. Han, L. Hong, H.-L. Huang,
Y.-H. Huo, L. Li, N. Li, S. Li, Y. Li, F. Liang, C. Lin,
J. Lin, H. Qian, D. Qiao, H. Rong, H. Su, L. Sun,
L. Wang, S. Wang, D. Wu, Y. Xu, K. Yan, W. Yang,
Y. Yang, Y. Ye, J. Yin, C. Ying, J. Yu, C. Zha, C. Zhang,
H. Zhang, K. Zhang, Y. Zhang, H. Zhao, Y. Zhao,
L. Zhou, Q. Zhu, C.-Y. Lu, C.-Z. Peng, X. Zhu, and J.-
W. Pan, Strong quantum computational advantage using
a superconducting quantum processor, Phys. Rev. Lett.
127, 180501 (2021).
[12] S. Krinner, N. Lacroix, A. Remm, A. D. Paolo, E. Genois,
C. Leroux, C. Hellings, S. Lazar, F. Swiadek, J. Her-
rmann, G. J. Norris, C. K. Andersen, M. M¨uller, A. Blais,
C. Eichler, and A. Wallraff, Realizing repeated quan-
tum error correction in a distance-three surface code,
arXiv:2112.03708 [quant-ph] (2021).
[13] Y. Zhao, Y. Ye, H.-L. Huang, Y. Zhang, D. Wu, H. Guan,
Q. Zhu, Z. Wei, T. He, S. Cao, F. Chen, T.-H. Chung,
H. Deng, D. Fan, M. Gong, C. Guo, S. Guo, L. Han,
N. Li, S. Li, Y. Li, F. Liang, J. Lin, H. Qian, H. Rong,
H. Su, L. Sun, S. Wang, Y. Wu, Y. Xu, C. Ying, J. Yu,
C. Zha, K. Zhang, Y.-H. Huo, C.-Y. Lu, C.-Z. Peng,
X. Zhu, and J.-W. Pan, Realizing an error-correcting sur-
face code with superconducting qubits, arXiv:2112.13505
[quant-ph] (2021).
[14] D. Bluvstein, H. Levine, G. Semeghini, T. T. Wang,
S. Ebadi, M. Kalinowski, A. Keesling, N. Maskara,
H. Pichler, M. Greiner, V. Vuletic, and M. D. Lukin, A
quantum processor based on coherent transport of entan-
gled atom arrays, arXiv:2112.03923 [quant-ph] (2021).
[15] A. D. C´orcoles, E. Magesan, S. J. Srinivasan, A. W.
Cross, M. Steffen, J. M. Gambetta, and J. M. Chow,
Demonstration of a quantum error detection code using
a square lattice of four superconducting qubits, Nature
communications 6, 1 (2015).
[16] M. A. Nielsen and I. L. Chuang, Quantum Computation
and Quantum Information: 10th Anniversary Edition
(Cambridge University Press, 2010).
[17] Y. Suzuki, K. Fujii, and M. Koashi, Efficient simulation of
quantum error correction under coherent error based on
the nonunitary free-fermionic formalism, Physical review
letters 119, 190503 (2017).
[18] Y. Tomita and K. M. Svore, Low-distance surface codes
under realistic quantum noise, Physical Review A 90,
062320 (2014).
[19] A. S. Darmawan and D. Poulin, Tensor-network simula-
tions of the surface code under realistic noise, Physical
review letters 119, 040502 (2017).
[20] S. Hakkaku, K. Mitarai, and K. Fujii, Sampling-based
quasiprobability simulation for fault-tolerant quantum
error correction on the surface codes under coherent
noise, Phys. Rev. Research 3, 043130 (2021).
[21] J. M. Chow, A. D. C´orcoles, J. M. Gambetta, C. Rigetti,
B. R. Johnson, J. A. Smolin, J. R. Rozen, G. A. Keefe,
M. B. Rothwell, M. B. Ketchen, and M. Steffen, Simple
all-microwave entangling gate for fixed-frequency super-
conducting qubits, Phys. Rev. Lett. 107, 080502 (2011).
[22] P. Krantz, M. Kjaergaard, F. Yan, T. P. Orlando, S. Gus-
tavsson, and W. D. Oliver, A quantum engineer’s guide
to superconducting qubits, Applied Physics Reviews 6,
021318 (2019),
[23] Y. Suzuki, Y. Kawase, Y. Masumura, Y. Hiraga,
M. Nakadai, J. Chen, K. M. Nakanishi, K. Mitarai,
R. Imai, S. Tamiya, et al., Qulacs: a fast and versatile
quantum circuit simulator for research purpose, Quan-
tum 5, 559 (2021).
[24] A. A. Hagberg, D. A. Schult, and P. J. Swart, Explor-
ing network structure, dynamics, and function using Net-
workX, in In Proceedings of the 7th Python in Science
Conference (SciPy2008) (2008) pp. 11–15.
[25] S. Sheldon, L. S. Bishop, E. Magesan, S. Filipp, J. M.
Chow, and J. M. Gambetta, Characterizing errors on
qubit operations via iterative randomized benchmarking,
Physical Review A 93, 012301 (2016).
ResearchGate has not been able to resolve any citations for this publication.
Full-text available
Solid-state spin qubits are a promising platform for quantum computation and quantum networks1,2. Recent experiments have demonstrated high-quality control over multi-qubit systems3-8, elementary quantum algorithms8-11 and non-fault-tolerant error correction12-14. Large-scale systems will require using error-corrected logical qubits that are operated fault-tolerantly, so that reliable computation becomes possible despite noisy operations15-18. Overcoming imperfections in this way remains a major outstanding challenge for quantum science15,19-27. Here, we demonstrate fault-tolerant operations on a logical qubit using spin qubits in diamond. Our approach is based on the 5-qubit code with a recently discovered flag protocol that enables fault-tolerance using a total of seven qubits28-30. We encode the logical qubit using a novel protocol based on repeated multi-qubit measurements and show that it outperforms non-fault-tolerant encoding schemes. We then fault-tolerantly manipulate the logical qubit through a complete set of single-qubit Clifford gates. Finally, we demonstrate flagged stabilizer measurements with real-time processing of the outcomes. Such measurements are a primitive for fault-tolerant quantum error correction. While future improvements in fidelity and the number of qubits will be required to suppress logical error rates below the physical error rates, our realization of fault-tolerant protocols on the logical-qubit level is a key step towards quantum information processing based on solid-state spins.
Full-text available
We propose a sampling-based simulation for fault-tolerant quantum error correction under coherent noise. A mixture of incoherent and coherent noise, possibly due to over-rotation, is decomposed into Clifford channels with a quasiprobability distribution. Then, an unbiased estimator of the logical error probability is constructed by sampling Clifford channels with an appropriate postprocessing. We characterize the sampling cost via the channel robustness and find that the proposed sampling-based method is feasible even for planar surface codes with relatively large code distances intractable for full state-vector simulations. As a demonstration, we simulate repetitive faulty syndrome measurements on the planar surface code of distance 5 with 81 qubits. We find that the coherent error increases the logical error rate. This is a practical application of the quasiprobability simulation for a meaningful task and would be useful to explore experimental quantum error correction on the near-term quantum devices.
Full-text available
To explore the possibilities of a near-term intermediate-scale quantum algorithm and long-term fault-tolerant quantum computing, a fast and versatile quantum circuit simulator is needed. Here, we introduce Qulacs, a fast simulator for quantum circuits intended for research purpose. We show the main concepts of Qulacs, explain how to use its features via examples, describe numerical techniques to speed-up simulation, and demonstrate its performance with numerical benchmarks.
Full-text available
Quantum error correction protects fragile quantum information by encoding it into a larger quantum system1,2. These extra degrees of freedom enable the detection and correction of errors, but also increase the control complexity of the encoded logical qubit. Fault-tolerant circuits contain the spread of errors while controlling the logical qubit, and are essential for realizing error suppression in practice3–6. Although fault-tolerant design works in principle, it has not previously been demonstrated in an error-corrected physical system with native noise characteristics. Here we experimentally demonstrate fault-tolerant circuits for the preparation, measurement, rotation and stabilizer measurement of a Bacon–Shor logical qubit using 13 trapped ion qubits. When we compare these fault-tolerant protocols to non-fault-tolerant protocols, we see significant reductions in the error rates of the logical primitives in the presence of noise. The result of fault-tolerant design is an average state preparation and measurement error of 0.6 per cent and a Clifford gate error of 0.3 per cent after offline error correction. In addition, we prepare magic states with fidelities that exceed the distillation threshold7, demonstrating all of the key single-qubit ingredients required for universal fault-tolerant control. These results demonstrate that fault-tolerant circuits enable highly accurate logical primitives in current quantum systems. With improved two-qubit gates and the use of intermediate measurements, a stabilized logical qubit can be achieved. Fault-tolerant circuits for the control of a logical qubit encoded in 13 trapped ion qubits through a Bacon–Shor quantum error correction code are demonstrated.
Full-text available
Significance Quantum teleportation and quantum error correction play crucial roles in fault-tolerant quantum computing. Here, we implemented error-correctable quantum teleportation to manipulate a logical qubit and observed the protection of quantum information. Our work presents a useful technology for scalable quantum computing and can serve as a quantum simulator for holographic quantum gravity.
Full-text available
Realizing the potential of quantum computing requires sufficiently low logical error rates ¹ . Many applications call for error rates as low as 10 ⁻¹⁵ (refs. 2–9 ), but state-of-the-art quantum platforms typically have physical error rates near 10 ⁻³ (refs. 10–14 ). Quantum error correction 15–17 promises to bridge this divide by distributing quantum logical information across many physical qubits in such a way that errors can be detected and corrected. Errors on the encoded logical qubit state can be exponentially suppressed as the number of physical qubits grows, provided that the physical error rates are below a certain threshold and stable over the course of a computation. Here we implement one-dimensional repetition codes embedded in a two-dimensional grid of superconducting qubits that demonstrate exponential suppression of bit-flip or phase-flip errors, reducing logical error per round more than 100-fold when increasing the number of qubits from 5 to 21. Crucially, this error suppression is stable over 50 rounds of error correction. We also introduce a method for analysing error correlations with high precision, allowing us to characterize error locality while performing quantum error correction. Finally, we perform error detection with a small logical qubit using the 2D surface code on the same device 18,19 and show that the results from both one- and two-dimensional codes agree with numerical simulations that use a simple depolarizing error model. These experimental demonstrations provide a foundation for building a scalable fault-tolerant quantum computer with superconducting qubits.
Full-text available
The realization of quantum error correction is an essential ingredient for reaching the full potential of fault-tolerant universal quantum computation. Using a range of different schemes, logical qubits that are resistant to errors can be redundantly encoded in a set of error-prone physical qubits. One such scalable approach is based on the surface code. Here we experimentally implement its smallest viable instance, capable of repeatedly detecting any single error using seven superconducting qubits—four data qubits and three ancilla qubits. Using high-fidelity ancilla-based stabilizer measurements, we initialize the cardinal states of the encoded logical qubit with an average logical fidelity of 96.1%. We then repeatedly check for errors using the stabilizer readout and observe that the logical quantum state is preserved with a lifetime and a coherence time longer than those of any of the constituent qubits when no errors are detected. Our demonstration of error detection with its resulting enhancement of the conditioned logical qubit coherence times is an important step, indicating a promising route towards the realization of quantum error correction in the surface code.
Full-text available
The promise of quantum computers is that certain computational tasks might be executed exponentially faster on a quantum processor than on a classical processor¹. A fundamental challenge is to build a high-fidelity processor capable of running quantum algorithms in an exponentially large computational space. Here we report the use of a processor with programmable superconducting qubits2,3,4,5,6,7 to create quantum states on 53 qubits, corresponding to a computational state-space of dimension 2⁵³ (about 10¹⁶). Measurements from repeated experiments sample the resulting probability distribution, which we verify using classical simulations. Our Sycamore processor takes about 200 seconds to sample one instance of a quantum circuit a million times—our benchmarks currently indicate that the equivalent task for a state-of-the-art classical supercomputer would take approximately 10,000 years. This dramatic increase in speed compared to all known classical algorithms is an experimental realization of quantum supremacy8,9,10,11,12,13,14 for this specific computational task, heralding a much-anticipated computing paradigm.
In order to realize fault-tolerant quantum computation, tight evaluation of error threshold under practical noise models is essential. While non-Clifford noise is ubiquitous in experiments, the error threshold under non-Clifford noise cannot be efficiently treated with known approaches. We construct an efficient scheme for estimating the error threshold of one-dimensional quantum repetition code under non-Clifford noise. To this end, we employ non-unitary free-fermionic formalism for efficient simulation of the one-dimensional repetition code under coherent noise. This allows us to evaluate the effect of coherence in noise on the error threshold without any approximation. The result shows that the error threshold becomes one third when noise is fully coherent. The dependence of the error threshold on noise coherence can be explained with a leading-order analysis with respect to coherence terms in the noise map. We expect that this analysis is also valid for the surface code since it is a two-dimensional extension of the one-dimensional repetition code. Moreover, since the obtained threshold is accurate, our results can be used as a benchmark for approximation or heuristic schemes for non-Clifford noise.
The surface code is a many-body quantum system, and simulating it in generic conditions is computationally hard. While the surface code is believed to have a high threshold, the numerical simulations used to establish this threshold are based on simplified noise models. We present a tensor-network algorithm for simulating error correction with the surface code under arbitrary local noise. Our simulation is exact within statistical fluctuations and we use it to study the threshold and the sub-threshold behaviour of the amplitude-damping and systematic rotation channels. We also compare these exact results to those obtained by making standard approximations to the noise models.