Quantum Error Correction and Quantum Error-Correcting Codes

Todd A. Brun Center for Quantum Information Science and Technology (CQIST)

QEC11

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: (This could be, for example, an undesired unitary, or one term from a

Kraus expansion.)

! ! E !

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.

A well-designed code can give information about errors without probing the encoded information!

000p0=p1=0

! ! 010p0=p1=1

! , 111p0=p1=0

! ! 101p0=p1=1

!

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 q-

bit 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 no-

cloning theorem.

A simple circuit that does this encoding is: 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 could determine which error (if any) occurred if we knew the parities of bits 1 and 2 and bits 2 and 3.

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).

3

|nj〉 · · · • · · · |nj〉j times j times

Ux U2 U2

· · ·

Um

(U2)−1

· · ·

(U2)−1 (Ux)−1|1〉 · · · · · · |1〉

· · · · · ·

· · · · · ·

|y〉 · · · · · ·∣∣∣xnj2

j

ymodN⟩

· · · · · ·

α |0〉+ β |1〉 • •

|0〉 !"#$%&'( α |000〉+ β |111〉

|0〉 !"#$%&'(

•

|ΨL〉 • •

•

|0〉 !"#$%&'( !"#$%&'( )*+,Z

|0〉 !"#$%&'( !"#$%&'( )*+,Z

We can determine the error by the following circuit: 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.

3

|nj〉 · · · • · · · |nj〉j times j times

Ux U2 U2

· · ·

Um

(U2)−1

· · ·

(U2)−1 (Ux)−1|1〉 · · · · · · |1〉

· · · · · ·

· · · · · ·

|y〉 · · · · · ·∣∣∣xnj2

j

ymodN⟩

· · · · · ·

α |0〉+ β |1〉 • •

|0〉 !"#$%&'( α |000〉+ β |111〉

|0〉 !"#$%&'(

•

|ΨL〉 • •

•

|0〉 !"#$%&'( !"#$%&'( )*+,Z

|0〉 !"#$%&'( !"#$%&'( )*+,Z

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:

If we apply this operator to (say) the first qubit of our code word

we get the following state: 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:

RX!( ) = exp !i!X / 2( ) = cos ! / 2( ) I ! isin ! / 2( )X.

cos ! / 2( ) ! 000 +" 111( )! isin ! / 2( ) ! 100 +" 011( ).

aI + bX1+ cX

2+ dX

3.

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: 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.

! 0 +" 1( ) 0!8"

!

8000 + 111( )

!3

+"

8000 # 111( )

!3

.

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.

[[n,k]] quantum error correcting code measure + correct

Pauli unitaries

Z X

Pauli group Discretization of errors

Shor ’95; Steane ‘96; Gottesman ’96; Calderbank, Rains, Shor, Sloane ‘96

•  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

commuting stabilizer generators

dual containing code

and commute

n=5, k=1

•  The symplectic product is defined by

•  and commute (anti-commute) iff

Classical symplectic codes

•  The correctable error set E is defined by:

degenerate code

•  The code space is defined as the simultaneous +1 eigenspace of the stabilizer operators

•  Correction involves measuring the “error syndrome” (i.e. the simultaneous eigenvector of the stabilizer generators) ,

distinct error syndromes

Y error on 4th q-bit

Quantum stabilizer codes

If E1 and E2 are in E, then at least one of the two conditions hold:

!

1) E2

tE1" Z(S)

2) E2

tE1# S

!

" S

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

Provided that H1 H2

T = 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)]].

Calderbank and Shor ’96; Steane ‘96

Hsymp

=H1

0

0

H2

!

"

##

$

%

&&, H

1H2

T= 0.

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.

And here is a basis for the code space:

More advanced codes

The Shor code was the first general-purpose quantumerror-correcting code, but since then many others havebeen discovered. An important example, discoveredindependently of the Shor code, is the seven-bit Steane code:

|0〉 →1√8

(

|0000000〉 + |1010101〉+ |0110011〉+ |1100110〉

+|0001111〉 + |1011010〉 + |0111100〉 + |1101001〉)

,

|1〉 →1√8

(

|1111111〉 + |0101010〉+ |1001100〉+ |0011001〉

+|1110000〉 + |0100101〉 + |1000011〉 + |0010110〉)

.

– p. 1/24Notice how the stabilizer description is more compact!

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 •  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).

H! !H

"H

"

#$

%

&', where the GF(4) elements map 0,!,",1! 00, 01,10,11.

Calderbank, Rains, Shor, Sloane ‘96

Measuring Error Syndromes

We already saw an example of how to measure error syndromes for the bit-flip code. In that case, we used control-NOT gates 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 = X =

Y =

3

|nj〉 · · · • · · · |nj〉j times j times

Ux U2 U2

· · ·

Um

(U2)−1

· · ·

(U2)−1 (Ux)−1|1〉 · · · · · · |1〉

· · · · · ·

· · · · · ·

|y〉 · · · · · ·∣∣∣xnj2

j

ymodN⟩

· · · · · ·

α |0〉+ β |1〉 • •

|0〉 !"#$%&'( α |000〉+ β |111〉

|0〉 !"#$%&'(

•

|ΨL〉 • •

•

|0〉 !"#$%&'( !"#$%&'( )*+,Z

|0〉 !"#$%&'( !"#$%&'( )*+,Z

|ψ〉 •

|0〉 !"#$%&'(|ψ〉 H • H

|0〉 !"#$%&'(

3

|nj〉 · · · • · · · |nj〉j times j times

Ux U2 U2

· · ·

Um

(U2)−1

· · ·

(U2)−1 (Ux)−1|1〉 · · · · · · |1〉

· · · · · ·

· · · · · ·

|y〉 · · · · · ·∣∣∣xnj2

j

ymodN⟩

· · · · · ·

α |0〉+ β |1〉 • •

|0〉 !"#$%&'( α |000〉+ β |111〉

|0〉 !"#$%&'(

•

|ΨL〉 • •

•

|0〉 !"#$%&'( !"#$%&'( )*+,Z

|0〉 !"#$%&'( !"#$%&'( )*+,Z

|ψ〉 •

|0〉 !"#$%&'(|ψ〉 H • H

|0〉 !"#$%&'(4

|ψ〉 S† H • H S

|0〉 !"#$%&'(S† H • H S

|ΨL〉 H • H

•

|0〉 !"#$%&'( !"#$%&'( !"#$%&'( )*+,Z

So, for example, to measure a stabilizer generator Y X Z we could use this circuit:

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).

4

|ψ〉 S† H • H S

|0〉 !"#$%&'(S† H • H S

|ΨL〉 H • H

•

|0〉 !"#$%&'( !"#$%&'( !"#$%&'( )*+,Z

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:

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.

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.

! 0!n"k UE# $# %

L.

Zk+1!UEZk+1UE

t= g

1, Zk+2 ! g

2,…, Zn ! gn"k.

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

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.

0 1 0

0 0 1

0 0 0

0 0 0

!

"

###

$

%

&&&

CNOTs' (''1 1 0

1 0 1

0 0 0

0 0 0

!

"

###

$

%

&&&

H' ('0 0 0

0 0 0

1 1 0

1 0 1

!

"

###

$

%

&&&.

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:

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.

! 0!n"k UE# $# %

L

N# $# ES%

L

UE

"1

# $# OS! s

1! s

n"k .

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.

Operator QECCs

Poulin; Bacon; Aly, Klappenecker and Sarvepalli

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

= # # $ 0n%k%r 0

n%k%r $ &G

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.)

An [[n,k;r]] OQECC: r = number of gauge q-bits

•  Write rowspace B of symplectic matrix H as

OQECC Stabilizer Formalism

•  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) E2

tE1" Z(S

I)

2) E2

tE1# S

I,S

G

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 Z I

I I I

I I I

I I I

Z Z I

I I I

I I I

I I I

Z Z I

I Z Z

I I I

I I I

I I I

I Z Z

I I I

I I I

I I I

I Z Z

X I I

X I I

I I I

I X I

I X I

I I I

I I X

I I X

I I I

I I I

X I I

X I I

I I I

I X I

I X I

I I I

I I X

I I 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 fault-tolerant 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.