% Independent paper discussion; figures credited to Yi Pan et al.
% Build: python3 build_slides.py slides.en.tex
\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}
\definecolor{WarmOrange}{RGB}{178,88,56}
\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}{%
  \hspace{8mm}{\color{gray}\scriptsize LeapQuant \;|\; arXiv:2609.38166v1}
  \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{\DQ}{\operatorname{dequant}}
\newcommand{\Q}{\operatorname{quant}}
\newcommand{\Diag}{\operatorname{Diag}}
\newcommand{\fig}[2]{\includegraphics[width=#1\linewidth,height=#2cm,keepaspectratio]}
\renewcommand{\arraystretch}{1.17}

\title[LeapQuant]{LeapQuant}
\subtitle{Efficient Linear Attention with\\Accurate Recurrent State Quantization}
\author{Paper by Yi Pan, Haocheng Xi, et al.\\[0.4em]
  \small Independent research group discussion}
\date{arXiv:2609.38166v1 \;|\; 29 September 2026\\
  \small Reading prepared 19 October 2026}

\begin{document}

% Main presentation: frames 1--22, approximately 25 minutes.
\begin{frame}
  \titlepage
  \vspace{-0.6em}
  \begin{center}
    \color{AcademicTeal}\large
    Quantize less often; protect the dominant state structure.
  \end{center}
\end{frame}

\begin{frame}{A fixed-size state still costs bandwidth and capacity}
  \centering
  \fig{0.98}{3.6}{figures/fig-01.pdf}
  \begin{itemize}
    \item Every decoded token loads and updates a dense state.
    \item Prefix caching stores many state checkpoints: one per 1,024 cached tokens in this experiment.
  \end{itemize}
  \papersource{Paper, Fig. 1, PDF p. 2. Left: GLM-5.3-Flash-NVFP4, B200, batch 256.
  Right: Qwen3.5-9B memory with prefix caching.}
\end{frame}

\begin{frame}{One recurrence describes both GDN and KDA}
  \[
  S_t=\Diag(\alpha_t)S_{t-1}
      +k_t\bigl(v_t-S_{t-1}^{\top}\beta_t\bigr)^\top,
  \qquad o_t=S_t^\top q_t
  \]
  \begin{columns}[T,onlytextwidth]
    \begin{column}{0.49\textwidth}
      \begin{block}{State and reads}
        $S_t\in\mathbb R^{d_k\times d_v}$\\
        $q_t,k_t,\beta_t\in\mathbb R^{d_k}$\\
        $v_t,o_t\in\mathbb R^{d_v}$
      \end{block}
    \end{column}
    \begin{column}{0.47\textwidth}
      \begin{block}{A compact update record}
        $u_t=v_t-S_{t-1}^{\top}\beta_t$\\[0.4em]
        Store $(\alpha_t,k_t,u_t)$:
        diagonal decay plus a rank-one write.
      \end{block}
    \end{column}
  \end{columns}
  \medskip
  $\beta_t$ here is a \alert{read vector}; native GDN/KDA notation also uses a scalar gate called $\beta_t$.
  \papersource{Paper, Eqs. (1), (3), PDF p. 4; architecture mappings in Appendix A, PDF p. 13.}
\end{frame}

\begin{frame}{Rounding errors become part of the next state}
  \begin{columns}[c,onlytextwidth]
    \begin{column}{0.55\textwidth}
      \centering
      \fig{1.0}{4.9}{figures/fig-03.pdf}
    \end{column}
    \begin{column}{0.42\textwidth}
      At fixed layer inputs,
      \[
        E_t=A_tE_{t-1}+\varepsilon_t,
      \]
      \[
        A_t=\Diag(\alpha_t)-k_t\beta_t^\top.
      \]
      \begin{itemize}
        \item Per-step rounding injects $\varepsilon_t$ at every token.
        \item At 64K, windowing lowers MSE by $100\times$ for BF16 and $39\times$ for INT8.
      \end{itemize}
    \end{column}
  \end{columns}
  \papersource{Paper, Fig. 3 / Sec. 3.2, PDF p. 4; Eq. (8), PDF p. 14.
  Qwen3.5-9B on PG-19; -w means a 16-token window. $A_t$ is a presentation shorthand.}
\end{frame}

\begin{frame}{Hold the boundary state fixed for 16 tokens}
  \centering
  \fig{0.86}{4.1}{figures/fig-02.pdf}
  \[
  S_\ell=\Gamma_{1:\ell}\hat S_0+
    \sum_{j=1}^{\ell}\Gamma_{j+1:\ell}k_ju_j^\top
  \]
  $\Gamma_{a:b}$ is the product of diagonal decays; quantize the full state only at $\ell=p$.
  \papersource{Paper, Fig. 2, PDF p. 3; Eq. (4), PDF p. 4.
  Error percentages in this illustration are schematic, not measured results.
  Dequantization of $\hat S_0$ is implicit.}
\end{frame}

\begin{frame}{Read the state without materializing it every step}
  \[
  S_\ell^\top x
    =\hat S_0^\top\Gamma_{1:\ell}x
     +\sum_{j=1}^{\ell}u_j
        \bigl(k_j^\top\Gamma_{j+1:\ell}x\bigr)
  \]
  \begin{enumerate}
    \item Read $S_{i-1}^\top\beta_i$ to compute the correction $u_i$.
    \item Append $(\alpha_i,k_i,u_i)$ to the buffer.
    \item Read $S_i^\top q_i$ to produce the current output.
  \end{enumerate}
  \begin{block}{Cost and latency}
    Base read: $O(d_kd_v)$; each record: $O(d_k+d_v)$.\\
    Output is produced every token. The base state is still read every token.
  \end{block}
  \papersource{Paper, Appendix B.2, Eq. (9), PDF p. 14; window start set to zero here.
  Cumulative decays are maintained incrementally.}
\end{frame}

\begin{frame}{Compensator Tokens preserve a few dominant directions}
  \centering
  \fig{0.96}{3.1}{figures/fig-04.pdf}
  \[
  R_p=S_p-\tilde K\tilde U^\top,\qquad
  \tilde S_p=\DQ_b(\hat R_p)+\tilde K\tilde U^\top
  \]
  \begin{itemize}
    \item Each vector pair is a rank-one record using the real-token path.
    \item Default: $r=4$ FP16 pairs, refitted at every boundary by power iteration.
    \item These records have no text content and produce no output.
  \end{itemize}
  \papersource{Paper, Fig. 4 / Eqs. (5)--(6), PDF p. 5; implementation, PDF p. 7.
  The schematic omits the decays shown in the full reconstruction equation.}
\end{frame}

\begin{frame}{Smooth the residual before assigning quantization levels}
  \centering
  \fig{0.99}{3.4}{figures/fig-06.pdf}
  \[
  c_a\simeq\sqrt{\frac{1}{d_v}\sum_j |(R_0)_{aj}|},
  \quad C=\Diag(c),\quad
  \hat R_0^C=\Q_b(C^{-1}R_0)
  \]
  \begin{itemize}
    \item Use a positive scale floor; recompute $C$ at each boundary.
    \item Restore $C$ on the residual read. Other records keep their original coordinates.
  \end{itemize}
  \papersource{Paper, Fig. 6 / Sec. 3.4, PDF p. 6.
  Panels (a),(b) normalize by the original-state median; (c) uses its own median.
  The displayed scale formula omits the positive floor.}
\end{frame}

\begin{frame}{The complete readout is the sum of three projections}
  \[
  \begin{aligned}
  S_\ell^\top x={}&
    \underbrace{\DQ_b(\hat R_0^C)^\top C\Gamma_{1:\ell}x}
      _{\text{quantized residual}}\\[0.7em]
   &+\underbrace{\tilde U(\tilde K^\top\Gamma_{1:\ell}x)}
      _{\text{high-precision compensators}}\\[0.7em]
   &+\underbrace{\sum_{j=1}^{\ell}u_j
      (k_j^\top\Gamma_{j+1:\ell}x)}
      _{\text{buffered real-token updates}} .
  \end{aligned}
  \]
  All contributions are combined in the original state coordinates.
  \papersource{Paper, Appendix B.3, Eq. (10), PDF p. 14.
  $\tilde K\in\mathbb R^{d_k\times r}$ and $\tilde U\in\mathbb R^{d_v\times r}$.}
\end{frame}

\begin{frame}{Boundary work is amortized across the window}
  \begin{enumerate}
    \item Reconstruct the current state from residual, compensators, and records.
    \item Fit new low-rank factors; replace the old compensators.
    \item Smooth and quantize the new residual.
    \item Clear the real-token buffer and start the next window.
  \end{enumerate}
  \begin{block}{Default implementation}
    $p=16$, $r=4$; FP16 compensators and update buffer, FP32 smoothing scales.\\
    At 4 bits, use $r=8$. vLLM integration with TileLang decode kernels.
  \end{block}
  No retraining or calibration data; boundary computation remains a runtime cost.
  \papersource{Paper, Secs. 3.3--3.4, PDF pp. 5--6; Sec. 4.1, PDF p. 7.}
\end{frame}

\begin{frame}{Quality uses three complete models and shared prompts}
  \centering
  \begin{tabular}{lll}
    \toprule
    Model & Recurrence & Evaluation\\
    \midrule
    Qwen3.5-9B & GDN & Quality + efficiency\\
    Qwen3.5-35B-A3B & GDN & Quality + efficiency\\
    Kimi-Linear-48B-A3B & KDA & Quality + efficiency\\
    Qwen3.8-Flash & GDN & 8 layers, efficiency only\\
    GLM-5.3-Flash & KDA & 8 layers, efficiency only\\
    \bottomrule
  \end{tabular}
  \begin{itemize}
    \item Main tasks: AIME 2026, GPQA-Diamond, LCB v6, MMLU-Pro.
    \item Three-seed averages; identical prompts and sampling within each model.
    \item Quantization baselines re-quantize every token; other components keep baseline precision.
  \end{itemize}
  \papersource{Paper, Sec. 4.1, PDF pp. 6--7; sampling details in Table 6, PDF p. 16.
  Kimi's full name ends with Instruct. LCB = LiveCodeBench.}
\end{frame}

\begin{frame}{Eight-bit LeapQuant matches the FP32 average}
  \begin{columns}[T,onlytextwidth]
    \begin{column}{0.49\textwidth}
      \centering
      \textbf{12 model--task pairs}\\[0.4em]
      \begin{tabular}{lr}
        \toprule
        State method & Avg. (\%)\\
        \midrule
        FP32 & 75.5\\
        BF16, per-step & 68.7\\
        \alert{LeapQuant 8-bit} & \alert{75.5}\\
        FP8, per-step & 34.2\\
        INT8, per-step & 26.3\\
        KVQuant, adapted & 67.0\\
        QuaRot, adapted & 50.1\\
        TurboQuant, adapted & 49.6\\
        \bottomrule
      \end{tabular}
    \end{column}
    \begin{column}{0.47\textwidth}
      \textbf{Qwen3.5-9B on AIME}
      \[
        \begin{array}{lr}
        \text{FP32} & 87.9\\
        \text{BF16} & 72.1\\
        \text{Per-step INT8} & 7.1\\
        \text{LeapQuant} & 87.9
        \end{array}
      \]
      \medskip
      Individual 8-bit scores differ from FP32 by at most 0.8 percentage points across the 12 pairs.
    \end{column}
  \end{columns}
  \papersource{Paper, Table 1, PDF p. 7. Higher is better.
  Average: 3 models $\times$ 4 tasks; excludes GSM8K.
  The 0.8-point range is calculated from the reported entries.}
\end{frame}

\begin{frame}{Four bits remain useful, but Qwen loses substantial quality}
  \centering
  \begin{tabular}{lrrr}
    \toprule
    State bits & LeapQuant avg. & Strong comparator & Comparator avg.\\
    \midrule
    8 & 75.5 & KVQuant & 67.0\\
    6 & 72.4 & TurboQuant & 31.9\\
    4 & 60.4 & TurboQuant & 22.9\\
    \bottomrule
  \end{tabular}
  \begin{itemize}
    \item FP32 average: 75.5\%. Four-bit LeapQuant uses $r=8$.
    \item Kimi at 4 bits: every main task stays within 1.1 percentage points of FP32.
    \item Qwen3.5-35B-A3B at 4 bits: AIME $91.5\to59.2$; LCB $75.6\to37.4$.
  \end{itemize}
  \begin{block}{Interpretation}
    Near-lossless quality is the strongest at 8 bits; lower precision is model- and task-dependent.
  \end{block}
  \papersource{Paper, Table 1, PDF p. 7; Sec. 4.2, PDF p. 8. Scores are percentages.}
\end{frame}

\begin{frame}{Large batches expose the benefit of lower state traffic}
  \centering
  \textbf{Single-layer kernel speedup at batch 512}\\[0.6em]
  \begin{tabular}{lrr}
    \toprule
    GPU & GDN & KDA\\
    \midrule
    NVIDIA B200 & $2.68\times$ & $2.41\times$\\
    RTX PRO 6000 & $3.95\times$ & $3.38\times$\\
    RTX 5090 & $4.25\times$ & $3.64\times$\\
    \bottomrule
  \end{tabular}
  \medskip
  \begin{itemize}
    \item One layer, 32 heads, $d_k=d_v=128$; baseline is the FLA FP32-state kernel.
    \item Larger batches make recurrent-state traffic a stronger bottleneck.
    \item These numbers measure the attention kernel, not the complete model.
  \end{itemize}
  \papersource{Paper, Fig. 7 / Sec. 4.3, PDF p. 8.
  Values transcribed at the specified batch size; the abstract reports averaged ranges.}
\end{frame}

\begin{frame}{Whole-model decode gains are smaller than kernel gains}
  \centering
  \begin{tabular}{lrr}
    \toprule
    Model & B200, batch 512 & PRO 6000, max batch\\
    \midrule
    Qwen3.5-9B & $1.23\times$ & $1.27\times$ (256)\\
    Qwen3.5-35B-A3B & $1.24\times$ & $1.41\times$ (256)$^{*}$\\
    Kimi-Linear-48B-A3B & $1.22\times$ & $1.22\times$ (256)\\
    GLM-5.3-Flash, 8 layers & $1.37\times$ & $1.42\times$ (512)\\
    Qwen3.8-Flash, 8 layers & $1.33\times$ & $1.57\times$ (512)\\
    \bottomrule
  \end{tabular}
  \medskip
  \begin{itemize}
    \item vLLM with CUDA graphs; context is 4K except $^{*}$2K.
    \item Small batches benefit less: Qwen35B on B200 at batch 32 is $1.00\times$.
    \item Other attention layers, projections, and MoE computation remain.
  \end{itemize}
  \papersource{Paper, Fig. 8 / Sec. 4.3, PDF p. 8.
  Baseline uses FP32 recurrent states. The two Flash models are truncated efficiency models.}
\end{frame}

\begin{frame}{The boundary state takes 1.19 bytes per element}
  \begin{block}{Representation accounting: $128\times128$ state, $r=4$}
    INT8 residual + FP16 factors + row/value scales:
    \[
      1+\frac{2r(d_k+d_v)}{d_kd_v}
        +\frac{4(d_k+d_v)}{d_kd_v}
      =1.1875\ \text{bytes/element}.
    \]
    Approximately $3.4\times$ smaller than FP32, before active-request buffers.
  \end{block}
  \begin{itemize}
    \item With a checkpoint per 1K cached tokens, reported total memory falls by 41\%, 51\%, and 56\% for Qwen9B, Qwen35B, and Kimi.
    \item Qwen9B on one B200 supports up to $1.4\times$ as many concurrent requests.
  \end{itemize}
  \papersource{Paper, Sec. 4.3, PDF pp. 8--9; scale layout in Appendix B.3, PDF p. 14.
  Formula is a size calculation with FP32 vector scales, not a separate memory measurement.}
\end{frame}

\begin{frame}{Offline output throughput improves by about 1.47$\times$}
  \centering
  \begin{tabular}{llrrr}
    \toprule
    GPU & Model & GSM8K & MMLU-Pro & GPQA\\
    \midrule
    B200 & Qwen9B & 1.23 & 1.30 & 1.44\\
         & Qwen35B & 1.43 & 1.60 & 1.58\\
         & Kimi48B & 1.54 & 1.60 & 1.47\\
    \midrule
    PRO 6000 & Qwen9B & 1.40 & 1.38 & 1.31\\
             & Qwen35B & 1.65 & 1.59 & 1.41\\
             & Kimi48B & 1.48 & 1.51 & 1.49\\
    \bottomrule
  \end{tabular}
  \medskip
  \begin{itemize}
    \item Entries are output-throughput ratios to FP32-state vLLM.
    \item Faster decode and more concurrent requests both contribute.
    \item Kimi uses Qwen9B's input/output length distribution.
  \end{itemize}
  \papersource{Paper, Fig. 9 / Sec. 4.3, PDF p. 9.
  Average of the 18 rounded ratios is approximately 1.47; this is not a latency metric.}
\end{frame}

\begin{frame}{Windowing repairs most of the damage; all parts matter}
  \centering
  \begin{tabular}{lrrr}
    \toprule
    Qwen3.5-9B state method & AIME & LCB & Kernel speedup\\
    \midrule
    FP32 per-step & 87.9 & 64.1 & $1.00\times$\\
    BF16 per-step & 72.1 & 49.6 & $1.64\times$\\
    BF16 + window & 87.8 & 62.9 & $1.71\times$\\
    \midrule
    INT8 per-step & 7.1 & 9.2 & $2.43\times$\\
    + Window & 82.4 & 60.6 & $2.64\times$\\
    + Compensator Tokens & 86.6 & 61.5 & $2.56\times$\\
    + Smoothing & \alert{87.9} & \alert{64.1} & \alert{$2.52\times$}\\
    \bottomrule
  \end{tabular}\par
  \medskip
  Added compensation and smoothing trade a little kernel speed for recovered quality.
  \papersource{Paper, Table 2, PDF p. 9.
  Accuracy in percent; kernel ratios measured at batch 256 against FP32.}
\end{frame}

\begin{frame}{Bigger windows and more compensators are not always better}
  \begin{columns}[T,onlytextwidth]
    \begin{column}{0.49\textwidth}
      \centering
      \textbf{Vary $p$, fix $r=4$}\\[0.5em]
      \begin{tabular}{rrrr}
        \toprule
        $p$ & AIME & LCB & Speedup\\
        \midrule
        4 & 86.2 & 62.8 & $1.59\times$\\
        8 & 87.1 & 63.2 & $2.13\times$\\
        16 & 87.9 & 64.1 & $2.52\times$\\
        32 & 87.9 & 64.2 & $2.20\times$\\
        \bottomrule
      \end{tabular}\par
      \medskip
      Larger buffers increase traffic and shared-memory use.
    \end{column}
    \begin{column}{0.49\textwidth}
      \centering
      \textbf{Vary $r$, fix $p=16$}\\[0.5em]
      \begin{tabular}{rrrr}
        \toprule
        $r$ & AIME & LCB & Speedup\\
        \midrule
        2 & 85.7 & 63.4 & $2.57\times$\\
        4 & 87.9 & 64.1 & $2.52\times$\\
        8 & 88.1 & 64.0 & $2.37\times$\\
        16 & 87.9 & 62.8 & $0.74\times$\\
        \bottomrule
      \end{tabular}\par
      \medskip
      Fitting and reconstruction costs become exposed as rank grows.
    \end{column}
  \end{columns}
  \medskip
  \centering
  \textbf{$p=16,\ r=4$ balances accuracy and speed in this ablation.}
  \papersource{Paper, Table 3, PDF p. 9. Qwen3.5-9B; accuracy in percent; batch 256 kernel ratios.}
\end{frame}

\begin{frame}{Sparse hybrid attention retains gains at long context}
  \centering
  \fig{0.98}{3.7}{figures/fig-11.pdf}
  \begin{itemize}
    \item B200, batch 256; both models use 8-layer efficiency versions.
    \item GLM: $1.23\times$ at 128K. Qwen: $1.20\times$ at 96K.
    \item With dense full attention, its growing cost dilutes the gain; Kimi still reaches $1.18\times$ at 8K, batch 512.
  \end{itemize}
  \papersource{Paper, Appendix D, Figs. 10--11, PDF p. 16.
  These are throughput measurements, not long-context accuracy results.}
\end{frame}

\begin{frame}{The useful regime follows the state cost and precision budget}
  \begin{block}{Strongest evidence}
    Near-FP32 quality at 8 bits on complete GDN/KDA models;
    throughput benefits at larger batches and with prefix checkpoints.
  \end{block}
  \begin{itemize}
    \item Four-bit quality depends strongly on the model and task.
    \item Small batches and expensive unmodified layers reduce end-to-end gains.
    \item The general recurrence covers more architectures than the evaluated models.
    \item Fixed-input error propagation explains a mechanism; it is not a full-model error bound.
  \end{itemize}
  \papersource{Evidence: Tables 1--3, PDF pp. 7--9; Fig. 8, PDF p. 8; Appendices A--B, PDF pp. 13--14.
  Interpretation synthesized for this discussion.}
\end{frame}

\begin{frame}{Quantization timing is part of the memory representation}
  \begin{enumerate}
    \item \textbf{Time:} keep recent updates in higher precision and quantize the full state only at window boundaries.
    \item \textbf{Structure:} preserve dominant components as rank-one records.
    \item \textbf{Coordinates:} smooth the residual and restore its scale during reads.
  \end{enumerate}
  \begin{block}{Takeaway}
    The main contribution is a practical combination of accurate recurrent storage and an efficient read/update path.
  \end{block}
  \medskip
  \href{https://arxiv.org/abs/2609.38166v1}{Yi Pan et al., LeapQuant, arXiv:2609.38166v1}\\
  \smallskip
  \small Backup slides follow: mappings, detailed scores, scales, and memory accounting.
  \papersource{Paper, Sec. 5, PDF p. 10; synthesis based on the method and ablations.}
\end{frame}

\appendix

\begin{frame}{Backup: GDN and KDA fit the same update form}
  Appendix notation:
  \[
  S_t=D_tS_{t-1}+\tilde k_t(v_t-S_{t-1}^\top b_t)^\top.
  \]
  \centering
  \begin{tabular}{lccc}
    \toprule
    Model & $D_t$ & $\tilde k_t$ & $b_t$\\
    \midrule
    DeltaNet & $I$ & $\beta_tk_t$ & $k_t$\\
    GDN & $\alpha_t I$ & $\beta_tk_t$ & $\alpha_t k_t$\\
    KDA & $\Diag(\alpha_t)$ & $\beta_tk_t$ & $\alpha_t\odot k_t$\\
    \bottomrule
  \end{tabular}
  \begin{itemize}
    \item In this table, $k_t,\beta_t$ are the native key and scalar update gate.
    \item RWKV7 uses two records: an erase sub-step and a separate write.
    \item DeltaProduct uses multiple delta-rule sub-steps per token.
  \end{itemize}
  \papersource{Paper, Appendix A / Table 4, PDF p. 13.
  The main-text write/read vectors are $\tilde k_t,b_t$ in the appendix.}
\end{frame}

\begin{frame}{Backup: eight-bit accuracy across all 12 main pairs}
  \centering
  \begin{tabular}{llrrrr}
    \toprule
    Model & State & AIME & GPQA & LCB & MMLU-Pro\\
    \midrule
    Qwen9B & FP32 & 87.9 & 81.3 & 64.1 & 83.3\\
           & LeapQuant & 87.9 & 81.8 & 64.1 & 83.8\\
    \midrule
    Qwen35B & FP32 & 91.5 & 84.7 & 75.6 & 85.9\\
            & LeapQuant & 91.0 & 83.9 & 76.1 & 85.8\\
    \midrule
    Kimi48B & FP32 & 67.5 & 70.3 & 41.4 & 72.4\\
            & LeapQuant & 68.3 & 69.8 & 41.3 & 72.1\\
    \bottomrule
  \end{tabular}\par
  \medskip
  GSM8K (FP32 $\to$ LeapQuant):\\
  Qwen9B $96.1\to96.3$;\quad Qwen35B $96.7\to96.5$;\quad Kimi $92.1\to92.0$.
  \papersource{Paper, Table 1, PDF p. 7; Table 5, PDF p. 15.
  Scores in percent, higher is better; means over three seeds.}
\end{frame}

\begin{frame}{Backup: the four-bit penalty differs sharply by model}
  \centering
  \begin{tabular}{llrrrr}
    \toprule
    Model & State & AIME & GPQA & LCB & MMLU-Pro\\
    \midrule
    Qwen9B & FP32 & 87.9 & 81.3 & 64.1 & 83.3\\
           & LeapQuant 4-bit & 58.1 & 65.7 & 34.0 & 80.2\\
    \midrule
    Qwen35B & FP32 & 91.5 & 84.7 & 75.6 & 85.9\\
            & LeapQuant 4-bit & 59.2 & 57.6 & 37.4 & 81.4\\
    \midrule
    Kimi48B & FP32 & 67.5 & 70.3 & 41.4 & 72.4\\
            & LeapQuant 4-bit & 67.9 & 69.2 & 40.5 & 73.4\\
    \bottomrule
  \end{tabular}\par
  \medskip
  Four-bit configuration: $p=16,\ r=8$. Qwen thinking traces are longer; the paper links this to greater sensitivity to recurrent error.
  \papersource{Paper, Table 1 / Sec. 4.2, PDF pp. 7--8.
  Scores in percent; the trace-length explanation is the authors' interpretation.}
\end{frame}

\begin{frame}{Backup: keep key and value scales on the residual path}
  Per-value-channel symmetric INT8:
  \[
  \DQ_8(\hat R_0^C)=\frac{Z_0}{127}B,\qquad C=\Diag(c).
  \]
  Then
  \[
  \left(C\frac{Z_0}{127}B\right)^\top\Gamma x
     =B\frac{Z_0^\top}{127}C\Gamma x.
  \]
  \begin{itemize}
    \item $Z_0$: integer payload; $B$: value-side scale matrix.
    \item $C$ and cumulative decay $\Gamma$ act on key coordinates.
    \item Compensator and real-token records are already in original coordinates.
  \end{itemize}
  \papersource{Paper, Appendix B.3, PDF p. 14.
  Multiplying residual scales into other records would change the represented recurrence.}
\end{frame}

\begin{frame}{Backup: generation settings are shared within each model}
  \centering
  \begin{tabular}{lrr}
    \toprule
    Setting & Both Qwen3.5 models & Kimi-Linear Instruct\\
    \midrule
    Temperature & 1.0 & 1.0\\
    Top-$p$ & 0.95 & 1.0\\
    Top-$k$ & 20 & --\\
    Presence penalty & 1.5 & 0\\
    Thinking & on & --\\
    Maximum output tokens & 81,920 & 65,536\\
    \bottomrule
  \end{tabular}
  \medskip
  \begin{itemize}
    \item Same prompts, sample set, and sampling settings for all methods of a model.
    \item Maximum model length = output limit + 8,192 tokens.
  \end{itemize}
  \papersource{Paper, Appendix E / Table 6, PDF p. 16.
  Kimi has no thinking mode; this table describes quality evaluation.}
\end{frame}

\begin{frame}{Backup: active-request buffers add to checkpoint storage}
  \centering
  \begin{tabular}{lrr}
    \toprule
    Record type & Values per token & FP16 bytes at $p=16$\\
    \midrule
    GDN & $1+d_k+d_v$ & 8,224\\
    KDA, explicit vector decay & $2d_k+d_v$ & 12,288\\
    \bottomrule
  \end{tabular}\par
  \medskip
  Here $d_k=d_v=128$; the buffer is allocated per active request, head, and layer.
  \begin{itemize}
    \item The main text quotes approximately 8 KiB, consistent with GDN's record count.
    \item The KDA figure above is a calculation from the appendix's explicit record layout.
    \item A cached boundary checkpoint does not need a full active-window buffer.
  \end{itemize}
  \papersource{Paper, memory discussion, PDF p. 8; Table 4, PDF p. 13.
  Buffer sizes calculated from the stated record counts; not measured allocator usage.}
\end{frame}

\begin{frame}{Reference and figure attribution}
  \textbf{LeapQuant: Efficient Linear Attention with Accurate Recurrent State Quantization}
  \medskip

  Yi Pan, Haocheng Xi, Kan Zhu, Xingyang Li, Yibo Wu,\\
  Mayank Mishra, Hongtao Zhang, William X. Zheng,\\
  Baris Kasikci, Song Han, Kurt Keutzer, Rishabh Iyer, Ion Stoica.
  \medskip

  \href{https://arxiv.org/abs/2609.38166v1}{arXiv:2609.38166v1, submitted 29 September 2026}
  \medskip

  Original figures reproduced from the authors' source package.\\
  Paper license: \href{https://creativecommons.org/licenses/by/4.0/}{Creative Commons Attribution 4.0}.
  \medskip

  This deck is an independent reading presentation.\\
  Quantitative tables are transcribed or explicitly calculated from this version.
\end{frame}

\end{document}