\chapter{Fundamentals of Classical and Quantum Error Correction}
\label{ch:Fundamentals}

\Ac{qec} is a field of research combining ``classical''
communications engineering and quantum information science.
This chapter provides the relevant theoretical background on both of
these topics and subsequently introduces the fundamentals of \ac{qec}.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Classical Error Correction}
\label{sec:Classical Error Correction}

The core concept underpinning error correcting codes is the
realization that introducing a finite amount of redundancy to
information before transmission can considerably reduce the error rate.
Specifically, Shannon proved in 1948 that for any channel, a block
code can be found that achieves arbitrarily small probability of
error at any communication rate up to the capacity of the channel
when the block length approaches infinity
\cite[Sec.~13]{shannon_mathematical_1948}.

In this section, we explore the concepts of ``classical'' (as in non-quantum)
error correction that are central to this work.
We start by looking at different ways of encoding information,
first considering binary linear block codes in general and then \ac{ldpc} and
\ac{sc}-\ac{ldpc} codes.
Finally, we pivot to the decoding process, specifically the \ac{bp}
algorithm.

\subsection{Binary Linear Block Codes}

%
% Codewords, n, k, rate
%

One particularly important class of coding schemes is that of binary
linear block codes.
The information to be protected takes the form of a sequence of
binary symbols, which is split into separate blocks.
Each block is encoded, transmitted, and decoded separately.
The encoding step introduces redundancy by mapping input messages
$\bm{u} \in \mathbb{F}_2^k$ of length $k \in \mathbb{N}$ (called the
\textit{information length}) onto \textit{codewords} $\bm{x} \in
\mathbb{F}_2^n$ of length $n \in \mathbb{N}$ (called the
\textit{block length}) with $n > k$.
A measure of the amount of introduced redundancy is the \textit{code
rate} $R = k/n$.
We call the set of all codewords $\mathcal{C}$ the \textit{code}
\cite[Sec.~3.1.1]{ryan_channel_2009}.

%
% d_min and the [] Notation
%

During the encoding process, a mapping from $\mathbb{F}_2^k$
onto $\mathcal{C} \subset \mathbb{F}_2^n$ takes place.
The input messages are mapped onto an expanded vector space, where
they are ``further apart'', giving rise to the error correcting
properties of the code.
This notion of the distance between two codewords $\bm{x}_1$ and
$\bm{x}_2$ can be expressed using the \textit{Hamming distance} $d(\bm{x}_1,
\bm{x}_2)$, which is defined as the number of positions in which they differ.
We define the \textit{minimum distance} of a code $\mathcal{C}$ as
%
\begin{align*}
    d_\text{min} := \min \left\{ d(\bm{x}_1, \bm{x}_2) : \bm{x}_1,
    \bm{x}_2 \in \mathcal{C}, \bm{x}_1 \neq \bm{x}_2 \right\}
    .
\end{align*}
%
We can signify that a binary linear block code has information length
$k$, block length $n$ and minimum distance $d_\text{min}$ using the
notation $[n,k,d_\text{min}]$ \cite[Sec.~1.3]{macwilliams_theory_1977}.

%
% Parity checks, H, and the syndrome
%

A particularly elegant way of describing the subspace $C$ of
$\mathbb{F}_2^n$ that the codewords make up is the notion of
\textit{parity checks}.
Since $\lvert \mathcal{C} \rvert = 2^k$ and $\lvert \mathbb{F}_2^n
\rvert = 2^n$, we could introduce $n-k$ conditions to constrain the
additional degrees of freedom.
These conditions, called parity checks, take the form of equations
over $\mathbb{F}_2^n$, linking the individual positions of each codeword.
We can arrange the coefficients of these equations in a
\textit{parity-check matrix} (\acs{pcm}) $\bm{H} \in
\mathbb{F}_2^{(n-k) \times n}$ and equivalently define the code as
\cite[Sec.~3.1.1]{ryan_channel_2009}
\begin{align*}
    \mathcal{C} = \left\{ \bm{x} \in \mathbb{F}_2^n :
    \bm{H}\bm{x}^\text{T} = \bm{0} \right\}
    .%
\end{align*}
Note that in general we may have linearly dependent parity checks,
prompting us to define the \ac{pcm} as $\bm{H} \in
\mathbb{F}_2^{m\times n}$ with $\hspace{2mm} m \ge n-k$ instead.
The \textit{syndrome} $\bm{s} = \bm{H} \bm{v}^\text{T}$ describes
which parity checks a candidate codeword $\bm{v} \in \mathbb{F}_2^n$ violates.
The representation using the \ac{pcm} has the benefit of providing a
description of the code, the memory complexity of which does not grow
exponentially with $n$, in contrast to keeping track of all codewords directly.

%
% The decoding problem
%

Figure \ref{fig:Diagram of a transmission system} visualizes the
communication process \cite[Sec.~1.1]{ryan_channel_2009}.
An input message $\bm{u}\in \mathbb{F}_2^k$ is mapped onto a codeword $\bm{x}
\in \mathbb{F}_2^n$. This is passed on to a modulator, which
interacts with the physical channel.
A demodulator processes the channel output and forwards the result
$\bm{y}$ to a decoder.
We differentiate between \textit{soft-decision} decoding, where
$\bm{y} \in \mathbb{R}^n$, and \textit{hard-decision} decoding, where
$\bm{y} \in \mathbb{F}_2^n$ \cite[Sec.~1.5.1.3]{ryan_channel_2009}.
Finally, the decoder is responsible for obtaining an estimate
$\hat{\bm{u}} \in \mathbb{F}_2^k$ of the original input message.
This is done by first finding an estimate $\hat{\bm{x}}$ of the sent
codeword and undoing the encoding.
The decoding problem that we generally attempt to solve thus consists
in finding the best estimate $\hat{\bm{x}}$ given $\bm{y}$.

\begin{figure}[t]
    \centering

    \tikzset{
        box/.style={
            rectangle, draw=black, minimum width=17mm, minimum height=8mm,
        },
    }

    \begin{tikzpicture}
        [
            node distance = 2mm and 7mm,
        ]
        \node                                              (in)  {};
        \node[box, right=of in]                            (enc) {Encoder};
        \node[box, minimum width=25mm, right=of enc]       (mod) {Modulator};
        \node[box, below right=of mod]                     (cha) {Channel};
        \node[box, minimum width=25mm, below left=of cha]  (dem) {Demodulator};
        \node[box, left=of dem]                            (dec) {Decoder};
        \node[left=of dec]                                 (out) {};

        \draw[-{latex}] (in)  -- (enc) node[midway, above] {$\bm{u}$};
        \draw[-{latex}] (enc) -- (mod) node[midway, above] {$\bm{x}$};
        \draw[-{latex}] (mod) -| (cha);
        \draw[-{latex}] (cha) |- (dem);
        \draw[-{latex}] (dem) -- (dec) node[midway, above] {$\bm{y}$};
        \draw[-{latex}] (dec) -- (out) node[midway, above] {$\hat{\bm{u}}$};
    \end{tikzpicture}

    \caption{Overview of a transmission system.}
    \label{fig:Diagram of a transmission system}
\end{figure}
%

%
% Hard vs. soft information
%

\subsection{Low-Density Parity-Check Codes}

%
% Core concept
%

Shannon's noisy-channel coding theorem is stated for codes whose block
length approaches infinity. This suggests that as the block length
becomes larger, the performance of the considered codes should
generally improve.
However, the size of the \ac{pcm}, and thus in general the decoding complexity,
of a linear block code grows quadratically with $n$.
This would quickly render decoding intractable as we increase the block length.
We can get around this problem by constructing $\bm{H}$ in such a
manner that the number of nonzero entries grows less than quadratically, e.g.,
only linearly.
This is exactly the motivation behind \ac{ldpc} codes
\cite[Ch.~1]{gallager_low_1960}.

%
% Tanner Graph, VNs and CNs
%

\ac{ldpc} codes belong to a class sometimes referred to as ``modern codes''.
These differ from ``classical codes'' in their decoding algorithms:
Classical codes are usually decoded using one-step hard-decision decoding,
whereas modern codes are suitable for iterative soft-decision
decoding \cite[Preface]{ryan_channel_2009}. The iterative decoding algorithms
in question are generally defined in terms of message passing on the
\textit{Tanner graph} of the code. The Tanner graph is a bipartite
graph that constitutes an alternative representation of the \ac{pcm}.
We define two types of nodes: \acp{vn}, corresponding to codeword
bits, and \acp{cn}, corresponding to individual parity checks.
We then construct the Tanner graph by connecting each \ac{cn} to
the \acp{vn} that make up the corresponding parity check
\cite[Sec.~5.1.2]{ryan_channel_2009}.
Figure \ref{PCM and Tanner graph of the Hamming code} shows this
construction for the [7,4,3]-Hamming code.
%
\begin{figure}[t]
    \centering

    \begin{align*}
        \bm{H} =
        \begin{pmatrix}
            0 & 1 & 1 & 1 & 1 & 0 & 0 \\
            1 & 0 & 1 & 1 & 0 & 1 & 0 \\
            1 & 1 & 0 & 1 & 0 & 0 & 1 \\
        \end{pmatrix}
    \end{align*}

    \vspace*{2mm}

    \tikzset{
        VN/.style={
            circle, fill=KITgreen, minimum width=1mm, minimum height=1mm,
        },
        CN/.style={
            rectangle, fill=KITblue, minimum width=1mm, minimum height=1mm,
        },
    }

    \begin{tikzpicture}
        \node[VN, label=above:$x_1$]                    (vn1) {};
        \node[VN, right=12mm of vn1, label=above:$x_2$] (vn2) {};
        \node[VN, right=12mm of vn2, label=above:$x_3$] (vn3) {};
        \node[VN, right=12mm of vn3, label=above:$x_4$] (vn4) {};
        \node[VN, right=12mm of vn4, label=above:$x_5$] (vn5) {};
        \node[VN, right=12mm of vn5, label=above:$x_6$] (vn6) {};
        \node[VN, right=12mm of vn6, label=above:$x_7$] (vn7) {};

        \node[
            CN, below=25mm of vn4,
            label={below:$x_1 + x_3 + x_4 + x_6 = 0$}
        ] (cn2) {};
        \node[
            CN, left=40mm of cn2,
            label={below:$x_2 + x_3 + x_4 + x_5 = 0$}
        ] (cn1) {};
        \node[
            CN, right=40mm of cn2,
            label={below:$x_1 + x_2 + x_4 + x_7 = 0$}
        ] (cn3) {};

        \foreach \n in {2,3,4,5} {
            \draw (cn1) -- (vn\n);
        }

        \foreach \n in {1,3,4,6} {
            \draw (cn2) -- (vn\n);
        }

        \foreach \n in {1,2,4,7} {
            \draw (cn3) -- (vn\n);
        }
    \end{tikzpicture}

    \caption{The \ac{pcm} and corresponding Tanner graph of the
    [7,4,3]-Hamming code.}
    \label{PCM and Tanner graph of the Hamming code}
\end{figure}

%
% N_V(j), N_C(i)
%

Mathematically, we represent a \ac{vn} using the index $i \in
\mathcal{I} := \left[
1 : n \right]$ and a \ac{cn} using the index $j \in \mathcal{J}
:= \left[ 1 : m \right]$.
We can then encode the information contained in the graph by defining
the neighborhood of a variable node $i$ as
$\mathcal{N}_\text{V} (i) = \left\{ j \in \mathcal{J} : \bm{H}_{j,i}
= 1 \right\}$
and that of a check node $j$ as
$\mathcal{N}_\text{C} (j) = \left\{ i \in \mathcal{I} : \bm{H}_{j,i}
= 1 \right\}$.

%
% Error floor and waterfall regions
%

We typically evaluate the performance of LDPC codes using the
\ac{ber} or the \ac{fer} (a \textit{frame} referes to one whole
transmitted block in this context).
Considering an \ac{awgn} channel, \autoref{fig:ldpc-perf} shows a
qualitative performance characteristic of an \ac{ldpc} code
\cite[Fig.~1]{costello_spatially_2014}. We talk of the
\textit{waterfall} and the \textit{error floor} regions.

\begin{figure}[t]
    \centering

    \begin{tikzpicture}
        \begin{axis}[
                width=12cm,
                height=9cm,
                xlabel={Signal-to-noise ratio},
                ylabel={Error rate},
                % xmin=0, xmax=6,
                enlarge x limits=false,
                ymin=1e-9, ymax=1,
                ticks=none,
                % y tick label={},
                ymode=log,
                grid=both,
                grid style={line width=0.2pt, draw=gray!30},
                major grid style={line width=0.4pt, draw=gray!50},
                legend pos=north east,
                legend cell align={left},
            ]

            \addplot+[mark=none, solid, smooth, KITblue] coordinates {
                (4.5789E-01, 1.1821E-01)
                (6.6842E-01, 9.4575E-02)
                (8.6316E-01, 5.2657E-02)
                (1.0421E+00, 2.2183E-02)
                (1.1789E+00, 8.3588E-03)
                (1.3368E+00, 1.4835E-03)
                (1.4895E+00, 1.6852E-04)
                (1.5842E+00, 2.8285E-05)
                (1.6737E+00, 4.2465E-06)
                (1.7684E+00, 3.4519E-07)
                (1.8316E+00, 3.9213E-08)
                (1.8684E+00, 6.2247E-09)
                (1.9053E+00, 1E-09)
            };
            \addlegendentry{Regular}

            \addplot+[mark=none, solid, smooth, KITorange] coordinates {
                (4.5789E-01, 1.1821E-01)
                (6.4211E-01, 4.9800E-02)
                (7.5263E-01, 1.2700E-02)
                (8.1579E-01, 2.3177E-03)
                (8.6842E-01, 3.5779E-04)
                (9.1053E-01, 5.3716E-05)
                (9.4737E-01, 4.8818E-06)
                (9.8947E-01, 6.5555E-07)
                (1.0421E+00, 9.5713E-08)
                % (1.0684E+00, 2.9670E-08)
                (1.1474E+00, 1.2499E-08)
                (1.3000E+00, 7.1560E-09)
                (1.4579E+00, 6.0535E-09)
                % (1.6105E+00, 5E-09)
                (1.9579E+00, 4E-09)
                (2.2947E+00, 3.1876E-09)
                % (2.8842E+00, 2.0403E-09)
            };
            \addlegendentry{Irregular}

            \draw[gray, densely dashed]
            (axis cs:0.65, 2e-3) rectangle (axis cs:1.65, 5e-5);
            \node[below] at (axis cs:1.15, 6e-5) {Waterfall};

            \draw[gray, densely dashed]
            (axis cs:1, 6e-8) rectangle (axis cs:2, 2e-9);
            \node[above] at (axis cs:1.5, 7e-8) {Error floor};
        \end{axis}
    \end{tikzpicture}

    \caption{
        Qualitative performance characteristic of \ac{ldpc} code
        in an \ac{awgn} channel. Adapted from
        \cite[Fig.~1]{costello_spatially_2014}.
    }
    \label{fig:ldpc-perf}
\end{figure}

Broadly, there are two kinds of \ac{ldpc} codes, \textit{regular} and
\textit{irregular}.
Regular codes are characterized by the fact that the weights, i.e.,
the numbers of ones, of their rows and columns are constant
\cite[Sec.~5.1.1]{ryan_channel_2009}.
Already during their introduction, regular \ac{ldpc} codes were shown to have
a minimum distance scaling linearly with the block length $n$ for
large values \cite[Ch.~2,~Theorem~1]{gallager_low_1960},
which leads to them not exhibiting an error floor under \ac{ml} decoding.
Irregular codes, on the other hand, generally do exhibit an error floor,
their redeeming quality being the ability to reach near-capacity
performance in the waterfall region \cite[Intro.]{costello_spatially_2014}.

\subsection{Spatially-Coupled LDPC Codes}

A relatively recent development in the world of \ac{ldpc} codes is
that of \ac{sc}-\ac{ldpc} codes.
Their key feature is that they combine the best properties of regular
and irregular codes.
They have a minimum distance that grows linearly with $n$, promising
good error floor behavior, and capacity approaching
iterative decoding behavior, promising good performance in the
waterfall region \cite[Intro.]{costello_spatially_2014}.

The essential property of \ac{sc}-\ac{ldpc} codes is that codewords
from different \textit{spatial positions}, that would ordinarily be sent
one after the other independently, are coupled.
This is achieved by connecting some \acp{vn} of one spatial position to
\acp{cn} of another, resulting in a \ac{pcm} of the form
\cite[Eq.~1]{hassan_fully_2016}
%
\begin{align*}
    \bm{H} =
    \begin{pmatrix}
        \bm{H}_0(1) &        &             \\
        \vdots      & \ddots &             \\
        \bm{H}_K(1) &        & \bm{H}_0(L) \\
        & \ddots &             \\
        &        & \bm{H}_K(L) \\
    \end{pmatrix}
    ,
\end{align*}
%
where $K \in \mathbb{N}$ is the \textit{coupling width} and $L \in
\mathbb{N}$ is the number of spatial positions.
This construction results in a Tanner graph as depicted in
\autoref{fig:sc-ldpc-tanner}.

\begin{figure}[t]
    \centering

    \tikzset{
        VN/.style={
            circle, fill=KITgreen, minimum width=1mm, minimum height=1mm,
        },
        CN/.style={
            rectangle, fill=KITblue, minimum width=1mm, minimum height=1mm,
        },
    }

    \begin{tikzpicture}[node distance=7mm and 1cm]
        \node[VN]                  (vn00) {};
        \node[VN, below = of vn00] (vn01) {};
        \node[VN, below = of vn01] (vn02) {};
        \node[VN, below = of vn02] (vn03) {};
        \node[VN, below = of vn03] (vn04) {};

        \coordinate (temp) at ($(vn01)!0.5!(vn02)$);

        \node[CN, right = of temp] (cn00) {};
        \node[CN, below = of cn00] (cn01) {};

        \draw (vn00) -- (cn00);
        \draw (vn01) -- (cn00);
        \draw (vn03) -- (cn00);
        \draw (vn01) -- (cn01);
        \draw (vn02) -- (cn01);
        \draw (vn04) -- (cn01);

        \foreach \i in {1,2,3} {
            \pgfmathtruncatemacro{\previ}{\i-1}
            \node[VN, right = 25mm of vn\previ 0] (vn\i0) {};

            \foreach \j in {1,...,4} {
                \pgfmathtruncatemacro{\prevj}{\j-1}
                \node[VN, below = of vn\i\prevj] (vn\i\j) {};
            }

            \coordinate (temp) at ($(vn\i1)!0.5!(vn\i2)$);

            \node[CN, right = of temp]  (cn\i0) {};
            \node[CN, below = of cn\i0] (cn\i1) {};

            \draw (vn\i0) -- (cn\i0);
            \draw (vn\i1) -- (cn\i0);
            \draw (vn\i3) -- (cn\i0);
            \draw (vn\i1) -- (cn\i1);
            \draw (vn\i2) -- (cn\i1);
            \draw (vn\i4) -- (cn\i1);
        }

        \node[right = 25mm of vn30] (vn40) {};
        \node[below = of vn40]      (vn41) {};
        \node[below = of vn41]      (vn42) {};
        \node[below = of vn42]      (vn43) {};
        \node[below = of vn43]      (vn44) {};

        \coordinate (temp) at ($(vn41)!0.5!(vn42)$);

        \node[right = of temp] (cn40) {};
        \node[below = of cn40] (cn41) {};

        \foreach \i in {0,1,2} {
            \pgfmathtruncatemacro{\next}{\i+1}
            \pgfmathtruncatemacro{\nextnext}{\i+2}

            \draw (vn\i 3) to[bend right] (cn\next 1);
            \draw (vn\i 1) to[bend left]  (cn\nextnext 0);
        }

        \draw (vn33) to[bend right] (cn41);

        \node at ($(cn40)!0.5!(cn41)$) {\dots};

        \draw[decorate, decoration={brace, amplitude=10pt}]
        ([xshift=-5mm,yshift=2mm]vn00.north) --
        ([xshift=5mm,yshift=2mm]vn00.north -| cn20.north)
        node[midway, above=4mm] {K};
    \end{tikzpicture}

    \caption{
        Visualization of the coupling between the Tanner graphs
        of individual spatial positions.
    }
    \label{fig:sc-ldpc-tanner}
\end{figure}

Note that at the first and last few spatial positions, some \acp{cn}
have lower degrees.
This leads to more reliable information about the
\acp{vn} that, as we will see, is
later passed to subsequent spatial positions during decoding.
This is precisely the effect that leads to the good performance of
\ac{sc}-\ac{ldpc} codes in the waterfall region \cite{costello_spatially_2014}.

\subsection{Iterative Decoding}
\label{subsec:Iterative Decoding}

% Introduction

\ac{ldpc} codes are generally decoded using efficient iterative
algorithms, something that is possible due to their sparsity
\cite[Sec.~5.3]{ryan_channel_2009}.
The algorithm originally proposed alongside LDPC codes for this
purpose by Gallager in 1960 is now known as the \ac{spa}
\cite[5.4.1]{ryan_channel_2009}, also called \ac{bp}.

The optimality criterion the \ac{spa} is built around is a
symbol-wise \ac{map} decision \cite[Sec.~5.4.1]{ryan_channel_2009}.
The core idea of the resulting algorithm is to view \acp{cn} as
representing single-parity check codes and \acp{vn} as representing
repetition codes.
The algorithm alternates between consolidating soft information about
the \acp{vn} in the \acp{cn}, and consolidating soft information about
the \acp{cn} in the \acp{vn}.
To this end, messages are passed back and forth along the edges of
the Tanner graph.
$L_{i\rightarrow j}$ represents a message passed from \ac{vn} $i$ to
\ac{cn} j, $L_{i\leftarrow j}$ represents a message passed from
\ac{cn} j to \ac{vn} i.
The \acp{vn} additionally receive messages \cite[5.4.2]{ryan_channel_2009}
\begin{align*}
    \tilde{L}_i = \log \frac{P(X=0 \vert Y=y)}{P(X=1 \vert Y=y)},
\end{align*}
computed from the channel outputs.
The consolidation of the information occurs in the \ac{vn} update
\begin{align*}
    L_{i\rightarrow j} = \tilde{L}_i + \sum_{j'\in \mathcal{N}(i)\setminus
    j} L_{i\leftarrow j'}
\end{align*}
and the \ac{cn} update
\begin{align*}
    L_{i\leftarrow j} = 2\cdot \tanh^{-1} \left( \prod_{i'\in
    \mathcal{N}(j)\setminus i} \tanh \frac{L_{i'\rightarrow j}}{2} \right)
    .
\end{align*}

A basic assumption for the derivation of the \ac{spa} is that the
messages are statistically independent.
If the Tanner graph has cycles, however, this
condition is not met.
The shorter the cycles, the sooner this condition is violated and the
worse the approximation becomes \cite[Sec.~5.4.4]{ryan_channel_2009}.
Cycles of length four (so-called \emph{$4$-cycles}) are the shortest
possible cycles and are thus especially problematic.

% Min-sum algorithm

A simplification of the \ac{spa} is the min-sum decoder. Here, the
\ac{cn} update is approximated as \cite[Sec.~5.5.1]{ryan_channel_2009}
\begin{align*}
    L_{i \leftarrow j} = \prod_{i' \in \mathcal{N}(j)\setminus i}
    \sign \left( L_{i' \rightarrow j} \right)
    \cdot \min_{i' \in \mathcal{N}(j)\setminus i} \lvert
    L_{i'\rightarrow j} \rvert
    .
\end{align*}

% Sliding-window decoding

For \ac{sc}-\ac{ldpc} codes, the iterative decoding process is wrapped by a
windowing step. This is done to reduce the latency and memory requirements and
also the overall computational complexity \cite{costello_spatially_2014}.
To this end, the Tanner graph is split into several overlapping windows.
During decoding, the messages that are passed along the edges of the
graph in the overlapping regions are kept in memory and used for the
decoding of subsequent blocks \cite[Sec.~III.~C.]{hassan_fully_2016}.

\section{Quantum Mechanics and Quantum Information Science}
\label{sec:Quantum Mechanics and Quantum Information Science}

Designing codes and decoders for \ac{qec} is generally performed on a
layer of abstraction far removed from the quantum mechanical
processes underlying the actual physics.
Nevertheless, having a fundamental understanding of the related
quantum mechanical concepts is useful to grasp the unique constraints
of this field.
The purpose of this section is to convey these concepts to the reader.

%%%%%%%%%%%%%%%%
\subsection{Core Concepts and Notation}
\label{subsec:Notation}

% Wave functions

In quantum mechanics, the state of a particle is described by a
\emph{wave function} $\psi(x,t)$.
Born's statistical interpretation provides a connection between this
function and the observable world:
$\lvert \psi (x,t) \rvert^2$ is the \ac{pdf} of finding a particle at
position $x$ and time $t$ \cite[Sec.~1.2]{griffiths_introduction_1995}.
Note that this presupposes a normalization of $\psi$ such that
$\int_{-\infty}^{\infty} \lvert \psi(x,t) \rvert^2 dx = 1$.

% Dirac notation

Much of the related mathematics can be very elegantly expressed
using the language of linear algebra.
The so-called Bra-ket or Dirac notation is especially appropriate,
having been proposed by Paul Dirac in 1939 for the express purpose
of simplifying quantum mechanical notation \cite{dirac_new_1939}.
Two new symbols are defined, \emph{bra}s $\bra{\cdot}$ and
\emph{ket}s $\ket{\cdot}$.
Kets denote column vectors, while bras denote their Hermitian conjugates.
For example, two vectors specified by the labels $a$ and $b$
respectively are written as $\ket{a}$ and $\ket{b}$.
Their inner product is $\braket{a\vert b}$.

% Expressing wave functions using linear algebra

The connection we will make between quantum mechanics and linear
algebra is that we will model the state space of a system as a
\emph{function space}, the Hilbert space $L_2$.
We will represent the state of a particle with wave function
$\psi(x,t)$ using the vector $\ket{\psi}$
\cite[Sec.~3.3]{griffiths_introduction_1995}.

% Operators

Another important notion is that of an \emph{operator}, a transformation
that takes a function as an input and returns another function as an
output \cite[Sec.~3.2.2]{griffiths_introduction_1995}.
Operators are useful to describe the relations between different
quantities relating to a particle.
An example of this is the differential operator $\partial x$.
We define the \emph{commutator} of two operators $P_1$ and $P_2$ as
\begin{align*}
    [P_1,P_2] = P_1P_2 - P_2P_1
\end{align*}
and the \emph{anticommutator} as
\begin{align*}
    [P_1,P_2]_+ = P_1P_2 + P_2P_1
    .%
\end{align*}
We say the two operators \emph{commute} iff $[P_1,P_2] = 0$, and they
\emph{anti-commute} iff $[P_1,P_2]_+ = 0$.

%%%%%%%%%%%%%%%%
\subsection{Observables}
\label{subsec:Observables}

% Observable quantities

An \emph{observable quantity} $Q(x,p,t)$ is a quantity of a quantum
mechanical system that we can measure, such as the position $x$ or
momentum $p$ of a particle.
In general, such measurements are not deterministic, i.e.,
measurements on identically prepared states can yield different results.
There are some states, however, that are \emph{determinate} for a
specific observable: measuring those will always yield identical
observations \cite[Sec.~3.3]{griffiths_introduction_1995}.

% General expression for expected value of observable quantity

If we know the wave function of a particle, we should be able to
compute the expected value $\braket{Q}$ of any observable quantity we wish.
It can be shown that for any $Q$, we can find a
corresponding Hermitian operator $\hat{Q}$ such that
\cite[Sec.~3.3]{griffiths_introduction_1995}
\begin{align}
    \label{eq:gen_expr_Q_exp}
    \braket{Q} = \int_{-\infty}^{\infty} \psi^*(x,t) \hat{Q} \psi(x,t) dx
    .%
\end{align}%
While the derivation of this relationship is out of the scope of this
work, we can at least look at an example to illustrate it.
Considering the position $Q = x$ of a particle and setting the observable
operator to $\hat{Q} = x$, we can write
\cite[Sec.~1.5]{griffiths_introduction_1995}
\begin{align*}
    \braket{x} = \int_{-\infty}^{\infty} \psi^*(x,t) \cdot x \cdot \psi(x,t) dx
    = \int_{-\infty}^{\infty} x \lvert \psi(x,t) \rvert ^2 dx
    .%
\end{align*}
Note that $\lvert \psi(x,t) \rvert^2 $ represents the \ac{pdf} of
finding a particle in a specific state. We immediately see that the
formula simplifies to the direct calculation of the expected value.

% Determinate states and eigenvalues

Let us now examine how the observable operator $\hat{Q}$ relates to
the determinate states of the observable quantity.
We begin by translating \autoref{eq:gen_expr_Q_exp} into linear algebra as
\cite[Eq.~3.114]{griffiths_introduction_1995}
\begin{align}
    \label{eq:gen_expr_Q_exp_lin}
    \braket{Q} = \braket{\psi \vert \hat{Q}\psi}
    .%
\end{align}
\autoref{eq:gen_expr_Q_exp_lin} expresses an inherently probabilistic
relationship.
The determinate states are inherently deterministic.
To relate the two, we note that since determinate states should
always yield the same measurement results, the variance of the
observable should be zero.
We thus compute \cite[Eq.~3.116]{griffiths_introduction_1995}
\begin{align}
    0 &\overset{!}{=} \braket{(Q - \braket{Q})^2}
    = \braket{e_n \vert (\hat{Q} - \braket{Q})^2 e_n} \nonumber\\
    &= \braket{(Q - \braket{Q})e_n \vert (\hat{Q} - \braket{Q})
    e_n} \nonumber\\
    &= \lVert (Q - \braket{Q}) e_n \rVert^2 \nonumber\\[3mm]
    &\hspace{-8mm}\Leftrightarrow (\hat{Q} - \braket{Q}) \ket{e_n} =
    0 \nonumber\\
    \label{eq:observable_eigenrelation}
    &\hspace{-8mm}\Leftrightarrow \hat{Q}\ket{e_n}
    = \underbrace{\braket{Q}}_{\lambda_n} \ket{e_n}
    .%
\end{align}%
%
Because we have assumed the variance to be zero, the expected value
$\braket{Q}$ is now the deterministic measurement result
corresponding to the determinate state
$\ket{e_n},~n\in \mathbb{N}$.
We can see that the determinate states are the \emph{eigenstates} of
the observable operator $\hat{Q}$ and that the measurement values are
the corresponding \emph{eigenvalues} $\lambda_n$
\cite[Sec.~3.3]{griffiths_introduction_1995}.

% Determinate states as a basis

As we are modelling the wave function $\psi(x,t)$ as a vector
$\ket{\psi}$, we can find a set of basis vectors to decompose it into.
We can use the determinate states for this purpose, expressing the state as%
\footnote{
    We are only considering the case of having a \emph{discrete
    spectrum} here, i.e., having a discrete set of eigenvalues and vectors.
    For continuous spectra, the procedure is analogous.
}
\begin{align}
    \label{eq:determinate_basis}
    \ket{\psi} = \sum_{n=1}^{\infty} c_n \ket{e_n}, \hspace{3mm}
    c_n := \braket{e_n \vert \psi}
    .%
\end{align}
Because of the normalization of the wave function such that
$\int_{-\infty}^{\infty} \lvert \psi(x,t) \rvert^2 dx = 1$, we have
$\sum_{n=1}^{\infty} \lvert c_n \rvert ^2 = 1$.
Inserting \autoref{eq:determinate_basis} into
\autoref{eq:gen_expr_Q_exp_lin} we obtain
% tex-fmt: off
\cite[Prob.~3.35c)]{griffiths_introduction_1995}
% tex-fmt: on
\begin{align*}
    \braket{Q} = \left( \sum_{n=1}^{\infty} c_n \bra{e_n} \right)
    \left( \sum_{m=1}^{\infty} c_m\hat{Q}\ket{e_m} \right)
    = \sum_{n=1}^{\infty} \sum_{m=1}^{\infty} c_n c_m
    \lambda_m\braket{e_n \vert e_m}
    = \sum_{n=1}^{\infty} \lambda_n \lvert c_n \rvert ^2
    .%
\end{align*}
We can thus interpret $\lvert c_n \rvert ^2$ as the probability of
obtaining value $\lambda_n$ from the measurement.

% Recap

To summarize, we mathematically model an observable quantity
$Q(x,t,p)$ using a corresponding operator $\hat{Q}$, which allows us
to compute the expected value as $\braket{Q} = \braket{\psi
\vert \hat{Q} \psi}$.
The eigenvectors of $\hat{Q}$ are the determinate states
$\ket{e_n},~n\in \mathbb{N}$ and the eigenvalues are the respective
measurement outcomes.
We can decompose an arbitrary state as $\ket{\psi} = \sum_{n=1}^{\infty} c_n
\ket{e_n}$, where $\lvert c_n \rvert ^2$ represents the probability
of obtaining a certain measurement value.
Note that when we speak of an \emph{observable}, we are usually
referring to the operator $\hat{Q}$.

%%%%%%%%%%%%%%%%
\subsection{Projective Measurements}
\label{subsec:Projective Measurements}

% Projective measurements

The measurements we considered in the previous section, for which
\autoref{eq:gen_expr_Q_exp_lin} holds, belong to the category of
\emph{projective measurements}.
For these, certain restrictions such as repeatability apply: the act
of measuring a quantum state should \emph{collapse} it onto one of
the determinate states.
Further measurements should then yield the same value.
More general methods of modelling measurements exist, e.g., describing
destructive measurements \cite[Box~2.5]{nielsen_quantum_2010}, but
they are not relevant to this work.

% Projection operators

We can model the collapse of the original state onto one of the
superimposed basis states as a \emph{projection}.
To see this, we use Equations \ref{eq:determinate_basis} and
\ref{eq:observable_eigenrelation} to compute
\begin{align*}
    \hat{Q}\ket{\psi} = \sum_{n=1}^{\infty} c_n \hat{Q} \ket{e_n}
    = \sum_{n=1}^{\infty} \lambda_n c_n \ket{e_n}
    .%
\end{align*}%
We see that $\hat{Q}$ has the effect of multiplying the component
along each basis vector with the corresponding eigenvalue.
We decompose $\hat{Q}$ into its constituent parts that act on each of
the separate components as
\begin{align*}
    \hat{Q} = \sum_{n=1}^{\infty} \lambda_n \hat{P}_n
\end{align*}
using \emph{projection operators} \cite[Eq.~3.160]{griffiths_introduction_1995}
\begin{align*}
    \hat{P}_n := \ket{e_n}\bra{e_n}, \hspace{3mm} n\in \mathbb{N}
    .
\end{align*}%
These project a vector onto the subspace spanned by $\ket{e_n}$.

% % Using projection operators to measure if a state has a component
% % along a basis vector
%
% A particularly interesting property of projection operators is that
% \begin{align*}
%     \hat{P}_n (\hat{P}_n \ket{\psi}) = \hat{P}_n^2 \ket{\psi}
%     = \hat{P}_n \ket{\psi},
% \end{align*}%
% and the only way this can hold for any $\ket{\psi}$ is if $\hat{P}_n$
% only has the eigenvalues $0$ or $1$
% % tex-fmt: off
% \cite[Prob.~3.57a)]{griffiths_introduction_1995}.
% % tex-fmt: on
% The eigenvalues can again be interpreted as possible measurement results.
% We can thus use $\hat{P}$ as an observable and treat
% the eigenvalue as an indicator of the state having a component along
% the related basis vector.

%%%%%%%%%%%%%%%%
\subsection{Qubits and Multi-Qubit States}
\label{subsec:Qubits and Multi-Qubit States}

% Intro

% TODO: Make sure `quantum gate` is proper terminology
A central concept for quantum computing is that of the \emph{qubit}.
We employ it analogously to the classical \emph{bit}.
For classical computers, we alter bits' states using \emph{gates}.
We can chain multiple of these gates together to build up more complex logic,
such as half-adders or eventually a full processor.
In principle, quantum computers work in a similar fashion, only that
instead of bits we use qubits and instead of, e.g., AND, OR, and XOR
operations we use \emph{quantum gates} \cite[Sec.~1.3]{nielsen_quantum_2010}.

% Qubits and multi-qubit states

We fix an orthonormal basis of $\mathbb{C}^2$ to be
\begin{align*}
    \ket{0} =
    \begin{pmatrix}
        1 \\
        0
    \end{pmatrix}, \hspace{5mm}
    \ket{1} =
    \begin{pmatrix}
        0 \\
        1
    \end{pmatrix}
    .%
\end{align*}
A qubit is defined to be a system with quantum state
\begin{align*}
    \ket{\psi} =
    \begin{pmatrix}
        \alpha \\
        \beta
    \end{pmatrix}
    = \alpha \ket{0} + \beta \ket{1}
    .%
\end{align*}
The overall state of a composite quantum system is described using
the \emph{tensor product}, denoted as $\otimes$
\cite[Sec.~2.2.8]{nielsen_quantum_2010}.
Take for example the two qubits
\begin{align*}
    \ket{\psi_1} = \alpha_1 \ket{0} + \beta_1 \ket{1},\hspace*{10mm}
    \ket{\psi_2} = \alpha_2 \ket{0} + \beta_2 \ket{1}
    .%
\end{align*}
We examine the state $\ket{\psi}$ of the composite system.
Assuming the qubits are independent, this is a \emph{product state}
$\ket{\psi} = \ket{\psi_1}\otimes\ket{\psi_2}$.
When not ambiguous, we may omit the tensor product symbol or even write
the entire product state as a single ket
\cite[Sec.~6.2]{griffiths_consistent_2001}.
We have
\begin{align}
    \label{eq:product_state}
    \begin{split}
        \ket{\psi} = \ket{\psi_1} \ket{\psi_2}
        &= \left( \alpha_1 \ket{0} + \beta_1 \ket{1} \right)
        \left( \alpha_2 \ket{0} + \beta_2 \ket{1} \right) \\
        &= \alpha_1\alpha_2\ket{00}
        + \alpha_1\beta_2\ket{01}
        + \beta_1\alpha_2\ket{10}
        + \beta_1\beta_2\ket{11}
        .%
    \end{split}
\end{align}
We call $\ket{x_0, \ldots, x_n}~, x_i \in \{0,1\}$ the
\emph{computational basis states} \cite[Sec.~4.6]{nielsen_quantum_2010}.
To additionally simplify set notation, we define
\begin{align*}
    \mathcal{M}^{\otimes n} := \underbrace{\mathcal{M}\otimes \ldots
    \otimes \mathcal{M}}_{n \text{ times}}
    .%
\end{align*}

% Entanglement

States that are not able to be decomposed into such products
are called \emph{entangled} \cite[Sec.~2.2.8]{nielsen_quantum_2010}.
An example of such states are the \emph{Bell states}
\begin{align*}
    \begin{split}
        \ket{\psi_{00}} &= \frac{\ket{00} + \ket{11}}{\sqrt{2}} \hspace{15mm}
        \ket{\psi_{01}} = \frac{\ket{01} + \ket{10}}{\sqrt{2}} \\
        \ket{\psi_{10}} &= \frac{\ket{01} - \ket{10}}{\sqrt{2}} \hspace{15mm}
        \ket{\psi_{11}} = \frac{\ket{00} - \ket{11}}{\sqrt{2}}
    \end{split}
    \hspace{4mm}.%
\end{align*}
Quantum entanglement plays a major role in the way information
is encoded on quantum systems compared to classical ones.
Instead of employing only the individual qubit states, the
information is stored in the correlations between the qubits
\cite[Sec.~2]{preskill_quantum_2018}.

% The size of the vector space

As we can see in \autoref{eq:product_state}, the number of
computational basis states needed to express the full composite state
is $2^n$.
This is in contrast to classical systems, where the dimensionality of
the state space only grows linearly with $n$.
This exponential growth of the state space is what makes it difficult
to simulate quantum systems on classical hardware.
It is also what motivated the research into performing computations
using quantum hardware in the first place
\cite[Sec.~3]{feynman_simulating_1982}.

% Basic types of gates

After examining the modelling of single- and multi-qubit systems,
we now shift our focus to describing the evolution of their states.
We model state changes as operators.
Unlike classical systems, where there are only two possible states and
thus the only possible state change is a bit-flip, a general qubit
state as shown in \autoref{eq:gen_qubit_state} lives on a continuum of values.
We thus technically also have an infinite number of possible state changes.
Fortunately, we can express any operator as a linear combination of the
\emph{Pauli operators} \cite[Sec.~2.2]{gottesman_stabilizer_1997}
\cite[Sec.~2.2]{roffe_quantum_2019}
\begin{align*}
    \begin{array}{c}
        I\text{ Operator} \\
        \hline\\
        \ket{0} \mapsto \ket{0} \\
        \ket{1} \mapsto \ket{1}
    \end{array}%
    \hspace{10mm}%
    \begin{array}{c}
        X\text{ Operator} \\
        \hline\\
        \ket{0} \mapsto \ket{1} \\
        \ket{1} \mapsto \ket{0}
    \end{array}%
    \hspace{10mm}%
    \begin{array}{c}
        Z\text{ Operator} \\
        \hline\\
        \ket{0} \mapsto \phantom{-}\ket{0} \\
        \ket{1} \mapsto -\ket{1}
    \end{array}%
    \hspace{10mm}%
    \begin{array}{c}
        Y\text{ Operator} \\
        \hline\\
        \ket{0} \mapsto \phantom{-}j\ket{1} \\
        \hspace{2.75mm}\ket{1} \mapsto -j\ket{0} \hspace*{1mm}.
    \end{array}
\end{align*}
In fact, if we allow for complex coefficients, the $X$ and $Z$
operators are sufficient to express any other operator as a linear
combination \cite[Sec.~2.2]{roffe_quantum_2019}.
$I$ is the identity operator and $X$ and $Z$ are referred to as
\emph{bit-flips} and \emph{phase-flips} respectively.
We call the set $\mathcal{G}_n = \left\{ \pm I,\pm jI, \pm X,\pm jX,
\pm Y,\pm jY, \pm Z, \pm jZ \right\}^{\otimes n}$ the \emph{Pauli
group} over $n$ qubits.

In the context of modifying qubit states, we also call operators \emph{gates}.
When working with multi-qubit systems, we can also apply Pauli gates
to individual qubits independently, which we write, e.g., as $I_1 X_2
I_3 Z_4 Y_5$.
We often omit the identity operators, instead writing, e.g., $X_2 Z_4 Y_5$.
Other important operators include the \emph{Hadamard} and
\emph{controlled-NOT (CNOT)} gates \cite[Sec.~1.3]{nielsen_quantum_2010}
\vspace*{-7mm}
\begin{figure}[H]
    \centering
    \begin{minipage}[t]{0.4\textwidth}
        \centering
        \begin{align*}
            \begin{array}{c}
                H\text{ Operator} \\
                \hline\\
                \ket{0} \mapsto \frac{1}{\sqrt{2}} \left( \ket{0} +
                \ket{1} \right) \\[2mm]
                \ket{1} \mapsto \frac{1}{\sqrt{2}} \left( \ket{0} -
                \ket{1} \right)
            \end{array}
        \end{align*}
    \end{minipage}%
    \begin{minipage}[t]{0.4\textwidth}
        \centering
        \begin{align*}
            \begin{array}{c}
                CNOT\text{ Operator} \\
                \hline\\
                \ket{00} \mapsto \ket{00} \\
                \ket{01} \mapsto \ket{01} \\
                \ket{10} \mapsto \ket{11} \\
                \hspace{2.75mm}\ket{11} \mapsto \ket{10} \hspace*{1mm}.
            \end{array}
        \end{align*}
    \end{minipage}%
\end{figure}
\vspace{-4mm}
\noindent Many more operators relevant to quantum computing exist, but they are
not covered here as they are not central to this work.

%%%%%%%%%%%%%%%%
\subsection{Quantum Circuits}
\label{Quantum Circuits}

% Intro

Using these quantum gates, we can construct \emph{circuits} to manipulate
the states of qubits \cite[Sec.~1.3.4]{nielsen_quantum_2010}.
Circuits are read from left to right and each horizontal wire
represents a qubit whose state evolves as it passes through
successive gates.

% General notation

A single line carries a quantum state, while a double line
denotes a classical bit, typically used to carry the result of a measurement.
A measurement is represented by a meter symbol.
In general, gates are represented as labeled boxes placed on one or more wires.
An exception is the CNOT gate, where the operation is represented as
the symbol $\oplus$.

% Controlled gates & example

We can additionally add a control input to a gate.
This conditions its application on the state of another qubit
\cite[Sec.~4.3]{nielsen_quantum_2010}.
The control connection is represented by a vertical line connecting
the gate to the corresponding qubit, where a filled dot is placed.
A controlled gate applies the respective operation only if the
control qubit is in state $\ket{1}$.
An example of this is the CNOT gate introduced in
\autoref{subsec:Qubits and Multi-Qubit States}, which is depicted in
\autoref{fig:cnot_circuit}.

\begin{figure}[t]
    \centering

    \begin{quantikz}
        \lstick{$\ket{\psi}_1$} & \ctrl{1} & \\
        \lstick{$\ket{\psi}_2$} & \targ{}  & \\
    \end{quantikz}

    \caption{CNOT gate circuit.}
    \label{fig:cnot_circuit}
\end{figure}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Quantum Error Correction}
\label{sec:Quantum Error Correction}

% TODO: Use this for the introduction as well

% General motivation behind QEC

One of the major barriers on the road to building a functioning
quantum computer is the inevitability of errors during quantum
computation. These arise due to the difficulty in sufficiently isolating the
qubits from external noise \cite[Intro.]{roffe_quantum_2019}.
This isolation is critical for quantum systems, as the constant interactions
with the environment act as small measurements, an effect called
\emph{decoherence} of the quantum state
\cite[Intro.]{gottesman_stabilizer_1997}.
\ac{qec} is one approach of dealing with this problem, by protecting
the quantum state in a similar fashion to information in classical error
correction.

% The unique challenges of QEC

The problem setting of \ac{qec} differs slightly from the classical case.
Three main restrictions apply \cite[Sec.~2.4]{roffe_quantum_2019}:
\begin{itemize}
    \item The no-cloning theorem states that it is
        impossible to exactly copy the state of one qubit into another.
    \item Qubits are susceptible to more types of errors than
        just bit-flips, as we saw in
        \autoref{subsec:Qubits and Multi-Qubit States}.
    \item Directly measuring the state of a qubit collapses it onto
        one of the determinate states, thereby potentially destroying
        information.
\end{itemize}

% General idea (logical vs. physical gates) + notation

Much like in classical error correction, in \ac{qec} information
is protected by mapping it onto codewords in a higher-dimensional space,
thereby introducing redundancy.
To this end, $k \in \mathbb{N}$ \emph{logical qubits} are mapped onto
$n \in \mathbb{N}$ \emph{physical qubits}, $n>k$.
We circumvent the no-cloning restriction by not copying the state of any of
the $k$ logical qubits, instead spreading the total state out over all $n$
physical qubits \cite[Intro.]{calderbank_good_1996}.
To differentiate quantum codes from classical ones, we denote a
code with parameters $k,n$ and minimum distance $d_\text{min}$ using
double brackets, as $\llbracket n,k,d_\text{min} \rrbracket$
\cite[Sec.~4]{roffe_quantum_2019}.

% The backlog problem

Another difference between quantum and classical error correction
lies in the resource constraints.
For \ac{qec}, the most important property is low latency, not, e.g.,
low overall computational complexity.
This is due to the \emph{backlog problem}
\cite[Sec.~II.G.3.]{terhal_quantum_2015}: There are certain gates
at which the effect of existing errors on single qubits may be
exacerbated by transforming them to multi-qubit errors.
We wish to correct the errors before passing qubits through such gates.
If the \ac{qec} system is not fast enough, there will be an increasing
backlog of information at this point in the circuit, leading to an
exponential slowdown in computation.

%%%%%%%%%%%%%%%%
\subsection{Stabilizer Measurements}
\label{subsec:Stabilizer Measurements}

% Setting the stage

Before we move on to the description of entire codes, we introduce
the notion of the \emph{stabilizer measurement}.
Consider the two-qubit repetition code
\cite[Sec.~2.4]{roffe_quantum_2019}, where we map
\begin{align*}
    \ket{\psi} = \alpha \ket{0} + \beta \ket{1}
    \hspace*{3mm} \mapsto \hspace*{3mm}
    \ket{\psi}_\text{L}
    = \alpha \underbrace{\ket{00}}_{=:\ket{0}_\text{L}} + \beta
    \underbrace{\ket{11}}_{=:\ket{1}_\text{L}}
    .%
\end{align*}
We call $\ket{\psi}_L$ the logical state, and
we define the \emph{codespace} as $\mathcal{C} := \text{span}\mleft\{
\ket{00}, \ket{11} \mright\}$ and the \emph{error subspace} as
$\mathcal{F} := \text{span} \mleft\{\ket{01}, \ket{10} \mright\}$.
Note that this code is only able to detect single $X$-type errors.

% Measuring stabilizers

To determine if an error occurred, we want to measure
whether a state belongs
% TODO: Remove footnote?
% \footnote{
%     It is possible for a state to not completely lie in either subspace.
%     In this case, we can interpret it as being in
%     $\mathcal{C}$ or $\mathcal{F}$ with a certain probability.
% }
to $\mathcal{C}$ or $\mathcal{F}$.
As explained in \autoref{subsec:Observables}, physical measurements
can be mathematically described using operators whose eigenvalues
are the possible measurement results.
Here, we need an operator with two eigenvalues and the corresponding
eigenspaces should be $\mathcal{C}$ and $\mathcal{F}$ respectively.
For the two-qubit code, $Z_1Z_2$ is such an operator:
\begin{align}
    Z_1Z_2 E \ket{\psi}_\text{L} &= (+1) E \ket{\psi}_\text{L}
    \hspace*{3mm} \forall
    E \ket{\psi}_\text{L} \in \mathcal{C} \\
    Z_1Z_2 E \ket{\psi}_\text{L} &= (-1) E \ket{\psi}_\text{L}
    \hspace*{3mm} \forall
    E \ket{\psi}_\text{L} \in \mathcal{F}
    .%
\end{align}
$E \in \left\{ X,I \right\}$ is an operator describing a possible
error and $E \ket{\psi}_\text{L}$ is the resulting state after that error.
By measuring the corresponding eigenvalue, we can determine if
$E\ket{\psi}_\text{L}$ lies in $\mathcal{C}$ or $\mathcal{F}$.
% TODO: If necessary, cite \cite[Sec.~3]{roffe_quantum_2019} for the
% non-compromising meausrement of the information
To do this without directly observing (and thus potentially
collapsing) the logical state $\ket{\psi}_\text{L}$, we prepare an
ancilla qubit with state $\ket{0}_\text{A}$ and entangle it with
$\ket{\psi}_\text{L}$ in such a way that the eigenvalue is indicated
by measuring the ancilla qubit instead.
More specifically, using a stabilizer measurement circuit as shown in
\autoref{fig:stabilizer_measurement}, we transform the state of the
three-qubit system as
\begin{align}
    \label{eq:error_projection}
    E\ket{\psi}_\text{L} \ket{0}_\text{A} \hspace*{3mm} \rightarrow
    \hspace*{3mm}
    \underbrace{\frac{1}{2} \mleft( I_1I_2 + Z_1Z_2 \mright)}_{=:
    P_\mathcal{C}} E\ket{\psi}_\text{L}
    \ket{0}_\text{A}
    + \underbrace{\frac{1}{2} \mleft( I_1I_2 - Z_1Z_2 \mright)}_{=:
    P_\mathcal{F}}
    E\ket{\psi}_\text{L} \ket{1}_\text{A}
    .%
\end{align}
If $E \ket{\psi}_\text{L} \in \mathcal{C}$, the second term will
cancel and we will deterministically measure $\ket{0}_\text{A}$ for
the ancilla qubit. Similarly, if $E \ket{\psi}_\text{L} \in
\mathcal{F}$, we will deterministically measure $\ket{1}_\text{A}$.

\begin{figure}[t]
    \centering

    % tex-fmt: off
    \begin{quantikz}
        \lstick[2]{$E\ket{\psi}_\text{L}$}    &          & \gate[2]{Z_1Z_2}   &          &          &                 \\
                                              &          &                    &          &          &                 \\
        \lstick{$\ket{0}_\text{A}$}           & \gate{H} & \ctrl{-1}          & \gate{H} & \meter{} & \setwiretype{c} \\
    \end{quantikz}
    % tex-fmt: on

    \caption{Stabilizer measurement circuit for the two-qubit repetition code.}
    \label{fig:stabilizer_measurement}
\end{figure}

% Digitization of errors

Note that it is possible for a vector $E\ket{\psi}$ to not completely
lie in either subspace.
In this case, we can interpret it as being in $\mathcal{C}$ or
$\mathcal{F}$ with a certain probability.
However, when we measure the stabilizer, we will find that the vector
lies either in one or the other.
This is because the act of measuring the error partly collapses the
state, eliminating the uncertainty about the type of the error
\cite[Sec.~10.2]{nielsen_quantum_2010}.
This can be seen in \autoref{eq:error_projection}, as the expressions
$P_\mathcal{C}$ and $P_\mathcal{F}$ constitute projection operators onto
$\mathcal{C}$ and $\mathcal{F}$.
E.g., $P_\mathcal{C}$ will eliminate all components of $E
\ket{\psi}_\text{L}$ that lie in $\mathcal{F}$.
This process, together with the fact that any coherent error can be
decomposed into a linear combination of $X$ and $Z$ errors, means
that it is sufficient for \ac{qec} to be able to correct only these
types of errors.
This effect is referred to as error \emph{digitization}
\cite[Sec.~2.2]{roffe_quantum_2019}.

% The stabilizer group

Operators such as $Z_1Z_2$ above are called \emph{stabilizers}.
More generally, an operator $P_i \in \mathcal{G}_n$ is called a stabilizer of an
$[[n, k, d_\text{min}]]$ code $\mathcal{C}$, if
\begin{itemize}
    \item It stabilizes all logical states, i.e.,
        $P_i\ket{\psi}_\text{L} = (+1)\ket{\psi}_\text{L} ~\forall~
        \ket{\psi}_\text{L} \in \mathcal{C}$.
    \item It commutes with all other stabilizers $P_j$ of the code,
        i.e., $[P_i, P_j] = 0$.
        This property is important to be able to measure the
        eigenvalue of a stabilizer without disturbing the
        eigenvectors of the others \cite[Sec.~1.2]{gottesman_stabilizer_1997}.
\end{itemize}
Formally, we define the \emph{stabilizer group} $\mathcal{S}$ as
\cite[Sec.~4.1]{roffe_quantum_2019}
\begin{align*}
    \mathcal{S} = \left\{P_i \in \mathcal{G}_n ~:~ P_i \ket{\psi}_\text{L} =
        (+1)\ket{\psi}_\text{L} \forall \ket{\psi}_\text{L} ~\cap~
    [P_i,P_j] = 0 \forall i,j\right\}
    .%
\end{align*}
We care in particular about the commuting properties of stabilizers
with respect to possible errors.
The measurement circuit for an arbitrary stabilizer $P_i$ modifies
the state as \cite[Eq.~29]{roffe_quantum_2019}
\begin{align*}
    E\ket{\psi}_\text{L}\ket{0}_\text{A}
    \hspace{3mm}\mapsto\hspace{3mm}
    \frac{1}{2} \left( I + P_i
    \right)E\ket{\psi}_\text{L}\ket{0}_\text{A} + \frac{1}{2}
    \left( I - P_i \right)E\ket{\psi}_\text{A} \ket{1}_\text{A}
    .%
\end{align*}
If a given error $E$ anticommutes with $P_i$, we have
\begin{align*}
    EP_i \ket{\psi}_{L} &= -P_i E \ket{\psi}_\text{L} \\
    \Rightarrow E \ket{\psi}_{L} &= -P_i E \ket{\psi}_\text{L} \\
    \Rightarrow \left( I + P_i \right)E\ket{\psi}_\text{L} &= 0
\end{align*}
and the stabilizer measurement returns 1.

%%%%%%%%%%%%%%%%
\subsection{Stabilizer Codes}
\label{subsec:Stabilizer Codes}

% Structure of a stabilizer code

For classical binary linear block codes, we use $n-k$ parity-checks
to reduce the degrees of freedom introduced by the encoding operation.
Effectively, each parity-check defines a local code splitting the
vector space in half, with only one part containing valid codewords.
The global code is the intersection of all local codes.
We can do the same in the quantum case.
Each split is represented using a stabilizer, whose eigenvalues signify
whether a candidate vector lies in the local codespace or local error subspace.
It is only a valid codeword if it lies in the codespace of all local codes.
We call codes constructed this way \emph{stabilizer codes}.

% Syndrome extraction circuitry

Similar to the classical case, we can use a syndrome vector to
describe which local codes are violated.
To obtain the syndrome, we simply measure the corresponding
operators $P_i$, each using a circuit as explained in
\autoref{subsec:Stabilizer Measurements}.
Note that this is an abstract representation of the syndrome extraction.
For the actual implementation in hardware, we can transform this into
a circuit that requires only CNOT and H-gates
\cite[Sec.~10.5.8]{nielsen_quantum_2010}.

% Logical operators

In order to modify the logical state encoded using the physical
qubits, we can use \emph{logical operators} \cite[Sec.~4.2]{roffe_quantum_2019}.
For each qubit, there are two logical operators, $X_i$ and $Z_j$.
These are operators that
\begin{itemize}
    \item Commute with all the stabilizers in $\mathcal{S}$.
    \item Anti-commute with one another, i.e., $[ \overline{X}_i,
        \overline{Z}_i ]_{+} = \overline{X}_i \overline{Z}_i +
        \overline{Z}_i \overline{X}_i = 0$.
\end{itemize}
We can also measure these operators to find out the logical state a
physical state corresponds to \cite[Sec.~2.6]{derks_designing_2025}.

% Parity-check matrix

% TODO: Do I have to introduce before that stabilizers only need X
% and Z operators?
We can represent stabilizer codes using a \emph{check matrix}
\cite[Sec.~10.5.1]{nielsen_quantum_2010}
\begin{align*}
    \bm{H} = \left[
        \begin{array}{c|c}
            \bm{H}_X & \bm{H}_Z
        \end{array}
    \right]
    ,%
\end{align*}
with $\bm{H} \in \mathbb{F}_2^{(n-k)\times(2n)}$.
This is similar to a classical \ac{pcm} in that it contains $n-k$
rows, each describing one constraint. Each constraint restricts an additional
degree of freedom of the higher-dimensional space we use to introduce
redundancy.
In contrast to the classical case, this matrix now has $2n$ columns,
as we have to consider both the $X$ and $Z$ type operators that make up
the stabilizers.
Take for example the Steane code \cite[Eq.~10.83]{nielsen_quantum_2010}.
We can describe it using the check matrix
\begin{align}
    \label{eq:steane}
    \bm{H}_\text{Steane} = \left[
        \begin{array}{ccccccc|ccccccc}
            0 & 0 & 0 & 1 & 1 & 1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
            0 & 1 & 1 & 0 & 0 & 1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
            1 & 0 & 1 & 0 & 1 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
            0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & 1 & 1 \\
            0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & 0 & 0 & 1 & 1 \\
            0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 & 1 & 0 & 1
        \end{array}
    \right]
    .%
\end{align}
The first $n$ columns correspond to $X$ operators acting on the
corresponding physical qubit, the rest to the $Z$ operators.

\begin{figure}[t]
    \centering

    % tex-fmt: off
    \begin{quantikz}
        \lstick[2]{$E\ket{\psi}_\text{L}$}  &          & \gate[2]{P_1} & \gate[2]{P_2} & \gate[style={draw=none},2]{\ldots} & \gate[2]{P_{n-k}} &          &          &                 \\
                                            &          &               &               &                                    &                   &          &          &                 \\
        \lstick{$\ket{0}_{\text{A}_1}$}     & \gate{H} & \ctrl{-1}     &               &                                    &                   & \gate{H} & \meter{} & \setwiretype{c} \\
        \lstick{$\ket{0}_{\text{A}_2}$}     & \gate{H} &               & \ctrl{-2}     &                                    &                   & \gate{H} & \meter{} & \setwiretype{c} \\
        \vdots\setwiretype{n}               &          &               &               &                                    &                   &          &          & \vdots          \\
        \lstick{$\ket{0}_{\text{A}_{n-k}}$} & \gate{H} &               &               &                                    & \ctrl{-4}         & \gate{H} & \meter{} & \setwiretype{c} \\
    \end{quantikz}
    % tex-fmt: on

    \caption{
        Illustration of a full syndrome extraction circuit.
        Adapted from \cite[Figure~4]{roffe_quantum_2019}.
    }
    \label{fig:sec}
\end{figure}

%%%%%%%%%%%%%%%%
\subsection{Calderbank-Shor-Steane Codes}
\label{subsec:Calderbank-Shor-Steane Codes}

% Intro

Stabilizer codes are especially practical to work with when they can
handle $X$ and $Z$ type errors independently.
As $Z$ errors anti-commute with $X$ operators in the stabilizers and
vice versa, this property translates into being able to split the
stabilizers into a subset being made up of only $X$
operators and the rest only of $Z$ operators.
We call such codes \ac{css} codes.
We can see this property in \autoref{eq:steane} in the check matrix
of the Steane code.

% Construction

We can exploit this separate consideration of $X$ and $Z$ errors in
the construction of \ac{css} codes.
We combine two binary linear codes $\mathcal{C}_1$ and
$\mathcal{C}_2$, each responsible for correcting one type of error
\cite[Sec.~10.5.6]{nielsen_quantum_2010}.
Using the dual code of $\mathcal{C}_2$ \cite[Eq.~3.4]{ryan_channel_2009}
\begin{align*}
    \mathcal{C}_2^\perp := \left\{ \bm{x}' \in \mathbb{F}^2 :
    \bm{x}' \bm{x}^\text{T} = 0 ~\forall \bm{x} \in \mathcal{C}_2 \right\}
    ,%
\end{align*}
we define $\bm{H}_X := \bm{H}(\mathcal{C}_2^\perp)$ and $\bm{H}_Z
:= \bm{H}(\mathcal{C}_1)$, and construct the check matrix as
\begin{align*}
    \left[
        \begin{array}{c|c}
            \bm{H}_X & \bm{0} \\
            \bm{0} & \bm{H}_Z
        \end{array}
    \right]
    .%
\end{align*}
In order to yield a valid stabilizer code, $\mathcal{C}_1$ and
$\mathcal{C}_2$ must satisfy the commutativity condition
\begin{align}
    \label{eq:css_condition}
    \bm{H}_X \bm{H}_Z^\text{T} = \bm{0}
    .%
\end{align}
We can ensure this is the case by choosing them such that
$\mathcal{C}_2 \subset \mathcal{C}_1$.

%%%%%%%%%%%%%%%%
\subsection{Quantum Low-Density Parity-Check Codes}
\label{subsec:Quantum Low-Density Parity-Check Codes}

% Intro

Various methods of constructing \ac{qec} codes exist
\cite{swierkowska_eccentric_2025}.
Topological codes, for example, encode information in the features of
a lattice and are intrinsically robust against local errors.
Among these, the \emph{surface code} is the most widely studied.
Another example are concatenated codes, which nest one code within
another, allowing for especially simple and flexible constructions
\cite[Sec.~3.2]{swierkowska_eccentric_2025}.
An area of research that has recently seen more attention is that of
quantum \ac{ldpc} (\acs{qldpc}) codes.
They have much better encoding efficiency than, e.g., the surface
code, scaling up of which would be prohibitively expensive
\cite[Sec.~I]{bravyi_high-threshold_2024}.

% Bivariate Bicycle codes

A recent addition to the class of \ac{qldpc} codes is that of \ac{bb}
codes \cite[Sec.~3]{bravyi_high-threshold_2024}.
These are a special type of \ac{css} code, where $\bm{H}_X$ and
$\bm{H}_Z$ are constructed from two matrices $\bm{A}$ and $\bm{B}$ as
\begin{align*}
    \bm{H}_X = [\bm{A} \vert \bm{B}]
    \hspace*{5mm} \text{and} \hspace*{5mm}
    \bm{H}_Z = [\bm{B}^\text{T} \vert \bm{A}^\text{T}]
    .%
\end{align*}
This way, we can guarantee the satisfaction of the commutativity
condition (\autoref{eq:css_condition}).
To define $\bm{A}$ and $\bm{B}$ we first introduce some additional notation.
We denote the identity matrix as $\bm{I_l} \in \mathbb{F}^{l\times l}$ and
the \emph{cyclic shift matrix} as $\bm{S_l} \in \mathbb{F}^{l\times
l},~S_{l,i,j}= \delta_{i+1,j}$, with $l \in \mathbb{N}$.
We further define
\begin{align*}
    x = \bm{S}_l \otimes \bm{I}_m
    \hspace*{5mm} \text{and} \hspace*{5mm}
    y = \bm{I}_l \otimes \bm{S}_m
    .%
\end{align*}
We can then construct $\bm{A}$ and $\bm{B}$ as bivariate polynomials
\begin{align*}
    \bm{A} = \bm{A}_1 + \bm{A}_2 + \bm{A}_3
    \hspace*{5mm} \text{and} \hspace*{5mm}
    \bm{B} = \bm{B}_1 + \bm{B}_2 + \bm{B}_3
    ,%
\end{align*}
where $\bm{A}_i$ and $\bm{B}_i$ are powers of $\bm{x}$ or $\bm{y}$.
\ac{bb} codes have large minimum distance $d_\text{min}$ and high rate,
offering a more than 10-fold reduction of encoding overhead over the
surface code.
Additionally, they posess short-depth syndrome measurement circuits,
leading to lower time requirements for the syndrome extraction
and thus lower error rates \cite[Sec.~1]{bravyi_high-threshold_2024}.

% Syndrome-based BP

As we saw in \autoref{subsec:Stabilizer Measurements}, we work only
with the parity information contained in the syndrome, to avoid
disturbing the quantum states of individual qubits.
This necessitates a modification of the standard \ac{bp} algorithm
introduced in \autoref{subsec:Iterative Decoding}
\cite[Sec.~3.1]{yao_belief_2024}.
Instead of attempting to find the most likely codeword directly, the
algorithm will now try to find an error pattern $\hat{\bm{e}} \in
\mathbb{F}_2^n$ that satisfies
\begin{align*}
    \bm{H} \hat{\bm{e}}^\text{T} = \bm{s}
    .%
\end{align*}
To this end, we initialize the channel \acp{llr} as
\begin{align*}
    \tilde{L}_i = \log{\frac{P(X_i = 0)}{P(X_i = 1)}} = \log{\frac{1
    - p_i}{p_i}}
    ,%
\end{align*}
where $p_i$ is the prior probability of error of \ac{vn} $i$.
Additionally, we amend the \ac{cn} update to consider the parity
indicated by the syndrome, calculating
\begin{align*}
    L_{i\leftarrow j} = 2\cdot (-1)^{s_j} \cdot \tanh^{-1} \left( \prod_{i'\in
    \mathcal{N}(j)\setminus \{i\}} \tanh \frac{L_{i'\rightarrow j}}{2} \right)
    .
\end{align*}
The resulting syndrome-based \ac{bp} algorithm is shown in
algorithm \ref{alg:syndome_bp}.

% tex-fmt: off
\tikzexternaldisable
\begin{algorithm}[t]
    \caption{Binary syndrome-based belief propagation (BP) algorithm.}
    \label{alg:syndome_bp}
    \begin{algorithmic}[1]
        \State \textbf{Initialize:} $\tilde{L}_i \leftarrow
               \log \frac{1-p_i}{p_i}$ for all $i \in \mathcal{I}$
        \State \textbf{Initialize:} $L_{i \rightarrow j} \leftarrow
               \tilde{L}_i$ for all $i \in \mathcal{I},\, j \in \mathcal{N}_\text{V}(i)$
        \State \textbf{Initialize:} $\hat{e} \leftarrow \bm{0}$

        \For{$\ell = 1, \ldots, n_\text{iter}$}

            \For{$j \in \mathcal{J}$}
                \For{$i \in \mathcal{N}_\text{C}(j)$}
                    \State $\displaystyle L_{i \leftarrow j} \leftarrow
                           2\cdot(-1)^{s_j}\cdot\tanh^{-1}
                           \!\left(
                               \prod_{i' \in \mathcal{N}_\text{C}(j)\setminus\{i\}}
                               \tanh\frac{L_{i'\rightarrow j}}{2}
                           \right)$
                \EndFor
            \EndFor

            \For{$i \in \mathcal{I}$}
                \For{$j \in \mathcal{N}_\text{V}(i)$}
                    \State $\displaystyle L_{i \rightarrow j} \leftarrow
                           \tilde{L}_i +
                           \sum_{j' \in \mathcal{N}_\text{V}(i)\setminus\{j\}}
                           L_{i \leftarrow j'}$
                \EndFor
            \EndFor

            \For{$i \in \mathcal{I}$}
                \State $\displaystyle \hat{e}_i \leftarrow
                       \mathbbm{1}\left\{
                           \tilde{L}_i +
                           \sum_{j \in \mathcal{N}_\text{V}(i)} L_{i \leftarrow j} < 0
                       \right\}$
            \EndFor

            \If{$\bm{H}\hat{\bm{e}}^\text{T} = \bm{s}$}
            \State \textbf{break}
            \EndIf

        \EndFor
        \State \textbf{return} $\hat{\bm{e}}$
    \end{algorithmic}
\end{algorithm}
\tikzexternalenable
% tex-fmt: on

% Degeneracy and short cycles

Decoding \ac{qldpc} codes poses some unique challenges.
One issue is that of \emph{quantum degeneracy}.
Because errors that differ by a stabilizer have the same impact on
all codewords, there can be multiple minimum-weight solutions to the
quantum decoding problem \cite[Sec.~II.C.]{babar_fifteen_2015}
\cite[Sec.~V]{roffe_decoding_2020}.
This leads to the decoding algorithm getting confused about the
direction to proceed in \cite[Sec.~5]{yao_belief_2024}.
Another problem is that due to the commutativity property of the stabilizers,
quantum codes inherently contain short cycles
\cite[Sec.~IV.C]{babar_fifteen_2015}.
As discussed in \autoref{subsec:Iterative Decoding}, these lead to
the violation of the independence assumption of the messages passed
during decoding, impeding performance.

% BPGD

The aforementioned issues both manifest themselves as convergence problems
of the \ac{bp} algorithm, and different ways of modifying the algorithm
to aid with convergence exist.
One approach is to use \ac{bp} with guided decimation (\acs{bpgd})
\cite[Alg.~1]{yao_belief_2024}.
Here, a number $T\in \mathbb{N}$ of \ac{bp} iterations are performed,
before \emph{decimating} the most reliable \ac{vn}, i.e., performing
a hard decision and excluding it from further decoding.
This constrains the solution space more and more as the decoding
progresses, encouraging the algorithm to converge to one of the
solutions \cite[Sec.~5]{yao_belief_2024}.
Algorithm \ref{alg:bpgd} shows this process.
Note that as the Tanner graph only has $n$ \acp{vn}, this is a
natural constraint on the maximum number of outer iterations of the algorithm.

% TODO: Explain that setting the channel LLR to infinity is the same
% as a hard decision and ignoring the VN in the further decoding
% tex-fmt: off
\tikzexternaldisable
\begin{algorithm}[t]
    \caption{Belief propagation with guided decimation (BPGD) algorithm.}
    \label{alg:bpgd}
    \begin{algorithmic}[1]
        \State \textbf{Initialize:} $\tilde{L}_i \leftarrow
               \log \frac{1-p_i}{p_i}$ for all $i \in \mathcal{I}$
        \State \textbf{Initialize:} $L_{i \rightarrow j} \leftarrow
               \tilde{L}_i$ for all $i \in \mathcal{I},\, j \in \mathcal{N}_\text{V}(i)$
        \State \textbf{Initialize:} $\hat{e} \leftarrow \bm{0}$
        \State \textbf{Initialize:} $\mathcal{I}' \leftarrow \mathcal{I}$

        \For{$r = 1, \ldots, n$}

            \For{$\ell = 1, \ldots, T$}
                \State Perform \ac{cn} update
                \State Perform \ac{vn} update
                \State  $L^\text{total}_i \leftarrow \tilde{L}_i + \sum_{j \in \mathcal{N}_\text{V}(i)} L_{i \leftarrow j}$
            \EndFor

            \For{$i \in \mathcal{I}$}
                \State $\displaystyle \hat{e}_i \leftarrow
                       \mathbbm{1}\left\{ L^\text{total}_i \right\}$
            \EndFor

            \If{$\bm{H}\hat{\bm{e}}^\text{T} = \bm{s}$}
                \State \textbf{break}
            \Else
                \State $i_\text{max} \leftarrow \argmax_{i \in \mathcal{I}'} \lvert L^\text{total}_i \rvert $
                \If{$L^\text{total}_{i_\text{max}} < 0$}
                    \State $\tilde{L}_{i_\text{max}} \leftarrow -\infty$
                \Else
                    \State $\tilde{L}_{i_\text{max}} \leftarrow +\infty$
                \EndIf
                \State $\mathcal{I}' \leftarrow \mathcal{I}'\setminus\{i_\text{max}\}$
            \EndIf

        \EndFor
        \State \textbf{return} $\hat{\bm{e}}$
    \end{algorithmic}
\end{algorithm}
\tikzexternalenable
% tex-fmt: on

