Stabilizer Codes: Definition and Construction

Hello! Welcome to the fifth lesson in our module on Quantum Error Correction Fundamentals.

In our last two lessons, we constructed codes to handle specific errors: the 3-qubit bit-flip code and the 3-qubit phase-flip code. We saw that they relied on measuring stabilizers like $Z_{i} Z_{j}$ and $X_{i} X_{j}$ , respectively. This ad-hoc approach, while instructive, isn't scalable for creating more powerful codes that can handle arbitrary errors. We need a more systematic and powerful language.

Today, we will develop that language. Our learning outcome is to define the stabilizer formalism and construct a stabilizer code from a set of commuting Pauli group generators. This elegant framework, developed by Daniel Gottesman, unifies the description of a vast class of important quantum codes, including the ones we've studied and many more we will encounter. It provides the essential theoretical machinery for designing and analyzing quantum error correction.

1. From Specific States to a General Principle

Let's start by reconsidering a familiar state, the Bell state $∣ Φ^{+} ⟩ = \frac{1}{2} (∣00 ⟩ + ∣11 ⟩)$ . We can describe this state not just by its coefficients but also by the operators for which it is a +1 eigenvector. For instance:

Applying $Z \otimes Z$ : $(Z \otimes Z) ∣ Φ^{+} ⟩ = \frac{1}{2} (Z_{1} Z_{2} ∣00 ⟩ + Z_{1} Z_{2} ∣11 ⟩) = \frac{1}{2} (∣00 ⟩ + ∣11 ⟩) = ∣ Φ^{+} ⟩$
Applying $X \otimes X$ : $(X \otimes X) ∣ Φ^{+} ⟩ = \frac{1}{2} (X_{1} X_{2} ∣00 ⟩ + X_{1} X_{2} ∣11 ⟩) = \frac{1}{2} (∣11 ⟩ + ∣00 ⟩) = ∣ Φ^{+} ⟩$

The state $∣ Φ^{+} ⟩$ is stabilized by the operators $Z_{1} Z_{2}$ and $X_{1} X_{2}$ . This is the core idea. Instead of defining a code by explicitly writing out its basis states (like $∣ 0_{L} ⟩ = ∣000 ⟩, ∣ 1_{L} ⟩ = ∣111 ⟩$ ), we can define it implicitly as the set of all states that are stabilized by a chosen group of operators.

2. The Pauli Group and the Stabilizer

The operators we use for this are drawn from the n-qubit Pauli group, $G_{n}$ . This group consists of all $n$ -fold tensor products of the Pauli matrices ${I, X, Y, Z}$ , including multiplicative factors of ${\pm 1, \pm i}$ . For our purposes, we can simplify this to $G_{n} = {\pm 1} \otimes {I, X, Y, Z}^{\otimes n}$ .

A key property of the Pauli group, which is fundamental to your physics background with spin matrices, is that any two of its elements either commute or anti-commute. This binary relationship is central to the formalism.

A stabilizer code is defined by a special subgroup of $G_{n}$ called the stabilizer, denoted by $S$ . This subgroup $S$ must satisfy two conditions:

It is abelian (commutative): For any two elements $M_{i}, M_{j} \in S$ , we must have $M_{i} M_{j} = M_{j} M_{i}$ . This ensures that the operators share a common set of eigenvectors.
It does not contain -I: $- I^{\otimes n} \in / S$ . If it did, any state $∣ ψ ⟩$ in the code would have to satisfy $- ∣ ψ ⟩ = ∣ ψ ⟩$ , which is only possible for the zero vector.

The code space, $C$ , is then defined as the simultaneous +1 eigenspace of all operators in the stabilizer group $S$ :

C = {∣ ψ ⟩ \in (C^{2})^{\otimes n} ∣ M ∣ ψ ⟩ = ∣ ψ ⟩ for all M \in S}

Any state $∣ ψ ⟩ \in C$ is called a codeword or stabilizer state.

3. Generators and the Code Space Dimension

Writing down every element of $S$ is impractical. Instead, we specify $S$ using a minimal set of generators, ${g_{1}, g_{2}, \dots, g_{m}}$ . These are elements of $S$ such that every element in $S$ can be written as a product of the generators, and no generator can be written as a product of the others (i.e., they are independent).

A crucial result of the formalism is that if we use $n$ physical qubits and our stabilizer $S$ has $m = n - k$ independent generators, the resulting code space $C$ has dimension $2^{k}$ . This means the code encodes $k$ logical qubits. Each independent generator you add to the stabilizer halves the dimension of the Hilbert space it defines.

Given your preference for foundational sources, it's worth noting that this entire framework originates from Daniel Gottesman.

Daniel Gottesman's Papers

The stabilizer formalism was introduced by Daniel Gottesman. His website provides access to his foundational papers. We'll use it to acknowledge the source before turning to a more pedagogical text.

Briefly scan the page, particularly the sections on 'Stabilizer codes' and 'Stabilizer States'. Note that Gottesman himself recommends his PhD thesis ('Stabilizer codes and quantum error correction') as a good introduction to the topic. We won't read it now, but it is the definitive reference.

Now, let's dive into a formal development of these ideas.

Chapter 7 Quantum Error Correction

For a structured and clear explanation, we will use John Preskill's highly-regarded lecture notes. This section formally defines the Pauli group, the stabilizer, the code space, and derives the relationship between the number of generators and the number of encoded qubits.

Please read section 7.9.1, 'General formulation' (pages 34-38). Focus on understanding three key points: The definition of the n-qubit Pauli group \mathcal{G}_n and its properties. The definition of a stabilizer code \mathcal{H}_S (what we're calling \mathcal{C}) as the simultaneous +1 eigenspace of an abelian subgroup S. The argument for why n-k independent generators define a 2^k-dimensional code space.

4. How to Construct a Stabilizer Code

The reading provides the theory; let's make it practical. To construct a valid $[[n, k]]$ stabilizer code (encoding $k$ logical qubits into $n$ physical qubits), you need to choose $n - k$ generators that satisfy a few simple rules.

The Rules for Generators ${g_{1}, \dots, g_{n - k}}$ :

Pauli Group Elements: Each $g_{i}$ must be an element of $G_{n}$ .
Commutativity: All generators must commute with each other: $g_{i} g_{j} = g_{j} g_{i}$ for all $i, j$ .
- Practical Trick: Two Pauli strings commute if they anti-commute on an even number of qubit positions. For example, $g_{1} = XZ$ and $g_{2} = ZX$ . On the first qubit, $X$ and $Z$ anti-commute. On the second, $Z$ and $X$ anti-commute. The total number of anti-commutations is 2 (even), so $[g_{1}, g_{2}] = 0$ .
Independence: The generators must be independent. You cannot create one generator by multiplying others (e.g., if you have $g_{1}$ and $g_{2}$ , you cannot add $g_{3} = g_{1} g_{2}$ as a third independent generator).
No -I: The group $S$ generated by the $g_{i}$ cannot contain $- I$ . This means no product of a subset of generators can equal $- I$ .

Example 1: The 3-Qubit Bit-Flip Code

Let's formalize the code from our previous lesson.

Physical Qubits: $n = 3$
Generators: Let's choose $g_{1} = Z_{1} Z_{2} I_{3}$ and $g_{2} = I_{1} Z_{2} Z_{3}$ .
Check the rules:
1. Pauli Elements: Yes.
2. Commute: $g_{1}$ and $g_{2}$ are products of only $Z$ and $I$ operators, so they trivially commute.
3. Independent: Yes, $g_{1} \neq = g_{2}$ .
4. No -I: The group is $S = {I, g_{1}, g_{2}, g_{1} g_{2} = Z_{1} Z_{3}}$ . None of these is $- I$ .
Result: We have $n = 3$ qubits and $n - k = 2$ generators. This implies $k = 1$ . It is a $[[3, 1]]$ code, as we knew. The code space is the set of states where $Z_{1} Z_{2} ∣ ψ ⟩ = ∣ ψ ⟩$ and $Z_{2} Z_{3} ∣ ψ ⟩ = ∣ ψ ⟩$ , which you can verify are spanned by $∣000 ⟩$ and $∣111 ⟩$ .

Example 2: The 5-Qubit Perfect Code

This code is a preview of our next lesson. It is a $[[5, 1]]$ code, so it uses $n = 5$ physical qubits to encode $k = 1$ logical qubit, and requires $n - k = 4$ generators. Here they are:

$g_{1} = XZZX I$
$g_{2} = I XZZX$
$g_{3} = X I XZZ$
$g_{4} = ZX I XZ$

Let's check if $g_{1}$ and $g_{2}$ commute using our trick:

Qubit 1: $X$ and $I$ (commute)
Qubit 2: $Z$ and $X$ (anti-commute)
Qubit 3: $Z$ and $Z$ (commute)
Qubit 4: $X$ and $Z$ (anti-commute)
Qubit 5: $I$ and $X$ (commute)
There are two positions where the operators anti-commute. Since 2 is an even number, $g_{1}$ and $g_{2}$ commute overall. You can (and should!) verify this for other pairs.

Test your understanding!

Consider the following set of two operators on three qubits:

$g_{1} = X_{1} X_{2} X_{3}$
$g_{2} = Z_{1} Z_{2}$

Do these operators form a valid set of generators for a stabilizer code? If so, what are the parameters $(n, k)$ of the code?

Show answer

Let's check the rules:

Pauli Elements: Yes.
Commutativity:
- Qubit 1: $X_{1}$ and $Z_{1}$ (anti-commute)
- Qubit 2: $X_{2}$ and $Z_{2}$ (anti-commute)
- Qubit 3: $X_{3}$ and $I_{3}$ (commute)
  The operators anti-commute on 2 positions. Since 2 is even, $g_{1}$ and $g_{2}$ commute. So this rule is satisfied.
Independence: Yes, $g_{1}$ is not a multiple of $g_{2}$ .
No -I: The group is $S = {I, g_{1}, g_{2}, g_{1} g_{2}}$ . None of these is $- I$ .

Yes, they form a valid set of generators. The parameters are $n = 3$ physical qubits and $n - k = 2$ generators, which means it is a $[[3, 1]]$ code, encoding $k = 1$ logical qubit.

Conclusion

Today we have made a significant leap from constructing specific codes to understanding the general principles that govern them. The stabilizer formalism is a cornerstone of quantum error correction.

Key Takeaways:

A quantum code can be defined as the common +1 eigenspace of a set of commuting operators, called the stabilizer group $S$ .
The stabilizer $S$ is an abelian subgroup of the n-qubit Pauli group $G_{n}$ that does not contain $- I$ .
A stabilizer is conveniently described by a minimal set of independent generators.
For a code on $n$ physical qubits, a set of $n - k$ independent generators defines a $2^{k}$ -dimensional code space, thus encoding $k$ logical qubits. This is an $[[n, k]]$ code.
To construct a code, one must choose a set of generators that are independent and mutually commuting.

Preview of the next lesson:
Now that we have the theoretical language to describe a code like the 5-qubit perfect code, our next step is to use it. We will see how measuring the stabilizer generators reveals a syndrome that diagnoses which error has occurred, allowing us to correct it. We will implement the syndrome measurement circuits for the 5-qubit code and use the outcome to restore the quantum state.