Download Document

QEC11
Quantum Error Correction and Quantum Error-Correcting Codes
Todd A. Brun
Center for Quantum Information Science and
Technology (CQIST)
Outline
1.  What is Quantum Error Correction?
2.  Classical Error-Correcting Codes
3.  Does Encoding Copy Information?
4.  Simplest Quantum Codes
5.  Structure of a quantum code
6.  The Stabilizer Formalism
7.  Connection to Classical Linear Codes
8.  Measuring Error Syndromes
9.  Encoding and Decoding Circuits For Quantum Codes
10.  Logical Operators
11.  Degeneracy and Passive Error Correction
12.  Operator (Subsystem) Quantum Error-Correcting Codes
What is Quantum Error Correction?
Quantum error-correction (obviously enough) is the attempt to
protect a quantum state from the effects of errors. So the real
question is: what is a quantum error?
Errors must arise in ways allowed by the laws of quantum mechanics.
In the simplest description, two kinds of errors seem of natural
concern: unitary errors (the Hamiltonian is not exactly what we
thought it was), and decoherence (the system has an uncontrolled
interaction with an external environment).
In both these cases, we can abstract the occurrence of an error as
our state being multiplied by an unknown and unwanted operator:
! !E !
(This could be, for example, an undesired unitary, or one term from a
Kraus expansion.)
Classical Error-Correcting Codes
The typical classical single-bit error is the bit-flip: 0 ↔ 1. If we
assume a simple error model (the binary symmetric channel) in
which bit flips errors occur on each bit independently with
probablility p per unit time, we expect a bit to be corrupted
after O(1/p) steps. (In general, we assume p ≪ 1.)
To get around this problem, we can use redundant coding to help
detect and correct errors. The simplest version of this is just to
keep multiple copies of each bit. If we keep two copies of each
bit, 0 and 1 are encoded in the pairs 00 and 11, respectively. If
an error occurs to one of the two bits, we will get the pair 01 or
10. Since these pairs should never occur, if we see them we
know that an error has happened. (Error detection!)
We can go further and actually correct errors by increasing
redundancy and keeping 3 copies of each bit: 0 → 000, 1 → 111.
So what are the properties of a code that make error detection and
correction possible? And what are the limitations?
1.  Information is stored redundantly across multiple bits.
2.  An error transforms an allowed code word into an illegal code
word. (Necessary for detection.)
3.  The allowed code words remain distinct even after errors occur.
(Necessary for correction.)
4.  No code can protect against every possible error. A code must
be designed with a particular set of correctable errors in mind.
This gives us guidelines in our quest for quantum error correction.
However, quantum information has some additional restrictions
and requirements that may complicate this picture.
Does encoding require information to be copied?
What are some of the limitations that arise from quantum
mechanics, that might prevent error correction?
• 
• 
• 
• 
No-cloning: a general quantum state cannot be copied.
Superpositions: measuring a quantum system will generally
disturb the state.
Continuous errors: the errors of a classical code are discrete.
The number of possible error operators E is continuously
infinite. In analog computation, continuous errors make
correction impossible.
Complementarity: Different possible errors need not commute.
This seems like a formidable list of obstacles, and in the early days
many people (including myself) doubted that quantum error
correction was even possible. Fortunately, we were wrong.
Copying: In fact, a classical bit 0/1 and a code word 000/111 contain
exactly the same information. Instead of storing information locally
in a single bit, it is stored in correlations between bits. (Classical
probability distributions also cannot be cloned, but that doesn’t
prevent classical error correction!)
Superpositions: Classically, there is no reason not to measure the exact
state of a codeword to check for errors. But in principle this is not
necessary. For instance, in the 3-bit repetition code, one need only
measure the parities of neighboring bits. This reveals an error
without revealing the actual stored value.
000
! ! 010
!,
p0 =p1 =0
p0 =p1 =1
111
! ! 101
!
p0 =p1 =0
p0 =p1 =1
A well-designed code can give information about errors without
probing the encoded information!
The Simplest Quantum Codes
For a first attempt, can we design a quantum code that emulates
our simplest classical code, and corrects a single bit flip? In the
quantum context, a bit-flip is the same as an X gate.
|0⟩ → X |0⟩ = |1⟩, |1⟩ → X |1⟩ = |0⟩,
|ψ⟩ = α|0⟩ + β|1⟩ → X |ψ⟩ = α|1⟩ + β|0⟩.
We protect from such errors by unitarily embedding this single qbit state in the state of three q-bits:
(α|0⟩ + β|1⟩)|0⟩|0⟩ → α|000⟩ + β|111⟩.
Note that we have not copied |ψ⟩, so this doesn’t violate the nocloning theorem.
|1!




Ûx
Û2
Û2
···




|y!



(Û2 )−1
···
···
Ûm
•
|0!
!"#$
%&'(
|0!
•
!"#$
%&'(
···
···






α |000! + β |111!





!"#$
%&'(
···
···
Suppose a single bit-flip error occurs on (say) bit 1. The state
becomes α|100⟩ + β|011⟩. Similarly, errors on bits 2 and 3
result in states α|010⟩ + β|101⟩ and α|001⟩ + β|110⟩. We
 error
could determine which
(if any) occurred if we knew the
•


parities of bits 1 and
 2 and bits 2 and 3.
•
•
|ΨL !



To really be quantum error correction, though,
• we need to be able
to determine the error and correct it without measuring the
individual qubits themselves
(and
thereby destroy
the state).
!"#$
%&'(
!"#$
%&'(
)
*
+
,
|0!
Ẑ
|0!
···
···
A simple circuit that does this encoding is:
α |0! + β |1!
···
!"#$
%&'(
Ẑ )*+,
(Û2 )−1
α |0! + β |1!
•
|0!
!"#$
%&'(
•
!"#$
%&'(
|0!






α |000! + β |111!





We can determine the error by the following circuit:




|ΨL !



|0!
|0!
•
•
•
•
!"#$
%&'(
!"#$
%&'(
Ẑ )*+,
!"#$
%&'(
!"#$
%&'(
Ẑ )*+,
Based on the results of these two measurements (the error
syndrome), we can undo the error with a unitary X operator on
one of the three qubits.
So we have two of the key requirements for a quantum code:
1.  Measure error syndromes, not individual qubits.
2.  Apply unitaries to correct the errors.
Discretization of Errors
The fact that we can replicate the performance of a classical code
while protecting quantum information is a good start. But this
code is more powerful than it might immediately appear.
Consider, instead of a bit flip operator X, a general X-rotation:
RX (! ) = exp (!i! X / 2 ) = cos (! / 2 ) I ! isin (! / 2 ) X.
If we apply this operator to (say) the first qubit of our code word
we get the following state:
cos (! / 2 ) (! 000 + " 111 ) ! isin (! / 2 ) (! 100 + " 011 ).
Note that this is a superposition of the code word with no error and
the code word with a single bit-flip. When we measure the
syndrome, we will project into one or the other state, and then
apply the corresponding correction. In fact, this code can
correct any error that is a linear combination error operators:
aI + bX1 + cX 2 + dX3.
Phase Errors
In QM there are many other kinds of errors besides bit flips. We
can construct a code to correct phase errors
|0⟩ → Z |0⟩ = |0⟩, |1⟩ → Z |1⟩ = -|1⟩,
|ψ⟩ = α|0⟩ + β|1⟩ → Z |ψ⟩ = α|0⟩ - β|1⟩.
exactly along the same lines as the bit-flip code:
(α|0⟩ + β|1⟩)|00⟩ → α|+ + +⟩ + β|- - -⟩.
The encoding circuit and syndrome measurement circuit can be
constructed exactly the same way as for the bit flip code, just by
applying Hadamard gates to switch between the X and Z bases.
The Shor Code
Consider the following encoding of a single qubit in nine qubits:
(! 0 + " 1 ) 0
!8
"
!3
!3
!
"
000
+
111
+
000
#
111
.
(
)
(
)
8
8
These 9-qubit code words have the structure of a phase-flip code, but
with each qubit in state (|0⟩ ± |1⟩) encoded in a bit-flip code as
(|000⟩ ± |111⟩). This type of code—one code nested inside
another—is called a concatenated code. This is a very important
concept in making quantum computers robust against noise. Here
it is used to protect against more than one kind of error.
We see that this code can detect a bit flip and a phase flip. But it can
do more than that! Recall that iY = ZX. A Y error is the same as an
X error followed by a Z error. So this code can correct Y errors as
well. Since any 1-bit operator can be written O = aI + bX + cY +
dZ , this code can correct any error on a single bit. The Shor code
protects against general one-qubit errors.
Structure of a Quantum Error-Correcting Code
These examples suggest a general structure for QECCs:
•  A QECC is a subspace of a larger Hilbert space (the codespace).
•  With a QECC we can associate a set of correctable errors. (In
general, there will be different choices of these sets.)
•  Each error in the set maps the codespace to a distinct,
orthogonal subspace (an error space) without disrupting
superpositions.
•  By measuring an observable (or observables), we can
determine which error space the state is in, and hence which
error occurred. This measurement preserves superpositions.
The measurement outcome is the error syndrome.
•  Any linear combination of correctable errors can be corrected
(discretization of errors).
•  Once the error has been determined, it can be corrected by
applying a unitary operator.
As we will see, we can somewhat generalize this structure, but
this is essentially the way any QECC works.
Stabilizer Codes
All of the QECCs we have seen so far are examples of stabilizer
codes. Consider the bit flip code. When we measure the
parities, we are measuring observables
Z⊗Z⊗I,I⊗Z⊗Z.
They both have eigenvalues +1 and −1. Our encoded state |ψL⟩ =
α|000⟩ + β|111⟩ is a +1 eigenstate of both these operators.
This means (Z ⊗ Z ⊗ I)|ψL⟩ =(I ⊗ Z ⊗ Z)|ψL⟩ =|ψL⟩. We call
these two parity-check operators stabilizer generators of the
code. The code space is the simultaneous +1 eigenspace of
both stabilizer generators.
The error operators X1,2,3 all anticommute with one or both of the
stabilizer generators. When one of these errors occurs, it moves
the state to the −1 eigenstate of one or both of the generators.
When we measure them, we can detect the error and correct it.
Similarly, the phase flip code has stabilizer generators X ⊗ X ⊗ I and
I ⊗ X ⊗ X. The Shor Code has eight stabilizer generators:
Z Z I I I I I I I, I Z Z I I I I I I,
I I I Z Z I I I I, I I I I Z Z I I I,
I I I I I I Z Z I, I I I I I I I Z Z,
X X X X X X I I I, I I I X X X X X X
(From here on we omit the tensor product symbols ⊗ as is the
general custom.)
In both these cases, the code space is the simultaneous +1
eigenspace of a set of commuting stabilizer generators.
Shor 95; Steane 96; Gottesman 96; Calderbank, Rains, Shor, Sloane 96
[[n,k]] quantum error correcting code
Discretization
of errors
Pauli group
Z
Pauli unitaries
measure + correct
X
Classical symplectic codes
•  The symplectic product
• 
and
is defined by
commute (anti-commute) iff
and
commute
•  An [[n,k]] quantum error correcting code is described by a (n-k) × 2n
parity check matrix H. Its rowspace B(H) is an isotropic subspace of
n=5, k=1
commuting
stabilizer
generators
dual containing code
Quantum stabilizer codes
•  The code space
is defined as the simultaneous
"S
+1 eigenspace of the stabilizer operators
•  The correctable error set E is defined by:
If E1 and E2 are in E, then at least one of the two
conditions hold:
!
1) E 2t E1 " Z(S)
distinct error syndromes
2) E 2t E1 # S
degenerate code
Y error on 4th q-bit
!
•  Correction involves measuring the error syndrome (i.e. the
simultaneous eigenvector of the stabilizer generators) ,
Calderbank and Shor 96; Steane 96
The Binary (CSS) Construction
The connection between stabilizer codes and symplectic codes
allows us to construct QECCs from classical linear codes.
Suppose that H1 and H2 are parity-check matrices for two
binary linear codes (possibly the same code). We can
construct the symplectic matrix
!
H symp = #
#
"
H1
0
0
H2
$
&, H H T = 0.
1 2
&
%
Provided that H1 H2T = 0 this corresponds to a well-defined
stabilizer code. (This requirement ensures that the stabilizer
generators commute.) If H1 = H2 this is the same are
requiring that the binary code be dual-containing.
If the two codes are [n,k1,d1] and [n,k2,d2], the resulting
quantum code is [[n,k1+k2-n,d≥min(d1,d2)]].
The Steane Code
We can think of a CSS code as the intersection between two
QECCs, one designed to correct bit flip errors, the other
designed to correct phase flip errors.
The canonical example of this is the [[7,1,3]] Steane code, built
from two copies of the [7,4,3] Hamming code.
Here are the stabilizer generators:
I I I X X X X, I X X I I X X, X I X I X I X,
I I I Z Z Z Z, I Z Z I I Z Z, Z I Z I Z I Z.
More advanced codes
The Shor code was the first general-purpose quantum
error-correcting code, but since then many others have
been discovered. An important example, discovered
independently
of the
code,
And here is a basis
for Shor
the code
space:is the seven-bit Steane code:
!
1
|0! → √ |0000000! + |1010101! + |0110011! + |1100110!
8
"
+|0001111! + |1011010! + |0111100! + |1101001! ,
!
1
|1! → √ |1111111! + |0101010! + |1001100! + |0011001!
8
"
+|1110000! + |0100101! + |1000011! + |0010110! .
Notice how the stabilizer description is more compact!
– p. 1/24
Calderbank, Rains, Shor, Sloane 96
The GF(4) Construction (CRSS)
•  Natural isometry between GF(4) and (Z2)2
•  Any dual containing classical [n,k,d]4 code can be made into a
[[n,2k–n,d]] QECC. We map the check matrix H to a symplectic matrix
" !H %
H !$
', where the GF(4) elements map 0, !, " ,1 ! 00, 01,10,11.
# "H &
•  When the classical code attains the Singleton bound n-k ≥ d-1 the
quantum code attains the quantum Singleton bound n-k ≥ 2(d-1).
•  When the classical code attains the Shannon limit
2 – H4(1 – 3p, p,p,p) on a quaternary symmetric channel, the quantum
code attains the Hashing limit 1-H2(1-3p, p,p,p).



|ΨL !



•
!"#$
%&'(
•|0!
•
!"#$
%&'(
•
Measuring Error Syndromes
|0!
!"#$
%&'(
!"#$
%&'(
|ψ!
•
Ẑ )*+,
We already saw an example of how to measure error syndromes
!"#$
%&'( used control-NOT
|0!
%&'(
%&'(
for the
case, !"#$
we
gates
|0! bit-flip code. In that!"#$
Ẑ )*+,
with an ancilla bit as target. This ancilla acquires the parity.
The same principle works for measuring X and Y operators, but
requires us to change basis:
Z=
|ψ!
•
|0!
!"#$
%&'(
X=
S†
H
Y=
|ψ!
|0!
|0!
H
•
!"#$
%&'(
H
•
H
H
!"#$
%&'(
|0!
4
|ψ!
|ψ!
•
!"#$
%&'(
H
S
Ẑ )*+,
4
|ψ!
S†
H
•
H
S
!"#$
%&'(
|0!
So, for example, to measure a stabilizer generator Y X Z we could
use this circuit:








|ΨL !






|0!
S†
H
H
•
•
H
S
H
•
!"#$
%&'(
!"#$
%&'(
!"#$
%&'(
Ẑ )*+,
Note that in a fault-tolerant circuit we would not want to target
the same ancilla qubit for fear of a single error propagating to
three. We would instead prepare three target ancillas in a
particular entangled state (the “cat” state).
Encoding and Decoding Circuits
Encoding a k-qubit quantum state into an [[n,k]] QECC requires
two steps: appending n-k ancilla qubits to the state, and then
applying an n-qubit unitary encoding operator:
! 0
!n"k
E
#U#
$ %L .
To see how we can find these circuits, notice that the set of all
possible input states is also a stabilizer state! The stabilizer
generators are Zk+1, Zk+2, …, Zn. So the encoding circuit is a
unitary that transforms one set of Pauli operators into another
set of Pauli operators.
Z k+1 ! U E Z k+1U Et = g1, Z k+2 ! g2 , …, Z n ! gn"k .
To do this, we need only consider encodings that are members of
the Clifford group. Circuits for such unitaries can be
constructed using only CNOTs, Hadamards, and Phase gates.
The encoding circuit can be derived by a sequence of steps
transforming the stabilizer generators.
CNOTij: Xi Xi Xj, Zi  Zi, Xj  Xj, Zj  Zi Zj
H: X  Z, Z  X
Phase: X  Y = iXZ
!
#
#
#
"
0 1 0
0 0 0
0 0 1
0 0 0
$
!
&
#
''( #
& 'CNOTs
&
#
%
"
1 1 0
0 0 0
1 0 1
0 0 0
$
!
&
#
(#
& 'H'
&
#
%
"
0 0 0
1 1 0
0 0 0
1 0 1
This can be thought of as a series of column operations on the
symplectic matrix representing the stabilizers. Above we see
how the symplectic matrix changes in encoding the phase flip
code.
$
&
&.
&
%
The encoding unitary is not uniquely defined. First, one can
choose between different sets of stabilizer generators for the
same stabilizer group. Second, the action of the unitary on
ancilla states other than 0 can vary.
By an appropriate choice of encoding unitary, one can choose
the decoding unitary to be simply its inverse, with the ancilla
qubits storing the error syndrome:
! 0
!n"k
"1
E
E
#U#
$ % L #N#
$ ES % L #U#
$ OS ! s1 ! sn"k .
In this picture, the ancilla qubits store information about which
error has occurred. This is a good way of understanding how
the error-correcting power of codes arises.
Logical Operators
Each information qubit to be encoded has an anticommuting pair
of operators associated with it: X and Z. Upon applying an
encoding unitary, each of these operators is transformed into
a new Pauli operator. The set of these operators (and the
operators they generate) are the logical operators of the code.
Bit-Flip: X I I  X X X, Z I I  Z I I
Phase-Flip: X I I  Z Z Z, Z I I  X I I
Steane: X I I I I I I  X X X X X X X, Z I I I I I I I  Z Z Z Z Z Z Z
Note that the set of logical operators is not uniquely defined:
each logical operator is actually an equivalence class of
operators that differ by being multiplied by an element of the
stabilizer group.
Degeneracy and Passive Correction
In one respect, QECCs differ significantly from classical codes. In
a quantum code, it is possible for two distinct errors to have
the same error syndrome and to be corrected by the same
operation. We saw this in the Shor code, where phase errors
on the same triplet of qubits have the same syndrome and can
be corrected by the same operation, Z I I.
Two errors are degenerate if they differ by an element of the
stabilizer. This means that whether or not a code is
degenerate is a function not only of the code, but also of the
set of correctable errors. (For every code, there is some set of
correctable errors for which that code is degenerate.)
Errors that are equal to elements of the stabilizer have no effect
on the encoded information—they are passively corrected. In
the most extreme version of this, the entire correctable error
set can be part of the stabilizer—a decoherence-free subspace.
Poulin; Bacon; Aly, Klappenecker and Sarvepalli
Operator QECCs
The basic idea of operator QECCs is that part of the system (the
noisy or gauge part) contains no information about either the
quantum information to be transmitted or the errors which
occur. We allow arbitrary noise to affect this gauge subsystem.
"e "e = # # $ 0 n%k%r 0 n%k%r $ &G
An [[n,k;r]] OQECC: r = number of gauge q-bits
!
Because
the gauge subsystem can be in any arbitrary state,
OQECCs are not subspaces. (That is, the superposition of two
valid states in the OQECC is not a valid state unless they have
the same state for the gauge subsystem.)
OQECC Stabilizer Formalism
•  Write rowspace B of symplectic matrix H as
•  Now, symplectic pairs to correspond to operations on the gauge qubits
•  The correctable error set E is defined by:
If E1 and E2 are in E, then at least one of the two
conditions hold:
1) E 2t E1 " Z(SI )
2) E 2t E1 # SI ,SG
The Bacon-Shor Code
The most famous example of an operator code is the Bacon-Shor
code. Imagine arranging nine qubits on a 3×3 lattice. The
“stabilizer generators” of this code are:
Z
I
I
Z
I
I
I
I
I
I
I
I
Z
I
I
Z
I
I
X
X
I
I
I
I
I
I
I
I
X
X
I
I
I
I
I
I
I
Z
I
I
Z
I
I
I
I
I
I
I
I
Z
I
I
Z
I
I
I
I
X
X
I
I
I
I
I
I
I
I
X
X
I
I
I
I
I
Z
I
I
Z
I
I
I
I
I
I
I
I
Z
I
I
Z
I
I
I
I
I
I
X
X
I
I
I
I
I
I
I
I
X
X
These “stabilizers” do not commute. They are actually products
of stabilizer operators and gauge operators. Because they do
not commute, measuring them all causes a change to the
state of the system. But! This change only affects the gauge
subsystem, not the encoded qubit.
In principle we give up some error-correcting power by not
measuring the gauge subsystem and using it to track errors.
But as we see in this example, this trade-off can be worth it:
by the use of gauge operators, we have dramatically
simplified the syndrome measurements and correction steps,
which can lead to much higher error thresholds in faulttolerant quantum computers.
Conclusions
• 
Quantum error correction is possible, based on principles very similar to
classical error correction. This is made possible by several important facts,
especially discretization of errors and the ability to measure error
syndromes without measuring individual qubits.
• 
Almost all known quantum error-correcting codes are stabilizer codes.
These have a connection to classical symplectic codes (and from them to
binary and quaternary linear codes), but only for dual-containing codes.
• 
For stabilizer codes, both syndrome measurements and encoding/decoding
can be done using Clifford circuits. The effects of these circuits are tracked
by transforming a finite set of Pauli operators (the generators).
• 
Quantum codes go beyond classical codes in the phenomenon of
degeneracy, where distinct errors can be corrected together.
• 
Operator (or subsystem) codes extend the usual formalism. They give up
some power of standard codes in exchange for passive error correction and
(in some cases) simplifying of operations.