% Research discussion slides based on arXiv:2608.15533v1.
% Build: python3 build_slides.py slides.en.tex
% Adapted from the arxiv-paper-reader Beamer template.
\documentclass[aspectratio=169,11pt]{beamer}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage{amsmath,amssymb,graphicx,booktabs}

\definecolor{AcademicBlue}{RGB}{26,57,86}
\definecolor{AcademicTeal}{RGB}{0,105,112}
\setbeamercolor{structure}{fg=AcademicBlue}
\setbeamercolor{frametitle}{fg=AcademicBlue,bg=white}
\setbeamercolor{title}{fg=AcademicBlue}
\setbeamercolor{alerted text}{fg=AcademicTeal}
\setbeamercolor{block title}{fg=white,bg=AcademicBlue}
\setbeamercolor{block body}{fg=black,bg=AcademicBlue!5}
\setbeamertemplate{navigation symbols}{}
\setbeamertemplate{itemize items}[circle]
\setbeamertemplate{footline}{\hfill\usebeamerfont{page number in head/foot}\insertframenumber\,/\,\inserttotalframenumber\hspace{4mm}\vspace{3mm}}
\setbeamersize{text margin left=8mm,text margin right=8mm}
\setbeamerfont{frametitle}{size=\Large,series=\bfseries}
\setbeamerfont{title}{size=\LARGE,series=\bfseries}
\newcommand{\papersource}[1]{\par\smallskip{\scriptsize\color{gray}#1\par}}
\newcommand{\Klog}{K_{\mathrm{log}}}
\newcommand{\Ulog}{U_{\mathrm{log}}}
\newcommand{\Llog}{\Lambda_{\mathrm{log}}}
\newcommand{\state}{C_{\mathrm{state}}}
\newcommand{\entry}{C_{\mathrm{entry}}}
\newcommand{\decay}{C_{\mathrm{decay}}}
\newcommand{\logtraffic}{C_{\mathrm{log}}}

\title[DeltaLog]{DeltaLog}
\subtitle{Deferred Materialization of Recurrent States\\for Linear Attention Decoding}
\author{Paper authors: Junqing Lin, Jingwei Sun, Guangzhong Sun\\\small University of Science and Technology of China}
\date{Research discussion \enspace$\cdot$\enspace 10 October 2026\\\small arXiv:2608.15533v1 \enspace$\cdot$\enspace 22 main slides + 3 backup slides}

\begin{document}

\begin{frame}
  \titlepage
  \vspace{-5mm}
  \begin{center}
    \alert{Keep each logical state current; commit the dense state periodically.}\\[1mm]
    \scriptsize\url{https://arxiv.org/abs/2608.15533v1}
  \end{center}
\end{frame}

\begin{frame}{A fixed-size state can still dominate decoding}
  \begin{columns}[T,onlytextwidth]
    \begin{column}{0.57\textwidth}
      \includegraphics[width=\linewidth,height=4.4cm,keepaspectratio]{figures/fig-02-state-share.pdf}
      \papersource{Paper, Fig. 2, PDF p. 3. Qwen3.6-35B-A3B.}
    \end{column}
    \begin{column}{0.40\textwidth}
      \begin{block}{The state-update tax}
        Compact factors: $O(d_k+d_v)$\\[2mm]
        Dense commit: $O(d_kd_v)$
      \end{block}
      At 1k context, the materialization share grows from \alert{25.2\% to 44.6\%} as batch size grows from 64 to 256.
    \end{column}
  \end{columns}
  \medskip
  $B=512$, $H=32$, $d_k=d_v=128$, FP32: \textbf{1 GiB of state per layer}; about 2 GiB for one dense read and write.
  \papersource{Paper, Secs. 2.3--2.4, PDF pp. 3--4.}
\end{frame}

\begin{frame}{The update is compact; the carried state is dense}
  \[
    D(\ell)=\operatorname{diag}(e^\ell),\qquad
    S_t=D(\lambda_t)S_{t-1}+a_tb_t^\top
  \]
  \begin{center}
    \begin{tabular}{ll}
      \toprule
      Quantity & Role \\
      \midrule
      $S_t\in\mathbb R^{d_k\times d_v}$ & Prefix memory for one head \\
      $\lambda_t$ & Scalar-per-head or key-wise log decay \\
      $a_t\in\mathbb R^{d_k},\ b_t\in\mathbb R^{d_v}$ & Compact update factors \\
      \bottomrule
    \end{tabular}
  \end{center}
  \medskip
  \begin{itemize}
    \item Delta-rule updates construct $b_t$ using an old-state readout.
    \item Output and correction reads must retain their operator-defined timing.
  \end{itemize}
  \papersource{Paper, Eq. (3), Table 1, PDF p. 2; Algorithm 1, PDF p. 5.}
\end{frame}

\begin{frame}{Store a dense base plus a bounded update log}
  \centering
  \includegraphics[width=0.94\linewidth,height=4.9cm,keepaspectratio]{figures/fig-04-overview.pdf}
  \par\medskip
  $M-1$ append steps $\longrightarrow$ one merge step.\quad Capacity $C=M-1$.
  \par\smallskip
  \alert{Read the dense base every step; avoid writing it on append steps.}
  \papersource{Paper, Fig. 4, PDF p. 5; Sec. 3, PDF p. 4. Original author figure.}
\end{frame}

\begin{frame}{Each logged update receives only later decay}
  \[
  \boxed{S_t=D(\bar\ell)\bar S+
  \sum_{i=0}^{L-1}D\!\left(\bar\ell-\Llog[i]\right)
  \Klog[i]\Ulog[i]^\top}
  \]
  \begin{itemize}
    \item $\bar S$: dense base at the last merge.
    \item $\bar\ell$: cumulative log decay since that merge.
    \item $\Llog[i]$: cumulative log decay when entry $i$ was inserted.
    \item $\Klog[i],\Ulog[i]$: the stored compact update factors.
  \end{itemize}
  \begin{block}{Why the difference of snapshots?}
    $\bar\ell-\Llog[i]$ selects the decay accumulated \emph{after} insertion. A new entry has zero later decay and therefore unit weight.
  \end{block}
  \papersource{Paper, state invariant, Eq. (7), Sec. 3.2, PDF p. 6.}
\end{frame}

\begin{frame}{Append and merge preserve the same recurrence}
  First compute required old-state readouts; then set
  $\bar\ell\leftarrow\bar\ell+\lambda_t$ and form $(a_t,b_t)$.
  \medskip
  \begin{columns}[T,onlytextwidth]
    \begin{column}{0.47\textwidth}
      \begin{block}{Append: $L<C$}
        Store $(a_t,b_t,\bar\ell)$ at slot $L$.\\[2mm]
        Increment $L$; retain the base.
      \end{block}
      \[
        D(\lambda_t)D(\ell)=D(\ell+\lambda_t)
      \]
      Old contributions decay correctly; the new one enters at weight 1.
    \end{column}
    \begin{column}{0.49\textwidth}
      \begin{block}{Merge: $L=C$}
        Materialize old entries \emph{and} the current update into $\bar S$.\\[2mm]
        Reset $\bar\ell=0$ and $L=0$.
      \end{block}
      \[
        S_t=\bar S \quad\text{after reset.}
      \]
      The current update needs no extra log slot.
    \end{column}
  \end{columns}
  \medskip
  \alert{Exact-arithmetic equivalence follows by induction over both paths.}
  \papersource{Paper, Algorithm 1 and Eqs. (4)--(7), PDF pp. 5--6.}
\end{frame}

\begin{frame}{Readouts can consume the log without a dense commit}
  For a state query $x\in\mathbb R^{d_k}$, expand the invariant:
  \[
  \begin{aligned}
    x^\top S_t
      &= (x\odot e^{\bar\ell})^\top\bar S
         +\sum_{i=0}^{L-1}c_i(x)\Ulog[i]^\top,\\
    c_i(x)
      &=x^\top D\!\left(\bar\ell-\Llog[i]\right)\Klog[i].
  \end{aligned}
  \]
  \begin{itemize}
    \item The base supplies long-range history; log entries supply recent updates.
    \item Each $c_i(x)$ is a scalar shared across all value coordinates.
    \item Query projections and Delta-rule correction projections can reuse this structure.
  \end{itemize}
  \papersource{Teaching derivation from Eq. (7), PDF p. 6; replay projections in Sec. 3.3, PDF pp. 6--7.}
\end{frame}

\begin{frame}{Write savings compete with growing replay traffic}
  \[
  \begin{aligned}
    T_{\mathrm{dense}}&\approx T_{\mathrm{common}}+2\state,\\
    T_{\mathrm{delta}}&\approx T_{\mathrm{common}}+
      \underbrace{\state}_{\text{base read}}+
      \underbrace{\state/M}_{\text{base write}}+
      \logtraffic(M)+2\decay,\\
    \logtraffic(M)&\approx
      \left(\frac{M-1}{M}+\frac{M-1}{2}\right)\entry.
  \end{aligned}
  \]
  \begin{itemize}
    \item Larger $M$: fewer merges, more live entries to replay.
    \item $\entry$: bytes per log entry; $\decay$: persistent decay bytes.
  \end{itemize}
  \begin{block}{A derived state-traffic ratio}
    Ignoring log overhead, the state-traffic ratio is $2/(1+1/M)$: only $1.78\times$ at $M=8$, even though dense writes fall $8\times$.
  \end{block}
  \papersource{Paper, Eqs. (8)--(11), PDF p. 6. Single-read replay model; scratch and indexing omitted.}
\end{frame}

\begin{frame}{Tile values; share replay coefficients and metadata}
  \centering
  \includegraphics[width=\linewidth,height=4.45cm,keepaspectratio]{figures/fig-05-kernel-ownership.pdf}
  \par\medskip
  \begin{itemize}
    \item Each tile owns $\bar S[:,\mathcal V_j]$, its value log, and its output.
    \item One logical writer commits shared key factors, snapshots, and length.
    \item Merge uses the same tiled grid, with dense-base tiles as the target.
  \end{itemize}
  \papersource{Paper, Fig. 5 and Sec. 3.3, PDF pp. 6--7. Exact crop from PDF p. 7.}
\end{frame}

\begin{frame}{Decay granularity and correction cost shape the design}
  \begin{center}
    \renewcommand{\arraystretch}{1.3}
    \begin{tabular}{llllc}
      \toprule
      Operator & Decay & Value factor & Log K/U & $M$ \\
      \midrule
      GDN & Per head & Corrected & BF16 / FP32 & 8 \\
      KDA & Per key & Corrected & BF16 / FP32 & 4 \\
      RWKV6 & Per key & Raw value & BF16 / BF16 & 4 \\
      \bottomrule
    \end{tabular}
  \end{center}
  \medskip
  \begin{itemize}
    \item All dense bases and log-decay metadata use FP32.
    \item GDN has cheap scalar rescaling; KDA retains elementwise rescaling.
    \item FP32 corrected values mitigate cancellation along the Delta-rule path.
  \end{itemize}
  \papersource{Paper, Sec. 3.4, PDF p. 7; selected kernel configurations, Table 3, PDF p. 9.}
\end{frame}

\begin{frame}{Serving needs phase-aware graphs and state slots}
  \begin{columns}[T,onlytextwidth]
    \begin{column}{0.48\textwidth}
      \begin{block}{Append queue / graph}
        Decode through compact appends.\\[2mm]
        Move requests at their merge boundary.
      \end{block}
    \end{column}
    \begin{column}{0.48\textwidth}
      \begin{block}{Merge queue / graph}
        Commit the dense state and clear logs.\\[2mm]
        Return requests to the append queue.
      \end{block}
    \end{column}
  \end{columns}
  \medskip
  \begin{itemize}
    \item Capture two graph variants per uniform decode-batch descriptor.
    \item Prefill initializes the base; newly admitted requests start with an empty log.
    \item Reset auxiliary state when a slot is reused; retain other live slots.
  \end{itemize}
  \medskip
  Evaluated in a \alert{batch-synchronous, graph-mode vLLM prototype}.
  \papersource{Paper, Sec. 4 and implementation scope in Sec. 5.1, PDF pp. 8--9. Diagrammatic layout is a teaching summary.}
\end{frame}

\begin{frame}{Evaluation separates kernels, mechanism, and serving}
  \begin{center}
    \renewcommand{\arraystretch}{1.2}
    \begin{tabular}{lp{10.0cm}}
      \toprule
      Layer & Configuration and comparison \\
      \midrule
      Kernels & H200 NVL / RTX 4090; $H/d_k/d_v=32/128/128$; batch 64--512; FLA, PyTorch Compile, available vLLM kernels \\
      Mechanism & H200 DRAM counters; split-replay ablation; merge-interval and aggregate-state-size sweeps \\
      Numerics & 128-token rollouts; batch 64, 128, 256; output and materialized-state errors against dense references \\
      Serving & H200; Qwen3.6-35B-A3B and Kimi-Linear-48B-A3B-Instruct; 128 generated tokens \\
      \bottomrule
    \end{tabular}
  \end{center}
  \medskip
  \alert{Compare complete decode behavior, including periodic merges.}
  \papersource{Paper, Secs. 5.1--5.6, PDF pp. 8--12. No prefill performance evaluation.}
\end{frame}

\begin{frame}{H200 kernels improve across all three operators}
  \centering
  \includegraphics[width=\linewidth,height=4.45cm,keepaspectratio]{figures/fig-06-h200.pdf}
  \par\medskip
  FLA-relative gains: GDN \textbf{1.34--1.60$\times$};
  KDA \textbf{1.19--1.60$\times$};\\
  RWKV6 \textbf{1.52--1.69$\times$}.
  \par\medskip
  Bars: reported TPOT on the left axis.\quad Lines: speedup on the right axis.
  \papersource{Paper, Fig. 6, PDF p. 9; Sec. 5.2, PDF pp. 9--10. Original author figure.}
\end{frame}

\begin{frame}{RTX 4090 reaches the headline 1.86$\times$ kernel gain}
  \centering
  \includegraphics[width=\linewidth,height=4.45cm,keepaspectratio]{figures/fig-07-4090.pdf}
  \par\medskip
  The maximum is \alert{GDN at $B=128$} relative to FLA.\\[2mm]
  KDA: 1.30--1.55$\times$.\qquad RWKV6: 1.41--1.63$\times$.
  \par\medskip
  The dependence on batch size differs from the H200 results.
  \papersource{Paper, Fig. 7, PDF p. 9; Sec. 5.2, PDF p. 10. Original author figure.}
\end{frame}

\begin{frame}{Counters confirm fewer writes, with extra replay reads}
  \begin{columns}[T,onlytextwidth]
    \begin{column}{0.68\textwidth}
      \includegraphics[width=\linewidth,height=4.15cm,keepaspectratio]{figures/fig-08-traffic.pdf}
    \end{column}
    \begin{column}{0.29\textwidth}
      \textbf{H200, GDN}\\
      $B=128$, $M=8$\\[3mm]
      Dense write:\\
      0.230 GiB/token\\[2mm]
      Amortized write:\\
      \alert{0.0294 GiB/token}
    \end{column}
  \end{columns}
  \medskip
  \begin{itemize}
    \item Append reads rise from 0.253 to 0.273 GiB as the log grows.
    \item Reported reduction: \textbf{7.83$\times$ in writes}, \textbf{1.64$\times$ in total traffic}.
    \item Merge restores a dense write, but only once per eight steps.
  \end{itemize}
  \papersource{Paper, Fig. 8 and Sec. 5.3, PDF p. 10. Ratios use the authors' reported precision.}
\end{frame}

\begin{frame}{Split replay helps only when reuse pays for preparation}
  \centering
  \includegraphics[width=0.88\linewidth,height=3.75cm,keepaspectratio]{figures/fig-09-split-replay.pdf}
  \par\medskip
  \begin{itemize}
    \item GDN, $M=8$: \textbf{1.05--1.11$\times$} faster than fused replay.
    \item KDA, $M=4$: essentially neutral (0.998--1.003$\times$).
    \item RWKV6, $M=4$: \textbf{about 2\% slower}; its fused path is already cheap.
  \end{itemize}
  \papersource{Paper, Fig. 9, PDF p. 11; Sec. 5.3, PDF p. 10. Full-cycle CUDA Graph timing, H200.}
\end{frame}

\begin{frame}{Longer merge intervals eventually lose to replay}
  \centering
  \includegraphics[width=0.91\linewidth,height=4.05cm,keepaspectratio]{figures/fig-10-merge-interval.pdf}
  \par\medskip
  H200, $B=128$: GDN selects $M=8$ (0.103 ms);\\
  KDA selects $M=4$ (0.116 ms); RWKV6 selects $M=4$ (0.110 ms).
  \par\smallskip
  \alert{Reducing merge frequency alone is insufficient.}
  \papersource{Paper, Fig. 10 and Sec. 5.4, PDF p. 11. Latencies are from this interval sweep.}
\end{frame}

\begin{frame}{Larger aggregate states provide more opportunity}
  \begin{columns}[T,onlytextwidth]
    \begin{column}{0.56\textwidth}
      \includegraphics[width=\linewidth,height=4.65cm,keepaspectratio]{figures/fig-11-state-size.pdf}
    \end{column}
    \begin{column}{0.41\textwidth}
      \textbf{128 $\rightarrow$ 1024 MiB}\\[3mm]
      GDN: 1.48 $\rightarrow$ 1.62$\times$\\[2mm]
      KDA: 1.02 $\rightarrow$ 1.58$\times$\\[2mm]
      RWKV6: 1.51 $\rightarrow$ 1.69$\times$\\[4mm]
      The paper changes \alert{batch size}, with head dimensions fixed.
    \end{column}
  \end{columns}
  \medskip
  KDA nearly breaks even at the smallest state size in this sweep.
  \papersource{Paper, Fig. 11 and Sec. 5.4, PDF p. 11. This campaign differs numerically from Fig. 6; see backup.}
\end{frame}

\begin{frame}{Measured equivalence is within floating-point tolerance}
  \begin{center}
    \renewcommand{\arraystretch}{1.25}
    \begin{tabular}{lcc}
      \toprule
      Operator & Output relative error (max) & State relative error (max) \\
      \midrule
      GDN & 0.00303 & $7.92\times10^{-7}$ \\
      KDA & 0.00450 & $4.61\times10^{-4}$ \\
      RWKV6 & 0.00376 & $2.86\times10^{-7}$ \\
      \bottomrule
    \end{tabular}
  \end{center}
  \medskip
  \begin{itemize}
    \item 128-token kernel rollouts; $B\in\{64,128,256\}$; selected $M$.
    \item Authors report passing repository and BF16-aware benchmark tolerances.
  \end{itemize}
  \begin{block}{What this supports}
    Mixed precision and reordered sums cause small differences. Agreement is established within tolerance over the measured 128-token horizon.
  \end{block}
  \papersource{Paper, Sec. 5.5 and Fig. 12, PDF p. 11. Exact arithmetic is covered separately by the invariant.}
\end{frame}

\begin{frame}{Full-model decode gains range from 1.05 to 1.20$\times$}
  \begin{columns}[T,onlytextwidth]
    \begin{column}{0.49\textwidth}
      \textbf{Qwen3.6-35B-A3B / GDN}\\
      $M=8$\par\medskip
      \begin{tabular}{rrrr}
        \toprule
        $B$ & Dense & DeltaLog & Gain \\
        \midrule
        64 & 8.36 & 7.75 & 1.08$\times$ \\
        128 & 10.30 & 9.01 & 1.14$\times$ \\
        256 & 16.07 & 13.40 & 1.20$\times$ \\
        \bottomrule
      \end{tabular}
    \end{column}
    \begin{column}{0.49\textwidth}
      \textbf{Kimi-Linear-48B-A3B-Instruct}\\
      KDA, $M=4$\par\medskip
      \begin{tabular}{rrrr}
        \toprule
        $B$ & Dense & DeltaLog & Gain \\
        \midrule
        64 & 7.66 & 7.33 & 1.05$\times$ \\
        128 & 8.92 & 8.13 & 1.10$\times$ \\
        256 & 13.98 & 12.54 & 1.12$\times$ \\
        \bottomrule
      \end{tabular}
    \end{column}
  \end{columns}
  \medskip
  TPOT in \textbf{ms/token}, lower is better. H200 NVL; 128 generated tokens.\\[2mm]
  Same models, precision, batch sizes, and graph replay settings.
  \par\medskip
  16.07 $\rightarrow$ 13.40 ms is a \textbf{16.6\% latency reduction}.\\[1mm]
  \alert{These measurements cover decode; prefill is excluded.}
  \papersource{Paper, Table 4, PDF p. 11; Sec. 5.6, PDF p. 12. Gain values retain paper rounding.}
\end{frame}

\begin{frame}{System gains depend on the optimized path's share}
  \[
    \mathrm{Speedup}_{\mathrm{model}}
    \approx\frac{1}{(1-f)+f/s}
  \]
  $f$: original runtime fraction in the optimized path.\quad $s$: its speedup.
  \medskip
  \begin{itemize}
    \item MLPs, normalization, scheduling, and other model work remain.
    \item Extra logs consume memory; merge steps add a periodic cost.
    \item Smaller states offer less write traffic to recover.
  \end{itemize}
  \begin{block}{Deployment questions that remain}
    Long-horizon numerical behavior and tail latency under mixed arrivals are separate from the reported fixed-batch decode measurements.
  \end{block}
  \papersource{Paper, Secs. 5.6 and 6, PDF p. 12. Amdahl formula is a teaching expression of the paper's explanation.}
\end{frame}

\begin{frame}{The physical state representation is an optimization lever}
  \begin{enumerate}
    \item \textbf{Preserve the logical recurrence.}\\
      A dense base and bounded factors can represent the same state.
      \medskip
    \item \textbf{Optimize the commit schedule.}\\
      Replace most dense writes with compact appends; tune replay against merge cost.
      \medskip
    \item \textbf{Measure at the right level.}\\
      Up to 1.86$\times$ kernel speedup; 7.83$\times$ fewer profiled writes; 1.05--1.20$\times$ full-model decode speedup.
  \end{enumerate}
  \medskip
  \alert{Best supported regime: large-batch recurrent decoding with costly state writes.}
  \papersource{Lin, Sun, and Sun. DeltaLog: Deferred Materialization of Recurrent States for Linear Attention Decoding. arXiv:2608.15533v1, 2026. Secs. 6--8, PDF pp. 12--13.}
\end{frame}

\appendix

\begin{frame}{Backup: a scalar example of deferred materialization}
  Teaching example: $S_0=10$, decay $1/2$, updates $2,3,4$, $M=3$.
  \medskip
  \begin{center}
    \renewcommand{\arraystretch}{1.5}
    \begin{tabular}{cccc}
      \toprule
      Step & Logical state & Dense base & Representation \\
      \midrule
      1 & 7 & 10 & $10/2+2$ \\
      2 & 6.5 & 10 & $10/4+2/2+3$ \\
      3 & 7.25 & 7.25 & $10/8+2/4+3/2+4$ \\
      \bottomrule
    \end{tabular}
  \end{center}
  \medskip
  The base remains unchanged for two steps, while the represented logical state changes every step. Step 3 merges and empties the log.
  \papersource{Teaching example, not a paper experiment. Based on Eqs. (6)--(7), PDF pp. 5--6.}
\end{frame}

\begin{frame}{Backup: bounded logs add a modest resident footprint}
  \[
  \begin{aligned}
    \entry&=BH(p_Kd_k+p_Ud_v+4d_\lambda),\\
    \decay&=4BHd_\lambda,\\
    C_{\mathrm{aux}}&=(M-1)\entry+\decay.
  \end{aligned}
  \]
  $p_K,p_U$: bytes/element.\quad $d_\lambda$: decay width (1 or $d_k$).
  \medskip
  \begin{center}
    \begin{tabular}{lrrr}
      \toprule
      Operator & $M$ & Auxiliary MiB & Relative to base \\
      \midrule
      GDN & 8 & 21.125 & 8.25\% \\
      KDA & 4 & 17.000 & 6.64\% \\
      RWKV6 & 4 & 14.000 & 5.47\% \\
      \bottomrule
    \end{tabular}
  \end{center}
  \medskip
  $B=128$, $H/d_k/d_v=32/128/128$: FP32 base = 256 MiB.\\
  Excludes scratch, indexing, and alignment; not measured peak memory.
  \papersource{Derived from paper Eq. (9), PDF p. 6, and Table 3, PDF p. 9.}
\end{frame}

\begin{frame}{Backup: separate the paper's measurement campaigns}
  \begin{block}{An unresolved numerical difference}
    Table 3's shape implies $B=64$ corresponds to 128 MiB of FP32 state. Yet KDA speedup is \textbf{1.19$\times$ in Fig. 6} and \textbf{1.02$\times$ in Fig. 11 / Sec. 5.4}. The paper does not explain the difference in settings or timing.
  \end{block}
  \medskip
  \begin{itemize}
    \item Report the kernel sweep and state-size sweep separately.
    \item Use ratios within each campaign; do not merge them into one curve.
    \item Numerical tests cover 128 steps; the exact relative-error denominator and full tolerance rules are not specified in the text.
  \end{itemize}
  \papersource{Paper, Fig. 6 and Table 3, PDF p. 9; Fig. 11 and Secs. 5.4--5.5, PDF p. 11. Reader comparison.}
\end{frame}

\end{document}