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

\acresetall

\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, consider a block code of length $n$ used to communicate
over a channel with capacity $C$ at rate $R$.
Shannon proved in 1948 that for any rate $R < C$, the probability of
error can be made arbitrarily small as $n \to \infty$
\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
%

Binary linear block codes form one particularly important class of
coding schemes.
The information to be protected is represented by 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$.
The \textit{code rate} $R = k/n$ is a measure of the amount of
introduced redundancy.
We call the set of all codewords
$\mathcal{C} = \{\bm{x}^{(1)}, \bm{x}^{(2)}, \ldots, \bm{x}^{(2^k)}\}$
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.
Since $n > k$, only a fraction $2^{k-n}$ of the vectors in $\mathbb{F}_2^n$
are valid codewords, leaving room to choose $\mathcal{C}$ such that any two
distinct codewords differ in many positions.
This separation gives rise to the error correcting properties of the code
and is quantified by the \textit{Hamming distance} $d(\bm{x}_1, \bm{x}_2)$,
defined as the number of positions in which $\bm{x}_1$ and $\bm{x}_2$ differ.
The \textit{minimum distance} of a code $\mathcal{C}$ is then defined 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 denote a binary linear block code with information length
$k$, block length $n$ and minimum distance $d_\text{min}$ by
$[n,k,d_\text{min}]$.

%
% Parity checks, H, and the syndrome
%

A particularly elegant way of describing the code space $\mathcal{C}$ is the
notion of \textit{parity checks}.
Since $\lvert \mathcal{C} \rvert = 2^k$ and $\lvert \mathbb{F}_2^n
\rvert = 2^n$, there are $n-k$ conditions 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}$, $\text{rank}(\bm{H}) = n-k$, and
equivalently define the code as \cite[Sec.~3.1.1]{ryan_channel_2009}
\begin{align*}
    \mathcal{C} := \text{kern}(\bm{H}) = \left\{ \bm{x} \in \mathbb{F}_2^n :
    \bm{H}\bm{x}^\mathsf{T} = \bm{0} \right\}
    .%
\end{align*}
In general, we 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}^\mathsf{T}$ describes
which parity checks a vector $\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
%

\Cref{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 can be done by first finding an estimate $\hat{\bm{x}}$ of the sent
codeword and undoing the encoding.
The decoding problem that we 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 $n$ 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} of a linear block code grows
quadratically with $n$.
This would quickly render decoding intractable as we increase the
block length, due to increased memory and computational complexity.
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}.
For \ac{ldpc} codes, the iterative decoding algorithms
are generally defined in terms of message passing on the
\textit{Tanner graph} of a 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.
Then, we 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}.
\Cref{PCM and Tanner graph of the Hamming code} shows the Tanner
graph of 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_0$]                    (vn1) {};
        \node[VN, right=12mm of vn1, label=above:$x_1$] (vn2) {};
        \node[VN, right=12mm of vn2, label=above:$x_2$] (vn3) {};
        \node[VN, right=12mm of vn3, label=above:$x_3$] (vn4) {};
        \node[VN, right=12mm of vn4, label=above:$x_4$] (vn5) {};
        \node[VN, right=12mm of vn5, label=above:$x_5$] (vn6) {};
        \node[VN, right=12mm of vn6, label=above:$x_6$] (vn7) {};

        \node[
            CN, below=25mm of vn4,
            label={below:$x_0 + x_2 + x_3 + x_5 = 0$}
        ] (cn2) {};
        \node[
            CN, left=40mm of cn2,
            label={below:$x_1 + x_2 + x_3 + x_4 = 0$}
        ] (cn1) {};
        \node[
            CN, right=40mm of cn2,
            label={below:$x_0 + x_1 + x_3 + x_6 = 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[ 0:n-1 \right] := \left\{ 0,1,\ldots,n-1 \right\}$
and a \ac{cn} using the index $j \in \mathcal{J}
:= \left[ 0 : m-1 \right]$.
We can then encode the information contained in the graph by defining
the neighborhood of a \ac{vn} $i$ as
$\mathcal{N}_\text{V} (i) = \left\{ j \in \mathcal{J} : H_{j,i}
= 1 \right\}$
and the neighborhood of a \ac{cn} $j$ as
$\mathcal{N}_\text{C} (j) = \left\{ i \in \mathcal{I} : 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, \Cref{fig:ldpc-perf} shows a
qualitative performance characteristic of an \ac{ldpc} code
\cite[Fig.~1]{costello_spatially_2014}.
We can observe the \textit{waterfall} and the \textit{error floor}
regions typical for \ac{ldpc} codes under iterative decoding.

\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 LDPC codes}

            \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 LDPC codes}

            \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 regular or
        irregular \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 a more favorable behavior of the error rate for high
signal-to-noise ratios.
Irregular codes, on the other hand, have more severe error floor behavior.
However, they have the the ability to reach near-capacity performance
in the waterfall region \cite[Intro.]{costello_spatially_2014}.

\subsection{Spatially-Coupled LDPC Codes}

A more recent development in the field 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}, which would ordinarily be sent
one after the other independently, are linked.
This is achieved by introducing edges between \acp{vn} of one spatial
position and \acp{cn} of another, resulting in a \ac{pcm} of the form
\cite[Eq.~1]{hassan_fully_2016}
%
\begin{align}
    \label{eq:PCM}
    \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.
The parts of the \ac{pcm} left empty in \Cref{eq:PCM} are filled with zeros.
This construction results in a Tanner graph as depicted in
\Cref{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=2$};
    \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 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 improved performance of
\ac{sc}-\ac{ldpc} codes in the waterfall region \cite{costello_spatially_2014}.

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

% Introduction

Due to their sparse graphs, efficient iterative decoders exist for
\ac{ldpc} codes \cite[Sec.~5.3]{ryan_channel_2009}.
The decoding algorithm originally proposed alongside LDPC codes by
Gallager in 1960 is now known as the \ac{spa}
\cite[5.4.1]{ryan_channel_2009}, also called \acf{bp}.

The optimality criterion the \ac{spa} is built around is a
bit-wise \ac{map} decision \cite[Sec.~5.4.1]{ryan_channel_2009}.
The core idea of the resulting algorithm is to view \acp{cn}
and \acp{vn} as representing individual local codes.
A \ac{cn} represents a single parity check on the connected \acp{vn},
so it can be understood as a single-parity check code.
Similarly, a \ac{vn} represents a bit, and all connected \acp{cn}
should agree on its value; it can therefore be understood as a repetition code.
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 computed in the nodes 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}_\text{V}(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}_\text{C}(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 algorithm. 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}_\text{C}(j)\setminus \{i\}}
    \sign \left( L_{i' \rightarrow j} \right)
    \cdot \min_{i' \in \mathcal{N}_\text{C}(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 mathematical 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
\begin{align*}
    \int_{-\infty}^{\infty} \lvert \psi(x,t) \rvert^2 dx = 1
    .%
\end{align*}

% Dirac notation

The language of linear algebra allows one to express the related
mathematics particularly elegantly.
The so-called Bra-ket or Dirac notation, introducced
by Paul Dirac in 1939 for the express purpose of simplifying quantum
mechanical notation \cite{dirac_new_1939}, is especially appropriate.
Two new symbols are defined, \emph{bra} $\bra{\cdot}$ and
\emph{ket} $\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}, namely the Hilbert space $L_2$.
The state of a particle with wave function $\psi(x,t)$ is represented
by the vector $\ket{\psi}$ \cite[Sec.~3.3]{griffiths_introduction_1995}.

% Operators

Another important notion is that of an \emph{operator}, a transformation
that maps a function onto another function
\cite[Sec.~3.2.2]{griffiths_introduction_1995}.
A prominent example of this is the differential operator $\partial x$.
Operators are useful to describe the relations between different
quantities relating to a particle.
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} $Q(x,p,t)$ is a quantity of a quantum
mechanical system that we can measure, e.g., 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.
However, some states are \emph{determinate} for a
specific observable: Measuring those will always yield identical
outcomes \cite[Sec.~3.3]{griffiths_introduction_1995}.

% General expression for expected value of observable quantity

If the wave function of a particle is known, the expected value
$\braket{Q}$ of any observable quantity can be computed.
Indeed, for any $Q$, there exists 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 $ is the \ac{pdf} of
finding a particle at position $x$. Hence, 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 \Cref{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}
\Cref{eq:gen_expr_Q_exp_lin} expresses an inherently probabilistic
relationship, whereas 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 must 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{(\hat{Q} - \braket{Q})e_n \vert (\hat{Q} - \braket{Q})
    e_n} \nonumber\\
    &= \lVert (\hat{Q} - \braket{Q}) e_n \rVert^2 \nonumber\\[3mm]
    &\hspace{-14mm}\iff (\hat{Q} - \braket{Q}) \ket{e_n}
    = 0 \nonumber\\
    \label{eq:observable_eigenrelation}
    &\hspace{-14mm}\iff \hat{Q}\ket{e_n}
    = \underbrace{\braket{Q}}_{\lambda_n} \ket{e_n}
    .%
\end{align}%
%
By setting the variance to zero, the expected value
$\braket{Q}$ becomes a deterministic measurement result
corresponding to the determinate state
$\ket{e_n},~n\in \mathbb{N}$.
The determinate states are precisely the \emph{eigenstates} of
the observable operator $\hat{Q}$, and the associated measurement
values are the corresponding \emph{eigenvalues} $\lambda_n$
\cite[Sec.~3.3]{griffiths_introduction_1995}.

% Determinate states as a basis

As we model the wave function $\psi(x,t)$ as a vector
$\ket{\psi}$, we can find a set of basis vectors to decompose it into.
In particular, we can use the determinate states for this purpose,
expressing the state as%
\footnote{
    We only consider 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 \Cref{eq:determinate_basis} into
\Cref{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
\Cref{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 \emph{collapses} it onto one of
the determinate states.
Further measurements then yield the same value.
More general methods of modelling measurements exist, e.g.,
destructive measurements \cite[Box~2.5]{nielsen_quantum_2010}, but
they are not relevant to this work.

% Projection operators

We model the collapse of the original state onto one of the
superimposed basis states as a \emph{projection}.
To see this, we use
\Cref{eq:determinate_basis,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*}%
which 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

A central concept for quantum computing is that of the \emph{qubit}.
It takes the place of the classical \emph{bit}.
For classical computers, we alter the state of a bit 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}
    \label{eq:gen_qubit_state}
    \ket{\psi} =
    \begin{pmatrix}
        \alpha \\
        \beta
    \end{pmatrix}
    = \alpha \ket{0} + \beta \ket{1}, \hspace{5mm} \alpha,\beta \in \mathbb{C}
    .%
\end{align}
The overall state of a multi-qubit 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},
i.e.,
\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 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 products of single-qubit states
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 \Cref{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 \Cref{eq:gen_qubit_state} lies 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}.
Hereby, $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
\begin{align}
    \mathcal{G}_n = \left\{ \pm I,\pm \mathrm{i}I, \pm
        X,\pm \mathrm{i}X,
    \pm Y,\pm \mathrm{i}Y, \pm Z, \pm \mathrm{i}Z \right\}^{\otimes n}
\end{align}
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$.
Each operator is applied to the qubit denoted in the corresponding subscript.
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}
                \text{CNOT 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 The CNOT operator is a 2-qubit gate that applies a bit-flip to the
second qubit conditioned on the state of the first one.
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}$.
\Cref{fig:cnot_circuit} depicts an example of this: The  CNOT gate
introduced in \Cref{subsec:Qubits and Multi-Qubit States}.

\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 and scalable
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[Sec.~1]{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[Sec.~1]{gottesman_stabilizer_1997}.
\ac{qec} is one approach of dealing with this problem, by protecting
a 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
        \Cref{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, \ac{qec} protects information by
introducing redundancy.
The information, represented by a state in a low-dimensional space,
is mapped onto an encoded state in a higher-dimensional space.
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[Sec.~I]{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.
If we ensure decoding with sufficiently low latency, we can correct
the errors before passing qubits through such gates.
However, 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}_\text{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 aim at to measuring 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 \Cref{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 repetition code, $Z_1Z_2 \in \mathcal{G}_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
single-qubit 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
\Cref{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 \Cref{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 a stabilizer of an
$\llbracket n, k, d_\text{min} \rrbracket$ 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 about the commuting properties of stabilizers with respect to
possible errors, in particular.
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}_i}
    \hspace{3mm}\mapsto\hspace{3mm}
    \frac{1}{2} \left( I + P_i
    \right)E\ket{\psi}_\text{L}\ket{0}_{\text{A}_i} + \frac{1}{2}
    \left( I - P_i \right)E\ket{\psi}_\text{L} \ket{1}_{\text{A}_i}
    .%
\end{align*}
If a given error $E$ anticommutes with $P_i$, we have
\begin{align*}
    & \frac{1}{2} \left( I + P_i \right)
    E\ket{\psi}_\text{L}\ket{0}_{\text{A}_i}
    + \frac{1}{2} \left( I - P_i \right)
    E\ket{\psi}_\text{L} \ket{1}_{\text{A}_i} \\
    = & \frac{1}{2} \left(
        E\ket{\psi}_\text{L} +  P_i E\ket{\psi}_\text{L}
    \right) \ket{0}_{\text{A}_i}
    + \frac{1}{2} \left(
        E\ket{\psi}_\text{L} - P_i E\ket{\psi}_\text{L}
    \right)\ket{1}_{\text{A}_i} \\
    = & \frac{1}{2} \left(
        E\ket{\psi}_\text{L} -  E\ket{\psi}_\text{L}
    \right) \ket{0}_{\text{A}_i}
    + \frac{1}{2} \left(
        E\ket{\psi}_\text{L} + E\ket{\psi}_\text{L}
    \right)\ket{1}_{\text{A}_i} \\
    = & E\ket{\psi}_\text{L}\ket{1}_{\text{A}_i}
\end{align*}
and measuring the ancilla $\text{A}_i$ corresponding to stabilizer
$P_i$ returns 1.
Similarly, if it commutes, the ancilla measurement returns 0.

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

% Structure of a stabilizer code

Stabilizer codes are the quantum analogue of classical binary linear
block codes, for which 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
\Cref{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 a $\llbracket n,k \rrbracket$ stabilizer code, there exist
logical operators generated by $2k$ representatives $X_i,
Z_j,~i,j\in[1:k]$ such that
\begin{itemize}
    \item They commute with all stabilizers in $\mathcal{S}$.
    \item For $i=j$, they 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$.
    \item For $i\neq j$, they 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 binary \emph{check matrix}
$\bm{H} \in \mathbb{F}_2^{(n-k)\times(2n)}$
\cite[Sec.~10.5.1]{nielsen_quantum_2010} with
\begin{align*}
    \bm{H} = \left[
        \begin{array}{c|c}
            \bm{H}_X & \bm{H}_Z
        \end{array}
    \right]
    .%
\end{align*}
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 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$ stabilizers acting on the
corresponding physical qubit, the rest to the $Z$ stabilizers.

\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 the
stabilizers can be split into one subset consisting only of
$Z$ stabilizers and one consisting only of $X$ stabilizers.
As $Z$ errors anti-commute with $X$ operators in the stabilizers and
vice versa, this property translates into being able to correct $X$
or $Z$ errors independently.
We call such codes \ac{css} codes.
We can see this property in \Cref{eq:steane} in the check matrix
of the Steane code.

% Construction

We can exploit this separate consideration of $X$ and $Z$ stabilizers in
the construction of \ac{css} codes.
We combine two binary linear codes $\mathcal{C}_1$ and
$\mathcal{C}_2$, each responsible for correcting either $Z$ or $X$ errors
\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}^\mathsf{T} = 0 ~\forall \bm{x} \in \mathcal{C}_2 \right\}
    ,%
\end{align*}
we define $\bm{H}_X$ as the \ac{pcm} of $\mathcal{C}_2^\perp$ and $\bm{H}_Z$
as the \ac{pcm} of $\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^\mathsf{T} = \bm{0}
    .%
\end{align}
We can ensure this by choosing $\mathcal{C}_1$ and $\mathcal{C}_2$
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 in a way that allows for local interactions between qubits.
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 higher rate than, e.g., surface codes, 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}^\mathsf{T} \vert \bm{A}^\mathsf{T}]
    .%
\end{align*}
This way, we can guarantee the satisfaction of the commutativity
condition \Cref{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 \Cref{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 \Cref{subsec:Iterative Decoding}
\cite[Sec.~3.1]{yao_belief_2024}.
Instead of attempting to find the most likely codeword directly, the
syndrome-based decoding algorithm tries to find an error pattern
$\hat{\bm{e}} \in \mathbb{F}_2^n$ that satisfies
\begin{align*}
    \bm{H} \hat{\bm{e}}^\mathsf{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{
        \left( \frac{1 - p_i}{p_i} \right)
    }
    ,%
\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}_\text{C}(j)\setminus \{i\}} \tanh
    \frac{L_{i'\rightarrow j}}{2} \right)
    .
\end{align*}
The resulting syndrome-based \ac{bp} algorithm is shown in
\Cref{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}}^\mathsf{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 \Cref{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}.
\Cref{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.

Quantum degeneracy additionally necessitates some care in the way
error rates are computed in simulations.
We must consider the fact that multiple solutions are valid by
comparing the logical states, computed by measuring the logical operators.
This way, we obtain the \ac{ler}.

% 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}}^\mathsf{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

