Quantum Error Correction and Fault Tolerance

1
Quantum Error Correction and Fault Tolerance

• Daniel Gottesman
• Perimeter Institute

2
The Classical and Quantum Worlds
3
Quantum Error Correction
4
Quantum Errors
For quantum error correction, we consider errors
to be caused by a quantum channel (superoperator)
? Ak ? Ak
Alice
?
Environment
Bob
For fault-tolerance, we must also consider errors
in the gates.
Examples of single-qubit errors
Bit Flip X X?0? ?1?, X?1? ?0?
Phase Flip Z Z?0? ?0?, Z?1? -?1?
Complete dephasing ? ? (? Z?Z)/2 (decoherence)
Rotation R??0? ?0?, R??1? ei2??1?
Frequently, we assume errors are rare, and assume
at most t errors, and try to correct just that
case.
5
QECC Conditions
Theorem A QECC can correct a set E of errors iff
??i?EaEb??j? Cab ?ij
where ??i? form a basis for the codewords, and
Ea, Eb ? E.
Note The matrix Cab does not depend on i and
j. As an example, consider Cab ?ab. Then we
can make a measurement to determine the error.
space with an error Ea
codespace
?1?
?1?
?0?
?0?
If Cab has rank lt maximum, the code is
degenerate. Otherwise, it is nondegenerate.
6
Linearity of QECCs
Theorem If a quantum error-correcting code
(QECC) corrects errors A and B, it also corrects
?A ?B.
A general single-qubit error ? ? ? Ak ? Ak acts
like a mixture of ??? ? Ak???, and Ak is a 2x2
matrix.
Define the Pauli group Pn on n qubits to be
generated by X, Y, and Z on individual qubits.
Then Pn consists of all tensor products of up to
n operators I, X, Y, or Z with overall phase 1,
i.
The weight of M ? Pn is the number of qubits on
which M acts as a non-identity operator. The
weight t Pauli operators span the space of
t-qubit errors. Therefore,
A QECC which corrects all weight t Paulis
automatically corrects all t-qubit errors.
7
Stabilizer Codes
A stabilizer code is a code defined in terms of a
stabilizer, a group of Pauli operators that have
eigenvalue 1 for every codeword. A stabilizer S
must be an Abelian subgroup of the Pauli group,
and cannot contain -1, but is otherwise arbitrary.
Theorem

• A stabilizer code with r generators on n qubits
  encodes k n - r logical qubits.
• Let N(S) Paulis P s.t. PM MP ? M? S, and
  let d be the minimum weight of an element of N(S)
  \ S. Then the code has distance d it corrects
  ?(d-1)/2? general errors.

We say the code is a n, k, d QECC.
8
Design Goals for QECCs
When we design new QECCs, there are many possible
goals

• High rate (high value of both k/n and d/n).
• Efficient decoding (for a general QECC,
  determining the exact error can take
  exponentially long in n).
• Efficient encoding (all stabilizer codes can be
  encoded using O(n2) operations, but O(n) is
  better).
• Specific error models (we can sometimes be more
  efficient if dont insist on correcting all
  t-qubit errors).
• Many symmetries (useful for fault-tolerance and
  sometimes other constructions).
• Other application-specific properties

9
5-Qubit Code
We can generate good codes by picking an
appropriate stabilizer. For instance
X ? Z ? Z ? X ? I
n 5 physical qubits
I ? X ? Z ? Z ? X
5,1,3 code
- 4 generators of S
X ? I ? X ? Z ? Z
k 1 encoded qubit
Z ? X ? I ? X ? Z
Code space is ??? s.t. M??? ??? ? M ? S.
Distance d of this code is 3
Each single-qubit error anticommutes with a
different set of generators, which determine its
error syndrome. E.g.
X ? I ? I ? I ? I has syndrome 0001 I ? I ? Y ? I
? I has syndrome 1110
10
CSS Codes
We can then define a quantum error-correcting
code by choosing two classical linear codes C1
and C2, and replacing the parity check matrix of
C1 with Zs and the parity check matrix of C2
with Xs.
E.g.
Z ? Z ? Z ? Z ? I ? I ? I
C1 7,4,3 Hamming
Z ? Z ? I ? I ? Z ? Z ? I
Z ? I ? Z ? I ? Z ? I ? Z
7,1,3 QECC
X ? X ? X ? X ? I ? I ? I
C2 7,4,3 Hamming
X ? X ? I ? I ? X ? X ? I
X ? I ? X ? I ? X ? I ? X
?0000000? ?1111000? ?1100110? ?1010101?
?0011110? ?0101101? ?0110011? ?1001011?
?0? ?
?1111111? ?0000111? ?0011001? ?0101010?
?1100001? ?1010010? ?1001100? ?0110100?
?1? ?
11
Fault Tolerance
12
Error Propagation
When we perform multiple-qubit gates during a
quantum computation, any existing errors in the
computer can propagate to other qubits, even if
the gate itself is perfect.
CNOT propagates bit flips forward
Phase errors propagate backwards
?0? ?1?
?0? ?1?
?0?
?0?
?0? ?1?
?0? ?1?
?0?
?0?
Of course gates can be wrong too. We assume a
faulty gate can cause errors in all qubits
involved in the gate. We must design protocols so
that one faulty gate causes at most one error per
block of the code.
13
Transversal Operations
Error propagation is only a serious problem if it
propagates errors within a block of the QECC.
Then one wrong gate could cause the whole block
to fail.
The solution Perform gates transversally - i.e.
only between corresponding qubits in separate
blocks.
7-qubit code
7-qubit code
For the 7-qubit code, we can perform CNOT,
Hadamard, and R?/4 (diag(1,i)) transversally.
These gates generate a group of unitaries called
the Clifford group.
14
Ancilla States
However, the Clifford group is not universal (it
can be efficiently simulated classically). In
order to get a universal set of gates, and to
perform fault-tolerant error correction, we must
create special ancilla states.
These ancillas are frequently (but not always)
specific states encoded using the same QECC.
Generally, we follow a procedure along these
lines

• Use a non-FT method to create the ancilla.
• Verify the ancilla carefully. This may be a
  very resource-intensive activity we often
  imagine a separate part of the computer, an
  ancilla factory, is dedicated just to making
  ancillas.
• Interact the ancilla with the data block, often
  using some form of teleportation.

15
Concatenated Codes
Threshold for fault-tolerance proven using
concatenated error-correcting codes.
Error correction is performed more frequently at
lower levels of concatenation.
Effective error rate
p ? Cp2
One qubit is encoded as n, which are encoded as
n2,
(for a code correcting 1 error)
If using a fault-tolerant protocol improves the
error rate, apply it again and again to get the
error rate as low as you like.
16
Threshold for Fault-Tolerance
Theorem There exists a threshold pt such that,
if the error rate per gate and time step is p lt
pt, arbitrarily long quantum computations are
possible.
The physical assumptions for the theorem are
discussed in the next few slides. We allow a
small imperfection in every part of the quantum
computer, including state preparation, gates,
qubit storage, and measurement of qubits.
Proof sketch Each level of concatenation changes
the effective error rate p ? pt (p/pt)2. The
effective error rate pk after k levels of
concatenation is then
and for a computation of length T, we need only
log (log T) levels of concatention, requiring
polylog (T) extra qubits, for sufficient accuracy.
17
Requirements for Fault-Tolerance
Without some form of the following requirements,
fault tolerance is impossible

1. Low gate error rates.
2. Ability to perform operations in parallel.
3. A way of remaining in, or returning to, the
   computational Hilbert space.
4. A source of fresh initialized qubits during the
   computation.
5. Benign error scaling error rates that do not
   increase as the computer gets larger, and no
   large-scale correlated errors.

18
Additional Desiderata
The following properties are desireable but not
essential

1. Ability to perform gates between distant qubits.
2. Fast and reliable measurement and classical
   computation.
3. Little or no error correlation (unless the
   registers are linked by a gate).
4. Very low error rates.
5. High parallelism.
6. An ample supply of extra qubits.
7. Even lower error rates.

It is difficult, perhaps impossible, to find a
physical system which satisfies all desiderata.
Therefore, we need to study tradeoffs which sets
of properties will allow us to perform
fault-tolerant protocols?
19
Threshold Values
Assumptions
Proof
Simulation
Long-range gates, many extra qubits
10-3
5 x 10-2
Two dimensions, nearest neighbor gates
10-5
6 x 10-3
One dimension, two lines of qubits, nearest
neighbor gates
10-6
All numbers assume probabilistic errors, good
classical processing and measurement, and full
parallelism. Proofs assume adversarial errors
with exponential bound (errors in r specific
locations have probability lt pr) Simulations
assume uncorrelated depolarizing channel.
20
Other Error Models

• Coherent errors Not serious could add
  amplitudes instead of probabilities, but this
  worst case will not happen in practice
  (unproven).
• Restricted types of errors Generally not
  helpful tough to design appropriate codes. (But
  other control techniques might help here.)
• There are some exceptions
• Depolarizing channel (threshold improves
  somewhat)
• Erasure errors (errors occur in known locations)
• Pure dephasing (but must match gates to model)
• Non-Markovian errors Allowed when the
  environment is weakly coupled to the system, at
  least for bounded system-bath Hamiltonians.

21
Summary

• Quantum error-correcting codes exist which can
  correct very general types of errors on quantum
  systems.
• A systematic theory of stabilizer codes allows us
  to build many interesting quantum codes.
• To design fault-tolerant protocols, we must
  isolate errors to prevent them from spreading too
  far.
• The threshold theorem states that we can perform
  arbitrarily long quantum computations provided
  the physical error rate is sufficiently low.
• Study of the threshold value is underway, under
  various assumptions about the properties of the
  quantum computer.

22
Further Information

• Short intro. to QECCs quant-ph/0004072
• Short intro. to fault-tolerance
  quant-ph/0701112
• Chapter 10 of Nielsen and Chuang
• Chapter 7 of John Preskills lecture notes
  http//www.theory.caltech.edu/preskill/ph229
• Threshold proof fault-tolerance
  quant-ph/0504218
• My Ph.D. thesis quant-ph/9705052
• Complete course on QECCs http//perimeterinstitu
  te.ca/personal/dgottesman/QECC2007

23
Quantum Error Correction Sonnet
We cannot clone, perforce instead, we
split Coherence to protect it from that
wrong That would destroy our valued quantum
bit And make our computation take too
long. Correct a flip and phase - that will
suffice. If in our code another error's bred, We
simply measure it, then God plays
dice, Collapsing it to X or Y or Zed. We start
with noisy seven, nine, or five And end with
perfect one. To better spot Those flaws we must
avoid, we first must strive To find which ones
commute and which do not. With group and
eigenstate, we've learned to fix Your quantum
errors with our quantum tricks.