Q1L5b.txt

#
# File:   content-mit-8371x-subtitles/Q1L5b.txt
#
# Captions for 8.421x module
#
# This file has 142 caption lines.
#
# Do not add or delete any lines.  If there is text missing at the end, please add it to the last line.
#
#----------------------------------------

We now employ the stabilizer formalism
to define a family of quantum codes, which
is the analog of classical linear codes.
The n, k stabilizer code C of S
is defined as the k qubit vector subspace of an n qubit Hilbert
space, stabilized by the stabilizer
S, a subgroup of the n qubit Pauli group where
S has the generators g1 through gn minus k.
We have previously seen how the nine qubit quantum
code is an example of this kind of definition.
Stabilizer codes satisfy the quantum error correction
criteria in the following way.
Given a set of errors, E sub a, which
are in the Pauli group on n qubits,
if there exists an element g in S,
such that g anti-commutes with E,
and this is true for all E, which are a product of any two
errors, that is e is equal to E sub a times E sub b,
then there will exist a recovery operation, namely a syndrome
measurement and the recovery operator which
corrects all the errors in this set, E sub a, on this code
C of S.
We prove this theorem by reducing it
to the orthogonality and non-deformation criteria
of the quantum error correction conditions.
First, we note that for all states psi in C of s
and for all stabilizers g in S, the matrix element of psi E
a, E b psi, is given by psi E times g times psi,
because psi is a plus 1 eigenstate of g.
Now by the theorem, E and g anti-commute, so
this is minus psi gE psi.
But again, psi is an eigenstate of g,
and note g is Hermitian because g is a Pauli operator,
and therefore, this is equal to minus of itself, meaning
it must be zero.
This proves we satisfy the orthogonality criteria
of the quantum error correction conditions,
namely that psi l E times any two errors in product
must be equal to zero.
That is errors do not cause once code word state to transform
into another code word state.
For the non-deformation criteria, we look at the case
when E sub a equals E sub b.
In this scenario, when E sub b equals E sub b, because they
are both Pauli operators we find the product is identity.
This then trivially shows us that
the non-deformation criterion is satisfied with d sub k
equal to 1.
Stabilizer codes thus give a very simple prescription
for checking for error correction criteria,
namely we check to see if an error anti-commutes
with a stabilizer element.
It is thus convenient to define for a given generator
set of a stabilizer, g sub 1 through g sub k,
and for error E, a error syndrome.
This is a bit string the size of the stabilizer generator
set where each bit is zero if the generator commutes
with an error and one otherwise, namely it anti-commutes.
This error syndrome bit string will
be used to determine where the error occurred
and what to do about the error.
And in the case when each error has a unique syndrome string,
the code will be known as a non-degenerate code.
Degenerate codes, on the other hand,
will have non-unique syndromes.
Let us look at some example stabilizer codes.
First, recall the 3-qubit qubit bit flip code
with stabilizer generators IZZ and ZZI.
If the error is, for example, a bit flip on the middle qubit,
than the syndrome will be one and one,
indicating that both generators anti-commute with the error.
What if the error were three bit flips?
All qubits being flipped, what would the syndrome be?
Well, go work this out for yourself,
but note something interesting.
This error does not anti-commute with any of the generators.
Let's look at another interesting example.
Suppose that the stabilizers were generated
by a single operator, XX.
In this case, the vector space stabilized, C of S,
the code word space, is spanned by 00 plus 11, and 01 plus 10.
Suppose the error were a single phase flip, IZ or ZI.
You have to be careful, in this case,
when computing the error syndrome
because actually, the product of the two errors is Z Z,
and this error, Z Z, commutes with X X, the stabilizer.
So in this case, what we have is an error detection code which
detects phase errors but cannot correct for the phase errors.
Here's a third example of a four qubit state
with four stabilizer generators, XZIZ
and its cyclic permutations, ZXZI, IZXZ, and ZIZX.

Again, n is equal to 4 and k equals 0,
meaning it's a state and not a space.
What errors anti-commute with these generators?
It turns out that any single qubit
error does, but no qubit is encoded by this code
because k equals 0.
Now let us look at a important seven qubit code example.
You will see this code later in your problem set.
The stabilizer generators are constructed by a nice pattern.
Namely, we iterate from 1 through 7 by column, like this.
So we have binary 001 going all the way up to binary 111 with
X's and then with Z's.
This gives us a total of six generators labeled
g1 through g6, acting on the seven qubits
and therefore, we have one encoded qubit
in seven physical qubits.
It is straightforward and instructive to look at all 64
possible syndrome values resulting from single qubit
errors I, X, Y, or Z. This is to be contrasted
with the number of possible errors that could occur,
namely 22 possible errors.
This code is, of course, the famous 7,
1 Steane code where every single qubit
error has a unique syndrome and, by the stabilizer code theorem,
is correctable.
This shows that we have a beautiful description
of the Steane code as being a stabilizer code.
Here is, as a final example, a code
with n equal 5 qubits, with the stabilizer generators
XZZXI and its cyclic permutations, that
is, IXZZX, XIXZZ, and ZXIXZ.
Again, we have five physical qubits
encoding one logical qubit, giving us a 5, 1 quantum error
correction code.
This is a stabilizer code with some remarkable properties.
You can verify for yourself that for arbitrary single qubit
errors, such as X1, we get a unique set of syndrome
strings, written here in order of the generators listed above.
So for example, Z1 gives us 1010 and X2
gives us 1000, and so forth, for all possible single qubit
errors.
Just as for the Steane code, every single qubit error
has a unique error syndrome and thus,
this code, which has fewer qubits, five qubits,
can correct for an arbitrary single qubit error.
This is the perfect 5-qubit quantum error correction code.
In many ways, it is a particularly uniquely quantum
code in that it has no origin in a classical linear code,
unlike the Steane code, which has its origins in the 7-bit Hamming code.