Quantum Information Theory Graduate Course Spring 2005

1
Quantum Information TheoryGraduate Course
Spring 2005
Lecture 5 02/21/05 Lecture 6 02/28/05 Lecture
7 03/07/05 Lecture 8 03/14/05

• Marco Lanzagorta Jeff Tollaksen
• George Mason University

2
Quantum Error-Correction

• High-Fidelity Transmission and Manipulation of
  Quantum Information

3
Why error correction is important?

• Bowman Open the pod bay doors, HAL.
• HAL 9000 Im sorry Dave, Im afraid I cannot do
  that.

4
All you need to know

• An n,k,d quantum error correction code C(S) is
  the vector space VS stabilized by a subgroup S of
  Gn such that and S has n-k
  independent and commuting generators
• and logical states stabilized by
• which can correct a set of correctable error
  operators Ei in Gn such that, for all j and k

5
Structure

• The best way to arrive to this complicated
  result, while fully understanding its meaning and
  implementation, is through an iterative
  structure
• We start by looking at error correction in
  classical computing, then we extend these ideas
  into quantum computing, then we formalize these
  results, and then we will further formalize, and
  so on
• Some concepts and examples will be seen more than
  once, but each time we will add a new layer of
  detail, complexity and abstraction.
• To avoid getting lost, it is important to be sure
  that you understand each step of the way!

6
Outline

• Classical Error Correction (L5)
• Quantum Error Correction (L5)
• Symmetrisation Procedures (L6)
• Quantum Error Correction Codes (L6)
• Formal Theory of Quantum Error Correction (L7)
• The Stabilizer Code Formalism (L7)
• The Stabilizer Group (L8)
• Constructing Quantum Codes (L8)
• Conclusions (L8)

7
1. Classical Error Correction

• This kind of thing has cropped up before, and it
  has always been attributable to human error
• HAL 9000

8
Classical Error Correction

• Error Correction is not unique to quantum
  computing, it has its origins in classical
  computing.
• Classical Error Correction makes classical
  communications fault tolerant.
• In reality, there is no errorless communication
  of information.
• CEC allows communications over noisy and
  erroneous data channels.
• Of fundamental importance for telecommunications,
  internet, fax

9
Classical Errors

• Suppose c binary sequences (or codewords) of
  length n w1, w2 wc.
• During transmission or storage, external noise
  produces random flips (the only type of error in
  CC).
• If the channel is a binary symmetric memory-less
  channel, then the set of possible received
  sequences is the set of all the 2n binary
  sequences of length n v1, v2 v2n.

10
Binary Symmetric Channel

• In a binary symmetric channel, each bit is
  transmitted with an error probability of e.
• 0 0
• 1 1

1 - e
e
e
1 - e
11
The Hamming Distance

• The task of the receiver is, given v0, to
  identify the most likely codeword wi sent by the
  transmitter.
• That is, the wi closest to v0.
• The distance between two binary sequences, d(wi,
  v0), is knows as the Hamming distance.
• It is measured by the number of digits in which
  the two strings differ.
• For a binary symmetric memoryless channel, the
  codeword with the smallest Hamming distance is
  also the most likely.

12
The Hamming Bound

• The larger the distance between codewords, the
  easier to distinguish them in the presence of
  errors.
• The code is more robust against the effects of
  noise.
• If
• then up to h errors can be corrected.
• Upper bound to the number of codewords c able to
  correct up to h errors.

13
The Hamming Bound Geometric View

• The Hamming bound can be visualized as a sphere
  of radius h around each codeword. If the code can
  correct the errors, then these spheres must be
  disjoint.
• The number of sequences in each sphere, times the
  number of spheres, has to be smaller than the
  total number of sequences of length n

14
Parity Check Codes

• The codewords w are chosen in such a way that
  they satisfy a set of linear equations,
  characterized by the parity check matrix M
• Mw 0
• The receiver then tests if v satisfies the
  equation. If v fails, then the receiver corrects
  its value.

15
Error Pattern and Error Syndrome

• Error Pattern
• z w v
• Error syndrome
• s -Mv -M(w-z) Mz
• The receiver has to detect an error syndrome s,
  and then try to determine the error pattern z
  that might have produced s.

16
Hamming Bound for Parity Check Codes

• If mrank(M), then kn-m bits can be specified
  arbitrarily, while the remaining m are parity
  check digits.
• Then, the number of linearly independent
  codewords is c 2n-m 2k then, the lower bound
  for the number of check digits m is

17
Simple Example

• If we wish to encode 1 bit using n bits, in such
  a way that 1 bit errors are tolerated, then the
  Hamming bound implies that we need to have ngt2.
• Therefore, we need at least 3 bits to encode 1
  bit in a code that protects against 1 bit errors.

18
Data Redundancy

• The major idea behind more sophisticated CECs is
  to encode k bits of data in n bits (ngtk).
• The n-k bits introduce additional information,
  encoding the original data in a redundant way.
• Such redundancy can be used to detect bit errors
  during transmission.
• An error correcting code with data redundancy
  that repeats the original information a number of
  times is also known as a repetition code.

19
Classical Linear Codes

• A code that encodes k bits in n bits (ngtk) is
  called an n,k code.
• A general code encoding k bits in n bits requires
  2k codewords of length n to specify the encoding.
• A linear code C encodes k bits of information
  into an n bit code space specified by an n by k
  generator matrix G with elements in Z2.
• A linear code only requires kn bits to specify
  the encode.

20
Linear Encoding

• We encode a k bits codeword x, into a n bits
  codeword c using a k by n generator matrix G as
  follows
• Error correction for linear codes is done using a
  (n-k) by n parity matrix.

21
Parity Check Equations

• Parity check matrix H is such that
• H c 0 and H GT 0
• The receiver gets the codeword r, which
  incorporates an error e
• r c e
• Then, the syndrome s is given by
• s H r H e

22
Error Correction Recovery

• Once we detect the syndrome s, we can find the
  error that occurred e.
• Now we can correct the error as
• c r e
• And finally we can recover the original
  codevector with
• xT cT G-1

23
General Steps for Classical Error Correction

• Encoding
• The sender encodes the codeword bits
• Error-Detection or Syndrome Diagnosis
• The receiver determines what type of error has
  occurred
• Recovery
• The receiver transform the defective codeword to
  obtain the most likely error-free codeword.
• Decoding
• - The receiver transforms the encoded
  codeword to retrieve the original codeword.

24
Logical Codewords

• The most general error correction codes are of
  the form n,1 and work only with the two logical
  codewords
• So a general binary message is transformed as

25
Dual Construction

• Suppose C is a n,k code with generator matrix G
  and parity check matrix H. Then
• H GT 0 and therefore G HT 0
• The dual of C, denoted by , is the code with
  generator matrix H and parity check matrix GT.
• The dual of C consists of all the codewords y
  such that y is orthogonal to all the codewords of
  C.

26
Self-Dual Codes

• A code is said to be weakly self-dual if
• A code is said to be strictly self-dual if

27
2. Quantum Error Correction

• To make errors is part of human nature, but if
  you really want to mess up things, then you need
  a quantum computer.
• Popular Proverb

28
The Quantum Channel

• A quantum channel is a connection that transmits
  qubits.
• Ideally, coherence is preserved in a quantum
  channel, but this is not the case in real
  systems.
• Quantum errors are usually more severe and varied
  than their classical counterparts.

29
The Problem of Quantum Noise

• Environment quantum noise affects the stability
  of the quantum registers.
• Quantum registers require to be stable for
  relatively long periods of time, so computations
  can be performed or information transmitted to
  other systems.
• Imposes severe limitations to practical quantum
  computing.

30
Limits of Quantum Computing

• Example, an ion trap quantum computer (qubit
  stored in a meta-stable optical transition)
  running Shors algorithm for n lt 2L. Then,
  because of spontaneous emissions, L is bounded
  by 2.2 (Ca), 1.6 (Hg) and 4.5 (Ba).
• Completely unacceptable bounds for most practical
  applications.

31
Quantum Error-Correction

• Quantum noise leads to the corruption of the
  information in the quantum register, and
  therefore it is unacceptable for the reliable
  transmission, manipulation and processing of
  quantum information.
• Quantum Error-Correction protocols encode quantum
  states in a special way that makes them resilient
  against the effects of noise, and then decoding
  when it is wished to recover the original state.

32
Error-Free Gates

• In the context of quantum error correction codes,
  we assume that the errors occur while a quantum
  state is being transmitted or seated on a
  register.
• That is, we assume that the quantum gates are
  error-free.
• Obviously this is not a realistic scenario, but
  Fault Tolerant Quantum Computing is the
  technique that deal with gate errors.

33
Illustration
34
Error Correction Codes

• A quantum correction code usually allows
  correction of a particular set SE of
  correctable errors.
• The task of code construction consists of finding
  codes whose correctable errors include the most
  likely to appear in the physical device.

35
General Steps for Quantum Error Correction

• Encoding
• The sender encodes the codeword
• Error-Detection or Syndrome Diagnosis
• The receiver determines what type of error has
  occurred
• Recovery
• The receiver transform the defective codeword to
  obtain the most likely error-free codeword.
• Decoding
• - The receiver transforms the encoded
  codeword to retrieve the original codeword.

36
Quantum Errors

• A quantum error may include any of the following
• A qubit may flip its value.
• A qubit may change its phase.
• A qubit may decohere (become entangled with the
  environment).

37
Difficulties for QEC

• Non-Cloning Theorem
• We cannot copy quantum states.
• Continuous Errors
• We require infinite precision to determine the
  error in a single qubit.
• Measurement destroys quantum information
• We cannot read the state of the quantum register
  before the end of the computation.

38
Quantum Codevectors

• In QEC we use quantum codevectors wgt, which are
  entangled states of n qubits.
• The information we want to protect is then
  spread by the entanglement over all the n
  qubits.
• Reading or decohering a few qubits will not
  necessarily lead to an irreversible loss of
  quantum information.

39
Error Measurement

• As we cannot measure the qubit to determine what
  error has occurred, we need a more subtle
  syndrome diagnosis procedure.
• Codevectors are chosen in such a way that an
  error will move the wgt into mutually orthogonal
  subspaces.
• Measurement of the syndrome will therefore reveal
  only which subspace wgt has moved to.

40
A Neat Measuring Trick

• Suppose we have an operator M, which is Hermitian
  and unitary, with eigenvalues 1 and 1.
• Then, the following circuit can be used to
  measure the eigenvalues of M, and leaving the
  qubit in the corresponding eigenvector

m
H
H
0gt
Ymgt
Ygt
M
41
Error Probabilities

• We presume that each qubit can undergo an error
  with probability e.
• We also assume that the errors on different
  qubits are independent.
• Then, the probability of errors on two qubits is
  of O(e2). So, if e is very small, then we can
  assume that only one error has occurred, and the
  probability of success is (1-e).
• A QEC that corrects single errors can increase
  the probability of success to (1-O(e2)).
• A QEC that corrects t errors can increase the
  probability of success to (1-O(et1)).

42
3. Symmetrisation Procedures

• I have to stay functional until my mission is
  complete. Then it does not matter.
• The Terminator

43
Symmetrisation Procedures

• Suppose that we can prepare R copies of a quantum
  state that we need to manipulate.
• Then, we project the state of the combined system
  onto the symmetric subspace (the space that
  contains all states which are invariant under any
  permutation of the sub-systems).
• The error free evolution of the R independent
  copies starts and finishes in the symmetric
  subspace.
• Then, frequent projections on the symmetric
  subspace will reduce errors induced by the
  environment.

44
Symmetrisation Operator

• In the sake of simplicity, consider a two qubit
  state.
• The symmetrisation operator is
• S (1/2)(P12 P21)
• where
• then

45
Density Matrices

• We perform the symmetrisation of the density
  matrix
• In particular
• with
• So rS is purer than r.

46
Environment Interaction

• To model the interaction with the environment,
  let us also suppose that
• where z is a traceless Hermitean matrix that
  represents the interaction with the environment

47
Purity of the States

• Taking the first order in perturbation
• We can calculate the average purity of the two
  copies before symmetrisation by calculating the
  average trace of the squared states

where
48
Purity of the Symmetrised States

• After symmetrisation each qubit is in the state
• and has purity
• Since this purity is closer than 1 than with
  the original states, the symmetrised state is
  left in a purer state.

49
Fidelity

• Before symmetrisation
• After symmetrisation

50
R Copies

• Purity
• Fidelity
• Thus, by choosing R very large, the residual
  error can in principle be controlled to lie
  within a small tolerance.

51
4. Quantum Error Correction Codes

• They will fix you.
• They fix everything.
• Robocop

52
Quantum Error Correction Codes

• General types of QECC, according to the type of
  quantum error
• Qubit bit flip codes
• Qubit phase flip codes
• Qubit bit flip and phase flip codes

53
Quantum Bit Flip Errors

• In this type of errors, a noisy channel may flip
  a qubit (aka bit flip channel).
• Similar to classical error.
• One possible solution data redundancy.

1-e
e
54
The Three Qubit Bit Flip Code (1)

• Encoding (repetition code)
• Projectors for Syndrome Diagnosis

         
55
The Three Qubit Bit Flip Code (2)

• Syndrome Diagnosis
• If ltP0gt 1, then, no error.
• If ltP1gt 1, then, bit flip error on qubit one
• If ltP2gt 1, then, bit flip error on qubit two
• If ltP3gt 1, then, bit flip error on qubit three
• Measurement in this basis does not change the
  state because they are orthogonal.
• Measurement does not yield any information about
  the values of a and b.

56
The Three Qubit Bit Flip Code (3)

• Recovery
• Flip the bits accordingly.
• This procedure works perfectly as long as a flip
  error occurs on at most 1 qubit (probability of
  error is 3e2 2e3).
• Measurement of the projector operators is
  theoretically viable, but it may be hard to
  implement using a small set of quantum gates.

57
Alternative Bit Flip Error Correction Code (1)

• Instead of using the projectors describe, we
  could perform two measurements on the observables
  Z1Z2I3 and I1Z2 Z3.
• Remember that
• Then

• Z1Z2I3 compares qubits 1 2

58
Alternative Bit Flip Error Correction Code (2)

• Each of these has eigenvalues 1 and 1, and the
  eigenvectors are the two valid codewords 000gt
  and 111gt.
• Syndrome table

59
Error Analysis (1)

• Quantum error correction should increase the
  fidelity of the transmission channel.
• Before error correction
• with Fidelity

60
Error Analysis (2)

• After using the three qubit bit flip code we
  have
• with fidelity
• Therefore, the fidelity bound is improved only
  if plt1/2.

61
Quantum Phase Flip Errors

• In this type of errors, a noisy channel may flip
  the phase of a qubit (aka phase flip channel).
• Without equivalent in classical error theory.
• One possible solution data redundancy.

1-e
e
62
Three Qubit Phase Flip Code (1)

• A very easy solution, when encoding the qubit,
  change the basis to
• Then, the phase flip error is equivalent to
• Which is a bit flip error!
• Then correct for bit flip errors in the ,-
  basis.

63
Three Qubit Phase Flip Code (2)

64
Three Qubit Phase Flip Code (3)

• Observables for syndrome measurement
• Syndrome table

65
Quantum Bit Flip and Phase Flip Errors

• A more general error may combine a bit flip (X)
  with a phase flip (Z).
• XZY
• To protect against both errors, first we encode
  the qubit using the phase flip code, and then
  encode them again using the bit flip code.
• Concatenation a common technique used to build
  better codes by applying one after the other.

66
Shors Nine Qubit Code (1)

• For the 3-qubit examples we have seen, to encode
  for phase flip and then for bit flip means that
  we require to encode 1 qubit of quantum
  information using 9 qubits

67
Shors Nine Qubit Code (2)

• Then

68
Shors Nine Qubit Code (3)

• Operators for Bit Flip Syndrome diagnosis
• Z1Z2
• Z2Z3
• Z4Z5
• Z5Z6
• Z7Z8
• Z8Z9

• Operators for Phase Flip Syndrome diagnosis
• X1X2 X3X4 X5X6
• X4X5 X6X7 X8X9

69
More General Types of Errors

• So far we have seen discrete errors
• No Error (I)
• Bit Flip Error (X)
• Phase Flip Error (Z)
• Bit and Phase Flip Error (YXZ)
• However, a more general type of error can occur

70
Arbitrary Errors

• Because the 4 Pauli matrices (I,X,Y,Z) form a
  basis for 2x2 matrices, then every general error
  E can be written as
• E e1 I e2 X e3 Z e4 Y
• Therefore, Shors nine qubit code can be used as
  a protection against completely arbitrary errors,
  as long as they affect a single qubit.

71
Discretization of Errors (1)

• A Continuum of errors can be reduced to a
  discrete set of errors.
• If we measure a syndrome in the (I,X,Y,Z) basis,
  the state collapses the superposition of errors
  into one of the four states.
• Then, we reduce an arbitrary error to one of the
  four basic ones.

72
Discretization of Errors (2)

• Suppose we have a noisy quantum channel.
• We describe the noise with a trace-preserving
  quantum operator E, which is represented by Ei.
  Then
• If error occurs only in the first qubit

73
Discretization of Errors (3)

• Measurement of the error syndrome then collapses
  the state into
• And recovery process is performed only for one
  type of error (X, Z, or Y).
• By correcting a discrete set of errors, the code
  automatically corrects for a much larger class of
  errors.

74
5. Formal Theory of Quantum Error Correction

• Quantum Computers are like the Gods in Nordic
  Mythology (Odin, Thor,) they impose lots of
  rules and show no mercy!
• Popular Proverb

75
A Zoology of Quantum Codes

• Quantum Error Correction Codes are characterized
  by the triplet n,k,d, where
• n is the length of the resulting codeword.
• k is the number of qubits to be encoded.
• d is the minimum distance.
• Notice that data redundancy implies ngtk
• A code with minimal distance d2t1 is able to
  correct errors on up to t bits.

76
Weight and Distance

• The weight t of an error is the number of qubits
  acted on by non-trivial Pauli Matrices (X,Y,Z).
• A code with minimal distance d can correct all
  errors with weight up to (d-1)/2.
• Thus, error correction means d at least 2t1
  (recall classical theory).
• Three-qubit bit flip code 3,1,1
• Shors nine qubit code 9,1,3.

77
Encoding as Space Mapping

• A quantum error correction encoding can be viewed
  as a mapping of k qubits in a 2k dimensional
  Hilbert space, into n qubits in a 2n dimensional
  Hilbert space.
• The additional n-k qubits provide the redundancy.

78
Quantum Codes

• Quantum states are encoded by a unitary operation
  into a quantum error-correcting code, a subspace
  C of a much larger Hilbert space.
• An operator P projects a quantum state onto the
  code space C.
• These subspaces have to be orthogonal for
  reliable syndrome measurement.
• Errors mapping to different subspaces must take
  the orthogonal codewords to orthogonal states.

79
Logical States

• A general state in the C space is called an
  encoded or logical state
• Remember, the first step in constructing error
  correction codes is to determine the most
  suitable 2k logical states that form a basis for
  C.

80
Example (1)

• Three qubit bit flip code.
• The encoding creates two logical states
• The error correction code subspace C is spanned
  by these two logical states.
• The projector P is given by

81
Example (2)

• Consider the set of errors
• Clearly, they take the logic states to orthogonal
  spaces
• Then, there is no ambiguity about the error
  syndrome that has occurred.

82
Example (3)

• A really bad choice for our quantum error
  correction code would be, for instance
• Because
• And we cannot distinguish what error really
  happened.

83
General Assumptions

• The quantum noise is described by a quantum
  operator E.
• The complete error-correction procedure is
  effected by a trace-preserving quantum operator
  R, which we call the error-correction operation.

84
Successful Quantum Error Correction

• If the quantum error correction code is
  successful, then, for any state r we have
• Sometimes we may be interested in E being a
  non-trace-preserving error operation, such as a
  measurement, so we cannot write .

85
Quantum Error Correction Conditions

• Theorem Let C be a quantum code, and let P be
  the projector onto C. Suppose E is a quantum
  operation with operation elements Ei. A
  necessary and sufficient condition for the
  existence of R correcting E on C is that
• for some Hermitean matrix a of complex
  numbers.

86
Correctable Errors

• If the Quantum Error Correction Conditions are
  satisfied, then we call the Ei elements the
  noise E errors and
• If such an error correcting code R exists, then
  we say that Ei constitutes a correctable set of
  errors.

87
Example

• For the 3 qubit bit flip code, we have
• And also
• Then, for instance

88
Distinguishable Errors (1)

• A sufficient condition for a code to correct two
  errors Ea and Eb, is that it must be able to
  distinguish them when acting on two different
  logical codewords.
• For Ea and Eb to be distinguishable, they have to
  be orthogonal
• It is sufficient, but not necessary!

89
Distinguishable Errors (2)

• A necessary condition for error correction,
  however, is that
• That is, the corrupted codevectors have to be
  orthogonal.
• Otherwise, we cannot tell them apart.

90
Distinguishable Errors (3)

• Therefore, the necessary and sufficient condition
  for error recovery is
• where
• is an arbitrary Hermitian matrix
  independent of the i-states.
• This is exactly the theorem we just saw!

91
Degenerate Codes

• When two or more different types of errors lead
  to the same codewords, we say we have a
  degenerate code.
• Example Z1 and Z2 have the same effect on both
  logical codewords of Shor code.
• Degeneracy is a quantum effect with no classical
  counterpart.
• Makes very difficult to establish bounds on code
  performance.
• On the good news, they pack more information.

92
Discretization of Errors

• Theorem Suppose C is a quantum code and R is
  the error-correction operation for E with Ei.
  Suppose F is a quantum operation with operator
  elements Fi which are linear combinations of
  Ei. Then, R also corrects for the effects of
  the noise process F on the code C.

93
Advantages of the Discretization of Errors

• Therefore, any code that corrects the
  depolarization channel automatically implies the
  ability to correct any arbitrary single qubit
  quantum operation.
• This is in strong contrast to classical error
  correction for analog systems, which is very
  complex because we cannot perform such a
  reduction.

94
Independent Error Models (1)

• Single-qubit errors may occur in more than 1
  qubit.
• This problem is simplified if we suppose that the
  errors are independent.
• If the noise is sufficiently weak, then we can
  protect the information.
• Note this is different than

95
Independent Error Models (2)

• Consider the depolarization channel
• with fidelity
• The depolarization channel for many qubits is

96
Errors in more than 1 qubit

• What happens if an error affects more than one
  qubit?
• If the error is small and the noise acts on the
  qubits independently, then we can correct the
  code.
• We make an expansion on the power of the error.
  No-error and 1-qubit-error will dominate the
  expansion.

97
Quantum Bounds

• Three most important bounds to quantum error
  correction codes are
• Quantum Hamming Bound
• Quantum Gilbert-Barshamov Bound
• Quantum Singleton / Knill-Laflamme Bound
• The are helpful to understand the theoretical
  limitations of building quantum error correction
  codes.

98
Quantum Hamming Bound (1)

• Suppose a non-degenerate quantum error correction
  code that encodes k qubits in n qubits in such a
  way that can protect up to h errors. Then
• Compared to the classical case, we have an extra
  3j factor due to the three possible errors we can
  have (X,Y,Z) in the quantum case.

99
Quantum Hamming Bound (2)

• Note that the quantum Hamming bound only applies
  to non-degenerate codes but gives some insight
  regarding the degenerate cases.
• Consider the case in which we wish to encode 1
  qubit in n qubits in such a way that errors on 1
  qubit are tolerated (k1, h1). In this case, ngt4.

100
Quantum Gilbert-Varshamov Bound

• Valid for non-degenerative n,k,d codes.
• A quantum code encoding k qubits in n qubits
  correcting errors on t qubits satisfy
• where H is the Shannon entropy

101
Quantum Singleton / Knill-Laflamme Bound

• For degenerate n,k,d quantum codes.
• To correct errors on any t qubits, the code has
  to satisfy
• This limit the minimal size of a quantum code
  resolving any arbitrary single error to n greater
  or equal than 5 qubits.

102
Good Quantum Codes

• A family of n,k,d quantum error correction
  codes is said to be good if
• The Gilbert-Varshamov bound tells us that such
  codes do exist.

103
Noise Reduction (1)

• As we have seen, the interaction between system
  and environment is given by
• Quantum error correction returns all terms of
  this sum having correctable errors to r0.
• Therefore, the fidelity of the corrected state,
  compared to the noise-free state is the sum of
  all coefficients ai associated with the
  uncorrectable errors.

104
Noise Reduction (2)

• Noise is typically a continuous process that
  affects all qubits all the time.
• In error correction, the syndrome is extracted by
  a projective measurement.
• The probability that an error occurs is
  equivalent to the probability that the syndrome
  extraction projects the state onto one which
  differs from the noise-free state by an error
  operator E.

105
Noise Reduction (3)

• It is convenient to rewrite HI as follows
• If only terms of weight1 appear, the environment
  acts individually on each qubit. It does not
  directly produce correlated errors across two or
  more qubits.
• In this case, errors of all weights still appear
  in the density matrix, but they are suppressed by
  a term of O(e2wt(E)), where e is the coupling
  strength between system and environment.

106
Noise Reduction (4)

• In this model, the fidelity of the corrected
  state can be estimated as
• F 1 P(t1)
• Where P is the probability of error with weight
  (t1) given by
• when all single-qubit error amplitudes can add
  coherently (the qubits share a common
  environment).

107
Noise Reduction (5)

• And
• when the errors act incoherently (either
  separate environments, or a common environment
  with couplings of randomly changing phase).

108
Noise Reduction (6)

• Notice that for a good code, t tends to infinity
  while t/n and k/n remain fixed.
• Therefore, good codes exist when t is large and
  e2lt t/3n.
• Our uncorrelated noise hypothesis is a reasonable
  approximation to many physical systems.
• But we have to be extremely careful regarding the
  order of the small coupling constants.

109
Error Avoiding

• A different case of quantum error correction
  codes can be used when a set of correlated
  errors, called burst errors, dominate the
  system-environment coupling.
• In principle, we could find a code whose
  stabilizer includes all these uncorrelated
  errors.
• This is called error avoiding, as in this case,
  the errors do not affect the logical states.
• In general, the more we know about the
  environment and its coupling to the physical
  system, the better we can find an error
  correction code.

110
6. The Stabilizer Code Formalism

• I may be synthetic, but Im not stupid
• Bishop

111
Digitization of Noise

• Any interaction between a set of qubits and
  another system can be expressed by
• where Ei is a tensor product of Pauli
  operators acting on the qubits, and the
  environment states are not required to be
  orthogonal or normalized.
• Then, we express decoherence and noise in terms
  of Pauli operators.

112
Tensor Products of Pauli Operators

• We introduce the notation XuZv for an arbitrary
  error operator, where u and v are binary vectors
  of length n.
• The non zero coordinates of u and v indicate
  where X and Z appear in the tensor product.
• Example
• Remember that Y XZ and thus we only need to
  correct X and Z errors.

113
Error Correction

• Error correction then takes place when
• If there are n qubits in the quantum system, then
  error operators will be of length n.
• The weight of an operator is the number of terms
  not equal to I.
• Then, X10011Z00110 from the previous example has
  length 5 and weight 4.

114
Stabilizer

• Let HM be a set of commuting error operators.
• Because they commute, let Cugt be the
  orthonormal set of simultaneous eigenstates with
  eigenvalue 1
• The set C is the quantum error correcting code,
  and H is the stabilizer.
• The states ugt are the code vectors or quantum
  codewords.

115
Example

• For Shors nine qubit code, we have that C has 2
  quantum codewords and
• Then, these are indeed quantum codevectors of the
  code, and Z1Z2 is part of their stabilizer.

116
Stabilizer Group

• We restrict our attention to the case where H is
  a group.
• For a n,k,d code, C has 2k members and the size
  of the stabilizer is 2n-k.
• C spans a 2k dimensional Hilbert space inside a
  2n dimensional Hilbert space.
• The group H is spanned by n-k linearly
  independent members of H.
• Stay tuned more about the stabilizer group in
  the next section.

117
Decoherence Free Subspaces

• Error operators in the stabilizer are correctable
• as these operators have no effect on the
  logical state.
• If these are the only errors, then the quantum
  error correction code is a noise-free subspace or
  decoherence-free subspace.

118
Correctable Errors

• The set of correctable errors S can be any set of
  errors Ei such that the product E1E2 is member
  of H, or anti-commutes with any member of H.
• But this is the same as before
• However, the stabilizer formulation is based only
  on operators and is completely independent of
  states.

119
Stabilizer Construction

• We construct the stabilizer using X and Z Pauli
  operators.
• Suppose M and M are members of the stabilizer.
  Then

120
Matrix Construction

• The stabilizer is specified by writing down the
  n-k linearly independent error operators that
  span it.
• We put the binary strings u and v which indicate
  the X and Z parts in the form of two (n-k) by n
  binary matrices HX and HZ.

121
Stabilizer Matrix

• We then specify the stabilizer as the (n-k) by 2n
  binary matrix
• H (HXHZ)
• and the requirement that all the operators
  commute (i.e. H is an abelian matrix)
• H is the quantum analogue to the parity check
  matrix in classical error correction.

122
Generator Matrix

• The quantum analogue to the classical generator
  matrix is
• G (GXGZ)
• which is (nk) by 2n and satisfies
• Therefore, H and G are duals with respect to the
  inner product defined by
• uuvv0

123
Dual Operators

• Because of
• then G contains H. Let G be the set of error
  operators generated by G, then also G contains H.
• We can directly obtain H from its dual G.

124
Detectable Errors

• If all members of G (other than the identity)
  have weight at least d, then all error operations
  (other than the identity) of weight less than d
  anticommute with a member of H, and so are
  detectable.
• Then, such a code can correct all error operators
  of weight less than (d-1)/2, where d is the
  minimum distance of the code.
• Same result as before!

125
Code Construction

• The problem of code construction is reduced to a
  problem of finding binary matrices H which
  satisfy
• and whose duals G, defined by
• have large weights.

126
7. The Stabilizer Group

• We are not computers, Sebastian, we are
  physical!
• Roy Batty

127
Stabilizer Codes (1)

• Stabilizer codes are also known as Additive
  Codes.
• Consider the EPR state
• It is easy to verify that
• So we say that the state is stabilized by the
  operators X1X2 and Z1Z2.

128
Stabilizer Codes (2)

• Such a state is unique, as it is the only one (up
  to a global phase) to be stabilized by both X1X2
  and Z1Z2.
• The basic idea of using the stabilizer group is
  to work with the stabilizer operators as group
  generators rather than with the states.
• The group theoretical formalism of the stabilizer
  codes offers a more compact description of the
  quantum error correction codes.

129
The Pauli Group

• The Pauli Group G1 on 1 qubit is given by
• This set of matrices generates a group under the
  operation of matrix multiplication.
• The Pauli Group Gn on n qubits is given by the
  n-fold tensor product of Pauli matrices.

130
Stabilized Vector Spaces

• Suppose S is a subgroup of Gn, and define VS to
  be the set of n qubit states which are fixed by
  every element of S.
• VS is the vector space stabilized by S, and S is
  the stabilizer of the space VS, since every
  element of VS is stable under the action of
  elements of S.

131
Simple Example

• Consider n3 and SI, Z1Z2, Z2Z3, Z1Z3 a
  subgroup of Gn. Then, the states stabilized by
  each member of the subgroup are
• Therefore VS is spanned by 000gt and 111gt.
• That is, S is the stabilizer of VS.

132
Trivial Vector Spaces

• Consider S I,-I,X,-X, then
• So, S is the stabilizer of the trivial vector
  space.
• Two conditions are necessary for S to stabilize a
  non-trivial vector space
• The elements of S must commute.
• (-I) is not an element of S.

133
Error Detection

• In order to perform error-detection operations
  using a stabilizer code, all we need to do is
  measure the eigenvalue of each generator of the
  stabilizer.
• This measurement uniquely identifies the syndrome
  from which we can conclude on the error occurred.

134
Shors Nine Qubit Stabilizer Code (1)

• Shors nine qubit code is an stabilizer code!
• Recalling the syndrome detection operators

135
Shors Nine Qubit Stabilizer Code (2)

• We can check that the two valid codewords we
  defined before are indeed eigenvectors of all
  eight operators M1 to M8 with eigenvalue 1.
• The Mis are the generators gis of the
  stabilizer group S.

136
Shors Nine Qubit Stabilizer Code (3)

• Remember that measuring the eigenvalue of M1 is
  used to determine if a bit flip error has
  occurred on either qubit 1 or qubit 2.
• These bit flip errors are represented by X1 and
  X2 operators.
• Then

137
Syndrome Detection

• So, in general, Mi anticommutes with the errors
  it can detect, while commutes with the errors it
  cannot detect
• We can use these relationships to uniquely
  identify what error has occurred.

138
Group Generators

• In general a n,k,d quantum error correction
  code will have an stabilizer group S generated by
  n-k independent and commuting elements from Gn.
• If the stabilizer has n-k generators, then we can
  prove that VS is a 2k-dimensional space.
• Then, a n,1,d code requires n-1 generators and
  will only have two logic states.

139
Logical States (1)

• In principle, given n-k generators for the
  stabilizer S we can choose any 2k orthonormal
  vectors in the codes to act as our logical
  computational basis states.
• A more systematic method is to choose operators
  such that
• forms an independent and commuting set.

140
Logical States (2)

• The Zj operators play the role of a logical Pauli
  z operator on logical qubit number j.
• We can also define Xj operators that take Zj into
  Zj under conjugation, and leaves all other Zi
  and gi alone.
• Clearly, Xj has the effect of a NOT gate on the
  jth encoded qubit.
• Thus, Xj commutes with all the other members of
  the stabilizer, except for Zj, with which it
  anticommutes.

141
Logical States (3)

• The logical computational basis state
• is therefore defined to be the state with the
  stabilizer

142
Example

• Consider the three qubit bit flip code logical
  states
• Then, it is clear that they are stabilized by

143
Unitary Gates (1)

• The stabilizer formalism can also be used to
  describe the dynamics of the vector spaces under
  a variety of quantum operations.
• Suppose we apply a unitary operation U to a
  vector space VS stabilized by S. Then, for each
  element of VS we have

144
Unitary Gates (2)

• Thus the state UYgt is stabilized by UgUt, from
  which we deduce that the vector space UVS is
  stabilized by the group
• Thus, to compute the change in the stabilizer, we
  need only to compute how it affects the
  generators of the stabilizer.

145
Compact Description of Entanglement (1)

• Imagine n qubits in a state stabilized by
• Applying the Hadamard gate to each qubit we
  arrive to a state stabilized by
• This state is the uniform superposition of all
  computational basis states.

146
Compact Description of Entanglement (2)

• Then, the description of the state vector
  requires 2n amplitudes.
• But we only require n parameters to describe it
  using its stabilizer!
• In general this compact description using the
  stabilizer is possible whenever we use Hadamard,
  phase and controlled-NOT operations.

147
The Normalizer

• The set of U unitary operators such that
  UGnUt Gn is the normalizer of Gn and is denoted
  as N(Gn).
• Theorem Suppose U is any unitary operator on n
  qubits with the property that
• Then, up to a global phase U may be composed
  from O(n2) Hadamard, phase and controlled-NOT
  gates (the normalizer gates).

148
Stabilizer Group Transformations
149
Measurement in the Stabilizer Formalism (1)

• Measurements in the computational basis may also
  be easily described within the stabilizer
  formalism.
• Consider the measurement of a g from Gn. As g is
  a Hermitian operator in can be regarded as an
  observable.
• There are two possibilities
• g commutes with all the generators of S
• g anti-commutes with one or more generators of S.

150
Measurement in the Stabilizer Formalism (2)

• If g commutes with the generators, then g or g
  is an element of S. In this case, a measurement
  of g yields 1 or 1 with probability one, and
  the measurement does not disturb the state of the
  system, leaving the stabilizer invariant.

151
Measurement in the Stabilizer Formalism (3)

• If g anticommutes with one or more members of S,
  then we have equal probabilities (1/2) that we
  will obtain 1 or -1, and the new state of the
  system (and its stabilizer) is

152
The Gottesman-Knill Theorem

• Theorem Suppose a quantum computation is
  performed which involves only the following
  elements state preparation in the computational
  basis, Hadamard gates, phase gates,
  controlled-NOT gates, Pauli gates, and
  measurements of observables in the Pauli group
  (which includes measurements in the computational
  basis as a special case), together with the
  possibility of classical control conditioned on
  the outcome of such measurements. Such a
  computation may be efficiently simulated on a
  classical computer.

153
Quantum Computing Simulations

• The Gottesman-Knill theorem shows that some
  quantum computations involving highly entangled
  states may be simulated efficiently (in
  polynomial time complexity) on classical
  computers.
• These computations include quantum teleportation
  and superdense coding.
• However, not all types of entanglement can be
  described efficiently with the stabilizer
  formalism.

154
Error Correction

• Suppose C(S) is a stabilizer code corrupted by an
  error E in Gn.
• If E takes C(S) to an orthogonal subspace, then
  the error can in principle be detected and
  corrected.
• If E is part of S the error does not corrupt the
  space at all.
• Potential problem if E commutes with all the
  elements of S, but it is not in S. That is

155
The Centralizer

• The centralizer of S in Gn, denoted by Z(S) is
  the set of E in Gn such that E commutes with all
  the generators of S.
• For the stabilizer groups of concern to error
  correction, the centralizer is identical to the
  normalizer of S.

156
Error Correction Conditions

• Theorem Let S be the stabilizer of the
  stabilizer code C(S). Suppose Ei is a set of
  operators in Gn such that
• for all j and k. Then, Ei is a correctable
  set of errors for the code C(S).

157
Error Detection

• Suppose g1,,gn-k is the set of generators for
  the stabilizer of an n,k stabilizer code, and
  that Ej is the set of correctable errors for
  the code.
• Error detection is performed by measuring the
  generators of the stabilizer to obtain the error
  syndrome, which consists of the results
  b1,,bn-k.
• If the error E occurred then the error syndrome
  is given by bm such that

158
Recovery (1)

• In the case where E is the unique error operator
  having this syndrome, recovery is done by
  applying Et.
• In the case where there there are two distinct
  errors E and E giving rise to the same error
  syndrome, it follows that
• EPEt EPEt and then EtEPEtE P
• and therefore EtE is part of S.

159
Recovery (2)

• Thus applying Et after the error E has occurred
  results in a successful recovery.
• Thus, for each possible error syndrome we simply
  pick out a single error E with that syndrome, and
  apply Et to achieve recovery when that syndrome
  is observed.

160
Quantum Error Correction Without Measurement (1)

• As discussed, for error correction, we measure an
  operator M and then execute conditionally an
  operator U.
• It is possible to do this correction by unitary
  operations and ancillas without any measurement.
• This is useful when measurement is undesirable.

161
Quantum Error Correction Without Measurement (2)

• We prepare an ancilla system with the basis state
  igt corresponding to the possible error
  syndromes.
• The ancilla start in a standard pure state 0gt
  before error correction.
• We define the operator U over the principal
  system and ancilla as

162
8. Constructing Quantum Codes

• Its all in the reflexes
• Jack Burton

163
Now we know how to build a quantum error
correction code!

• An n,k,d quantum error correction code C(S) is
  the vector space VS stabilized by a subgroup S of
  Gn such that and S has n-k
  independent and commuting generators
• and logical states stabilized by
• which can correct a set of correctable error
  operators Ei in Gn such that, for all j and k

164
The Three Qubit Bit Flip Code 3,1,1
165
The Nine Qubit Shor Code 9,1,3
166
The Five Qubit Code 5,1,3
167
Calderbank-Shor-Steane Codes (1)

• CSS codes are a subclass of stabilizer codes.
• They construct quantum error correction codes
  from classical linear codes.
• As a general rule, to detect X errors, CSS take a
  classical parity check matrix P, replaces 1 by Z
  and Is elsewhere.
• To detect Z errors, replace Xs instead of Zs in
  the matrix.

168
Calderbank-Shor-Steane Codes (2)

• If P and Q are orthogonal then we can combine
  these two codes. This means that the dual code of
  each code must be a subset of the other code.
• Combining a Pn,k,d with a Qn,k,d yields a
  CCS(P,Q)n,k-k,d3 with d3 mind,d.

169
Calderbank-Shor-Steane Codes (3)

• Remember that to construct a code we need to find
  H and G such that
• Then, we can write
• where Hi is the parity check matrix of the
  classical code Ci generated by Gi.

170
Calderbank-Shor-Steane Codes (4)

• Clearly
• and we force
• which means that

171
Calderbank-Shor-Steane Codes (5)

• In this case, the quantum logical states are
  given by
• where u is a k-bit binary word, x is an n-bit
  binary word, and D is a k by n matrix of coset
  leaders.

172
The Steane Seven Qubit CSS Code 7,1,3

• The 7-qubit Steane code is the most popular CSS
  code.
• It is created with a classical Hamming code
  7,4,3 which is self dual.
• The matrix P is taken as the classical parity
  check matrix H.
• The matrix Q is taken as the transposed of its
  generator GT.

173
The Steane Seven Qubit CSS Code 7,1,3
174
Conclusions

• Let there be light!
• Dark Star Bomb Computer

175
On the positive side

• Quantum error correction can be formalized in
  terms of quantum states and projectors,
  stabilizer subspaces or the stabilizer group.
• All these formalizations are equivalent.
• Getting through the mathematical language, the
  theory of quantum error correction is quite
  elegant and simple.
• We saw examples of several quantum error
  correction codes, and discussed how they are used
  to correct wide classes of errors on 1 or more
  qubits.

176
On the negative side

• While the theory is simple, the implementation
  may be very difficult.
• Construction of quantum error correction codes is
  not an easy task.
• Implementation of these quantum error correction
  protocols using quantum gates may also be a
  nontrivial task. Not so much for the complexity
  of the code, but for the large number of gates
  involved.