wikillm

Paper · 2026-10-22 · cs.LG

Speculative Diffusion is a Tale of Two Tradeoffs

Speculative decoding with a diffusion drafter that runs K denoising steps per verifier call, plus lenient acceptance that shifts the verifier toward the draft by weight lambda. Jointly varying K and lambda traces speed-quality Pareto frontiers that extend single-step diffusion drafting, per the authors. Headline results are in figures only; text gives baseline accuracies and a throughput model.

Speculative decodingDiscrete diffusioninferencedecodingspeculative-decodingdiffusion-language-modelrejection-sampling

arXivPDFMarkdown18 min read

AI-compiled by claude-haiku-5-5 on 2026-11-21, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.

In plain words

Large language models write one token at a time, which is slow. A common speed-up uses a small, fast "drafter" model to guess several tokens ahead; the big model then checks the whole guess in one pass and keeps the tokens it agrees with. Diffusion language models are a different kind of drafter: they fill in a whole block of tokens in parallel, and they can be run for more or fewer refinement passes. More passes give better guesses but cost more time.

The verifier can also be made more lenient. Instead of keeping only the tokens it would have produced itself, it accepts some guesses that it would have rejected. This is faster, but the output is no longer exactly the big model's output. The authors treat these as two separate knobs: how hard the drafter works, and how lenient the check is. They argue that the best trade-off between speed and quality comes from turning both knobs together, not from turning either one alone. Their experiments on maths, coding and reasoning questions are consistent with that claim.

TL;DR

  • Speculative decoding with a diffusion drafter that runs K denoising steps per verifier call, with a linear acceptance leniency λ that mixes the verifier distribution with the draft distribution. §3.2 alg. 1 eq. 5
  • λ = 0 is lossless; λ = 1 accepts every drafted token. §2
  • Joint variation of K and λ extends the speed-quality Pareto frontier beyond single-step drafting in the authors' runs (author-reported). §4.2 fig. 4 fig. 5
  • The text states no headline speed or accuracy numbers for the frontiers; they appear only in figures, so the card does not quote them. fig. 4 fig. 5
  • No official code was found. [Paper vs code]

Problem

Autoregressive decoding is bound by its one-token-at-a-time order §1. Lossless speculative decoding keeps the verifier's exact distribution, but its speed-up is limited by how closely the drafter matches the verifier §1 §2. Lossy variants relax the exact guarantee to gain speed §1 §2. Diffusion drafters can produce several tokens per call, but their quality depends on how many denoising steps they take §1 §2. The authors ask what happens when both knobs are varied together, and they note that the proposal probability of a multi-step diffusion draft is not directly defined, which makes exact rejection sampling unclear §3.2.

Method

Background (the two parameters). A diffusion drafter generates one block of B tokens conditioned on a prefix h, using K denoising steps; K is called "diffusion effort" §2. Standard speculative decoding accepts a drafted token y with probability min{1, p(y|h)/q(y|h)} and resamples a rejected position from [p − q]_+ §2. Lossy acceptance replaces the verifier p by a modified target p~ chosen before the draft token is drawn; the acceptance rate is then 1 − D_TV(p~, q) §2.

Linear acceptance. The authors use the mixture p~ = (1 − λ) p + λ q eq. 5. Under a total-variation budget ε, the optimal target at a fixed prefix is the mixture with λ = ε / D_TV(p, q), and it reaches acceptance 1 − D_TV(p, q) + ε (Theorem 1, proof in app. A and app. B) §2 eq. 5. Lossless sampling is λ = 0 and λ = 1 samples from the draft §2.

Cactus (comparison). Cactus instead changes the verifier after it sees the drafted token. It sets the target probability of that token to γ, the largest value whose KL divergence from the verifier's probability stays within a budget δ, and rescales the other tokens to keep a distribution §2 app. E eq. 17. The paper's experiments solve for γ with Newton's method; a second-order Taylor approximation is given as a closed form app. E eq. 18.

Speculative diffusion loop. Each round drafts B tokens with K steps, runs the verifier once to get B + 1 next-token distributions, builds the relaxed target for each drafted position, accepts tokens in order until the first rejection, and then either resamples the rejected position or draws one bonus token from the verifier if all B were accepted alg. 1 §3.2.

Pseudocode
# Speculative diffusion  [alg. 1]
# Arguments: current context h; draft length B; number of refinement
#            passes K; drafter; verifier; relax_target (linear or Cactus)
# Returns: the context extended by the tokens committed this run

def speculative_diffusion(h, B, K, f, p, relax_target):
    # Repeat rounds until the end-of-sequence token appears  [alg. 1]
    while EOS not in h:
        # Draft B tokens in K denoising steps; keep the vectors q that
        # produced each token  [§3.2] [alg. 1]
        y, q = diffusion_draft(f, h, B, K)  # y (B,), q (B, V)
        # One verifier pass gives B + 1 next-token distributions  [alg. 1]
        p_all = verifier_forward(p, h, y)  # (B + 1, V)
        # Target for each drafted position, built from p, q and y  [alg. 1]
        p_tilde = relax_target(p_all[:B], q, y)  # (B, V)
        k = 0
        # Accept position k with probability min(1, p~ / q)  [alg. 1] [§2]
        while k < B and uniform() <= p_tilde[k][y[k]] / q[k][y[k]]:
            k = k + 1
        # Rejected at k: resample from the normalised residual  [alg. 1]
        if k < B:
            residual = relu(p_tilde[k] - q[k])
            new_token = sample(residual / sum(residual))
        # All B accepted: draw the bonus token from the verifier  [alg. 1]
        else:
            new_token = sample(p_all[B])
        # Keep the accepted prefix, then the corrected or bonus token  [alg. 1]
        h = h + y[:k] + [new_token]
    # Return the sequence cut at EOS  [alg. 1]
    return truncate(h)

Linear relaxation, the target used in the main experiments:

Pseudocode
# Linear acceptance target  [§2] [eq. 5]
# lam in [0, 1]: 0 is lossless, 1 accepts every drafted token
def linear_relax_target(p_rows, q_rows, lam):
    # Shift each position's verifier distribution toward the draft  [eq. 5]
    return (1 - lam) * p_rows + lam * q_rows  # (B, V)

Cactus, closed form from the second-order Taylor expansion. The experiments use Newton's method instead app. E:

Pseudocode
# Cactus approximation for the drafted token  [app. E] [eq. 18]
# p_y: verifier probability of the drafted token; delta: KL budget
def cactus_gamma_taylor(p_y, delta):
    # Taylor-approximate the KL constraint and solve for gamma  [app. E]
    gamma = p_y + sqrt(2 * delta * p_y * (1 - p_y))
    # Cap the new probability at one  [app. E]
    return min(gamma, 1.0)
    # Cactus then accepts the token with probability min(1, gamma / q)  [app. E]

Why the proposal is the final-step vector. Multi-step drafting does not keep the autoregressive property that each position is conditioned on accepted tokens, and a token can come from many denoising trajectories §3.2. The authors propose using the final-step probabilities (final transition probabilities for uniform diffusion, marginals for masked diffusion) as the proposal probabilities q §3.2. Proposition 2 states that rejection sampling with a fixed target p~ and a random proposal Q, whose distribution is unknown, gives outcome distribution p~ app. D eq. 15 eq. 16.

Throughput model. Let ᾱ be the expected acceptance rate and d_K the verifier-draft total-variation distance at K steps with no leniency. Then ᾱ_K(λ) = 1 − (1 − λ) d_K and the verifier agreement is 1 − λ d_K §3.3 eq. 6. Drafter time is c_d(K) ≈ a + bK, verifier time c_v is constant, and throughput is modelled as the expected tokens per round divided by round time §3.3 eq. 7. Expected tokens per round are the geometric sum over j = 0..B of ᾱ^j app. C eq. 9.

Pseudocode
# Acceptance and verifier agreement at effort K and leniency lam  [§3.3] [eq. 6]
def speed_quality(d_K, lam):
    # Expected acceptance: 1 - D_TV(p~, q)  [§3.3]
    alpha_bar = 1 - (1 - lam) * d_K
    # Agreement with the verifier: 1 - D_TV(p, p~)  [§3.3]
    agreement = 1 - lam * d_K
    return alpha_bar, agreement
Pseudocode
# Predicted throughput in tokens per unit time  [§3.3] [eq. 7] [app. F.4]
# alpha_bar: expected acceptance; B: block size (512 in calibration)
def predicted_throughput(alpha_bar, K, B, a, b, c_verify):
    # Expected tokens per round as a geometric sum  [app. C] [eq. 9]
    tokens = sum(alpha_bar ** j for j in range(B + 1))
    # Drafter cost is linear in K, verifier cost is constant  [§3.3]
    round_time = (a + b * K) + c_verify
    return tokens / round_time

Key equations, as printed in the paper:

\alpha(h) = \sum_{v} \min\{p(v \mid h), q(v \mid h)\} = 1 - D_{\mathrm{TV}}(p, q) eq. 1

D_{\mathrm{TV}}(p, q) = \tfrac{1}{2} \sum_{v} |p(v) - q(v)| eq. 2

\tilde p^\star(v \mid h) = (1-\lambda)\, p(v \mid h) + \lambda\, q(v \mid h), \qquad \lambda = \frac{\epsilon}{D_{\mathrm{TV}}(p(\cdot \mid h), q(\cdot \mid h))} eq. 5

\bar\alpha_K(\lambda) = 1 - (1-\lambda)\, d_K, \qquad 1 - \overline{D}_{\mathrm{TV}}(p, \tilde p) = 1 - \lambda\, d_K eq. 6

\mathcal{T}(K, \bar\alpha) = \frac{\sum_{j=0}^{B} \bar\alpha^{\,j}}{c_d(K) + c_v} eq. 7

\Phi(\gamma) = \gamma \log \frac{\gamma}{p(y \mid x_{<t})} + (1-\gamma) \log \frac{1-\gamma}{1-p(y \mid x_{<t})} \le \delta eq. 17

Hyperparameters

Setup from app. F. Values are as printed; "not stated" means the paper does not give them.

NameValueWhereNotes
Hardwaresingle H200 GPUapp. Fabsolute latency is hardware-specific
Drafter / verifier pair 1Dream-v0-Instruct-7B / Qwen2.5-32B-Instructtab. 2 §4.1masked diffusion
Drafter / verifier pair 2diffusiongemma-26B-A4B-it / gemma-4-31B-ittab. 2 §4.1uniform diffusion (as the paper classifies it); the 26B-A4B name is as printed
Shared verifierQwen3-8B§4.3 tab. 2the Qwen3-8B checkpoint itself is not listed in tab. 2; only s-sahoo/uno-qwen3-8B is
Other draftersSDAR-8B-Chat-b16, SDAR-1.7B-Chat-b16, Uno (s-sahoo/uno-qwen3-8B), DFlash (z-lab/Qwen3-8B-DFlash-b16), DSpark (deepseek-ai/dspark_qwen3_8b_block7)tab. 2HF ids as printed
AR drafter in motivating exampleQwen2.5-1.5B-Instruct§3.1checkpoint id not in tab. 2
Thinking modedisabled for all modelsapp. F.2
Generation limit512 (GSM8K, HumanEval); 2048 (GPQA)app. F.2 tab. 4
Dream block sizeremaining generation canvas, at most 512tab. 4 app. G.2G.2 also sweeps B = 32, 64, 128
DiffusionGemma block size256app. F.2 tab. 4
SDAR and Uno block size16tab. 4
DFlash block16 positions (1 anchor + 15 draft)tab. 4
DSpark block7tab. 4
Dream baseline steps512 (GSM8K, HumanEval); 1024 (GPQA)app. F.1used to select benchmarks
Dream unmaskingentropy-based, deterministic position selectionapp. F.2per-step schedule not stated
DiffusionGemma baseline capnative sampler, up to 48 stepsapp. F.1
DiffusionGemma as drafterfixed K steps replacing its entropy-bound samplerapp. F.2how the K-step schedule is built is not stated
SDAR baseline thresholdτ = 0.9app. F.1
SDAR drafter effortτ ∈ {0.3, 0.5, 0.7, 0.9}, or fixed K = 1app. F.2 tab. 4commits tokens whose confidence exceeds τ
Uno effortK = 1 in main results; K ∈ {1, 2, 4} in G.5tab. 4 app. G.5
DFlash, DSpark draftingreleased procedures; λ variedapp. F.2DSpark keeps confidence threshold 0
Linear λ grid (main sweeps){0, 0.1, …, 1}app. F.3
Linear λ grid (shared verifier, Uno){0, 0.2, 0.4, 0.6, 0.8, 1}§4.3 app. G.5
Dream K (GSM8K){1, 2, 3, 4}app. F.3 tab. 4
Dream K (HumanEval){1, 2, 3} in F.3; {1, 2, 3, 4} in tab. 4 and tab. 5app. F.3conflict, see Pitfalls
DiffusionGemma K (GPQA){1, 2, 4, 8}app. F.3 tab. 4
DiffusionGemma K (HumanEval){1, 2, 4, 6, 10}app. F.3 tab. 5
Throughput model block sizeB = 512app. F.4
Throughput calibration50 random GSM8K questions; K ∈ {1, 2, 3, 4}app. F.4
Cactus solverNewton's method on Φ(γ) = δapp. ETaylor form is an approximation only
Cactus budget δsee Table 5 belowtab. 5units not stated
Drafting cost a, b; verifier cost c_vnot stated in textapp. F.4 fig. 6fitted values are only in figure 6

Sampling settings from tab. 3 (A dash means no extra truncation was recorded):

SamplerTemperatureTop-pTop-k
Dream draft / standalone0.20.95–
Qwen2.5-32B verifier0.70.820
DiffusionGemma draft / standalone0.8 → 0.4 (annealed during denoising)0.95–
Gemma-4-31B verifier1.00.9564
SDAR draft0.60.9520
Uno draft1.00.9550
DFlash draftgreedy––
DSpark draft1.0––
Qwen3-8B verifier / AR1.00.9550

For DiffusionGemma, the temperature is annealed over the denoising steps, and a one-step run uses 0.4 instead tab. 3.

Main experimental configurations from tab. 4:

PairBenchmarkEffort (K or τ)LeniencyDraft lengthMax new tokens
Dream 7B + Qwen2.5 32BGSM8KK ∈ {1, 2, 3, 4}Cactus≤ 512512
Dream 7B + Qwen2.5 32BHumanEvalK ∈ {1, 2, 3, 4}Cactus≤ 512512
DiffusionGemma 26B-A4B + Gemma-4 31BGPQAK ∈ {1, 2, 4, 8}Cactus2562048
DiffusionGemma 26B-A4B + Gemma-4 31BGPQAK ∈ {1, 2, 4, 8}Linear2562048
SDAR 8BGSM8K, HumanEvalτ ∈ {0.3, 0.5, 0.7, 0.9} or fixed K = 1Linear16512
SDAR 1.7BGSM8K, HumanEvalτ ∈ {0.3, 0.5, 0.7, 0.9} or fixed K = 1Linear16512
UnoGSM8K, HumanEvalK = 1Linear16512
DFlashGSM8K, HumanEvalone draft passLinear16512
DSparkGSM8K, HumanEvalfixed samplerLinear7512

Cactus budgets δ per effort level, as printed in tab. 5 (the ellipses are kept as printed):

Model pair / datasetKBudgets δ
Dream–Qwen / GSM8K10, 0.25, 0.5, 1, …, 8
Dream–Qwen / GSM8K20, 0.25, 0.5, 1, …, 11
Dream–Qwen / GSM8K30, 0.25, 0.5, 1, …, 13
Dream–Qwen / GSM8K40, 0.25, 0.5, 1, …, 15
DiffusionGemma–Gemma / GPQA10, 0.25, 0.5, 1, …, 5
DiffusionGemma–Gemma / GPQA20, 0.25, 0.5, 1, …, 6
DiffusionGemma–Gemma / GPQA40, 0.25, 0.5, 1, …, 8, 10
DiffusionGemma–Gemma / GPQA81, 3, 5, 7, 10, 15
Dream–Qwen / HumanEval10, 0.25, 0.5, 1, …, 6
Dream–Qwen / HumanEval20, 0.25, 0.5, 1, …, 12
Dream–Qwen / HumanEval30, 0.25, 0.5, 1, …, 13
Dream–Qwen / HumanEval40, 0.25, 0.5, 1, …, 15
DiffusionGemma–Gemma / HumanEval10, 0.25, 0.5, 1, …, 8
DiffusionGemma–Gemma / HumanEval20, 0.25, 0.5, 1, …, 12
DiffusionGemma–Gemma / HumanEval40, 0.25, 0.5, 1, …, 16
DiffusionGemma–Gemma / HumanEval60, 0.25, 0.5, 1, …, 15
DiffusionGemma–Gemma / HumanEval100.25, 0.5, 1, …, 15, 20

Benchmarks: 500 randomly drawn GSM8K questions, all 198 GPQA Diamond items and all 164 HumanEval problems app. F.1 tab. 1. GSM8K and GPQA are graded on the extracted final answer; HumanEval accuracy comes from running the generated code against its tests, reported as pass@1. Exactly one completion per problem app. F.1. Pairs are kept only when the drafter beats random and the two models differ in accuracy; these criteria are not given as numbers §4.1.

Results

Author-reported. Setup: standalone baseline accuracy for each drafter and verifier, one standard error, on the benchmarks in app. F.1 tab. 1. The gap column is verifier minus drafter as printed.

Model pairBenchmarknDrafter (%)Verifier (%)Gap (pp)
Dream 7B → Qwen2.5 32BGSM8K50079.8 ± 1.895.0 ± 1.0+15.2
Dream 7B → Qwen2.5 32BHumanEval16457.3 ± 3.984.8 ± 2.8+27.4
Dream 7B → Qwen2.5 32BGPQA Diamond19822.7 ± 3.045.5 ± 3.5+22.7
SDAR 8B → Qwen3 8BGSM8K50085.0 ± 1.692.2 ± 1.2+7.2
SDAR 8B → Qwen3 8BHumanEval16439.6 ± 3.885.4 ± 2.8+45.7
SDAR 8B → Qwen3 8BGPQA Diamond19825.3 ± 3.143.4 ± 3.5+18.2
DiffusionGemma 26B-A4B → Gemma-4 31BGSM8K50096.4 ± 0.896.6 ± 0.8+0.2
DiffusionGemma 26B-A4B → Gemma-4 31BHumanEval16491.5 ± 2.293.3 ± 2.0+1.8
DiffusionGemma 26B-A4B → Gemma-4 31BGPQA Diamond19864.1 ± 3.473.2 ± 3.1+9.1

Source: tab. 1. The main pairs are scored on different sets: Dream and SDAR on the math and code sets, DiffusionGemma on GPQA §4.1. Dream and SDAR are dropped on GPQA because they perform worse than random there app. F.1.

Cost-model values fitted by profiling the Dream-7B drafter against Qwen2.5-32B on 50 GSM8K questions app. F.4:

Kd_K (TV, no leniency)Lossless acceptance 1 − d_K
10.5660.434
20.5170.483
30.4240.576
40.3600.640

Qualitative results, as the authors state them. No frontier coordinates or speed-up factors are given in the text; read them from the figures.

SettingFinding (author-reported)Source
Motivating example, Dream 7BA diffusion drafter can run over 10× faster; an AR drafter with leniency covers a much narrower speed range and does not reach the full frontier; Dream's accuracy plateaus at high step counts§3.1 fig. 2
Throughput modelThe acceptance-quality trade-off is roughly linear; no single K captures the full throughput-quality frontier§3.3 fig. 3
Masked pair (Dream–Qwen) and uniform pair (DiffusionGemma–Gemma), Cactus acceptance; the Fig. 4 caption names no benchmarkSeveral K values contribute to the Pareto frontier; low K with strict acceptance gives the high-accuracy end, high K with lenient acceptance gives the high-speed end§4.2 fig. 4
Block-size ablation, Dream–Qwen GSM8KThe pattern holds for B = 32, 64, 128 and the remaining-canvas setting; no single K covers the frontierapp. G.2 fig. 9
SDAR (8B and 1.7B) with Qwen3-8BJoint variation over τ or K and λ substantially improves SDAR's speed-accuracy frontier versus K = 1§4.3 fig. 5 app. G.4
One-step specialised drafters (Uno, DFlash, DSpark)They remain strong, especially in throughput§4.3 fig. 5
Uno with K = 1, 2, 4K = 1 alone reproduces the latency frontier on both benchmarks and the HumanEval throughput frontier. A low-accuracy K = 2 point also sits on the GSM8K throughput frontier; K = 4 sits on neitherapp. G.5 fig. 13
Cactus vs linear acceptanceFig. 4 uses modified Cactus; linear acceptance is qualitatively similar§4.2 app. G.1 fig. 7 fig. 8
Failure modes at high leniency (Dream, GSM8K and HumanEval)Repetition, formatting markers and syntax errors appear at high λ; examples are printed in fullapp. H

Paper vs code

No official code.

Searched, in order:

  1. The paper's abstract page and arXiv metadata: no code or project link, and no comments field.
  2. The LaTeX source: no repository URL. The only GitHub link is a math macro library, and the Hugging Face checkpoints in tab. 2 are model cards, not this paper's code. A TeX comment refers to a run directory named vgdllm-runs app. F (comment in the source), which is the only hint of an internal project name.
  3. GitHub repository search for vgdllm, speculative diffusion tradeoffs, speculative diffusion lenient, dream speculative decoding diffusion, speculative diffusion (62 results; the page was read only in part and none of the visible owners is an author) and daniel israel diffusion. Also a GitHub user search for daniel israel ucla. All returned no matching repository belonging to the authors; the vgdllm search with a second term returned 403.

Pitfalls

  • Headline numbers are only in figures. The text gives no frontier coordinates and no speed-up factor for the joint variation. Do not infer them from the abstract; read fig. 4 and fig. 5 or the appendix figures.
  • Multi-step rejection sampling is only proven for a fixed target. Proposition 2 assumes a fixed target p~ and a random proposal Q app. D. Algorithm 1 builds p~ from the drafter vector q_{1:B} alg. 1, which is the same random quantity that is the proposal. The paper does not show that the guarantee holds in that case. This is an inference from the algorithm and the proof, not something the authors state. With λ = 0 the target is the verifier itself, so exact sampling is not in doubt there.
  • The proposal must be the vector that produced the token. The acceptance ratio and the residual both use q, so the card's q must be the exact vector sampled from alg. 1 §3.2. The text says "final step probabilities" but does not say whether these are the vectors at the step where each token was committed or at the last step of the whole block.
  • Cactus has no stated correction rule. Cactus defines the target only at the drafted token and rescales the rest app. E. Algorithm 1 resamples rejected positions from normalised [p~ − q]_+ alg. 1. The paper does not say how this residual is formed when p~ depends on the sampled y.
  • Global λ versus Theorem 1. Theorem 1 gives λ = ε / D_TV(p, q) per prefix §2 eq. 5. The sweeps use one λ in [0, 1] for all positions app. F.3. The text does not say whether the experiments use the per-prefix form. The card's linear_relax_target uses a constant λ, which the sweeps imply.
  • Cactus budget units and edge cases. δ is a KL budget with the logarithm base not stated app. E tab. 5. The closed form is given only for 0 < p(y) < 1 app. E. Behaviour at p(y) = 0 or 1 is not stated.
  • Taylor form is not what the experiments use. The γ closed form app. E is an approximation; the experiments solve it with Newton's method. Use the Newton solution to reproduce the reported runs.
  • Cost model assumes universal acceptance. The authors say the assumption of a single ᾱ across positions is incorrect and that leniency changes the prefix distribution §3.3. Proposition 1 also assumes independent, identically distributed acceptance app. C. Use the model for trends only.
  • Fitted cost constants are not in the text. a, b and c_v are fitted in fig. 6 only app. F.4; the card does not give numbers.
  • Drafting schedules are underspecified. The text gives the unmasking rule for Dream (entropy-based, deterministic positions) but not the per-step schedule that maps K to positions app. F.2. For DiffusionGemma the change from its entropy-bound sampler to fixed K is not described app. F.2. For SDAR the rule "commits tokens whose confidence exceeds τ" does not say what happens when none does app. F.2.
  • K and latency are not fixed for SDAR. Its number of denoising passes varies with τ app. F.2, so its points on the latency axis are not matched at equal K.
  • Gap column rounding. Four rows of tab. 1 differ by 0.1 pp from the difference of the printed means: Dream HumanEval (84.8 − 57.3 = 27.5, printed +27.4), Dream GPQA (45.5 − 22.7 = 22.8, printed +22.7), SDAR HumanEval (85.4 − 39.6 = 45.8, printed +45.7) and SDAR GPQA (43.4 − 25.3 = 18.1, printed +18.2). The source says gaps were computed before rounding tab. 1; use the printed values.
  • Internal inconsistencies.
    • Dream HumanEval effort: K ∈ {1, 2, 3} in app. F.3, but K ∈ {1, 2, 3, 4} in tab. 4 and tab. 5.
    • DiffusionGemma: "only run on GPQA Diamond" §4.1, but app. G.3 and tab. 5 include DiffusionGemma–Gemma HumanEval sweeps.
    • λ grid: 0.1 steps in app. F.3; 0.2 steps in §4.3 and app. G.2.
  • Single runs, no frontier uncertainty. Each problem gets one completion app. F.1. Standard errors are given only for the baseline accuracies tab. 1. The text gives no uncertainty for frontier points, so small differences between frontiers may be noise.
  • Latency and throughput both matter. Throughput can be inflated by long unnecessary output and latency by short outputs; the authors report both §4.2. Compare frontiers on both axes.
  • Benchmark selection is judgement-based. Pairs were excluded when the two models were nearly equal or the drafter was worse than random §4.1, without numeric thresholds. DiffusionGemma on GSM8K and HumanEval was dropped on this basis, but see the inconsistency above.
  • Review annotations in the source. The TeX source carries review markup: blue highlight macros around some figures and the theorem box, and comments. The text used here is the uncoloured prose.

Lineage

Source and license

Adapted from “Speculative Diffusion is a Tale of Two Tradeoffs” by Aaron Zorel, Guy Van den Broeck, Aditya Grover, Daniel Israel (arXiv:2610.31819), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors.