MATH 5352

Quantum Error Correction: CSS Codes

Akul Sethi
[Link]@[Link]

December 9, 2025

Abstract
Since physical realizations of qubits are highly sensitive to noise, the ability to correct errors
is a necessity for practical quantum computation. Classical computation faces similar, albeit less
severe, issues and so classical solutions to this problem are a good starting point. However, there
are several unique properties of quantum mechanics that make the conversion from classical to
quantum codes highly non-trivial. This paper explores the basic theory of both types of error
correction and concludes with the presentation of CSS codes which provide a general framework
for converting classical error correcting codes to quantum ones.

1 Introduction
We will begin with the more simple classical case where information is stored as bits. Generally,
the idea in error correction is to store the information using more bits in such a way where you
become robust to errors. The simplest code is a repetition code. For example we can replace each
0 with 000 and each 1 with 111. Say during transmission of a 0, one of the bits gets flipped. We
can immediately recognize an error has taken place as none of {001, 010, 100} are ever sent by the
protocol and by majority vote, determine the original message. If two bits are flipped we can still
recognize an error but majority vote handles the error incorrectly, and so we cannot correct this
sort of error.
It may at first appear that the classical repetition code can easily be extended to the quantum
case, but this is untrue. As the name suggests, the No-Cloning Theorem forbids the duplication
of a quantum state, and so this approach immediately fails. Moreover, in the classical case we
only had to consider bit flip errors. In the quantum case, there are infinite unitary transformations
which can corrupt our state. Finally, assuming we handle both these issues, the measurement
axiom of quantum mechanics means that when we make a measurement to detect the error, we
destroy superpositions. The stabilizer code formalism introduced later will demonstrate how we
can cleverly overcome these barriers.
The next section will introduce a rigorous formalism for classical error correction which will be
necessary to discuss CSS codes.

2 Classical Error Correction

The repetition code example from above motivates the following definition.
Definition 2.1. A classical error-correcting code (e, E) is a map e : Zk2 → Zn2 with a set of
correctable errors E (consisting of maps E : Zn2 → Zn2 ) with the following property: ∃ map d : Zn2 →
Zk2 such that ∀E ∈ E, ∀x ∈ Zk2 .
d(E(e(x))) = x (1)
MATH 5352

Here, e forms the encoder while d forms the decoder. For the rest of this paper we will use the
word code to refer to the image of e and denote it C.

We would also like a way to formally refer to the strength of errors as well as codes.
Definition 2.2. The weight of some error E, denoted wt(E), is the number of bits it acts on.
Definition 2.3. Let C ⊆ Zn2 be a code. The distance of C is given by
min{wt(E)|∃x ̸= y ∈ C, E(x) = y} (2)
Using this new terminology we can now say that the triple repetition code can only handle
weight 1 errors and has distance 3. We will also use the term [n, k, d] code to refer to a code which
encodes k bits of information using n bits and has distance d. For example, the triple repetition
code is a [3, 1, 3] code.

2.1 Linear Codes

In this section we introduce a simple framework for constructing classical codes, known as linear
codes.
Definition 2.4. An error-correcting code C ⊆ Zn2 is a linear code if x, y ∈ C =⇒ x + y ∈ C.
Note that since we are working in the field Z2 , ∀x ∈ Zn2 , x−1 = x. Therefore, if C is non-empty
then 0 ∈ C and since the only scalars are 0 and 1 the above definition is equivalent to a linear
subspace. Thus, we can uniquely identify a linear code by some basis x1 , . . . , xk ∈ Zn2 . Since there
are 2k vectors in this subspace, we can see that this code encodes k bits of information using n bits.
Definition 2.5. The generator matrix GC of a linear code C is a matrix with row i equal to xi .
This generator matrix can be used as an encoder and so now we just need a way to detect
errors.
Definition 2.6. Let C be a linear code and let G be its generator. A parity check matrix HC for
C is a matrix with rows which form a basis for the nullspace of G.
Theorem 2.1. If C has k encoded bits and n physical bits, then GC is a k × n matrix and HC is
an (n − k) × n matrix. GC HCT = 0 and HC GTC = 0.
Proof. The size of GC is trivial from the definition as are the last two statements of the theorem.
The proof that HC is (n − k) × n is as follows. By definition of GC its rows must be linearly
independent, and so it has rank k. By the rank-nullity theorem the dimensions of its nullspace
must therefore be (n − k) which gives the desired result.

If we represent bit flip errors as e ∈ Zn2 where an error acts on the encoded bits by addition,
then we can detect errors using the parity check matrix as follows. Let x denote the physical bits
and let v denote the logical bits.
HC (x + e) = HC x + HC e = HC GTC v + HC e = HC e (3)
We can then use HC e to detect the type of error which has occurred. Note that if HC e is 0 it does
not necessarily mean that no error has occurred. It is still possible that the initial code word was
moved to another one.
Definition 2.7. The error syndrome of an error e for linear code C is HC e
In the next section we give an example.
MATH 5352

2.2 Example: Hamming Code

Say we wanted to only correct 1-bit flip errors. Then, then the only errors we need to consider are
the basis vectors of Zn2 . Thus, the error syndromes will simply be the columns of our parity check
matrix. If we fix some number of rows r and make every column a unique bit string of length r,
we get a Hamming Code.
Definition 2.8. The [2r − 1, 2r − r − 1, 3] Hamming code is the code whose r × (2r − 1) parity check
matrix has as columns all possible r-bit strings.
Note that since we want the 0 vector to denote that no error has taken place we cannot include
it as a column and so we get 2r − 1 columns. For example, if we set r = 3 we get a [7, 4, 3] code
with the following parity check matrix.
 
1 1 1 1 0 0 0
1 1 0 0 1 1 0 (4)
1 0 1 0 1 0 1

If we now find a basis for the orthogonal complement to the row space of the parity check matrix,
we get the following generator matrix.
 
1 1 1 1 1 1 1
1 1 1 1 0 0 0

1
 (5)
1 0 0 1 1 0
1 0 1 0 1 0 1

2.3 Dual Code

The final portion of classical coding theory necessary to define CSS codes is the notion of a dual
code.
Definition 2.9. If C is a linear code, the dual code C ⊤ is the orthogonal complement of C. i.e;

C ⊤ = {y ∈ Zn2 |x · y = 0∀x ∈ C} (6)

Lemma 2.2. If C is a linear code with generator GC and parity check matrix HC then C ⊤ is the
linear code with generator HC and parity check matrix GC .
Proof. We first want to show that C ⊤ really is a linear code. Take a, b ∈ C ⊤ . Then, ∀x ∈
C, x · (a + b) = (x · a) + (x · b) = 0 + 0 = 0 and so a + b ∈ C ⊤ . Next we want to show that HC
is a generator for C ⊤ . The rows of HC form a basis for the nullspace of GC . The nullspace of GC
is equivalent to the orthogonal complement of its rowspace (which is a basis for C) and so HC is a
generator for C ⊤ . Using the same logic we can see how GC is a parity check matrix for C ⊤ .

It follows from 2.2 that (C ⊤ )⊤ = C.

3 Stabilizer Codes
We are now finally ready to introduce the first quantum codes which address the barriers presented
in the introduction. Stabilizer codes work by taking some Hilbert space and encoding it in a larger
one whose orthogonal subspaces are assigned different meanings. One is referred to as the code
space, and the others are referred to as error spaces. The initial message is placed in the code
MATH 5352

space, and errors move it into the error spaces. We can then use the specific error space to detect
the type of error and correct it.
We will begin by introducing the quantum equivalent of general classical error correcting codes
before defining the more specific stabilizer codes.

Definition 3.1. A quantum error-correcting code (V, E) consists of an isometric encoder V : HK →

HN and a set of correctable errors E (consisting of linear maps E : HN → HN ) with the following
property: there exist an ancilla state |0⟩ and a unitary decoder U : HN ⊗ HA → HK ⊗ HA such
that for all E ∈ E and all |ψ⟩ ∈ HK ,


U E V |ψ⟩ ⊗ |0⟩ = V |ψ⟩ ⊗ |ωE ⟩, (7)

where |ωE ⟩ ∈ HA depends only on E and not on |ψ⟩.

Like the classical definition of an error correcting code, this one includes an encoder, decoder,
and set of correctable errors. However, there are a few important differences. The first is that the
decoder returns the physical code word rather than the logical one and so one last step is required
to obtain the original qubits. Since the encoder is defined to be an isometry it will always be
invertible on its image and so this is always possible. Note that this was just done to make the
decoder a true unitary and the proofs a little simpler.
Additionally, as we suggested earlier, this definition allows for the set of errors to be uncountably
infinite, which at first seems like an impossible task. We will begin this section by reasoning about
finite sets of errors, and later generalize to the uncountable case.
Finally, the above definition only requires that a decoder function exist, and it is not immediately
clear how to determine if one does. The following theorem, also known as the QECC conditions,
seeks to address this.

Theorem 3.1. Let V : HK → HN be an isometry and E = {Ea } be a finite set of errors. (V, E) is
a QECC iff ∀|ψ⟩, |ϕ⟩ ∈ HK , ∀Ea , Eb ∈ E,

⟨ψ|V † Ea† Eb V |ϕ⟩ = Cab ⟨ψ|ϕ⟩ (8)

For some fixed matrix C which does not depend on |ψ⟩ or |ϕ⟩.

Proof. We will begin by showing how equation 8 is a necessary condition for a decoder to exist.
Assume that some unitary decoder U : HN ⊗HA → HN ⊗HA exists such that ∀|ψ⟩ ∈ HK , ∀Ea ∈ E,

U (Ea V |ψ⟩ ⊗ |0⟩) = V |ψ⟩ ⊗ |ϕa ⟩ (9)

for some error syndrome |ωa ⟩ ∈ HA . Define |ψa ⟩ := Ea V |ψ⟩. Then, for all |ψ⟩, |ϕ⟩ ∈ HK

U (|ψa ⟩ ⊗ |0⟩) = V |ψ⟩ ⊗ |ωa ⟩, U (|ϕb ⟩ ⊗ |0⟩) = V |ϕ⟩ ⊗ |ωa ⟩ (10)

Because U is unitary, it preserves inner produces. If we compute the inner produce of the left hand
side we get
⟨|ψa ⟩ ⊗ |0⟩, |ϕb ⟩ ⊗ |0⟩⟩ = ⟨ψa |ϕb ⟩⟨0|0⟩ = ⟨ψa |ϕb ⟩ (11)
and for the right hand side

⟨V |ψ⟩ ⊗ |ωa ⟩, V |ϕ⟩ ⊗ |ωb ⟩⟩ = ⟨V ψ, V ϕ⟩⟨ωa |ωb ⟩ = ⟨ψ|ϕ⟩⟨ωa |ωb ⟩ (12)

MATH 5352

since V is an isometry. Therefore, if we define Cab = ⟨ωa |ωb ⟩ and equate both sides we get
⟨ψa |ϕb ⟩ = ⟨Ea V ψ, Eb V ϕ⟩
= ⟨ψ|V † Ea† Eb V |ϕ⟩ (13)
= Cab ⟨ψ|ϕ⟩
which is the desired result.
Now we will show that equation 8 is also a sufficient condition for a decoder to exist. Assume
the equation holds. First we show that C necessarily must be Hermitian i.e. Cab = Cba ∗ . By

conjugate symmetry of the inner product,

⟨ψ, V † Eb† Ea V ϕ⟩ = ⟨V † Eb† Ea V ϕ, ψ⟩ = ⟨ϕ, V † Ea† Eb V ψ⟩ = Cba ⟨ψ|ϕ⟩ (14)

∗ . Since C is Hermitian we can diagonalize
If we conjugate the last two terms we get that Cab = Cba
it via some unitary U and diagonal matrix D (where D has non-negative diagonal)
U CU † = D (15)
The intuition behind the proof is that we can now express the errors in a new basis which makes
it easy to construct a decoder. Define
X
Fr := Ura Ea (16)
a

Now in this new basis, X

∗
⟨Fr V ψ, Fs V ϕ⟩ = Ura Usb ⟨Ea V ψ, Eb V ϕ⟩
a,b
X
∗
= Ura Usb Cab ⟨ψ|ϕ⟩
(17)
a,b

= (U CU † )rs ⟨ψ|ϕ⟩
= Drr δrs ⟨ψ|ϕ⟩
√
In this form we can see that each error Fr acts as an isometry up to a scale factor Drr on the
code space, and moreover the image of each error is orthogonal to the rest.
Let Q = Im(V ). Since the operators Fr V have mutually orthogonal images, we may define a
unitary U on HN ⊗ HA by specifying its action on each subspace Fr Q ⊗ |0⟩:
U (Fr V |ψ⟩ ⊗ |0⟩) = V |ψ⟩ ⊗ |r⟩, (18)
where {|r⟩} is an orthonormal basis for the ancilla space HA . This is well defined because if r ̸= s
then Fr Q is orthogonal
√ to Fs Q, and for fixed r the map Fr V |ψ⟩ 7→ V |ψ⟩ is an isometry up to the
known scalar Drr . We may therefore extend U arbitrarily to a full unitary on all of HP N ⊗ HA .
†
Now let an arbitrary error Ea act on an encoded state. Using the change of basis Ea = r Uar Fr ,
we have
! !
X X X
† † †
U (Ea V |ψ⟩ ⊗ |0⟩) = U Uar Fr V |ψ⟩ ⊗ |0⟩ = Uar (V |ψ⟩ ⊗ |r⟩) = V |ψ⟩ ⊗ Uar |r⟩ (19)
r r r

where the ancilla portion depends solely on the error type and not on |ψ⟩. Thus U has the required
form

U Ea V |ψ⟩ ⊗ |0⟩ = V |ψ⟩ ⊗ |ωa ⟩ (20)
MATH 5352

This theorem will be used later to reason about the correctable errors of a stabilizer code. We
can now generalize from correcting finitely many errors to the uncountable case.
Theorem 3.2. Let (V, E) be a QECC. If (V, E) can correct errors E and F then it can correct
αE + βF for all α, β ∈ C.
Proof. Let U be a decoder as defined above and let |ψ⟩ ∈ Hk . If we try to correct (αE + βF )V |ψ⟩
we get
U ((αE + βF )V |ψ⟩ ⊗ |0⟩) = α(V |ψ⟩ ⊗ |ω⟩E ) + β(V |ψ⟩ ⊗ |ω⟩F )
(21)
= V |ψ⟩ ⊗ (α|ω⟩E + β|ω⟩F )
and so by the definition 3.1 U must correct αE + βF .

This theorem is exceedingly important, as it means that if we can correct some finite set of
errors then we immediately can correct its linear span for free. Since the set of all unitaries is
spanned by the Pauli matrices, if we correct the Pauli errors, then we correct all possible unitary
errors. Specifically, we will focus on correcting the following.
Definition 3.2. The Pauli group Pn is composed of tensor products of I, X, Y , and Z on n qubits,
with an overall phase of ±1 or ±i.
Since it will also sometimes be useful to drop the phase, we will define
Definition 3.3. Let P̂n ∼= Pn /{I, iI, −I, −iI}. Further, if P ∈ Pn then P̂ is defined to be the
element in P̂n corresponding to P. Similarly, if S ⊆ Pn , then Ŝ is the subset of P̂n consisting of P̂
for all P ∈ S.
As we did in the case of classical errors, we want a way to speak of the strength of a quantum
error.
Definition 3.4. Let E ∈ Pn . We define the weight of E to be the number of tensor factors which
are not equal to the identity.
As we alluded to before, the stabilizer code is a specific case of the general QECC framework
described above which uses Pauli operators to specify its code space.
Definition 3.5. Let S ⊆ Pn be an Abelian group, with −I ∈ S. The code space of the stabilizer
code is then
T (S) = {|ψ⟩|M |ψ⟩ ∀M ∈ S} (22)
S is referred to as the stabilizer of the code with its generators called stabilizer generators.
We claim that it is possible to detect if qubits have been moved from this code space in a
non-destructive way. Let T (S) be a stabilizer code with stabilizer S and E ∈ Pn be an error. For
each M ∈ S, E either commutes or anti-commutes with M . Say E anti-commutes with M . Then,
for all encoded states |ψ⟩ ∈ T (S)

M (E|ψ⟩) = −E(M |ψ⟩) = −E|ψ⟩ (23)

and so E|ψ⟩ is a −1 eigenstate of M . If instead E commutes with M then

M (E|ψ⟩) = E(M |ψ⟩) = E|ψ⟩ (24)

and so E|ψ⟩ is a +1 eigenstate of M . By checking if the received state E|ψ⟩ is a +1 or −1 eigenstate

of all generators we can obtain an error syndrome similar to the case of classical codes. All that
needs to show is that it is possible to do this without destroying the contents of the state.
MATH 5352

3.1 Measuring Eigenvalues

Theorem 3.3. Let M ∈ Pn and |ψ⟩ be a ±1 eigenstate. Then measuring the observable M returns
the eigenvalue of |ψ⟩ and leaves |ψ⟩ unchanged up to global phase.

Proof. Since M ∈ Pn it is binary observable and so its eigenvalues are ±1. By the spectral theorem
we can say
M = Π+ − Π− (25)
for some projections Π+ and Π− . The probability of measuring +1 or −1 is

p+ = ⟨ψ|Π+ |ψ⟩, p− = ⟨ψ|Π− |ψ⟩ (26)

with resultant states

Π+ |ψ⟩ Π− |ψ⟩
|ψ+ ⟩ = √ , |ψ− ⟩ = √ (27)
p+ p−
Assume that |ψ⟩ is a +1 eigenstate. Then since Π+ and Π− project onto orthogonal spaces, p+ = 1
(p− = 0) with resultant state |ψ+ ⟩ = |ψ⟩. Likewise, if |ψ⟩ is a −1 eigenstate then p− = 1 and the
resultant state |ψ− ⟩ = |ψ⟩.

This theorem lets us obtain information about the received state E|ψ⟩ without destroying its
potential superposition which was one of the barriers presented in the introduction.

3.2 Detectable Errors and Parameters of Stabilizer Codes

Finally, we can combine the previous results to rigorously determine what are the errors that a
stabilizer code can correct.
†
Theorem 3.4. The stabilizer code with stabilizer S corrects a set of errors E ⊆ Pn iff Eˆa Eb ∈
/
N̂ (S)\Ŝ for all Ea , Eb ∈ E. Here N (S) = {N ∈ Pn |N M = M N ∀M ∈ S} denotes the normalizer
of S.

Proof. Let Ea , Eb be arbitrary elements in E. By theorem 3.1 we know that S corrects E iff
∀|ψ⟩, |ϕ⟩ ∈ T (S)
⟨ψ|Ea† Eb |ϕ⟩ = Cab ⟨ψ|ϕ⟩ (28)
for some Cab . Let F = Ea† Eb . We can consider the three cases.

1. Case 1: F̂ ∈ Ŝ. Then for some choice of phase, F ∈ S and F |ϕ⟩ = |ϕ⟩, so

⟨ψ|F |ϕ⟩ = ⟨ψ|ϕ⟩ (29)

and so Cab = 1.

2. Case 2: F̂ ∈
/ N̂ (S). Then ∃M ∈ S such that F M = −M F for any phase of F . Then,

⟨ψ|F |ϕ⟩ = ⟨ψ|M F M |ϕ⟩ = −⟨ψ|F |ϕ⟩ = 0 (30)

Since M 2 = I. Note that we can insert M in the inner product because it is a stabilizer.
Therefore, Cab = 0.
MATH 5352

3. Case 3: F̂ ∈ N̂ (S)\Ŝ. Since F ∈ / S, ∃|ϕ⟩ such that F |ϕ⟩ ̸= ϕ. Let |ψ⟩ = F |ϕ⟩. Since
F ∈ N (S), |ψ⟩ is also a codeword. However,
1
⟨ψ|F |ϕ⟩ = 1 = ⟨ψ|ϕ⟩ (31)
⟨ψ|ϕ⟩

whereas
⟨ψ|F |ϕ⟩ = ⟨ψ||⟩⟩ = (⟨ϕ|ψ⟩)⟨ϕ|ψ⟩ (32)
and so there can be no constant Cab .

Using this theorem, for any set of stabilizer generators we can easily determine the set of
correctable Pauli errors for its code. Additionally, it is possible to reason about the distance of a
stabilizer code this way, but we do not do so in this paper to keep things short.
There were two more important properties of classical codes: n and k which we can also derive
from the stabilizer generators. If a Hilbert space has dimension 2r we say it consists of r qubits
and so in the quantum case n corresponds to the number of qubits of the code space and k to the
number of qubits of the entire space. To find the relationship between n and k we simply must find
the dimension of the simultaneous +1 eigenspace of all stabilizer generators.

Theorem 3.5. Let S ⊆ Pn be a stabilizer with |S| = 2r , i.e. S has r independent generators. Then
the stabilizer code T (S) has dimension 2n−r . In particular, the code encodes

k =n−r (33)

logical qubits.

Proof. Let ΠS be the projection operator onto T (S). By definition,

1 X
ΠS = M (34)
|S|
M ∈S

It is straightforward to check that Π2S = ΠS and Π†S = ΠS , so ΠS is indeed a projector onto T (S).
The dimension of T (S) is equal to the trace of this projector:
1 X
dim T (S) = tr ΠS = tr M (35)
|S|
M ∈S

Every n-qubit Pauli operator other than the identity has trace 0, since its eigenvalues are ±1 with
equal multiplicity. The only element of S with nonzero trace is therefore the identity I, which has
trace 2n . Hence
tr I 2n
tr ΠS = = r = 2n−r (36)
|S| 2
Thus dim T (S) = 2n−r , so the stabilizer code encodes k = n − r logical qubits.

This result will be used to derive the properties of CSS codes.

MATH 5352

4 CSS Codes
Even though the stabilizer code formalism is much easier to work with compared to the general
QECC definition, it is still not as simple as the classical linear codes. For instance, it is difficult to
determine what is a good set of stabilizer generators and for a given set, what are the properties
of the code. CSS codes allow you to take a linear code and under certain conditions turn it into
a stabilizer code. Further, properties of the quantum code can then be derived from the classical
one.
In this section we will assume knowledge of the binary symplectic representation of the Pauli
operators and the symplectic inner product.

Definition 4.1. A stabilizer code is a CSS code if there is a choice of generators for which the
stabilizer’s binary symplectic representation is of the form
 
0 A
(37)
B 0

where A is a r1 × n matrix and B is a r2 × n matrix for r1 , r2 . The generators of the form (b|0)
are X generators and the generators of the form (0|a) are Z generators.

We can make such a set of generators by using one linear code to construct matrix A and
another to construct matrix B. One code will deal with correcting X errors while the other will
handle Z errors.

Theorem 4.1. Let C1 be an [n, k1 , d1 ] linear code with parity check matrix H1 and C2 be an
[n, k2 , d2 ] linear code with parity check matrix H2 . Suppose C1⊤ ⊆ C2 . Let S be the CSS code with
stabilizer  
0 H1
(38)
H2 0
Then S is an [n, k, d] quantum code with k = k1 + k2 − n and d ≥ min{d1 , d2 }.

Proof. First we want to confirm that the given set of generators forms a valid set of stabilizer
generators. To do so we want to show that they are Abelian. By Lemma 2.2, the rows of H1 span
C1⊤ and the rows of H2 span C2⊤ .
Two Pauli operators commute if and only if their binary symplectic inner product vanishes. In
particular, an X generator (x|0) commutes with a Z generator (0|z) iff

(x|0) ⊙ (0|z) = x · z = 0, (39)

where x · z is the usual binary inner product. Thus the stabilizer is Abelian exactly when x · z = 0
for all x ∈ C2⊤ and all z ∈ C1⊤ . Since we assume

C1⊤ ⊆ (C2⊤ )⊤ = C2 . (40)

the generators commute and S is a valid stabilizer group.

Next we determine the parameters of the resulting stabilizer code. The matrix H1 has n − k1
rows and H2 has n − k2 rows, so the stabilizer has

r = (n − k1 ) + (n − k2 ) = 2n − k1 − k2 (41)
MATH 5352

generators. Since the X and Z generators act on separate halves of the symplectic representation,
no product of them can give the identity, so these generators are independent. By theorem 3.5 the
code space has dimension
2n−r = 2k1 +k2 −n , (42)
and hence the CSS code encodes
k = k1 + k2 − n (43)
logical qubits.
It remains to show that the distance of the CSS code is at least min{d1 , d2 }. We first treat pure
Z errors and then generalize. A Z error on n qubits can be represented by a binary vector z ∈ Zn2 ,
where zi = 1 iff a Z acts on qubit i. The X stabilizer generators are given by the rows of H2 , so
the syndrome of z is
H2 z ∈ Z2n−k2 . (44)
If wt(z) < d2 and H2 z = 0, then z is a codeword of C2 of weight strictly smaller than d2 , con-
tradicting the fact that C2 has distance d2 . Thus for every nonzero z with wt(z) < d2 we must
have H2 z ̸= 0, so some X generator anticommutes with the error and the corresponding Z error is
detected.
The argument for pure X errors is identical with the roles of C1 and C2 swapped. Finally,
consider a general Pauli error E on n qubits. Up to an overall phase we can write E uniquely as
the product of X and Z errors, where x, z ∈ Zn2 record the locations of the X and Z components.
Its weight satisfies
wt(E) ≥ max{wt(x), wt(z)}. (45)
Suppose wt(E) < min{d1 , d2 }. Then wt(x) < d1 and wt(z) < d2 . If x ̸= 0, the argument above
shows that H1 x ̸= 0, so some Z generator detects the error. If instead x = 0 but z ̸= 0, then
H2 z ̸= 0, and an X generator detects the error. The only remaining case is x = 0 and z = 0, in
which E is proportional to the identity and acts trivially on the code space.
Therefore every nontrivial Pauli error of weight strictly less than min{d1 , d2 } produces a nonzero
syndrome and is detectable.

5 Afterword
Since this paper covered many topics very quickly there is a lot that was beyond its scope. For
instance Gottesman goes into far more depth on error syndromes for stabilizer codes as well as var-
ious error channels. Additionally, Nelson and Chuang covers bounds on the properties of quantum
codes.
MATH 5352

6 Bibliography
Joschka Roffe. Quantum Error Correction: An Introductory Guide. arXiv:1907.11157. Available
at: [Link]
Gottesman, D. (2024). Surviving as a Quantum Computer in a Classical World. Unpublished
manuscript. Available at: [Link]
pdf.
Nielsen, M. A., and Chuang, I. L. (2010). Quantum Computation and Quantum Information.
Cambridge University Press, 10th Anniversary Edition.
Wright, S. (2024). Lecture 4: Quantum Error-Correcting Codes. Quantum Coding Theory, UC
Berkeley EECS. Available at: [Link]
scribe%20notes/[Link].