Transcript Quantum Error Correction and Fault Tolerance

Quantum Error Correction and Fault
Tolerance
Daniel Gottesman
Perimeter Institute
The
Classical
and
Quantum
Worlds
Quantum Error Correction
Quantum Errors
For quantum error correction, we consider errors to be caused
by a quantum channel (superoperator):
Alice 
Environment
 Ak  Ak†
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.
QECC Conditions
Theorem: A QECC can correct a set E of errors iff
iEa†Eb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
0
1
0
If Cab has rank < maximum, the code is degenerate.
Otherwise, it is nondegenerate.
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.
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.
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 don’t insist on correcting all t-qubit errors).
• Many symmetries (useful for fault-tolerance and
sometimes other constructions).
• Other application-specific properties
5-Qubit Code
We can generate good codes by picking an appropriate stabilizer. For
instance:
[[5,1,3]] code:
XZZXI
IXZZX
XIXZZ
ZXIXZ
n = 5 physical qubits
- 4 generators of S
k = 1 encoded qubit
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
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 Z’s and the parity check matrix of C2 with X’s.
E.g.:
[[7,1,3]]
QECC
ZZZZ I I I
ZZ I IZZ I
Z IZ IZ IZ
XXXXI I I
XX I IXXI
X IX IX IX
C1: [7,4,3]
Hamming
C2: [7,4,3]
Hamming
0  0000000 + 1111000 + 1100110 + 1010101 +
0011110 + 0101101 + 0110011 + 1001011
1  1111111 + 0000111 + 0011001 + 0101010 +
1100001 + 1010010 + 1001100 + 0110100
Fault Tolerance
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:
0 1
0 1
0
0 1
Phase errors propagate
backwards:
0 + 1
0 + 1
0 - 1
0 + 1
0 + 1
0 - 1
0 - 1
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.
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.
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.
Concatenated Codes
Threshold for fault-tolerance proven using concatenated errorcorrecting codes.
Error correction is
performed more
frequently at lower
levels of concatenation.
Effective error rate
One qubit is encoded
as n, which are
encoded as n2, …
p  Cp2
(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.
Threshold for Fault-Tolerance
Theorem: There exists a threshold pt such that, if the error rate per
gate and time step is p < 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
2k
pk  pt (p/ pt )
and for a computation of length T, we need only log (log T) levels of
concatention, requiring polylog (T) extra qubits, for sufficient accuracy.

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.
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?
Threshold Values
Assumptions
Long-range gates,
many extra qubits
Proof
Simulation
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 < pr)
Simulations assume uncorrelated depolarizing channel.
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.
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.
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 Preskill’s 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://perimeterinstitute.ca/personal/dgottesman/QECC2007
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.