% TODO: Make all [H] -> [t]
\chapter{Decoding under Detector Error Models}

In \Cref{ch:Fundamentals} we introduced the fundamentals of classical
error correction, before moving on to quantum information science and
finally combining the two in \acf{qec}.
In \Cref{ch:Fault tolerance} we then turned to fault-tolerance, with
a focus on a specific way of implementing it, called \acfp{dem}.
In this chapter, we move on from the fundamental concepts and examine
how to apply them in practice.
Specifically, we concern ourselves with the practical aspects of decoding
under \acp{dem}.

We investigate decoding \acf{qldpc} codes under \acp{dem} in particular.
We focus on \ac{qldpc} codes, as they have emerged as leading
candidates for practical quantum error correction, offering
comparable thresholds with substantially improved encoding rates
\cite[Sec.~1]{bravyi_high-threshold_2024}.
Because of this, the decoding algorithms we consider will all be
related to \acf{bp} in some way.
Our aim is to build a fault-tolerant \ac{qec} system that works well
even in the presence of circuit-level noise.
We must overcome two main challenges to achieve this.

First, recall the problems related to degeneracy, which is inherent
to quantum codes.
Because multiple minimum-weight codewords exist, the \ac{bp}
algorithm becomes uncertain of the direction to proceed in.
Additionally, the commutativity conditions of the stabilizers
necessitate the existence of short cycles.
Together, these two aspects lead to substantial convergence problems
of \ac{bp} for quantum codes, when it is used on its own.

Second, the consideration of circuit-level noise introduces many more
error locations into the circuit.
Using \acp{dem}, we construct a new circuit code and model each of
these error locations as a new \acf{vn}.
We also perform multiple rounds of syndrome measurements,
exacerbating the problem.
This leads to a massively increased computational complexity and
latency of the decoding process.
In our experiments using the $\llbracket 144,12,12 \rrbracket$
\acf{bb} code with $12$ syndrome measurement rounds, for example, the
number of \acp{vn} grew from $144$ to $9504$, and the
number of \acfp{cn} grew from $72$ to $1008$.

The first problem is not inherent to \acp{dem} or fault-tolerance,
but rather quantum codes in general.
Many different approaches to solving it exist, usually centered
around somehow modifying \ac{bp}.
The most popular approach is combining a few initial
iterations of \ac{bp} with a second decoding algorithm, \ac{osd}
\cite{roffe_decoding_2020}.
Other approaches exist, such as \ac{aed}
\cite{koutsioumpas_automorphism_2025}, where multiple variations of
the code are decoded simultaneously to increase the chances of convergence.
Here, we will focus on the \acf{bpgd} algorithm
\cite{yao_belief_2024} we already introduced in \Cref{ch:Fundamentals},
for reasons that will become clear later in the chapter.

The second problem is inherent to decoding using \acp{dem}.
This is an area that has received less attention.
As we saw in \Cref{sec:Quantum Error Correction}, for \ac{qec},
latency is the main constraint, not raw computational complexity.
The main way this is addressed in the literature is \emph{sliding
window decoding}, which attempts to divide the overall decoding
problem into many smaller ones that can be solved more efficiently.

% TODO: This could potentially be a bit more text (e.g., go into
% SC-LDPC like structure that serves as the inspiration for the
% warm-start decoding. Or just go into warm-start decoding)
Our own work will focus mostly on the the solution of the second
problem using sliding-window decoding.
We will start by briefly reviewing the existing work related to
sliding-window decoding,
before focusing on one specific realization.
We will then introduce a modification to the existing algorithm and
perform numerical simulations to evaluate it.

% and reducing latency is the main goal of the existing literature.
% This is generally done using windowing approaches; either
% sliding-window based, where the latency is reduced due to an earlier
% start to the decoding process \cite{kuo_fault-tolerant_2024}%
% \cite{huang_improved_2023}\cite{huang_increasing_2024}\cite{gong_toward_2024},
% or by decoding multiple windows in parallel
% \cite{skoric_parallel_2023}\cite{tan_scalable_2023}.
% This work is based on the sliding-window method.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Sliding-Window Decoding}
\label{sec:Sliding-Window Decoding}

% Spacetime codes

\ac{qec} codes are often viewed through the lenses of the
\emph{space} and \emph{time} dimensions.
Both directions add redundancy, but they do so in a different way and
guard against different defects.
The space dimension corresponds to the redundancy added through the
code itself, while the time dimension corresponds to the repetition
of the syndrome measurements \cite[Sec.~IV.B]{dennis_topological_2002}.

% Basic idea

The idea of sliding-window decoding is to exploit the time-like
structure by splitting the circuit into overlapping windows along the
time dimension.
Each of these windows is then decoded separately.

%%%%%%%%%%%%%%%%
\subsection{Review of Existing Literature}
\label{subsec:Review of Existing Literature}

\begin{figure}[t]
    \centering

    \tikzset{
        literature/.append style={
            minimum width=6mm,
            minimum height=6mm,
            text width=18mm,
            align=left,
        }
    }
    \tikzset{
        heading/.append style={
            draw=black,
            minimum width=22mm,
            minimum height=6mm,
            align=left,
            rounded corners = 1mm,
        }
    }

    \tikzexternaldisable
    \begin{tikzpicture}[node distance = 0mm and 0mm]
        % tex-fmt: off
        \node[heading, minimum width=15mm, fill=gray!25]                  (code)  {Code};
        \node[heading, below right=2mm and -5mm of code, fill=orange!20]  (top)   {Topological};
        \node[heading, below right=45mm and -5mm of code, fill=orange!20] (qldpc) {QLDPC};

        \node[literature, below right=1mm and -12mm of top] (dennis) {\cite{dennis_topological_2002}};
        \node[literature, below=of dennis]                  (tan)    {\cite{tan_scalable_2023}};
        \node[literature, below=of tan]                     (skoric) {\cite{skoric_parallel_2023}};
        \node[literature, below=of skoric]                  (bombin) {\cite{bombin_modular_2023}};
        \node[literature, below=of bombin]                  (kuo)    {\cite{kuo_fault-tolerant_2024}};

        \node[literature, below right=1mm and -12mm of qldpc] (huang) {\cite{huang_improved_2023},\cite{huang_increasing_2024}};
        \node[literature, below=of huang]                     (gong)  {\cite{gong_toward_2024}};
        \node[literature, below=of gong]                      (kang)  {\cite{kang_quits_2025}};

        \coordinate (code-anchor)  at ($(code.south) + (-2mm,0)$);
        \coordinate (top-anchor)   at ($(top.south) + (-5mm,0)$);
        \coordinate (qldpc-anchor) at ($(qldpc.south) + (-5mm,0)$);

        \draw (code-anchor) |- (top);
        \draw (code-anchor) |- (qldpc);

        \draw (top-anchor) |- (dennis);
        \draw (top-anchor) |- (tan);
        \draw (top-anchor) |- (skoric);
        \draw (top-anchor) |- (bombin);
        \draw (top-anchor) |- (kuo);

        \draw (qldpc-anchor) |- (huang);
        \draw (qldpc-anchor) |- (gong);
        \draw (qldpc-anchor) |- (kang);

        \draw [
            line width=1pt,
            decorate,
            decoration={brace,amplitude=2mm,raise=5mm}
        ]
        (dennis.north east) -- (dennis.south east)
        node[midway,right,xshift=10mm]{Sequential};

        \draw [
            line width=1pt,
            decorate,
            decoration={brace,amplitude=2mm,raise=5mm}
        ]
        (tan.north east) -- (kuo.south east)
        node[midway,right,xshift=10mm]{Parallel};

        \draw [
            line width=1pt,
            decorate,
            decoration={brace,amplitude=2mm,raise=5mm}
        ]
        (huang.north east) -- (kang.south east)
        node[midway,right,xshift=10mm]{Sequential};
        % tex-fmt: on
    \end{tikzpicture}
    \tikzexternalenable

    \caption{Overview of literature on sliding-window decoding.}
    \label{fig:literature}
\end{figure}

% Some general notes

\Cref{fig:literature} gives an overview over the existing body of work
related to sliding-window decoding.
The papers \cite{huang_improved_2023} and \cite{huang_increasing_2024} are
lumped together, as they share the same content;
one is simply a preprint published earlier.
We will only refer to \cite{huang_increasing_2024} in the following.
\cite{kang_quits_2025} is somewhat special in that the authors focus
more on the introduction of a new simulator framework they call
QUITS, rather than the performance of sliding-window decoding itself.
\cite{gong_toward_2024} and \cite{kang_quits_2025} have made their
software freely available online%
\footnote{
    \url{https://github.com/mkangquantum/quits}
}%
\footnote{
    \url{https://github.com/gongaa/SlidingWindowDecoder}
}.
A final thing to note is that \cite{dennis_topological_2002} never
explicitly mentions sliding windows; the authors call their scheme
``overlapping recovery''.

% Topological vs QLDPC

Research has focused on two categories of \ac{qec} codes, topological
and \ac{qldpc} codes.
Most of the work on topological codes has treated surface codes,
with the exception of \cite{kuo_fault-tolerant_2024} where toric
codes were considered.
With regard to \ac{qldpc} codes, in \cite{huang_increasing_2024}
the authors examine \emph{hypergraph product} (\acs{hgp}) and
\emph{lifted-product} (\acs{lp}) codes.
HGP codes are constructed from the product of two classical codes,
while LP codes generalize this construction by additionally applying
a lift to reduce the qubit overhead.
In \cite{kang_quits_2025}, \emph{balanced product codes} (\acs{bpc})
are additionally considered.
Like HGP codes, BPC codes are derived from a product construction,
but exploit an additional symmetry to yield fewer physical qubits for
the same code parameters.
Finally, \cite{gong_toward_2024} explores \ac{bb} codes.

% Sequential vs parallel

After having divided the whole circuit into separate windows, the question
arises of how exactly to realize the decoding.
There are two main approaches, with differing mechanisms of reducing
the latency.
Some papers decode the sliding windows in a parallel fashion.
The benefit in this case is
is that classical hardware can be utilized more effectively.
Others choose a sequential approach.
Here, decoding can start earlier, as there is no need to wait for the
syndrome measurements of all windows before beginning with the decoding.
With the exception of \cite{dennis_topological_2002}, literature
treating topological codes has mostly focused on parallel decoding
while literature treating \ac{qldpc} codes has wholly considered
sequential decoding.

% Deep-dive into QLDPC methods

For this work, the publications treating \ac{qldpc} codes are
especially interesting.
The experimental conditions for these are summarized in
\Cref{table:experimental_conditions}.
As we noted above, \ac{hgp} and \ac{lp} codes are considered in
\cite{huang_increasing_2024},
\ac{hgp}, \ac{lp} and \ac{bpc} codes are considered in \cite{kang_quits_2025},
and \ac{bb} codes are considered in \cite{gong_toward_2024}.
The employed noise models also differ;
\cite{huang_increasing_2024} uses phenomenological noise, while
\cite{gong_toward_2024} and \cite{kang_quits_2025} use circuit-level noise.
Finally, in \cite{gong_toward_2024} the authors introduce their own variation of
\ac{bpgd}, \ac{bp} with \ac{gdg}, while \cite{huang_increasing_2024}
and \cite{kang_quits_2025} use \ac{bp} + \ac{osd}.
We would additionally like to note that only in
\cite{gong_toward_2024} and \cite{kang_quits_2025}
explicitly work with the \ac{dem} formalism.

\renewcommand{\arraystretch}{1.1}
\setlength{\tabcolsep}{12pt}
\begin{table}[t]
    \centering
    \caption{Experimental conditions in the literature on
    sliding-window decoding for \ac{qldpc} codes.}
    \vspace*{3mm}
    \label{table:experimental_conditions}
    \begin{tabular}{l|ccc}
        % tex-fmt: off
        Publication                                                            &    Code                       & Noise Model                     & Decoder \\ \hline
        \hspace{-2.5mm}\cite{huang_improved_2023},\cite{huang_increasing_2024} & \acs{hgp}, \acs{lp}           & Phenomenological noise & \acs{bp} + \acs{osd} \\
        \hspace{-2.5mm}\cite{gong_toward_2024}                                 & \acs{bb}                      & Circuit-level noise             & \acs{bp} + \acs{gdg} \\
        \hspace{-2.5mm}\cite{kang_quits_2025}                                  & \acs{hgp}, \acs{lp}, \acs{bpc}  & Circuit-level noise             & \acs{bp} + \ac{osd}
        % tex-fmt: on
    \end{tabular}
\end{table}

% \red{
%     Existing work
%     \begin{itemize}
%         \item \cite{gong_toward_2024}
%             \begin{itemize}
%                 \item BB codes (QLDPC)
%                 \item Circuit-level noise
%                 \item Sequential
%                 \item Cites $\underbrace{\cite{dennis_topological_2002}
%                         \cite{tan_scalable_2023}
%                     \cite{skoric_parallel_2023}}_\text{Surface code}
%                     \underbrace{\cite{huang_improved_2023}}_\text{QLDPC,Phenomenological}$
%             \end{itemize}
%         \item \cite{huang_improved_2023}
%             \begin{itemize}
%                 \item Hypergraph product codes, Lifted product codes (QLDPC)
%                 \item Phenomenological noise
%                 \item Sequential
%                 \item Cites $\underbrace{\cite{dennis_topological_2002}
%                         [Huang, Brown, 2021]
%                         \cite{skoric_parallel_2023}
%                         \cite{tan_scalable_2023}
%                     \cite{bombin_modular_2023}}_\text{Surface code}$
%             \end{itemize}
%         \item \cite{dennis_topological_2002}
%             \begin{itemize}
%                 \item Surface code (Topological)
%                 \item No idea what noise, don't care either (Gong et
%                     al. say circuit-level noise)
%                 \item ``Overlapping recovery'' -> Sequential
%             \end{itemize}
%         \item \cite{tan_scalable_2023}
%             \begin{itemize}
%                 \item Surface code (Topological)
%                 \item Circuit-level noise
%                 \item Parallel
%                 \item Cites \cite{dennis_topological_2002}
%             \end{itemize}
%         \item \cite{skoric_parallel_2023}
%             \begin{itemize}
%                 \item Surface code (Topological)
%                 \item Circuit-level noise
%                 \item Parallel
%                 \item Cites \cite{dennis_topological_2002}
%             \end{itemize}
%         \item \cite{huang_increasing_2024}
%             \begin{itemize}
%                 \item Same as \cite{huang_improved_2023}
%             \end{itemize}
%         \item \cite{kuo_fault-tolerant_2024}
%             \begin{itemize}
%                 \item Toric codes (Topological)
%                 \item Circuit-level noise
%                 \item Parallel
%                 \item Cites \cite{dennis_topological_2002}
%                     \cite{tan_scalable_2023}
%                     \cite{skoric_parallel_2023} \cite{gong_toward_2024}
%             \end{itemize}
%         \item \cite{bombin_modular_2023}
%             \begin{itemize}
%                 \item Surface codes (Topological)
%                 \item No idea if it's even fault-tolerant
%                 \item Parallel
%                 \item Cites \cite{dennis_topological_2002}
%                     \cite{tan_scalable_2023}
%                     \cite{skoric_parallel_2023} \cite{leverrier_decoding_2022}
%             \end{itemize}
%             % This is not BP and not parallelization over the time dimension
%             % \item \cite{leverrier_decoding_2022}
%             %     \begin{itemize}
%             %         \item Quantum tanner codes (QLDPC)
%             %         \item Parallel
%             %         \item No idea if it's even fault-tolerant
%             %         \item Cites [don't care]
%             %     \end{itemize}
%         \item \cite{kang_quits_2025}
%             \begin{itemize}
%                 \item Cites \cite{huang_increasing_2024} \ldots
%             \end{itemize}
%     \end{itemize}
% }

%%%%%%%%%%%%%%%%
\subsection{Window Splitting and Sequential Sliding-Window Decoding}
\label{subsec:Window Splitting and Sequential Sliding-Window Decoding}

In this section, we will examine the methodology by which a detector
error matrix is divided into overlapping windows.
The algorithm detailed here follows \cite{kang_quits_2025}, which
is in turn based on \cite{huang_increasing_2024}.

% Very high-level overview

Sliding-window decoding is made possible by the time-like structure
of the syndrome extraction circuitry.
This is especially clearly visible under the \ac{dem} formalism, where
this manifests as a block-diagonal structure of the detector
error matrix $\bm{H}$.
Note that this presupposes a choice of detectors as seen in
\Cref{subsec:Detector Error Matrix}.
This block-diagonal structure introduces some locality in the
interdependence between \acp{vn} and \acp{cn}.
For each local set of \acp{vn}, there is only a local set of connected \acp{cn}.
We exploit this fact by partitioning the matrix into overlapping windows.
\Cref{fig:windowing_pcm} depicts this process using the $\llbracket
72, 6, 6 \rrbracket$ BB code as an example.

% High-level overview

How the locality is leveraged can be understood by considering the
decoding process.
After decoding a window, there is a subset of \acp{cn} that
no longer contribute to decoding, since none of their
neighboring \acp{vn} appear in subsequent windows.
We call the set of \acp{vn} connected to those \acp{cn} the
\emph{commit region} and we wish to commit them before moving to the
next window, i.e., fix the values we estimate for the corresponding bits.
As mentioned above, the benefit of this sequential sliding-window
decoding approach
is that the decoding process can begin as soon as the syndrome
measurements for the first window are complete.

% W and F and why we look at rows, not columns

There are two degrees of freedom in how we perform the windowing.
The \emph{window size} $W \in \mathbb{N}$ represents the number of
syndrome extraction rounds lumped into one window, while
the \emph{step size} $F \in \mathbb{N}$ represents the number of
syndrome extraction rounds skipped before starting the next window.
$W$ controls the size of the windows while $F$ controls the overlap
between them.
As illustrated in \Cref{fig:windowing_pcm}, $W$ and $F$ control the
window dimensions and locations by defining the related \acp{cn},
not the \acp{vn}.
This is because while the number of overall \acp{cn} is only affected
by the choice of the underlying code and the number of syndrome
measurement rounds, the number of \acp{vn} depends on the noise model
and is difficult to predict beforehand.

\begin{figure}[t]
    \centering

    \hspace*{-114mm}%
    \begin{tikzpicture}
        \draw[decorate, decoration={brace, amplitude=10pt}, line width=1pt]
        (0,0) -- (3.1,0) node[midway, above=4mm] {Commit region};
    \end{tikzpicture}

    \centering
    \includegraphics[scale=0.75]{res/72_bb_dem.pdf}

    \vspace*{-25.3mm}

    \hspace*{-98mm}%
    \begin{tikzpicture}
        \draw[{Latex}-{Latex}, line width=.7pt] (0,   -0.75mm) -- (0,  5mm);
        \draw[line width=1pt]                   (-1mm,-0.75mm) --
        (3mm,-0.75mm);
        \draw[line width=1pt]                   (-1mm,5mm)     -- (3mm,5mm);
        \node[left] at                          (-2mm,2.125mm) {$\sim W$};

        \draw[{Latex}-{Latex}, line width=.3pt] (6.5cm,1.6mm)  -- (6.5cm,5mm);
        \draw[line width=1pt]                   (6.5cm,4.9mm)  -- (6.5cm,7mm);
        \node[above] at                         (6.5cm,7mm) {$\sim F$};
    \end{tikzpicture}

    \vspace*{10mm}

    \caption{
        Visualization of the windowing process on a detector error
        matrix generated from the $\llbracket 72, 6, 6 \rrbracket$
        BB code under circuit-level noise.
        The block-diagonal structure reflects the time-like locality
        of the syndrome extraction circuit., with each block
        corresponding to one syndrome measurement round.
        Two consecutive windows are highlighted: the window size $W$
        controls the number of syndrome rounds included in each
        window, while the step size $F$ controls how many rounds
        separate the start of one window from the next.
        The bracketed region indicates the commit
        region of the first window, i.e., the \acp{vn} that are committed
        before moving to the second window.
        % Visualization of the windowing process on a detector
        % error matrix generated from the $\llbracket 72, 6, 6
        % \rrbracket$ BB code.
    }
    \label{fig:windowing_pcm}
\end{figure}

% Notation recap

We briefly reintroduce the notation important for the definition of the windows.
We use the variables $n,m \in \mathbb{N}$ to describe the number of
\acp{vn} and \acp{cn} respectively.
We index the \acp{vn} using the variable $i \in \mathcal{I} :=
[0:n-1]$ and the \acp{cn} using the variable $j \in \mathcal{J} := [ 0 : m-1]$.
Finally, we call $\mathcal{N}_\text{V}(i) = \left\{ j\in \mathcal{J}:
\bm{H}_{j,i} = 1 \right\}$ and $\mathcal{N}_\text{C}(j) := \left\{ i
\in \mathcal{I} : \bm{H}_{j,i} = 1 \right\}$ the neighborhoods of the
corresponding nodes.
In this case, we take $\bm{H} \in \mathbb{F}_2^{m\times n}$ to be the
check matrix of the underlying code, from which the \ac{dem} was generated.
We use $m_\text{DEM}, \mathcal{I}_\text{DEM}$, and $\mathcal{J}_\text{DEM}$
to refer to the respective values defined from the detector error matrix.

% How we get the corresponding rows

We begin by describing the sets of \acp{cn} relevant to each window.
For indexing, we use the variable $\ell \in [0:n_\text{win} - 1]$,
where $n_\text{win} \in \mathbb{N}$ is the number of windows.
Because we defined the step size $F$ as the number of syndrome
extraction rounds to skip, the first \ac{cn} of window $\ell$ should have index
$\ell F m$.
Similarly, because of the way we defined the window size $W$, the
number of \acp{cn} should be $Wm$ for all but the last window.
The number of \acp{cn} in the last window may differ if there are
not enough \acp{cn} left to completely fill it.
We thus define
\begin{align*}
    \mathcal{J}_\text{win}^{(\ell)} &:= \left\{ j\in \mathcal{J}_\text{DEM}:~
        \ell F m \le j < \min \left\{m_\text{DEM}, (\ell F + W) m \right\}
    \right\} \\[2mm]
    & \hspace{30mm} \text{and} \\[2mm]
    \mathcal{J}_\text{commit}^{(\ell)} &:= \left\{ j\in \mathcal{J}_\text{DEM}:~
        \ell F m \le j < \min \left\{m_\text{DEM}, (\ell + 1) F m \right\}
    \right\}
    .%
\end{align*}
$\mathcal{J}_\text{win}^{(\ell)}$ is the set of all \acp{cn} in the
window while $\mathcal{J}_\text{commit}^{(\ell)}$ is the set of \acp{cn}
that do not contribute to the next window and whose neighboring
\acp{vn} will thus be committed.
We can additionally define the set of \acp{cn} that are shared between windows
$\ell$ and $\ell + 1$ as $\mathcal{J}_\text{overlap}^{(\ell)} :=
\mathcal{J}_\text{win}^{(\ell)}\setminus \mathcal{J}_\text{commit}^{(\ell)}$.

% How we get the corresponding columns

We can now turn our attention to defining the sets of \acp{vn} relevant
to each window.
We first introduce a helper function $i_\text{max} :
\mathcal{P}(\mathbb{N}) \to \mathbb{N}$, which takes a set of
\ac{cn} indices and returns the largest neighboring \ac{vn} index.
We define
\begin{align*}
    i_\text{max}\left( \mathcal{S} \right) := \max \left\{ i\in
    \mathcal{N}_\text{C}(j) : j\in \mathcal{S} \right\}
    ,
\end{align*}
where we set $i_\text{max} (\emptyset) = -1$ by convention%
\footnote{
    This has the effect of later automatically setting the lower
    bounds for the indices in $\mathcal{I}_\text{commit}^{(\ell)}$
    and $\mathcal{I}_\text{win}^{(\ell)}$ appropriately.
}%
.
The commit region of window $\ell$ should include all of the \acp{vn}
neighboring any of the \acp{cn} in $\mathcal{J}_\text{commit}^{(\ell)}$.
Consequently, the maximum index of the \acp{vn} we consider should be
$i_\text{max}(\mathcal{J}_\text{commit}^{(\ell)})$.
Additionally, the set of \acp{vn} committed in the next window should
start immediately afterwards.
We thus define
\begin{align*}
    \mathcal{I}_\text{commit}^{(\ell)}
    &:= \left\{i \in \mathcal{I}_\text{DEM} :~
        i_\text{max}\left( \mathcal{J}_\text{commit}^{(\ell-1)} \right)
        < i \le
        i_\text{max}\left( \mathcal{J}_\text{commit}^{(\ell)} \right)
    \right\}\\[2mm]
    & \hspace{39mm} \text{and} \\[2mm]
    \mathcal{I}_\text{win}^{(\ell)}
    &:= \left\{i \in \mathcal{I}_\text{DEM} :~
        i_\text{max}\left( \mathcal{J}_\text{commit}^{(\ell-1)} \right)
        < i \le
        i_\text{max}\left( \mathcal{J}_\text{win}^{(\ell)} \right)
    \right\}
    .%
\end{align*}
Again, we set $\mathcal{I}_\text{overlap}^{(\ell)} =
\mathcal{I}_\text{win}^{(\ell)}\setminus \mathcal{I}_\text{commit}^{(\ell)}$.
Note that we have
\begin{align*}
    \bigcup_{\ell=0}^{n_\text{win}-1}
    \mathcal{I}_\text{commit}^{(\ell)} = \mathcal{I}
\end{align*}
and after decoding all windows we will therefore have committed all \acp{vn}.

\begin{figure}[t]
    \centering

    \begin{tikzpicture}
        \def\sx{1.5}
        \def\sy{1.5}

        \coordinate (a00) at (0,0);
        \coordinate (a01) at (0,      3*\sy);
        \coordinate (a11) at (6*\sx,  3*\sy);
        \coordinate (a10) at (6*\sx,  0*\sy);

        \coordinate (b00) at (3.2*\sx, -1*\sy);
        \coordinate (b01) at (3.2*\sx,  2*\sy);
        \coordinate (b11) at (9.2*\sx,  2*\sy);
        \coordinate (b10) at (9.2*\sx, -1*\sy);

        \fill[gray!40] (a00) -- (a00 |- b01) -- (b01) -- (b01 |- a00) -- cycle;

        \draw (a00) -- (a01) -- (a11) -- (a10) -- cycle;
        \draw[densely dashed] (b00) -- (b01) -- (b11) -- (b10) -- cycle;

        \draw [
            decorate,
            decoration={brace,amplitude=3mm,raise=1mm}
        ]
        (a01) -- (a11)
        node[midway,above,yshift=4mm]{$\mathcal{I}_\text{win}^{(\ell)}$};

        \draw [
            decorate,
            decoration={brace,amplitude=3mm,raise=1mm}
        ]
        (a00 -| b00) -- (a00)
        node[midway,below,yshift=-4mm]{$\mathcal{I}_\text{commit}^{(\ell)}$};

        \draw [
            decorate,
            decoration={brace,amplitude=3mm,raise=1mm}
        ]
        (a00) -- (a01)
        node[midway,xshift=-3mm,left]{$\mathcal{J}_\text{win}^{(\ell)}$};

        \draw [
            decorate,
            decoration={brace,amplitude=3mm,raise=1mm}
        ]
        (a11) -- (a11 |- b11)
        node[midway,xshift=3mm,right]{$\mathcal{J}_\text{commit}^{(\ell)}$};

        \draw [
            decorate,
            decoration={brace,amplitude=3mm,raise=1mm}
        ]
        (a11 |- b11) -- (a10)
        node[midway,xshift=3mm,right]{$\mathcal{J}_\text{overlap}^{(\ell)}
            := \mathcal{J}_\text{win}^{(\ell)} \setminus
        \mathcal{J}_\text{commit}^{(\ell)}$};

        \draw [
            decorate,
            decoration={brace,amplitude=3mm,raise=1mm}
        ]
        (a10) -- (a00 -| b00)
        node[midway,yshift=-8.25mm,xshift=-8mm,right]{$\mathcal{I}_\text{overlap}^{(\ell)}
            := \mathcal{I}_\text{win}^{(\ell)} \setminus
        \mathcal{I}_\text{commit}^{(\ell)}$};

        \node[align=center] at ($(a00)!0.5!(b01)$)
        {%
            $\bm{H}_\text{overlap}^{(\ell)}$ \\[3mm]
            $=
            \left(\bm{H}_\text{DEM}\right)_{\mathcal{J}_\text{overlap}^{(\ell)},
            \mathcal{I}_\text{commit}^{(\ell)}}$%
        };
    \end{tikzpicture}

    \caption{
        Visual representation of the index sets used to define a sliding window.
        The solid box delimits the rows ($\mathcal{J}_\text{win}^{(\ell)}$)
        and columns ($\mathcal{I}_\text{win}^{(\ell)}$) of the detector
        error matrix considered when decoding window $\ell$, while the
        dashed box shows the analogous region for window $\ell + 1$.
        The shaded region marks the submatrix
        $\bm{H}_\text{overlap}^{(\ell)}$, whose rows correspond to the
        overlap CNs $\mathcal{J}_\text{overlap}^{(\ell)}$ shared with
        the next window, and whose columns correspond to the
        committed VNs $\mathcal{I}_\text{commit}^{(\ell)}$.
        After decoding window $\ell$, this submatrix is used to update
        the syndrome of the overlap CNs based on the committed bit estimates.
    }
    \label{fig:vis_rep}
\end{figure}

% Syndrome update

\Cref{fig:vis_rep} illustrates the meaning of the various sets of nodes.
We can also see a subtlety we must handle carefully when
moving on to decode the next window.
While the \acp{vn} in $\mathcal{J}_\text{commit}^{(\ell)}$ have no
bearing on the further decoding process, the values commited for the
\acp{vn} in $\mathcal{I}_\text{commit}^{(\ell)}$ do.
This is the case because these \acp{vn} have neighboring \acp{cn} in
the next window.
The part of the detector error matrix $\bm{H}_\text{DEM}$ describing
these connections is
$\bm{H}_\text{overlap}^{(\ell)} =
\left(\bm{H}_\text{DEM}\right)_{\mathcal{J}_\text{overlap}^{(\ell)},
\mathcal{I}_\text{commit}^{(\ell)}}$.
We have to account for this fact by updating the syndrome $\bm{s}$
based on the committed bit values.
Specifically, if $\hat{\bm{e}}_\text{commit}^{(\ell)}$ describes the error
estimates committed after decoding window $\ell$, we have to set
\begin{align*}
    \left(\bm{s}\right)_{\mathcal{J}_\text{overlap}^{(\ell)}} =
    \bm{H}_\text{overlap}^{(\ell)}
    \left( \hat{\bm{e}}_\text{commit}^{(\ell)} \right)^\text{T}
    .%
\end{align*}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Warm-Start Sliding-Window Decoding}
\label{sec:warm_start_bp}

% Intro: Problem with above procedure

The sliding-window structure visible in \Cref{fig:windowing_pcm} is
highly reminiscent of windowed decoding for \ac{sc}-\ac{ldpc} codes.
Switching our viewpoint to the Tanner graph depicted in
\Cref{fig:messages_decimation_tanner}, however, we can see an important
difference between \ac{sc}-\ac{ldpc} decoding and the
sliding-window decoding procedure detailed above.
While the windowing process is similar, the algorithm above
reinitializes the decoder to start from a clean state when moving to
the next window.
It therefore does not make use of the integral property of
windowed \ac{sc}-\ac{ldpc} decoding of exploiting the spatially coupled
structure by passing soft information from earlier to later spatial positions.

% Passing messages requires messages

The act of passing messages from one window to the next requires
there being messages after completing decoding of one window that are
still relevant to the decoding of the next.
This may somewhat limit the variety of \emph{inner decoders}, i.e.,
the decoders decoding the individual windows, the warm-start
initialization can be used with.
E.g., \ac{bp}+\ac{osd} does not immediately seem suitable, though
this remains to be investigated.
We chose to investigate first plain \ac{bp} due to its simplicity and
then \ac{bpgd} because of the availability of recently computed messages.

% TODO: Include this?
% \content{Mention that our own work ties into the bottom category in
% \Cref{fig:literature}}

%%%%%%%%%%%%%%%%
\subsection{Warm Start For Belief Propagation Decoding}
\label{subsec:Warm-Start Belief Propagation}

\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 = 5mm]
        \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, left =10mm 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,4} {
            \pgfmathtruncatemacro{\prev}{\i-1}

            \node[VN, right = 25mm of vn\prev 0] (vn\i0) {};
            \node[VN, below = of vn\i0]          (vn\i1) {};
            \node[VN, below = of vn\i1]          (vn\i2) {};
            \node[VN, below = of vn\i2]          (vn\i3) {};
            \node[VN, below = of vn\i3]          (vn\i4) {};

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

            \node[CN, left = 10mm 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);
        }

        \foreach \i in {1,2,3,4} {
            \pgfmathtruncatemacro{\prev}{\i-1}

            \draw (vn\prev 3) -- (cn\i 0);
            \draw (vn\prev 4) -- (cn\i 1);
        }

        \node[
            draw, inner sep=5mm,line width=1pt,
            fit=(vn00)(vn04)(cn00)(cn01)(vn20)(vn24)(cn20)(cn21)
        ]
        (box1) {};
        \node[
            draw, dashed, inner sep=5mm, inner ysep=8mm,line width=1pt,
            fit=(vn10)(vn14)(cn10)(cn11)(vn30)(vn34)(cn30)(cn31)
        ]
        (box2) {};

        \draw[KITorange, line width=2pt] (cn10) -- (vn10);
        \draw[KITorange, line width=2pt] (cn10) -- (vn11);
        \draw[KITorange, line width=2pt] (cn10) -- (vn13);
        \draw[KITorange, line width=2pt] (cn11) -- (vn11);
        \draw[KITorange, line width=2pt] (cn11) -- (vn12);
        \draw[KITorange, line width=2pt] (cn11) -- (vn14);

        \draw[KITorange, line width=2pt] (vn13) -- (cn20);
        \draw[KITorange, line width=2pt] (vn14) -- (cn21);

        \draw[KITorange, line width=2pt] (cn20) -- (vn20);
        \draw[KITorange, line width=2pt] (cn20) -- (vn21);
        \draw[KITorange, line width=2pt] (cn20) -- (vn23);
        \draw[KITorange, line width=2pt] (cn21) -- (vn21);
        \draw[KITorange, line width=2pt] (cn21) -- (vn22);
        \draw[KITorange, line width=2pt] (cn21) -- (vn24);

        % Marker for W on the bottom
        \draw[line width=1pt]
        ([yshift=-5mm, line width=1pt]box1.south west) -- ++(0,-4mm)
        coordinate (dim1l);
        \draw[line width=1pt]
        ([yshift=-5mm]box1.south east) -- ++(0,-4mm)
        coordinate (dim1r);
        \draw[{Latex}-{Latex}, line width=1pt]
        ([yshift=1mm]dim1l) -- ([yshift=1mm]dim1r)
        node[midway, below=2pt] {$W$};

        % Marker for F on top
        \draw[line width=1pt]
        ([yshift=3mm]box2.north west) -- ++(0,4mm)
        coordinate (dim3l);
        \draw[line width=1pt]
        ([yshift=3mm]box2.north west -| box1.north west) -- ++(0,4mm)
        coordinate (dim3r);
        \draw[{Latex}-{Latex}, line width=1pt]
        ([yshift=-1mm]dim3l) -- ([yshift=-1mm]dim3r)
        node[midway, above=2pt] {$F$};

        % Arrow on the top right
        \draw[-{Latex}, line width=1pt]
        ([yshift=8mm] box1.north east) -- ++(28mm,0);
    \end{tikzpicture}

    \caption{
        \red{Visualization of the messages used for the
        initialization of the next window under BP decoding.}
        \Acfp{vn} are represented using green circles while \acfp{cn}
        are represented using blue squares.
    }
    \label{fig:messages_tanner}
\end{figure}

% Proposed modification: Overview

We propose a modification to the procedure detailed in
\Cref{subsec:Window Splitting and Sequential Sliding-Window Decoding}:
Instead of zero-initializing the \ac{bp} messages of the next window,
we perform a \emph{warm start} by initializing the messages in the
overlapping region to the values last held during the decoding of the
previous window.

% Practical realization: Problem with naive approach

To see how we realize this in practice, we reiterate the steps of the
\ac{bp} algorithm
\begin{align}
    \label{eq:init}
    \text{Initialization: } & L_{i \rightarrow j} = \tilde{L}_i \\[3mm]
    \text{\ac{cn} Update (SPA): }&
    \displaystyle 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) \\[3mm]
    \text{\ac{cn} Update (Min-Sum): }&
    \displaystyle L_{i \leftarrow j} = (-1)^{s_j}\cdot \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 \\[3mm]
    \label{eq:vn_update}
    \text{\ac{vn} Update: } & \displaystyle L_{i \rightarrow j} =
    \tilde{L}_i +
    \sum_{j' \in \mathcal{N}_\text{V}(i)\setminus\{j\}}
    L_{i \leftarrow j'}
\end{align}
and turn our attention to \Cref{fig:messages_tanner}.
We consider the right-most boundary of the first window, drawn with a
solid line.
The fact that we partition the overall Tanner graph at this location,
i.e., with the last nodes of the last window being \acp{vn} and the
first nodes of the next window being \acp{cn}, is due to
the windowing construction detailed in
\Cref{subsec:Window Splitting and Sequential Sliding-Window Decoding}.
We consider the edges connecting the last set of \acp{vn}
still in the first window to the next set of \acp{cn}.
These edges are the routes along which information is transferred
to subsequent spatial positions, in the form of the \ac{vn} to \ac{cn}
messages $L_{i\rightarrow j}$.
Note that these edges are not considered during the decoding the first
window, since they leave its bounds.
Consequently, no messages have been computed for these when the
decoding of the first window completes.
This means that simply initializing the edges in the overlap region
with the exising $L_{i\rightarrow j}$ messages and starting the
decoding of the next window with a \ac{cn} update is not enough.

% Practical realization: working approach

We can resolve this issue by initializing the edges using the existing
\ac{cn} to \ac{vn} messages $L_{i\leftarrow j}$ and beginning the
decoding of the next window with a \ac{vn} update instead.
This way, we recompute the existing $L_{i\rightarrow j}$ messages and
additionally compute the messages crossing the window boundary.
We can then continue decoding the next window as usual.

% Practical realization: Simplification of algorithm

We can further simplify the algorithm.
Looking carefully at \Cref{eq:vn_update} we notice that when the
\ac{cn} to \ac{vn} messages $L_{i\leftarrow j}$ have been zero-initialized,
the \ac{vn} update degenerates to
\begin{align*}
    \displaystyle L_{i \rightarrow j} =
    \tilde{L}_i +
    \sum_{j' \in \mathcal{N}_\text{V}(i)\setminus\{j\}}
    L_{i \leftarrow j'} = \tilde{L}_i
    ,%
\end{align*}
i.e., the \ac{vn} update \Cref{eq:vn_update} becomes the same as the
initialization step \Cref{eq:init}.
We conclude that as long as we zero-initialize the
$L_{i\leftarrow j}$ messages, there is no need for a separate
initialization step.
\Cref{alg:warm_start_bp} shows the full warm-start sliding-window
decoding algorithm using \ac{bp} as the inner decoder for the
windows.
Note that the decoding procedure performed on the individual windows
(lines 4-8 in \Cref{alg:warm_start_bp}) is functionally equivalent to
\Cref{alg:syndome_bp} when using the \acf{spa} variant of \ac{bp}.

% tex-fmt: off
\tikzexternaldisable
\begin{algorithm}[t]
    \caption{Sliding-window belief propagation (BP) decoding algorithm with warm start.}
    \label{alg:warm_start_bp}
    \begin{algorithmic}[1]
        \State \textbf{Initialize:} $\hat{\bm{e}}^\text{total} \leftarrow \bm{0}$
        \State \textbf{Initialize:} $L_{i\leftarrow j} = 0
            ~\forall~ i\in \mathcal{I}, j\in \mathcal{J}$
        \For{$\ell = 0, \ldots, n_\text{win}-1$}
            \For{$\nu = 0, \ldots, n_\text{iter}-1$}
                \State Perform \ac{vn} update for window $\ell$
                \State Perform \ac{cn} update for window $\ell$
                \State Compute $\hat{\bm{e}}^{(\ell)}$ and check early
                    termination condition
            \EndFor
            \State $\displaystyle\left(\hat{\bm{e}}^\text{total}\right)_{\mathcal{I}^{(\ell)}_\text{commit}} \leftarrow \hat{\bm{e}}^{(\ell)}_\text{commit}$
            \State $\displaystyle\left(\bm{s}\right)_{\mathcal{J}_\text{overlap}^{(\ell)}}
                \leftarrow \bm{H}_\text{overlap}^{(\ell)}
                \left( \hat{\bm{e}}_\text{commit}^{(\ell)} \right)^\text{T}$
            \If{$\ell < n_\text{win} - 1$}
                \State $L^{(\ell+1)}_{i\leftarrow j} \leftarrow
                L^{(\ell)}_{i\leftarrow j}
                ~\forall~ i \in \mathcal{I}_\text{overlap}^{(\ell)},
                    j \in \mathcal{J}_\text{overlap}^{(\ell)}$
            \EndIf
        \EndFor
        \State \textbf{return} $\hat{\bm{e}}$
    \end{algorithmic}
\end{algorithm}
\tikzexternalenable
% tex-fmt: on

%%%%%%%%%%%%%%%%
\subsection{Warm Start for Belief Propagation with Guided Decimation Decoding}
\label{subsec:Warm-Start Belief Propagation with Guided Decimation Decoding}

% Intro: Recap of BPGD

We now direct our attention at using \ac{bpgd} as an inner decoder.
Recall that for \ac{bpgd}, after a number $T \in \mathbb{N}$ of
iterations we decimate
the most reliable \ac{vn}, meaning we perform a hard decision and
remove it from the following decoding process.

This means that when moving from one window to the next, we now have
more information available: not just the \ac{bp} messages but also the
information about what \acp{vn} were decimated and to what values.
We call this \emph{decimation information} in the following.
We can extend \Cref{alg:warm_start_bp} by additionally passing the
decimation information after initializing the \ac{cn} to \ac{vn} messages.
\Cref{fig:messages_decimation_tanner} visualizes this process.

% TODO: Do this in the fundamentals chapter. Then write a proper
% algorithm for warm-start sliding-window decoding with BPGD as well
%\content{(?) Explicitly mention decimation info = channel llrs?}

\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 = 5mm]
        \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, left =10mm 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,4} {
            \pgfmathtruncatemacro{\prev}{\i-1}

            \node[VN, right = 25mm of vn\prev 0] (vn\i0) {};
            \node[VN, below = of vn\i0]          (vn\i1) {};
            \node[VN, below = of vn\i1]          (vn\i2) {};
            \node[VN, below = of vn\i2]          (vn\i3) {};
            \node[VN, below = of vn\i3]          (vn\i4) {};

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

            \node[CN, left = 10mm 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);
        }

        \foreach \i in {1,2,3,4} {
            \pgfmathtruncatemacro{\prev}{\i-1}

            \draw (vn\prev 3) -- (cn\i 0);
            \draw (vn\prev 4) -- (cn\i 1);
        }

        \node[
            draw, inner sep=5mm,line width=1pt,
            fit=(vn00)(vn04)(cn00)(cn01)(vn20)(vn24)(cn20)(cn21)
        ]
        (box1) {};
        \node[
            draw, dashed, inner sep=5mm, inner ysep=8mm,line width=1pt,
            fit=(vn10)(vn14)(cn10)(cn11)(vn30)(vn34)(cn30)(cn31)
        ]
        (box2) {};

        \draw[KITorange, line width=2pt] (cn10) -- (vn10);
        \draw[KITorange, line width=2pt] (cn10) -- (vn11);
        \draw[KITorange, line width=2pt] (cn10) -- (vn13);
        \draw[KITorange, line width=2pt] (cn11) -- (vn11);
        \draw[KITorange, line width=2pt] (cn11) -- (vn12);
        \draw[KITorange, line width=2pt] (cn11) -- (vn14);

        \draw[KITorange, line width=2pt] (vn13) -- (cn20);
        \draw[KITorange, line width=2pt] (vn14) -- (cn21);

        \draw[KITorange, line width=2pt] (cn20) -- (vn20);
        \draw[KITorange, line width=2pt] (cn20) -- (vn21);
        \draw[KITorange, line width=2pt] (cn20) -- (vn23);
        \draw[KITorange, line width=2pt] (cn21) -- (vn21);
        \draw[KITorange, line width=2pt] (cn21) -- (vn22);
        \draw[KITorange, line width=2pt] (cn21) -- (vn24);

        \node[VN, draw=KITorange, fill=KITorange] at (vn10) {};
        \node[VN, draw=KITorange, fill=KITorange] at (vn11) {};
        \node[VN, draw=KITorange, fill=KITorange] at (vn12) {};
        \node[VN, draw=KITorange, fill=KITorange] at (vn13) {};
        \node[VN, draw=KITorange, fill=KITorange] at (vn14) {};

        \node[VN, draw=KITorange, fill=KITorange] at (vn20) {};
        \node[VN, draw=KITorange, fill=KITorange] at (vn21) {};
        \node[VN, draw=KITorange, fill=KITorange] at (vn22) {};
        \node[VN, draw=KITorange, fill=KITorange] at (vn23) {};
        \node[VN, draw=KITorange, fill=KITorange] at (vn24) {};

        % Marker for W on the bottom
        \draw[line width=1pt]
        ([yshift=-5mm, line width=1pt]box1.south west) -- ++(0,-4mm)
        coordinate (dim1l);
        \draw[line width=1pt]
        ([yshift=-5mm]box1.south east) -- ++(0,-4mm)
        coordinate (dim1r);
        \draw[{Latex}-{Latex}, line width=1pt]
        ([yshift=1mm]dim1l) -- ([yshift=1mm]dim1r)
        node[midway, below=2pt] {$W$};

        % Marker for F on top
        \draw[line width=1pt]
        ([yshift=3mm]box2.north west) -- ++(0,4mm)
        coordinate (dim3l);
        \draw[line width=1pt]
        ([yshift=3mm]box2.north west -| box1.north west) -- ++(0,4mm)
        coordinate (dim3r);
        \draw[{Latex}-{Latex}, line width=1pt]
        ([yshift=-1mm]dim3l) -- ([yshift=-1mm]dim3r)
        node[midway, above=2pt] {$F$};

        % Arrow on the top right
        \draw[-{Latex}, line width=1pt]
        ([yshift=8mm] box1.north east) -- ++(28mm,0);
    \end{tikzpicture}

    \caption{
        \red{Visualization of the messages and decimation information
            used for the
        initialization of the next window under \ac{bpgd} decoding}.
        \Acfp{vn} are represented using green circles while \acfp{cn}
        are represented using blue squares.
    }
    \label{fig:messages_decimation_tanner}
\end{figure}

% % tex-fmt: off
% \tikzexternaldisable
% \begin{algorithm}[t]
%     \caption{Sliding-window decoding algorithm with warm start for generic inner decoder.}
%     \label{alg:warm_start_general}
%     \begin{algorithmic}[1]
%         \State \textbf{Initialize:} $\hat{\bm{e}}^\text{total} \leftarrow \bm{0}$
%         \State \textbf{Initialize:} $L_{i\leftarrow j} = 0
%             ~\forall~ i\in \mathcal{I}, j\in \mathcal{J}$
%         \For{$\ell = 0, \ldots, n_\text{win}-1$}
%             \State Obtain $\hat{\bm{e}}^{(\ell)}$ from inner decoder
%             \State $\displaystyle\left(\hat{\bm{e}}^\text{total}\right)_{\mathcal{I}^{(\ell)}_\text{commit}} \leftarrow \hat{\bm{e}}^{(\ell)}_\text{commit}$
%             \State $\displaystyle\left(\bm{s}\right)_{\mathcal{J}_\text{overlap}^{(\ell)}}
%                 \leftarrow \bm{H}_\text{overlap}^{(\ell)}
%                 \left( \hat{\bm{e}}_\text{commit}^{(\ell)} \right)^\text{T}$
%             \If{$\ell < n_\text{win} - 1$}
%                 \State $L^{(\ell+1)}_{i\leftarrow j} \leftarrow
%                 L^{(\ell)}_{i\leftarrow j}
%                 ~\forall~ i \in \mathcal{I}_\text{overlap}^{(\ell)},
%                     j \in \mathcal{J}_\text{overlap}^{(\ell)}$
%             \EndIf
%         \EndFor
%         \State \textbf{return} $\hat{\bm{e}}$
%     \end{algorithmic}
% \end{algorithm}
% \tikzexternalenable
% % tex-fmt: on
%
% \content{Make algorithm 4 specific to BPGD?}

\section{Numerical Results}
\label{sec:Numerical Results}

% Intro

In this section, we perform numerical experiments to evaluate the
modification to sliding-window decoding we introduced in
\Cref{sec:warm_start_bp}.
For the practical aspects of implementation, several layers of
abstraction must be considered.

% Software stack: Layer 1

The lowest layer is the circuit-level simulator.
This serves as the backbone of all further simulations, handling the
quantum mechanical aspects of the system, including the modeling of
noise on gates, idling qubits, and measurements according to the
chosen noise model.

% Software stack: Layer 2

Moving one level of abstraction higher, the syndrome extraction
circuit itself must be generated.
This entails constructing the full circuit, including the ancilla
measurements and the error locations introduced by the chosen noise
model, both of which depend on the code and noise model in question.

% Software stack: Layer 3

Even further up, given an already constructed syndrome extraction
circuit and the resulting \acf{dem}, we must split the detector error
matrix into separate windows and manage the interplay between the
inner decoders acting on those individual windows.

% Software stack: Layer 4

Finally, we require the decoder itself, which operates on a
\acf{pcm} and a syndrome, with no dependence on the complexity of the
layers below.

% Software stack: Tools

In our implementation, Stim \cite{gidney_stim_2021} served as the
circuit-level simulator, chosen for its efficiency and native support
for the \ac{dem} formalism.
For the circuit generation, we employed utilities from QUITS
\cite{kang_quits_2025}, which provides syndrome extraction circuitry
generation for a number of different \ac{qldpc} codes.
We initially created a Python implementation, which used QUITS for the window
splitting and subsequent sliding-window decoding as well.
The \ac{bp} and \ac{bpgd} decoders were also initially implemented in Python.
After a preliminary investigation, we opted for a complete
reimplementation in Rust to achieve higher simulation speeds leveraging
the compiled nature of the language.
We reimplemented both the window splitting and the decoders.

% Global experimental setup

We chose to carry out our simulations on \ac{bb} codes, as they have
recently emerged as particularly promising candidates for practical
\ac{qec}, offering high encoding rates and large minimum distances
while admitting short-depth syndrome extraction circuits
\cite[Sec.~1]{bravyi_high-threshold_2024}.
Specifically, we chose the $\llbracket 144, 12, 12 \rrbracket$ BB
code, as it represents a good trade-off between code size and
simulation tractability.
For the generation of the \ac{dem} we set the number of syndrome
extraction rounds to $12$, similarly to \cite{gong_toward_2024}, and
we defined our detectors as in the example in
\Cref{subsec:Detector Error Matrix}.
We employed circuit-lose noise as described in
\Cref{subsec:Choice of Noise Model} as our noise model, specifically standard
ciruit-based depolarizing noise \cite[Sec.~VIII]{fowler_high-threshold_2009},
i.e., all error locations in the circuit get assigned the same
physical error probability.
We report performance in terms of the per-round \ac{ler} as defined
in \Cref{subsec:Per-Round Logical Error Rate} and all datapoints were
generated by simulating at least $200$ logical error events.

%%%%%%%%%%%%%%%%
\subsection{Belief Propagation}
\label{subsec:Belief Propagation}

% Local experimental setup

We began our investigation by using \ac{bp} with no further
modifications as the inner decoder.
We chose the min-sum variant of \ac{bp} due to its low computational complexity.

% [Thread] Get impression for max gain

We initially wanted to gain an impression for the performance gain we could
expect from a modification to the sliding-window decoding procedure.
To this end, we began by analyzing the decoding performance of the
original process, without our warm-start modification.
We will call this \emph{cold-start} decoding in the following.
Because we expected more global decoding to work better (the inner
    decoder then has access to a larger portion of the long-range
    correlations encoded in the detector error matrix before any commit
is made) we initially decided to use decoding on the whole detector
error matrix as a proxy for the attainable decoding performance.

\begin{figure}[t]
    \centering
    \begin{tikzpicture}
        \begin{axis}[
                width=\figwidth,
                height=\figheight,
                ymode=log,
                legend style={
                    cells={anchor=west},
                    cells={align=left},
                },
                enlargelimits=false,
                ymin=1e-5, ymax=2e-1,
                grid=both,
                legend pos = south east,
                xtick={0.001,0.0015,...,0.004},
                xticklabel style={/pgf/number format/fixed},
                xticklabel style={/pgf/number format/precision=4},
                scaled x ticks=false,
                xlabel={Physical error rate},
                ylabel={Per-round-LER},
            ]

            \foreach \W/\col/\mark in
            {3/KITred/triangle*,4/KITblue/diamond*,5/KITorange/square*} {
                \edef\temp{\noexpand
                    \addplot+[mark=\mark, solid, mark
                    options={fill=\col}, \col]
                    table[
                        col sep=comma, x=physical_p,
                        y=LER_per_round,
                    ]
                    {res/sim/WF/WindowingSyndromeMinSumDecoder/max_iter_200/pass_soft_info_False/F_1/W_\W/LERs.csv};
                }
                \temp

                \addlegendentryexpanded{$W = \W$}
            }

            \addplot+[mark=*, solid, mark options={fill=black}, black]
            table[
                col sep=comma, x=physical_p,
                y=LER_per_round,
            ]
            {res/sim/whole/SyndromeMinSumDecoder/max_iter_200/LERs.csv};

            \addlegendentry{Whole}
        \end{axis}
    \end{tikzpicture}

    \caption{
        \red{\lipsum[2]}
    }
    \label{fig:whole_vs_cold}
\end{figure}

% [Experimental parameters] Figure 4.6

\Cref{fig:whole_vs_cold} shows the simulation results for this initial
investigation.
The three colored curves correspond to cold-start sliding-window
decoding with window sizes $W \in \{3, 4, 5\}$, all with the step
size fixed to $F = 1$, while the black curve gives the per-round
\ac{ler} obtained when decoding on the whole detector error matrix at once.
In all cases, the inner \ac{bp} decoder was allowed a maximum of
$200$ iterations, and the physical error rate was swept from
$p = 0.001$ to $p = 0.004$ in steps of $0.0005$.

% [Description] Figure 4.6

Across the entire range of physical error rates, all curves exhibit
the expected monotonic increase in logical error rate with increasing
physical noise.
The $W = 3$ decoder consistently yields the highest LER, performing
roughly an order of magnitude worse than the baseline at low physical
error rates.
Increasing the window size to $W = 4$ substantially closes this gap,
and the $W = 5$ curve nearly coincides with the whole-block decoder
across the full range of physical error rates.

% [Interpretation] Figure 4.6

This behavior is consistent with the intuition behind sliding-window decoding.
The detector error matrix encodes correlations between detection
events that span the full syndrome extraction history, so errors
lying in the commit region of an early window are in general
constrained by check nodes that only become visible in subsequent windows.
Larger windows expose the inner decoder to more of these constraints
before any commit is made, leading to better-informed decisions and a
lower per-round \ac{ler}.
Decoding the whole matrix at once represents the limiting case of
this trend and, as expected, achieves the strongest performance.
The fact that the $W = 5$ curve is already very close to the
whole-block decoder indicates that the marginal benefit of enlarging
the window saturates after a certain point.
From a practical standpoint, the choice of $W$ thus represents a
trade-off between decoding latency and accuracy: larger windows
delay the start of decoding by requiring more syndrome extraction
rounds to be collected upfront, while the diminishing returns above
$W = 4$ suggest that growing the window much further yields little
additional accuracy in return.

% [Thread] First comparison with warm start

Next, we additionally generated error rate curves for warm-start
sliding-window decoding to assess how much of the gap between
cold-start and whole-block decoding can be recovered by our modification.
We chose the same window sizes as before, so that the warm- and
cold-start curves can be compared directly at matching values of $W$.

\begin{figure}[t]
    \centering
    \begin{tikzpicture}
        \begin{axis}[
                width=\figwidth,
                height=\figheight,
                ymode=log,
                legend style={
                    cells={anchor=west},
                    cells={align=left},
                },
                enlargelimits=false,
                ymin=1e-5, ymax=2e-1,
                grid=both,
                legend pos = south east,
                xtick={0.001,0.0015,...,0.004},
                xticklabel style={/pgf/number format/fixed},
                xticklabel style={/pgf/number format/precision=4},
                scaled x ticks=false,
                xlabel={Physical error rate},
                ylabel={Per-round-LER},
                extra description/.code={
                    \node[rotate=90, anchor=south]
                    at ([xshift=10mm]current axis.east)
                    {Warm s. (---), Cold s. (- - -)};
                },
            ]

            \foreach \W/\col/\mark in
            {3/KITred/triangle,4/KITblue/diamond,5/KITorange/square} {
                \edef\temp{\noexpand
                    \addplot+[
                        mark=\mark, densely dashed, mark options={fill=\col},
                        \col, forget plot
                    ]
                    table[
                        col sep=comma, x=physical_p,
                        y=LER_per_round,
                    ]
                    {res/sim/WF/WindowingSyndromeMinSumDecoder/max_iter_200/pass_soft_info_False/F_1/W_\W/LERs.csv};
                }
                \temp
            }

            \foreach \W/\col/\mark in
            {3/KITred/triangle*,4/KITblue/diamond*,5/KITorange/square*} {
                \edef\temp{\noexpand
                    \addplot+[mark=\mark, solid, mark
                    options={fill=\col}, \col]
                    table[
                        col sep=comma, x=physical_p,
                        y=LER_per_round,
                    ]
                    {res/sim/WF/WindowingSyndromeMinSumDecoder/max_iter_200/pass_soft_info_True/F_1/W_\W/LERs.csv};
                }
                \temp

                \addlegendentryexpanded{$W = \W$}
            }

            \addplot+[mark=*, solid, mark options={fill=black}, black]
            table[
                col sep=comma, x=physical_p,
                y=LER_per_round,
            ]
            {res/sim/whole/SyndromeMinSumDecoder/max_iter_200/LERs.csv};

            \addlegendentry{Whole}
        \end{axis}
    \end{tikzpicture}

    \caption{
        \red{\lipsum[2]}
    }
    \label{fig:whole_vs_cold_vs_warm}
\end{figure}

% [Experimental parameters] Figure 4.7

\Cref{fig:whole_vs_cold_vs_warm} extends the previous comparison by
additionally including the warm-start variant of sliding-window decoding.
The dashed colored curves reproduce the cold-start results from
\Cref{fig:whole_vs_cold}, while the solid colored curves show the
corresponding warm-start runs for the same window sizes
$W \in \{3, 4, 5\}$.
The remaining experimental parameters are unchanged:
the step size is fixed to $F = 1$,
the inner \ac{bp} decoder is allowed up to $200$ iterations per
window invocation, the black curve again gives the whole-block
reference, and the physical error rate is swept from $p = 0.001$ to
$p = 0.004$ in steps of $0.0005$.

% [Description] Figure 4.7

For each window size, the warm-start variant consistently outperforms
its cold-start counterpart, with the dashed curves lying above the
corresponding solid curves across the entire range of physical error rates.
The performance gap between the two approaches is most pronounced for
the largest window ($W = 5$) and gradually narrows as the window size decreases.
Additionally, the gap between the cold- and warm-start curves
generally widens as the physical error rate decreases.

% [Interpretation] Figure 4.7

The improvement of warm-start over cold-start decoding matches the
motivation for the modification:
By reusing already existing messages from the previous window in the
overlap region, the next window invocation has additional information
at its disposal about the reliability of the \acp{vn} and \acp{cn}.
The widening of the gap towards larger window sizes is consistent
with this picture, since with $F$ fixed to $1$ the overlap between
consecutive windows spans $W - F = W - 1$ syndrome rounds, so larger
$W$ implies that more messages are carried over and a larger fraction
of the next window starts in a warm state.
% TODO: Possibly insert explanation for higher gain at lowre error rates
A perhaps surprising observation is that the warm-start curve for
$W = 5$ actually lies below the whole-block reference across the
entire range of physical error rates, even though warm-start
sliding-window decoding is, by construction, more local than
whole-block decoding.
A possible explanation for this effect is discussed in the following.

% [Thread] Warm start is better than whole due to more effective iterations

A possible explanation for this surprising behavior lies in the
number of \ac{bp} iterations effectively spent on the \acp{vn}
inside the overlap region.
Each \ac{vn} in such an overlap is processed by multiple consecutive
window invocations, and because every new window resumes from the
messages left over by its predecessor, these invocations effectively
accumulate iterations on the same \acp{vn} rather than restarting
from scratch.
The whole-block decoder, by contrast, performs only a single run of
at most $200$ iterations on the entire detector error matrix, so
each of its \acp{vn} receives at most that many iterations.
It seems this larger effective iteration budget on the overlap
regions can outweigh the loss of globality incurred by windowing.

A natural way to test this hypothesis is to raise the maximum number
of \ac{bp} iterations of the whole-block decoder until its per-round
\ac{ler} saturates.
If the above interpretation is correct, the resulting saturation
level should constitute a lower bound that no windowed scheme,
irrespective of the initialization, can beat, since by construction
whole-block decoding has access to the full set of constraints
available to any window.

\begin{figure}[t]
    \centering
    \begin{tikzpicture}
        \def\spyxmin{32}
        \def\spyxmax{512}
        \def\spyymin{5e-3}
        \def\spyymax{7e-2}

        \newcommand{\plotcurves}{%
            \foreach \W/\col/\mark in
            {3/KITred/triangle,4/KITblue/diamond,5/KITorange/square} {
                \edef\temp{\noexpand
                    \addplot+[mark=\mark, densely dashed,
                    forget plot, \col]
                    table[
                        col sep=comma, x=max_iter,
                        y=LER_per_round,
                    ]
                    {res/sim/max_iter/WindowingSyndromeMinSumDecoder/p_0.0025/pass_soft_info_False/F_1/W_\W/LERs.csv};
                }
                \temp
            }
            \foreach \W/\col/\mark in
            {3/KITred/triangle*,4/KITblue/diamond*,5/KITorange/square*} {
                \edef\temp{\noexpand
                    \addplot+[mark=\mark, solid, mark
                    options={fill=\col}, \col, forget plot]
                    table[
                        col sep=comma, x=max_iter,
                        y=LER_per_round,
                    ]
                    {res/sim/max_iter/WindowingSyndromeMinSumDecoder/p_0.0025/pass_soft_info_True/F_1/W_\W/LERs.csv};
                }
                \temp
            }
            \addplot+[mark=*, solid, mark options={fill=black}, black,
            forget plot]
            table[col sep=comma, x=max_iter, y=LER_per_round]
            {res/sim/max_iter/SyndromeMinSumDecoder/p_0.0025/LERs.csv};
        }

        \begin{axis}[
                name=main,
                width=\figwidth,
                height=\figheight,
                ymode=log,
                enlargelimits=false,
                ymin=1e-3, ymax=1e-1,
                grid=both,
                legend pos=north east,
                xtick={32, 512, 1024, 1536, 2048, 2560, 3072, 3584, 4096},
                xticklabels={$32$,$512$,$1{,}024$,,$2{,}048$,,$3{,}072$,,$4{,}096$},
                xticklabel style={/pgf/number format/fixed},
                scaled x ticks=false,
                xlabel={Number of BP iterations},
                ylabel={Per-round-LER},
                extra description/.code={
                    \node[rotate=90, anchor=south]
                    at ([xshift=10mm]current axis.east)
                    {Warm s. (---), Cold s. (- - -)};
                },
            ]

            \plotcurves

            \addlegendimage{KITred, mark=triangle*}
            \addlegendentry{$W = 3$}
            \addlegendimage{KITblue, mark=diamond*}
            \addlegendentry{$W = 4$}
            \addlegendimage{KITorange, mark=square*}
            \addlegendentry{$W = 5$}
            \addlegendimage{black, mark=*}
            \addlegendentry{Whole}

            \node[draw=black, fit={(axis cs:\spyxmin,\spyymin) (axis
            cs:\spyxmax,\spyymax)}, inner sep=0pt, name=spybox] {};

        \end{axis}

        \begin{axis}[
                name=inset,
                at={(main.north)},
                anchor=south,
                xshift=0mm, yshift=6mm,
                width=6.5cm, height=4.875cm,
                ymode=log,
                enlargelimits=false,
                xmin=\spyxmin, xmax=\spyxmax,
                ymin=\spyymin, ymax=\spyymax,
                xtick={32,128,256, 512},
                yticklabels={\empty},
                xticklabels={\empty},
                grid=both,
                axis background/.style={fill=white},
            ]

            \plotcurves
        \end{axis}

        \draw (spybox.north east) -- (inset.south west);
    \end{tikzpicture}

    \caption{
        \red{\lipsum[2]}
    }
    \label{fig:bp_w_over_iter}
\end{figure}

% [Experimental parameters] Figure 4.8

\Cref{fig:bp_w_over_iter} shows the per-round \ac{ler} as a function
of the maximum number of \ac{bp} iterations granted to the inner decoders.
The dashed colored curves correspond to cold-start sliding-window
decoding for $W \in \{3, 4, 5\}$, the solid colored curves to the
corresponding warm-start sliding-window decoding, and the black curve
to the whole-block reference.
The physical error rate is fixed at $p = 0.0025$, the step size at
$F = 1$, and the iteration budget is swept over
$n_\text{iter} \in \{32, 128, 256, 512, 1024, 2048, 4096\}$.
The enlarged plot magnifies the low-iteration regime
$n_\text{iter} \in [32, 512]$.

% [Description] Figure 4.8

All curves decrease monotonically with the iteration budget, but
contrary to our expectation, none of them appears to fully saturate
within the swept range: even at $n_\text{iter} = 4096$, every curve
still exhibits a noticeable downward slope.
At $n_\text{iter} = 32$, the whole-block curve lies below both the
$W=4$ and $W=5$ sliding-window curves.
At $n_\text{iter} = 128$ the whole-block curve already performs
better than the $W=4$ sliding-window curve
and at $n_\text{iter} = 512$ the whole-block and warm-start $W = 5$
curves also cross.
From this point onwards, the whole-block decoder lies strictly below
all windowed schemes, this difference becoming more pronounced as the
iteration budget grows further.
Within the magnified plot, the gap between the warm-start and
cold-start curves at fixed $W$ is largest for the smallest iteration
counts and shrinks rapidly as $n_\text{iter}$ grows, and at fixed
$n_\text{iter}$ the size of this gap grows with the window size,
mirroring the behavior already observed in \Cref{fig:whole_vs_cold_vs_warm}.

% [Interpretation] Figure 4.8

These observations are largely consistent with the effective-iterations
hypothesis put forward above.
The whole-block decoder eventually overtaking every windowed scheme
matches the prediction made there: with a sufficiently large
iteration budget, the whole-block decoder reaches an error rate
that nonone of the windowed schemes can beat, because of the more global
nature of the considered constraints.
Furthermore, the pronounced advantage of warm- over cold-start decoding at low
numbers of iterations makes sense if we consider the overall trend of the plots.
At low iteration budgets, each additional iteration is worth more
than at high budgets.
As the number of permitted iteration increases, the benefit of
the additional ``free'' iterations gained due to the the warm-start
initialization diminishes, and the curves approach each other.

The fact that no curve clearly saturates within the swept range is
itself worth noting.
We know that \ac{bp} on \ac{qldpc} codes suffers from poor
convergence due to the short cycles in the underlying Tanner graph,
so even after several thousand iterations the
decoder may continue to slowly refine its message estimates rather
than settle into a stable fixed point.
This is one of the core motivations for moving from plain \ac{bp} to
the guided-decimation variant studied in
\Cref{subsec:Belief Propagation with Guided Decimation}.

Another thing to note is that setting the per-invocation iteration
budget of the inner decoder equal to the iteration budget of the
whole-block decoder is not a fair comparison in terms of total
computational effort.
The sliding-window scheme processes each \ac{vn} in an overlap region
multiple times and therefore spends more iterations overall.
In the context of \ac{qec}, however, the relevant figure of merit is
not total compute but decoding latency, and in terms of latency the
sliding-window approach is still at an advantage.

% [Thread] Exploration of the effect of the step size

Having examined the effect of the window size $W$, we next turned to
the second windowing parameter, the step size $F$.
We carried out an investigation analogous to the one above:
we first compared warm- and cold-start decoding across the full range
of physical error rates at a fixed iteration budget, and then we
examined the dependence on the iteration budget at a fixed physical
error rate.
The window size was held fixed at $W = 5$ throughout, the value at
which the warm-start variant produced the strongest performance in the
previous experiments.

\begin{figure}[t]
    \centering
    \begin{subfigure}{0.48\textwidth}
        \centering
        \hspace*{-7mm}
        \begin{tikzpicture}
            \begin{axis}[
                    width=8cm,
                    height=6cm,
                    ymode=log,
                    legend style={
                        cells={anchor=west},
                        cells={align=left},
                    },
                    enlargelimits=false,
                    ymin=1e-5, ymax=2e-1,
                    grid=both,
                    legend pos = south east,
                    xtick={0.001,0.0015,...,0.004},
                    xticklabel style={/pgf/number format/fixed},
                    xticklabel style={/pgf/number format/precision=4},
                    x tick label style={rotate=45, anchor=north east,
                    inner sep=1mm},
                    scaled x ticks=false,
                    xlabel={Physical error rate},
                    ylabel={Per-round-LER},
                    % extra description/.code={
                    %     \node[rotate=90, anchor=south]
                    %     at ([xshift=10mm]current axis.east)
                    %     {Warm s. (---), Cold s. (- - -)};
                    % },
                ]

                \foreach \F/\col/\mark in
                {3/KITred/triangle,2/KITblue/diamond,1/KITorange/square} {
                    \edef\temp{\noexpand
                        \addplot+[
                            mark=\mark, densely dashed, mark
                            options={fill=\col},
                            \col, forget plot
                        ]
                        table[
                            col sep=comma, x=physical_p,
                            y=LER_per_round,
                        ]
                        {res/sim/WF/WindowingSyndromeMinSumDecoder/max_iter_200/pass_soft_info_False/F_\F/W_5/LERs.csv};
                    }
                    \temp
                }

                \foreach \F/\col/\mark in
                {3/KITred/triangle*,2/KITblue/diamond*,1/KITorange/square*} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, solid, mark
                        options={fill=\col}, \col]
                        table[
                            col sep=comma, x=physical_p,
                            y=LER_per_round,
                        ]
                        {res/sim/WF/WindowingSyndromeMinSumDecoder/max_iter_200/pass_soft_info_True/F_\F/W_5/LERs.csv};
                    }
                    \temp

                    \addlegendentryexpanded{$F = \F$}
                }
            \end{axis}
        \end{tikzpicture}

        \caption{\red{Lorem ipsum dolor sit amet, consectetur adipiscing
        elit, sed do eiusmod tempor incididunt}}
        \label{fig:bp_f_over_p}
    \end{subfigure}%
    \hfill%
    \begin{subfigure}{0.48\textwidth}
        \centering
        \hspace*{-27mm}
        \begin{tikzpicture}
            \def\spyxmin{32}
            \def\spyxmax{512}
            \def\spyymin{5e-3}
            \def\spyymax{5e-2}

            \newcommand{\plotcurvesb}{%
                \foreach \F/\col/\mark in
                {3/KITred/triangle,2/KITblue/diamond,1/KITorange/square} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, densely dashed,
                        forget plot, \col]
                        table[
                            col sep=comma, x=max_iter,
                            y=LER_per_round,
                        ]
                        {res/sim/max_iter/WindowingSyndromeMinSumDecoder/p_0.0025/pass_soft_info_False/F_\F/W_5/LERs.csv};
                    }
                    \temp
                }
                \foreach \F/\col/\mark in
                {3/KITred/triangle*,2/KITblue/diamond*,1/KITorange/square*} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, solid, mark
                        options={fill=\col}, \col, forget plot]
                        table[
                            col sep=comma, x=max_iter,
                            y=LER_per_round,
                        ]
                        {res/sim/max_iter/WindowingSyndromeMinSumDecoder/p_0.0025/pass_soft_info_True/F_\F/W_5/LERs.csv};
                    }
                    \temp
                }
            }

            \begin{axis}[
                    name=main,
                    width=8cm,
                    height=6cm,
                    ymode=log,
                    legend style={
                        cells={anchor=west},
                        cells={align=left},
                    },
                    enlargelimits=false,
                    ymin=1e-3, ymax=1e-1,
                    grid=both,
                    legend pos = north east,
                    xtick={32, 512, 1024, 1536, 2048, 2560, 3072, 3584, 4096},
                    xticklabels =
                    {$32$, $512$,$1{,}024$,,$2{,}048$,,$3{,}072$,,$4{,}096$},
                    xticklabel style={/pgf/number format/fixed},
                    xticklabel style={/pgf/number format/precision=4},
                    x tick label style={rotate=45, anchor=north east,
                    inner sep=1mm},
                    scaled x ticks=false,
                    xlabel={Number of BP iterations},
                    extra description/.code={
                        \node[rotate=90, anchor=south]
                        at ([xshift=10mm]current axis.east)
                        {Warm s. (---), Cold s. (- - -)};
                    },
                ]

                \plotcurvesb

                \addlegendimage{KITorange, mark=square*}
                \addlegendentry{$F = 1$}
                \addlegendimage{KITblue, mark=diamond*}
                \addlegendentry{$F = 2$}
                \addlegendimage{KITred, mark=triangle*}
                \addlegendentry{$F = 3$}

                \node[draw=black, fit={(axis cs:\spyxmin,\spyymin) (axis
                cs:\spyxmax,\spyymax)}, inner sep=0pt, name=spybox] {};
            \end{axis}

            \begin{axis}[
                    name=inset,
                    at={(main.north west)},
                    anchor=south,
                    xshift=-6mm, yshift=6mm,
                    width=6.5cm, height=4.875cm,
                    ymode=log,
                    enlargelimits=false,
                    xmin=\spyxmin, xmax=\spyxmax,
                    ymin=\spyymin, ymax=\spyymax,
                    xtick={32,128,256,512},
                    yticklabels={\empty},
                    xticklabels={\empty},
                    grid=both,
                    axis background/.style={fill=white},
                ]

                \plotcurvesb
            \end{axis}

            \draw (spybox.north east) -- (inset.south east);
        \end{tikzpicture}
        \vspace{-3.2mm}

        \caption{\red{Lorem ipsum dolor sit amet, consectetur adipiscing
        elit, sed do eiusmod tempor incididunt}}
        \label{fig:bp_f_over_iter}
    \end{subfigure}

    \caption{
        \red{\lipsum[2]}
    }
    \label{fig:bp_f}
\end{figure}

% [Experimental parameters] Figure 4.9

\Cref{fig:bp_f} summarizes the results of this investigation.
In both panels the dashed colored curves correspond to cold-start
sliding-window decoding for $F \in \{1, 2, 3\}$ and the solid colored
curves to the corresponding warm-start runs.
The window size is fixed to $W = 5$ throughout.
\Cref{fig:bp_f_over_p} sweeps the physical error rate over
$p \in [0.001, 0.004]$ in steps of $0.0005$ at a fixed maximum of
$n_\text{iter} = 200$ \ac{bp} iterations per window invocation,
mirroring the experimental setup of \Cref{fig:whole_vs_cold_vs_warm}.
\Cref{fig:bp_f_over_iter} fixes the physical error rate at
$p = 0.0025$ and sweeps the iteration budget over
$n_\text{iter} \in \{32, 128, 256, 512, 1024, 2048, 4096\}$,
mirroring the setup of \Cref{fig:bp_w_over_iter} and again including
an inset that magnifies the low-iteration regime
$n_\text{iter} \in [32, 512]$.

% [Description] Figure 4.9

In \Cref{fig:bp_f_over_p}, every curve exhibits the expected
monotonic increase of the per-round \ac{ler} with the physical
error rate.
At fixed $F$, the warm-start approach lies below
cold-start across the entire sweep, and at fixed
warm- or cold-start, smaller $F$ produces a lower \ac{ler}.
Both gaps grow as the physical error rate decreases:
the curves at $F = 1$ separate further from those at $F = 2$ and $F = 3$,
and the warm-start curves separate further from the cold-start ones.
In \Cref{fig:bp_f_over_iter}, all six curves again decrease
monotonically with the iteration budget, with no clear saturation
even at $n_\text{iter} = 4096$.
Lower $F$ yields a lower \ac{ler} throughout, and warm-start
consistently outperforms cold-start at matching $F$.
At $n_\text{iter} = 32$, all three cold-start curves coincide at
roughly the same per-round \ac{ler}, while the warm-start curves are
visibly spread out.
Furthermore, the magnified plot confirms that the gap between warm-
and cold-start curves at fixed $F$ shrinks as $n_\text{iter}$ grows,
and that at fixed $n_\text{iter}$ this gap is largest for $F = 1$.

% [Interpretation] Figure 4.9

The observed dependence on the step size mirrors the dependence on
the window size studied earlier and the same explanation applies.
With $W$ held fixed, decreasing $F$ enlarges the overlap between
consecutive windows from $W - F$ to $W - F + 1$ syndrome measurement rounds, so
a smaller step size is beneficial for the same reason that a larger
window size is:
each \ac{vn} in an overlap region participates in more window
invocations, and the warm-start modification effectively accumulates
iterations on it across these invocations.
The widening of the warm/cold gap towards low iteration counts and
low physical error rates similarly mirrors the patterns already
observed in
\Cref{fig:whole_vs_cold_vs_warm,fig:bp_w_over_iter}.

In contrast to the window size $W$, the step size $F$ has no effect
on decoding latency.
The time at which the inner decoder for a given window can begin
decoding is determined solely by when the syndromes for the rounds
covered by that window have been collected, which is independent of
how much the window overlaps with its predecessor.
Similarly, assuming the decoder is fast enough to keep up with the
incoming syndrome measurements corresponding to the \acp{cn} of
subsequent windows, the time at which decoding is complete depends only
on the amount of time spent on decoding the very last window.
A smaller $F$ thus only costs additional total compute and not
additional latency, which is favorable for a warm-start
sliding-window implementation.
This is especially favorable for our warm-start modification, as it
works best where the overlap is largest, i.e., for low values of $F$.

% Conclusion of BP investigation

We conclude our investigation into the performance of warm-start
sliding-window decoding under plain \ac{bp} by summarizing our findings.
The warm-start modification raises the number of \ac{bp} iterations
effectively spent on the \acp{vn} in an overlap region by reusing the
messages from the previous window invocation instead of restarting
from scratch.
This explains why decoding performance improved monotonically with
the size of the overlap, and consequently why both larger window
sizes $W$ and smaller step sizes $F$ yielded lower per-round \acp{ler}.
The warm-start gain over cold-start was most pronounced at low
per-window iteration budgets,
% and at low physical error rates, the
% regimes
the regime in which each additional iteration carries proportionally
more information.
Additionally, we would like to note that the warm-start modification
incurs no computational cost relative to cold-start decoding.
It changes neither the decoding latency nor the total compute, since
both schemes process the same windows for the same number of
iterations and differ only in the initialization of the \ac{bp}
messages of each new window.
We also observed that plain \ac{bp} did not saturate even at $4096$
iterations, which we attribute to the short cycles in the underlying
Tanner graph.
This motivates the next subsection, in which we replace the inner
\ac{bp} decoder by its guided-decimation variant.

%%%%%%%%%%%%%%%%
\subsection{Belief Propagation with Guided Decimation}
\label{subsec:Belief Propagation with Guided Decimation}

% [Thread] Intro to BPGD + Local experimental setup

We now turn to \ac{bpgd} as the inner decoder, in order to address
the convergence issues of plain \ac{bp} on \ac{qec} codes.
For the underlying \ac{bp} step we use the \ac{spa} variant rather
than the min-sum approximation employed in
\Cref{subsec:Belief Propagation}, since this made the implementation
of the guided decimation more straightforward.
Furthermore, we set $T=1$, as this eases the
computational requirements and \cite{yao_belief_2024} showed that most of
the gain can be achieved even for low values of $T$.

\begin{figure}[t]
    \centering
    \hspace*{-6mm}
    \begin{subfigure}{0.5\textwidth}
        \centering
        \begin{tikzpicture}
            \begin{axis}[
                    width=8cm,
                    height=6cm,
                    ymode=log,
                    legend style={
                        cells={anchor=west},
                        cells={align=left},
                    },
                    enlargelimits=false,
                    ymin=1e-5, ymax=2e-1,
                    grid=both,
                    legend pos = south east,
                    xtick={0.001,0.0015,...,0.004},
                    xticklabel style={/pgf/number format/fixed},
                    xticklabel style={/pgf/number format/precision=4},
                    x tick label style={rotate=45, anchor=north east,
                    inner sep=1mm},
                    scaled x ticks=false,
                    xlabel={Physical error rate},
                    ylabel={Per-round-LER},
                    % extra description/.code={
                    %     \node[rotate=90, anchor=south]
                    %     at ()
                    %     {Warm s. (---), Cold s. (- - -)};
                    % },
                ]

                \foreach \W/\col/\mark in
                {3/KITred/triangle,4/KITblue/diamond,5/KITorange/square} {
                    \edef\temp{\noexpand
                        \addplot+[
                            mark=\mark, densely dashed, mark
                            options={fill=\col},
                            \col, forget plot
                        ]
                        table[
                            col sep=comma, x=physical_p,
                            y=LER_per_round,
                        ]
                        {res/sim/WF/WindowingSyndromeSpaGdDecoder/max_iter_5000/pass_soft_info_False/F_1/W_\W/LERs.csv};
                    }
                    \temp
                }

                \foreach \W/\col/\mark in
                {3/KITred/triangle*,4/KITblue/diamond*,5/KITorange/square*} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, solid, mark
                        options={fill=\col}, \col]
                        table[
                            col sep=comma, x=physical_p,
                            y=LER_per_round,
                        ]
                        {res/sim/WF/WindowingSyndromeSpaGdDecoderPassDecimation/max_iter_5000/pass_soft_info_True/F_1/W_\W/LERs.csv};
                    }
                    \temp

                    \addlegendentryexpanded{$W = \W$}
                }
            \end{axis}
        \end{tikzpicture}

        \caption{\red{Lorem ipsum dolor sit amet, consectetur adipiscing
        elit, sed do eiusmod tempor incididunt}}
        \label{fig:bpgd_w}
    \end{subfigure}%
    \hfill%
    \begin{subfigure}{0.5\textwidth}
        \centering
        \begin{tikzpicture}
            \begin{axis}[
                    width=8cm,
                    height=6cm,
                    ymode=log,
                    legend style={
                        cells={anchor=west},
                        cells={align=left},
                    },
                    enlargelimits=false,
                    ymin=1e-5, ymax=2e-1,
                    grid=both,
                    legend pos = south east,
                    xtick={0.001,0.0015,0.002,...,0.004},
                    xticklabel style={/pgf/number format/fixed},
                    xticklabel style={/pgf/number format/precision=4},
                    x tick label style={rotate=45, anchor=north east,
                    inner sep=1mm},
                    scaled x ticks=false,
                    xlabel={Physical error rate},
                    yticklabels={\empty},
                    % ylabel={Per-round-LER},
                    extra description/.code={
                        \node[rotate=90, anchor=south]
                        at ([xshift=10mm]current axis.east)
                        {Warm s. (---), Cold s. (- - -)};
                    },
                ]

                \foreach \F/\col/\mark in
                {3/KITred/triangle,2/KITblue/diamond,1/KITorange/square} {
                    \edef\temp{\noexpand
                        \addplot+[
                            mark=\mark, densely dashed, mark
                            options={fill=\col},
                            \col, forget plot
                        ]
                        table[
                            col sep=comma, x=physical_p,
                            y=LER_per_round,
                        ]
                        {res/sim/WF/WindowingSyndromeSpaGdDecoder/max_iter_5000/pass_soft_info_False/F_\F/W_5/LERs.csv};
                    }
                    \temp
                }

                \foreach \F/\col/\mark in
                {3/KITred/triangle*,2/KITblue/diamond*,1/KITorange/square*} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, solid, mark
                        options={fill=\col}, \col]
                        table[
                            col sep=comma, x=physical_p,
                            y=LER_per_round,
                        ]
                        {res/sim/WF/WindowingSyndromeSpaGdDecoderPassDecimation/max_iter_5000/pass_soft_info_True/F_\F/W_5/LERs.csv};
                    }
                    \temp

                    \addlegendentryexpanded{$F = \F$}
                }
            \end{axis}
        \end{tikzpicture}

        \caption{\red{Lorem ipsum dolor sit amet, consectetur adipiscing
        elit, sed do eiusmod tempor incididunt}}
        \label{fig:bpgd_f}
    \end{subfigure}

    \caption{
        \red{\lipsum[2]}
    }
    \label{fig:bpgd_wf}
\end{figure}

% [Experimental parameters] Figure 4.10

\Cref{fig:bpgd_wf} shows the per-round \ac{ler} of \ac{bpgd}
sliding-window decoding as a function of the physical error rate.
In both panels the dashed curves correspond to cold-start
sliding-window decoding and the solid curves to the
corresponding warm-start decoding, where the warm start carries over both
the \ac{bp} messages and the decimation information of the overlap
region as described in
\Cref{subsec:Warm-Start Belief Propagation with Guided Decimation Decoding}.
The maximum number of inner \ac{bp} iterations was set to
$n_\text{iter} = 5000$.
This value was chosen to be at least as large as the number of
\acp{vn} in any single window, since with one \ac{bp} iteration
between consecutive decimations ($T = 1$ in the notation of
\Cref{alg:bpgd}) this is the maximum number of inner iterations
that can occur before every \ac{vn} in the window has been decimated.
A preliminary investigation showed that \ac{bpgd} only delivers its
intended performance gain once most \acp{vn} have actually been decimated,
which motivated this choice.
The physical error rate was swept from $p = 0.001$ to $p = 0.004$
in steps of $0.0005$.
\Cref{fig:bpgd_w} sweeps over the window size with
$W \in \{3, 4, 5\}$ at fixed step size $F = 1$, and
\Cref{fig:bpgd_f} sweeps over the step size with
$F \in \{1, 2, 3\}$ at fixed window size $W = 5$.

% [Description] Figure 4.10

In both panels, every curve again exhibits the expected monotonic
increase of the per-round \ac{ler} with the physical error rate.
Across both panels and across all parameter choices, the warm-start
curves lie above the corresponding cold-start curves, i.e.,
the warm-start variant performsworse than its cold-start counterpart.
This is the opposite of what we observed for plain \ac{bp}, where
warm-start improved upon cold-start at every parameter setting.
The gap between the warm- and cold-start curves additionally widens
as the physical error rate decreases:
at the lowest sampled rate $p = 0.001$, the per-round \ac{ler} of the
warm-start runs is more than two orders of magnitude above that of
the corresponding cold-start runs.
In \Cref{fig:bpgd_w}, larger window sizes yield lower per-round
\acp{ler} for both warm- and cold-start, and the spacing between the
cold-start curves shrinks as $W$ grows.
In \Cref{fig:bpgd_f}, the cold-start curves follow the previously seen
ordering with $F = 1$ at the bottom and $F = 3$ at the top.
The warm-start curves, however, exhibit the opposite ordering:
$F = 1$ now yields the highest per-round \ac{ler}, $F = 2$ lies below
it, and $F = 3$ is the lowest of the three warm-start curves.

% [Interpretation] Figure 4.10

The fact that warm-start sliding-window decoding now performs worse
than its cold-start counterpart is surprising in light of the results
for plain \ac{bp}, where the warm-start modification was uniformly beneficial.
The dependence on the window size in \Cref{fig:bpgd_w} is, on its own,
consistent with the same explanation that we gave for
\Cref{fig:whole_vs_cold}: larger windows expose the inner decoder to
a larger fraction of the constraints encoded in the detector error
matrix at the time of decoding, and this benefits both warm- and
cold-start decoding.
The dependence on the step size in \Cref{fig:bpgd_f}, however, is the
opposite of the corresponding dependence under plain \ac{bp}
(\Cref{fig:bp_f_over_p}): for warm-start, smaller $F$ now hurts
rather than helps, even though smaller $F$ implies a larger overlap
in both cases.

This inversion provides a clue to what is going wrong.
Recall from
\Cref{subsec:Warm-Start Belief Propagation with Guided Decimation Decoding}
that the warm start for \ac{bpgd} carries over not only the \ac{bp}
messages on the edges of the overlap region but also the decimation
information.
Because we run with an iteration budget large enough to decimate
every \ac{vn} in a window, by the time window $\ell$ ends, all
of its \acp{vn} have already been hard-decided.
For the \acp{vn} that lie in the overlap region with window $\ell + 1$
this hard decision is then carried into the next window through the
warm-start initialization, and the next window thus begins decoding
with a substantial fraction of its \acp{vn} already frozen, before
its own parity checks have had any chance to influence the
corresponding bit estimates.
This identifies one of two competing effects on the warm-start performance.
The larger the overlap, the more such prematurely frozen \acp{vn} the
next window inherits, which hurts performance.
On the other hand, a larger window still exposes the inner decoder to
a larger set of constraints, which helps performance.
The two effects together are consistent with what we observe in
\Cref{fig:bpgd_wf}.
Increasing $W$ at fixed $F$ enlarges both the overlap and the window
itself, and the benefit due to the larger $W$ dominates.
Decreasing $F$ at fixed $W$, by contrast, enlarges only the overlap
without enlarging the window, so the freezing effect is no longer
offset and warm-start performance worsens with smaller $F$.

% [Thread] Test hypothesis by carying number of iterations

The hypothesis from the previous paragraph is straightforward to test.
If the warm-start regression in \Cref{fig:bpgd_wf} is indeed caused by
the decimation state being carried across the window boundary, then
reducing the maximum number of inner \ac{bp} iterations
$n_\text{iter}$ should reduce the maximum number of \acp{vn} that can
be decimated before window $\ell$ commits, and the warm-start
performance should approach that of warm-start under plain \ac{bp} as
$n_\text{iter}$ is lowered.
We therefore now vary $n_\text{iter}$ at fixed window parameters and
fixed physical error rate.

\begin{figure}[t]
    \centering
    \hspace*{-6mm}
    \begin{subfigure}{0.48\textwidth}
        \centering
        \begin{tikzpicture}
            \begin{axis}[
                    width=8cm,
                    height=6cm,
                    ymode=log,
                    % xmode=log,
                    legend style={
                        cells={anchor=west},
                        cells={align=left},
                    },
                    enlargelimits=false,
                    ymin=1e-3, ymax=1e-1,
                    grid=both,
                    legend pos = south west,
                    xtick={32,512,1024,2048,4096},
                    % xtick={0.001,0.0015,...,0.004},
                    xticklabels =
                    {$32$,$512$,$1{,}024$,,$2{,}048$,,$3{,}072$,,$4{,}096$},
                    xtick={32, 512, 1024, 1536, 2048, 2560, 3072, 3584, 4096},
                    xticklabel style={/pgf/number format/fixed},
                    xticklabel style={/pgf/number format/precision=4},
                    x tick label style={rotate=45, anchor=north east,
                    inner sep=1mm},
                    scaled x ticks=false,
                    xlabel={Number of BP iterations},
                    ylabel={Per-round-LER},
                    % extra description/.code={
                    %     \node[rotate=90, anchor=south]
                    %     at ([xshift=10mm]current axis.east)
                    %     {Warm s. (---), Cold s. (- - -)};
                    % },
                ]

                \foreach \W/\col/\mark in
                {3/KITred/triangle,4/KITblue/diamond,5/KITorange/square} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, densely dashed,
                        forget plot, \col]
                        table[
                            col sep=comma, x=max_iter,
                            y=LER_per_round,
                        ]
                        {res/sim/max_iter/WindowingSyndromeSpaGdDecoderPassDecimation/p_0.0025/pass_soft_info_False/F_1/W_\W/LERs.csv};
                    }
                    \temp
                }

                \foreach \W/\col/\mark in
                {3/KITred/triangle*,4/KITblue/diamond*,5/KITorange/square*} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, solid, mark
                        options={fill=\col}, \col]
                        table[
                            col sep=comma, x=max_iter,
                            y=LER_per_round,
                        ]
                        {res/sim/max_iter/WindowingSyndromeSpaGdDecoderPassDecimation/p_0.0025/pass_soft_info_True/F_1/W_\W/LERs.csv};
                    }
                    \temp

                    \addlegendentryexpanded{$W = \W$}
                }
            \end{axis}
        \end{tikzpicture}

        \caption{\red{Lorem ipsum dolor sit amet, consectetur adipiscing
        elit, sed do eiusmod tempor incididunt}}
        \label{fig:bpgd_iter_W}
    \end{subfigure}%
    \hfill%
    \begin{subfigure}{0.48\textwidth}
        \centering
        \begin{tikzpicture}
            \begin{axis}[
                    width=8cm,
                    height=6cm,
                    ymode=log,
                    % xmode=log,
                    legend style={
                        cells={anchor=west},
                        cells={align=left},
                    },
                    enlargelimits=false,
                    ymin=1e-3, ymax=1e-1,
                    grid=both,
                    legend pos = south west,
                    xtick={32,512,1024,2048,4096},
                    % xtick={0.001,0.0015,...,0.004},
                    xticklabels =
                    {$32$,$512$,$1{,}024$,,$2{,}048$,,$3{,}072$,,$4{,}096$},
                    xtick={32, 512, 1024, 1536, 2048, 2560, 3072, 3584, 4096},
                    xticklabel style={/pgf/number format/fixed},
                    xticklabel style={/pgf/number format/precision=4},
                    x tick label style={rotate=45, anchor=north east,
                    inner sep=1mm},
                    scaled x ticks=false,
                    xlabel={Number of BP iterations},
                    % ylabel={Per-round-LER},
                    yticklabels={\empty},
                    extra description/.code={
                        \node[rotate=90, anchor=south]
                        at ([xshift=10mm]current axis.east)
                        {Warm s. (---), Cold s. (- - -)};
                    },
                ]

                \foreach \F/\col/\mark in
                {3/KITred/triangle,2/KITblue/diamond,1/KITorange/square} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, densely dashed,
                        forget plot, \col]
                        table[
                            col sep=comma, x=max_iter,
                            y=LER_per_round,
                        ]
                        {res/sim/max_iter/WindowingSyndromeSpaGdDecoderPassDecimation/p_0.0025/pass_soft_info_False/F_\F/W_5/LERs.csv};
                    }
                    \temp
                }

                \foreach \F/\col/\mark in
                {3/KITred/triangle*,2/KITblue/diamond*,1/KITorange/square*} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, solid, mark
                        options={fill=\col}, \col]
                        table[
                            col sep=comma, x=max_iter,
                            y=LER_per_round,
                        ]
                        {res/sim/max_iter/WindowingSyndromeSpaGdDecoderPassDecimation/p_0.0025/pass_soft_info_True/F_\F/W_5/LERs.csv};
                    }
                    \temp

                    \addlegendentryexpanded{$F = \F$}
                }
            \end{axis}
        \end{tikzpicture}

        \caption{\red{Lorem ipsum dolor sit amet, consectetur adipiscing
        elit, sed do eiusmod tempor incididunt}}
        \label{fig:bpgd_iter_F}
    \end{subfigure}

    \caption{
        \red{\lipsum[2]}
    }
    \label{fig:bpgd_iter}
\end{figure}

% [Experimental parameters] Figure 4.11

\Cref{fig:bpgd_iter} shows the per-round \ac{ler} of \ac{bpgd}
sliding-window decoding as a function of the maximum number of inner
\ac{bp} iterations $n_\text{iter}$.
The dashed colored curves correspond to cold-start sliding-window
decoding and the solid colored curves to warm-start, again carrying
over both the \ac{bp} messages and the channel \acp{llr} on the
overlap region.
The physical error rate is fixed at $p = 0.0025$ and the iteration
budget is swept over $n_\text{iter} \in \{32, 128, 256, 512, 1024,
1536, 2048, 2560, 3072, 3584, 4096\}$.
\Cref{fig:bpgd_iter_W} sweeps over the window size with
$W \in \{3, 4, 5\}$ at fixed step size $F = 1$, and
\Cref{fig:bpgd_iter_F} sweeps over the step size with
$F \in \{1, 2, 3\}$ at fixed window size $W = 5$.

% [Description] Figure 4.11

For low iteration budgets, all curves in both panels behave similarly
to the plain-\ac{bp} curves in
\Cref{fig:bp_w_over_iter,fig:bp_f_over_iter}.
The per-round \ac{ler} decreases gradually with $n_\text{iter}$, and
the warm-start curves lie below their cold-start counterparts at
matching window parameters.
As $n_\text{iter}$ continues to grow, however, the cold-start curves
undergo a sharp drop, after which they lie roughly an order of
magnitude below the warm-start curves, and eventually settle into a
flat plateau.
The warm-start curves first reach a minimum at an intermediate
iteration count, then turn upwards, and finally also approach a
plateau, albeit at a substantially higher per-round \ac{ler}.
The warm-start curves are also less smooth than the cold-start ones
at certain points.

In \Cref{fig:bpgd_iter_W}, the iteration count at which the
cold-start curves drop sharply increases with the window size, from
roughly $n_\text{iter} \approx 2000$ for $W = 3$, to
$\approx 2500$ for $W = 4$, to $\approx 3000$ for $W = 5$.
The corresponding warm-start curves reach their minima at
approximately the same iteration counts, and from there onwards begin
to worsen.
At the largest sampled iteration budget, the cold-start curves have
plateaued at per-round \acp{ler} of order $10^{-3}$ while the
warm-start curves have grown to per-round \acp{ler} above
$4 \times 10^{-2}$.
In \Cref{fig:bpgd_iter_F}, the cold-start curves drop sharply at
roughly the same iteration count for all three step sizes, while
the warm-start curves now show a clear reordering as $n_\text{iter}$
grows.
At low iteration budgets the warm-start ordering matches the
cold-start ordering, with $F = 1$ best and $F = 3$ worst, but at the
largest iteration budget this ordering is fully inverted: warm-start
$F = 1$ is now the worst and $F = 3$ the best.

% [Interpretation] Figure 4.11

The cold-start behavior matches the preliminary investigation that
motivated our choice of $n_\text{iter} = 5000$ in \Cref{fig:bpgd_wf}.
At low iteration budgets the inner decoder has not yet had time to
decimate a substantial fraction of the \acp{vn}, so its behavior
remains close to that of plain \ac{bp}.
Once the iteration budget is large enough for the decimation effects
to become pronounced, the per-round \ac{ler} drops sharply and
\ac{bpgd} delivers its intended performance gain.
Once every \ac{vn} in a window has been decimated, no further
iterations can change the outcome, which is why each cold-start curve
reaches a flat plateau.

The warm-start curves exhibit the same two regimes, but with the
opposite outcome in the second one, which is exactly what our earlier
hypothesis  predicts.
At low $n_\text{iter}$, decimation has not yet taken hold and the
warm-start initialization carries forward only the \ac{bp} messages
in any meaningful sense, so the warm-start variant outperforms its
cold-start counterpart for the same reason as in the plain-\ac{bp}
investigation.
As $n_\text{iter}$ grows past the point where decimation begins to
matter, the decimation information carried over starts to impede the
decoding performance.

The same mechanism explains the inversion of the step-size ordering
in \Cref{fig:bpgd_iter_F}.
At low iteration budgets, the ordering is set by the same overlap
argument as for plain \ac{bp}: smaller $F$ implies a larger overlap
between consecutive windows, more shared messages, and therefore
better warm-start performance.
At large iteration budgets, the ordering is set by the premature hard
decisions of the \acp{vn}.
We do not have a definitive explanation for the roughness visible in some
of the warm-start curves and limit ourselves to noting it.

% [Thread] Turn to previous way of warm-start

The natural consequence of the previous diagnosis is to drop the
problematic part of the warm-start initialization for \ac{bpgd} and
to carry over only the \ac{bp} messages on the edges of the overlap
region, as in \Cref{fig:messages_tanner}, while leaving the channel
\acp{llr} of the next window in their original cold-start state.
Note that some information about the previous window's decimation
state is still implicitly carried over through the \ac{bp} messages,
since the decimation decisions were made based on the messages themselves.

\begin{figure}[t]
    \centering
    \hspace*{-6mm}
    \begin{subfigure}{0.5\textwidth}
        \centering
        \begin{tikzpicture}
            \begin{axis}[
                    width=8cm,
                    height=6cm,
                    ymode=log,
                    legend style={
                        cells={anchor=west},
                        cells={align=left},
                    },
                    enlargelimits=false,
                    ymin=1e-5, ymax=2e-1,
                    grid=both,
                    legend pos = south east,
                    xtick={0.001,0.0015,...,0.004},
                    xticklabel style={/pgf/number format/fixed},
                    xticklabel style={/pgf/number format/precision=4},
                    x tick label style={rotate=45, anchor=north east,
                    inner sep=1mm},
                    scaled x ticks=false,
                    xlabel={Physical error rate},
                    ylabel={Per-round-LER},
                    % extra description/.code={
                    %     \node[rotate=90, anchor=south]
                    %     at ([xshift=10mm]current axis.east)
                    %     {Warm s. (---), Cold s. (- - -)};
                    % },
                ]

                \foreach \W/\col/\mark in
                {3/KITred/triangle,4/KITblue/diamond,5/KITorange/square} {
                    \edef\temp{\noexpand
                        \addplot+[
                            mark=\mark, densely dashed, mark
                            options={fill=\col},
                            \col, forget plot
                        ]
                        table[
                            col sep=comma, x=physical_p,
                            y=LER_per_round,
                        ]
                        {res/sim/WF/WindowingSyndromeSpaGdDecoder/max_iter_5000/pass_soft_info_False/F_1/W_\W/LERs.csv};
                    }
                    \temp
                }

                \foreach \W/\col/\mark in
                {3/KITred/triangle*,4/KITblue/diamond*,5/KITorange/square*} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, solid, mark
                        options={fill=\col}, \col]
                        table[
                            col sep=comma, x=physical_p,
                            y=LER_per_round,
                        ]
                        {res/sim/WF/WindowingSyndromeSpaGdDecoder/max_iter_5000/pass_soft_info_True/F_1/W_\W/LERs.csv};
                    }
                    \temp

                    \addlegendentryexpanded{$W = \W$}
                }
            \end{axis}
        \end{tikzpicture}

        \caption{\red{Lorem ipsum dolor sit amet, consectetur adipiscing
        elit, sed do eiusmod tempor incididunt}}
        \label{fig:bpgd_msg_W}
    \end{subfigure}%
    \hfill%
    \begin{subfigure}{0.5\textwidth}
        \centering
        \begin{tikzpicture}
            \begin{axis}[
                    width=8cm,
                    height=6cm,
                    ymode=log,
                    legend style={
                        cells={anchor=west},
                        cells={align=left},
                    },
                    enlargelimits=false,
                    ymin=1e-5, ymax=2e-1,
                    grid=both,
                    legend pos = south east,
                    xtick={0.001,0.0015,0.002,...,0.004},
                    xticklabel style={/pgf/number format/fixed},
                    xticklabel style={/pgf/number format/precision=4},
                    x tick label style={rotate=45, anchor=north east,
                    inner sep=1mm},
                    scaled x ticks=false,
                    xlabel={Physical error rate},
                    yticklabels={\empty},
                    % ylabel={Per-round-LER},
                    extra description/.code={
                        \node[rotate=90, anchor=south]
                        at ([xshift=10mm]current axis.east)
                        {Warm s. (---), Cold s. (- - -)};
                    },
                ]

                \foreach \F/\col/\mark in
                {3/KITred/triangle,2/KITblue/diamond,1/KITorange/square} {
                    \edef\temp{\noexpand
                        \addplot+[
                            mark=\mark, densely dashed, mark
                            options={fill=\col},
                            \col, forget plot
                        ]
                        table[
                            col sep=comma, x=physical_p,
                            y=LER_per_round,
                        ]
                        {res/sim/WF/WindowingSyndromeSpaGdDecoder/max_iter_5000/pass_soft_info_False/F_\F/W_5/LERs.csv};
                    }
                    \temp
                }

                \foreach \F/\col/\mark in
                {3/KITred/triangle*,2/KITblue/diamond*,1/KITorange/square*} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, solid, mark
                        options={fill=\col}, \col]
                        table[
                            col sep=comma, x=physical_p,
                            y=LER_per_round,
                        ]
                        {res/sim/WF/WindowingSyndromeSpaGdDecoder/max_iter_5000/pass_soft_info_True/F_\F/W_5/LERs.csv};
                    }
                    \temp

                    \addlegendentryexpanded{$F = \F$}
                }
            \end{axis}
        \end{tikzpicture}

        \caption{\red{Lorem ipsum dolor sit amet, consectetur adipiscing
        elit, sed do eiusmod tempor incididunt}}
        \label{fig:bpgd_msg_F}
    \end{subfigure}

    \caption{
        \red{\lipsum[2]}
    }
    \label{fig:bpgd_msg}
\end{figure}

% [Experimental parameters] Figure 4.12

\Cref{fig:bpgd_msg} repeats the experiment of \Cref{fig:bpgd_wf}
with the modified warm-start procedure that carries over only the
\ac{bp} messages.
All other experimental parameters are unchanged: the maximum number
of inner \ac{bp} iterations is $n_\text{iter} = 5000$, and the
physical error rate is swept from $p = 0.001$ to $p = 0.004$ in steps
of $0.0005$.
The cold-start curves (dashed) are identical to those in
\Cref{fig:bpgd_wf}.
The warm-start curves are shown with solid lines.
\Cref{fig:bpgd_msg_W} sweeps over the window size with
$W \in \{3, 4, 5\}$ at fixed step size $F = 1$, and
\Cref{fig:bpgd_msg_F} sweeps over the step size with
$F \in \{1, 2, 3\}$ at fixed window size $W = 5$.

% [Description] Figure 4.12

The warm-start curves now lie below their cold-start counterparts
across both panels and across the entire physical error rate range,
in contrast to \Cref{fig:bpgd_wf}.
In \Cref{fig:bpgd_msg_W}, larger window sizes again yield lower
per-round \acp{ler} for both warm- and cold-start, and the warm-start
advantage over cold-start is more pronounced for $W \in \{4, 5\}$
than for $W = 3$, where the warm- and cold-start curves nearly coincide.
In \Cref{fig:bpgd_msg_F}, smaller step sizes again yield lower
per-round \acp{ler} for both warm- and cold-start, and the warm-start
advantage over cold-start is most pronounced for $F = 1$ and shrinks
as $F$ grows.

% [Description] Interpretation 4.12

Removing the channel \acp{llr} from the warm-start initialization lifts
the warm-start regression observed in \Cref{fig:bpgd_wf},
and warm-start now consistently outperforms cold-start.
The dependence on the window size and the step size also recovers
the qualitative behavior we observed for plain \ac{bp} in
\Cref{fig:whole_vs_cold_vs_warm,fig:bp_f_over_p}: a larger overlap
between consecutive windows, achieved either by enlarging $W$ or by
decreasing $F$, both improves the absolute decoding performance and
increases the warm-start advantage over cold-start.
This is consistent with the original effective-iterations picture.
Without the premature hard decisions from carried-over decimation
information, the warm-start initialization once again amounts to
additional \ac{bp} iterations on the \acp{vn} of the overlap region,
and the larger the overlap, the more such effective iterations are gained.

% [Thread] As before, view max iter behavior

Finally, we repeat the iteration-budget sweep of \Cref{fig:bpgd_iter}
with the message-only warm-start procedure.
This serves both to verify that the premature hard decision effect
does not reappear at any iteration count and to compare the warm- and
cold-start curves across the entire range of $n_\text{iter}$ available to us.

\begin{figure}[t]
    \centering
    \hspace*{-6mm}
    \begin{subfigure}{0.48\textwidth}
        \centering
        \begin{tikzpicture}
            \begin{axis}[
                    width=8cm,
                    height=6cm,
                    ymode=log,
                    % xmode=log,
                    legend style={
                        cells={anchor=west},
                        cells={align=left},
                    },
                    enlargelimits=false,
                    ymin=1e-3, ymax=1e-1,
                    grid=both,
                    legend pos = north east,
                    xtick={32,512,1024,2048,4096},
                    % xtick={0.001,0.0015,...,0.004},
                    xticklabels =
                    {$32$,$512$,$1{,}024$,,$2{,}048$,,$3{,}072$,,$4{,}096$},
                    xtick={32, 512, 1024, 1536, 2048, 2560, 3072, 3584, 4096},
                    xticklabel style={/pgf/number format/fixed},
                    xticklabel style={/pgf/number format/precision=4},
                    x tick label style={rotate=45, anchor=north east,
                    inner sep=1mm},
                    scaled x ticks=false,
                    xlabel={Number of BP iterations},
                    ylabel={Per-round-LER},
                    % extra description/.code={
                    %     \node[rotate=90, anchor=south]
                    %     at ([xshift=10mm]current axis.east)
                    %     {Warm s. (---), Cold s. (- - -)};
                    % },
                ]

                \foreach \W/\col/\mark in
                {3/KITred/triangle,4/KITblue/diamond,5/KITorange/square} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, densely dashed,
                        forget plot, \col]
                        table[
                            col sep=comma, x=max_iter,
                            y=LER_per_round,
                        ]
                        {res/sim/max_iter/WindowingSyndromeSpaGdDecoder/p_0.0025/pass_soft_info_False/F_1/W_\W/LERs.csv};
                    }
                    \temp
                }

                \foreach \W/\col/\mark in
                {3/KITred/triangle*,4/KITblue/diamond*,5/KITorange/square*} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, solid, mark
                        options={fill=\col}, \col]
                        table[
                            col sep=comma, x=max_iter,
                            y=LER_per_round,
                        ]
                        {res/sim/max_iter/WindowingSyndromeSpaGdDecoder/p_0.0025/pass_soft_info_True/F_1/W_\W/LERs.csv};
                    }
                    \temp

                    \addlegendentryexpanded{$W = \W$}
                }
            \end{axis}
        \end{tikzpicture}

        \caption{\red{Lorem ipsum dolor sit amet, consectetur adipiscing
        elit, sed do eiusmod tempor incididunt}}
        \label{fig:bpgd_msg_iter_W}
    \end{subfigure}%
    \hfill%
    \begin{subfigure}{0.48\textwidth}
        \centering
        \begin{tikzpicture}
            \begin{axis}[
                    width=8cm,
                    height=6cm,
                    ymode=log,
                    % xmode=log,
                    legend style={
                        cells={anchor=west},
                        cells={align=left},
                    },
                    enlargelimits=false,
                    ymin=1e-3, ymax=1e-1,
                    grid=both,
                    legend pos = north east,
                    xtick={32,512,1024,2048,4096},
                    % xtick={0.001,0.0015,...,0.004},
                    xticklabels =
                    {$32$,$512$,$1{,}024$,,$2{,}048$,,$3{,}072$,,$4{,}096$},
                    xtick={32, 512, 1024, 1536, 2048, 2560, 3072, 3584, 4096},
                    xticklabel style={/pgf/number format/fixed},
                    xticklabel style={/pgf/number format/precision=4},
                    x tick label style={rotate=45, anchor=north east,
                    inner sep=1mm},
                    scaled x ticks=false,
                    xlabel={Number of BP iterations},
                    % ylabel={Per-round-LER},
                    yticklabels={\empty},
                    extra description/.code={
                        \node[rotate=90, anchor=south]
                        at ([xshift=10mm]current axis.east)
                        {Warm s. (---), Cold s. (- - -)};
                    },
                ]

                \foreach \F/\col/\mark in
                {3/KITred/triangle,2/KITblue/diamond,1/KITorange/square} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, densely dashed,
                        forget plot, \col]
                        table[
                            col sep=comma, x=max_iter,
                            y=LER_per_round,
                        ]
                        {res/sim/max_iter/WindowingSyndromeSpaGdDecoder/p_0.0025/pass_soft_info_False/F_\F/W_5/LERs.csv};
                    }
                    \temp
                }

                \foreach \F/\col/\mark in
                {3/KITred/triangle*,2/KITblue/diamond*,1/KITorange/square*} {
                    \edef\temp{\noexpand
                        \addplot+[mark=\mark, solid, mark
                        options={fill=\col}, \col]
                        table[
                            col sep=comma, x=max_iter,
                            y=LER_per_round,
                        ]
                        {res/sim/max_iter/WindowingSyndromeSpaGdDecoder/p_0.0025/pass_soft_info_True/F_\F/W_5/LERs.csv};
                    }
                    \temp

                    \addlegendentryexpanded{$F = \F$}
                }
            \end{axis}
        \end{tikzpicture}

        \caption{\red{Lorem ipsum dolor sit amet, consectetur adipiscing
        elit, sed do eiusmod tempor incididunt}}
        \label{fig:bpgd_msg_iter_F}
    \end{subfigure}

    \caption{
        \red{\lipsum[2]}
    }
    \label{fig:bpgd_msg_iter}
\end{figure}

% [Experimental parameters] Figure 4.13

\Cref{fig:bpgd_msg_iter} repeats the experiment of
\Cref{fig:bpgd_iter} with the modified warm-start procedure that
carries over only the \ac{bp} messages.
All other experimental parameters are unchanged: the physical error
rate is fixed at $p = 0.0025$ and the iteration budget is swept over
$n_\text{iter} \in \{32, 128, 256, 512, 1024, 1536, 2048, 2560,
3072, 3584, 4096\}$.
The cold-start curves (dashed) are identical to those in
\Cref{fig:bpgd_iter}.
\Cref{fig:bpgd_msg_iter_W} sweeps over the window size with
$W \in \{3, 4, 5\}$ at fixed step size $F = 1$, and
\Cref{fig:bpgd_msg_iter_F} sweeps over the step size with
$F \in \{1, 2, 3\}$ at fixed window size $W = 5$.

% [Description] Figure 4.13

The warm-start curves now again lie consistently below their cold-start
counterparts across both panels and across the entire range of
$n_\text{iter}$, contrary to \Cref{fig:bpgd_iter}.
The warm-start curves furthermore track the overall shape of the
corresponding cold-start curves closely, including the iteration
count at which they drop sharply and the level at which they plateau.
The warm-start improvement over cold-start grows with the window size
in \Cref{fig:bpgd_msg_iter_W} and shrinks with the step size in
\Cref{fig:bpgd_msg_iter_F}, with the largest gap visible at $W = 5$
and at $F = 1$, respectively.

% [Interpretation] Figure 4.13

These observations match our expectations.
With only the \ac{bp} messages carried over, the warm-start
initialization no longer freezes any \acp{vn} in the next window
The dependence of this benefit on $W$ and $F$ also recovers the
pattern observed for plain \ac{bp} in
\Cref{fig:whole_vs_cold_vs_warm,fig:bp_f_over_p}:
larger overlap, achieved by larger $W$ or smaller $F$, yields more
effective extra iterations and therefore a larger warm-start gain.

% BPGD conclusion

We conclude our investigation into the performance of warm-start
sliding-window decoding under \ac{bpgd} by summarizing our findings.
Warm-starting the inner decoder still provides a consistent
performance gain when the inner decoder is upgraded from plain
\ac{bp} to its guided-decimation variant, but only if some care is
taken in choosing what to carry over.
Passing the channel \acp{llr} along with the \ac{bp} messages,
as suggested by naively carrying over the warm-start idea to \ac{bpgd},
leads to premature hard decisions on \acp{vn} in the overlap region.
This leads to warm-start initialization actually worsening the
performance compared to cold-start initialization.
Restricting the warm start to the \ac{bp} messages alone removes
this effect and recovers a consistent warm-start improvement over
cold-start that follows the same behavior as for plain \ac{bp} with
regard to overlap.
A second observation specific to \ac{bpgd} is that its iteration
requirements are substantially larger than those of plain \ac{bp}:
the per-round \ac{ler} drops sharply only once the iteration budget
is on the order of the number of \acp{vn} in each window.

