Pith. sign in

REVIEW 4 major objections 5 minor 2 cited by

UnMaskFork shows that masked diffusion language models scale at test time when search explores deterministic unmasking actions across multiple models, beating stochastic temperature-based scaling on code and math benchmarks.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

T0 review · deepseek-v4-flash

2026-08-03 04:37 UTC pith:FLZ2YZXY

load-bearing objection UMF is a genuinely new and promising TTS recipe for masked diffusion, but the cross-tokenizer re-encoding is underspecified and needs quantitative support before I'd trust the interleaving gains. the 4 major comments →

arxiv 2602.04344 v2 pith:FLZ2YZXY submitted 2026-02-04 cs.LG cs.AI

UnMaskFork: Test-Time Scaling for Masked Diffusion via Deterministic Action Branching

classification cs.LG cs.AI
keywords masked diffusion language modelstest-time scalingMonte Carlo tree searchdeterministic action branchingrollout cachingcode generationmathematical reasoninginference compute
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

UnMaskFork (UMF) is a test-time scaling method for masked diffusion language models (MDLMs) that treats the unmasking trajectory as a search tree and uses Monte Carlo tree search to decide which deterministic unmasking action to apply at each step. The paper's central claim is that structural diversity—branching across multiple pretrained MDLMs and deterministic remasking strategies at low temperature—scales better than the stochastic temperature-based sampling commonly used for autoregressive models. At a fixed budget of 12,288 function evaluations, UMF reaches 28.0/88.0/72.0 Pass@1 on LiveCodeBench/HumanEval+/MBPP+, outperforming the strongest tree-search baseline at 21.0/81.0/68.0. On 105 MATH problems, UMF improves from 49.52 to 60.95 Pass@1 as the budget grows, suggesting the approach transfers beyond code. The paper argues a reader should care because deterministic, reusable branching may be a more compute-efficient axis for scaling non-autoregressive generators than injecting noise.

Core claim

UMF's core discovery is that, for MDLMs, test-time scaling should derive diversity from deterministic structural variation rather than stochastic noise. The paper defines an action as an inference configuration — a model, a temperature, and a remasking strategy — and shows that when the transition is deterministic (greedy decoding with confidence-based token commitment), the same state-action pair can be cached, so revisiting a branch costs zero NFE. Using multiple pretrained MDLMs as alternative actions yields the largest gains, and a simple inequality over per-step KL errors shows that interleaving the locally best kernel per step can beat any single static kernel. Empirically, determinist

What carries the argument

The central object is the action tuple a = (θa, Ta, ga): model parameters, sampling temperature, and a deterministic remasking strategy, which together define a transition Fa from one partially masked state to the next. Because the paper uses low temperature and confidence-based deterministic token commitment, Fa is deterministic and therefore cacheable: intermediate states and terminal rewards along a rollout are stored, so revisiting the same state-action pair costs no extra forward passes. The UnMaskToNextRatio procedure advances a state to the next residual mask ratio, and MCTS with UCT (exploration coefficient 1) selects which actions to try, with a fixed schedule of mask ratios [0.9, 0

Load-bearing premise

The load-bearing premise is that low-temperature greedy unmasking with a fixed remasking strategy is perfectly deterministic in practice; if tie-breaking or batching introduces nondeterminism, cached rollouts become stale and the reported zero-cost reuse collapses.

What would settle it

Re-run the same (state, action) pair multiple times in a batched setting—say, a partially masked sequence with one of the coding models at its recommended low temperature and deterministic remasking—and compare the resulting tokens; if any run differs, the deterministic-transition assumption fails. Then recompute a cached rollout and check whether the stored reward matches; a mismatch means the cache is stale, invalidating UMF's zero-NFE reuse claim.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • With deterministic caching, the marginal cost of revisiting a known branch is zero, so larger inference budgets go to wider exploration; the paper shows continuing gains up to NFE=24,576 on LiveCodeBench.
  • Interleaving two models inside a single unmasking trajectory beats both independent ensembling and stochastic multi-model search, indicating that choice of model per step is a new effective scaling lever.
  • The variance analysis implies stochastic actions waste NFE on repeated rollouts for value estimation; future MDLM scaling methods should favor low-variance deterministic actions or variance reduction.
  • The framework transfers to mathematical reasoning with a process reward model, so it applies to any task with a scalar reward signal, not just unit-tested code.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • If batched inference violates the paper's fixed tie-breaking assumption, cached rollouts could disagree with true re-evaluations, so the reported NFE efficiency might be optimistic; this is testable but not tested in the paper.
  • The 'no structural degradation' from tokenizer re-encoding is only qualitative; a stress test that perturbs the re-encoding could reveal whether the multi-model interleaving gain is sensitive to round-trip fidelity, which the paper does not quantify.
  • The inequality in Sec 5.1 says the best per-step kernel can beat any fixed kernel, but identifying that best step requires search; as the action set grows, learned policies or value functions—which the paper lists as future work—may become necessary to keep the search efficient.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes UnMaskFork (UMF), a Monte Carlo Tree Search method for test-time scaling of masked diffusion language models. UMF defines actions as deterministic inference configurations (model choice, temperature, remasking strategy) and branches the unmasking trajectory by switching between these actions. Because low-temperature rollouts are treated as deterministic, intermediate states and rewards are cached and reused. The manuscript reports experiments on LiveCodeBench, HumanEval+, MBPP+, and MATH showing that UMF with Dream-Coder and LLaDA outperforms Best-of-N, DTS*, and AB-MCTS at matched NFE budgets, and ablations showing multi-model interleaving and caching drive the gains.

Significance. If the reported results are reproducible, UMF is a useful contribution to test-time scaling for non-autoregressive models: it provides a way to obtain diversity without the quality loss that the authors observe from high-temperature sampling, and its deterministic caching improves the NFE-vs-quality trade-off. The experimental protocol is largely internally consistent and often favorable to baselines (baseline temperatures are reported as the best among {0.1, 0.5, 1.0}). However, the main multi-model advantage rests on an underspecified cross-tokenizer re-encoding, and the action set is selected on the same benchmarks used for evaluation. Without quantitative evidence on re-encoding fidelity and a cleaner evaluation protocol, the central claim that interleaving model capabilities is superior is not fully supported. The MATH result is promising but based on only 105 problems.

major comments (4)
  1. [§4.3, Table 5] Multi-model UMF's largest gain (Table 5) depends on interleaving models with different tokenizers. The text-based mapping in §4.3 does not guarantee that the decoded/re-encoded sequence has the same token count or that the mask positions are preserved: BPE tokenizers with different vocabularies can split the same text into different numbers of tokens. If re-encoding changes length or alignment, the fixed 768-token state, the mask-ratio schedule, the cache key (z,a), and the UCT statistics are undefined. The only support is "we observed no structural degradation," which is qualitative. Please report quantitative round-trip statistics (e.g., distribution of token-count differences, position-level agreement after re-encoding), and specify padding/truncation and tie-breaking behavior.
  2. [§4.3, Table 1] The action set is selected using the same benchmarks on which UMF is then evaluated. §4.3 states "Extensive experiments in Section 6 confirmed..." and §6.3.2/Table 4 identify "model(Dream-Coder, LLaDA)" as the best action type on LiveCodeBench/HumanEval+/MBPP+. Baselines are also tuned on these benchmarks via best-temperature reporting, but UMF's multi-model interleaving is the paper's central idea and its configuration is not fixed a priori. This selection-on-test-data can inflate the reported margin. Please provide a pre-registered action set or hold out a separate benchmark for configuration choice.
  3. [§6.1.1, Tables 1–2] No error bars, confidence intervals, or significance tests are reported. Most comparisons are on 100 samples per benchmark, and some reported margins are modest (e.g., LiveCodeBench 28.0 vs 21.0 at NFE=12288, Table 1). The MATH evaluation uses only 105 problems, so the "strong scalability" claim in the abstract rests on a small sample. Please report variance over repeated evaluations or bootstrap CIs, and clarify whether all methods are evaluated on the same fixed set of problems.
  4. [§5.2, Eq. (1)] Eq. (1) is a standard inequality and does not by itself favor UMF over stochastic sampling; the authors acknowledge this. The variance argument in §5.2 is heuristic: "m∝Var[R]/ε²" describes Monte Carlo estimation, but the terminal reward is a deterministic function of the trajectory, and stochastic sampling does not automatically make the value estimate hard. More importantly, UMF's "Var[R]≈0" claim depends on fixed tie-breaking, which is only mentioned as an assumption in §3.3. If tie-breaking is not actually deterministic in batched inference, cached (z,a) rollouts may be invalid. Please specify how ties are broken and how determinism is enforced in implementation.
minor comments (5)
  1. [Abstract] Typographical issue: "proposeUnMaskFork" is missing a space; also a numbered list appears in the Introduction without a list environment.
  2. [Figures 3–4] Fig. 4 caption refers to a "starred node" but the text/figure does not clearly show a star. Please add the marker or describe the selection rule for the submitted node.
  3. [§6.1.3] The baseline count "16 (= (3 + 1)∗2∗2)" is opaque because the three temperatures only apply to the deterministic-remasking condition, while the random-remasking condition is at T≈0. Please spell out the configuration grid explicitly.
  4. [§3.3] The term "remasking strategy" is potentially confusing because the paper assumes monotonic unmasking and tokens are never actually re-masked. Consider using "unmasking/selection strategy" to avoid contradiction.
  5. [§6.3.3] The "Pair of single-model UMFs" baseline splits the total NFE equally between two models (6144 each). The manuscript does not report how ties are broken when both models produce equal reward; please specify.

Circularity Check

0 steps flagged

No significant circularity: UMF's central claims are empirical, Eq. (1) is a standard inequality, and the only self-citation (AB-MCTS) is a baseline, not load-bearing.

full rationale

The paper's claimed derivation chain is: (1) MDLM unmasking is formulated as a search tree; (2) actions are inference configurations (model, temperature, remasking strategy); (3) deterministic actions enable caching; (4) Eq. (1) motivates switching among actions. None of these steps reduces to its inputs by construction. Eq. (1) is the mathematically true inequality sum_t min_a <= min_a sum_t; the paper uses it only as a heuristic motivation for exploring diverse actions, not as a derivation of UMF's empirical advantage. The headline results are empirical comparisons against external baselines (Best-of-N, DTS*, AB-MCTS) on LiveCodeBench/HumanEval+/MBPP+ and MATH. The reward used for selection (public/standard tests) is distinct from the reported private/extended test sets, so this is standard best-of-N evaluation, not fitting a parameter and then calling it a prediction. The AB-MCTS baseline is from the authors' prior work (Inoue et al., 2025), a self-citation, but it is not load-bearing: it is one of several baselines and the comparison is empirical. The main substantive caveat is that the cross-tokenizer re-encoding (Sec. 4.3) is asserted to cause 'no structural degradation' without quantitative evidence, and the 'nearly deterministic' assumption (T=0.1 for Dream) is an idealization; however, these are missing validations or robustness concerns, not circularity. No prediction is equivalent to an input by construction, so the circularity score is low.

Axiom & Free-Parameter Ledger

2 free parameters · 3 axioms · 0 invented entities

No new physical or mathematical entities are postulated. The central claim rests on hand-chosen hyperparameters (c_exp, schedule), the monotonic-unmasking and determinism assumptions, and the unverified empirical validity of cross-tokenizer state mapping for interleaved model trajectories.

free parameters (2)
  • MCTS exploration coefficient c_exp = 1
    Set by hand in Sec 4.2; standard default but directly controls the exploration/exploitation trade-off in UCT.
  • Mask ratio schedule = [0.9,0.8,0.7,0.6,0.5,0.4,0.2]
    Chosen by hand in Sec 4.2 to sample early stages more frequently; no sensitivity analysis is reported.
axioms (3)
  • domain assumption Monotonic unmasking: positions once committed are never re-masked.
    Assumed in Sec 3.2; limits the search space and rules out correction through remasking. If remasking were allowed, the action space and caching scheme would change.
  • standard math Eq. (1): sum_t min_a eps_t^a <= min_a sum_t eps_t^a (adaptive kernel selection bound).
    Used in Sec 5.1 to justify interleaving models; the inequality itself is standard, but the mapping to actual MDLM ELBO error terms is asserted rather than derived.
  • domain assumption Low-temperature greedy transitions are deterministic given fixed tie-breaking.
    Sec 3.3; caching depends on identical state-action pairs producing identical transitions. Real batched inference may introduce nondeterminism, which would break cache validity.

pith-pipeline@v1.3.0-alltime-deepseek · 14440 in / 10389 out tokens · 95136 ms · 2026-08-03T04:37:17.408852+00:00 · methodology

0 comments
read the original abstract

Test-time scaling strategies have effectively leveraged inference-time compute to enhance the reasoning abilities of Autoregressive Large Language Models. In this work, we demonstrate that Masked Diffusion Language Models (MDLMs) are inherently amenable to advanced search strategies, owing to their iterative and non-autoregressive generation process. To leverage this, we propose UnMaskFork (UMF), a framework that formulates the unmasking trajectory as a search tree and employs Monte Carlo Tree Search to optimize the generation path. In contrast to standard scaling methods relying on stochastic sampling, UMF explores the search space through deterministic partial unmasking actions performed by multiple MDLMs. Our empirical evaluation demonstrates that UMF consistently outperforms existing test-time scaling baselines on complex coding benchmarks, while also exhibiting strong scalability on mathematical reasoning tasks.

Figures

Figures reproduced from arXiv: 2602.04344 by Kou Misaki, Takuya Akiba.

Figure 1
Figure 1. Figure 1: Conceptual diagram of UnMaskFork. Nodes generated during rollouts (dotted lines) and their evaluation results are cached to be reused in subsequent expansion steps, minimizing redundant computations. Algorithm 1 outlines the UMF procedure. One iteration of MCTS consists of three steps: Select, Expand, and Backup. Select. In the Select step, we traverse the tree from the root to a node where unexplored acti… view at source ↗
Figure 2
Figure 2. Figure 2: Scaling plots (Pass@1) on LiveCodeBench, HumanEval+, and MBPP+. selected for final evaluation. We report the Pass@1 score computed on the private test set (LiveCodeBench) and the extended test set (EvalPlus). Beyond coding, we also evaluated UMF on the MATH dataset (Hendrycks et al., 2021). We sampled 15 problems from each of the 7 categories, totaling 105 problems. We employed Qwen2.5-Math-PRM-7B (Zhang e… view at source ↗
Figure 3
Figure 3. Figure 3: Text generated by unmasking up to the starred node in [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Example of the UMF search tree for LiveCodeBench at NFE=12288. “D” denotes unmasking by Dream-Coder, and “L” denotes unmasking by LLaDA. The starred node represents the node used for submission, which is correct for this problem [PITH_FULL_IMAGE:figures/full_fig_p008_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Scaling plots (Pass@1) of LLaDA baselines on LiveCodeBench, HumanEval+, and MBPP+. 768 1536 3072 6144 12288 24576 NFE 10 20 30 pass@1 (%) LiveCodeBench 768 1536 3072 6144 12288 NFE 20 40 60 80 pass@1 (%) HumanEval+ 768 1536 3072 6144 12288 NFE 30 40 50 60 70 pass@1 (%) MBPP+ Best-of-N (Dream-Coder, T=0.1) DTS* (Dream-Coder, T=0.1) Best-of-N (Dream-Coder, T=0.1, remask=origin) UMF (Dream-Coder+LLaDA) Best-o… view at source ↗
Figure 6
Figure 6. Figure 6: Scaling plots (Pass@1) of Dream baselines on LiveCodeBench, HumanEval+, and MBPP+. A. Additional Results In this section, we present comprehensive results on coding tasks for the 28 baseline configurations discussed in Section 6.1.3. The scaling behaviors are illustrated in Figures 5, 6, 7, and 8. Unless otherwise specified, the default remasking strategies are entropy-based and low-confidence strategies. … view at source ↗
Figure 7
Figure 7. Figure 7: Scaling plots (Pass@1) of pair baselines on LiveCodeBench, HumanEval+, and MBPP+. 768 1536 3072 6144 12288 24576 NFE 10 20 30 pass@1 (%) LiveCodeBench 768 1536 3072 6144 12288 NFE 20 40 60 80 pass@1 (%) HumanEval+ 768 1536 3072 6144 12288 NFE 30 40 50 60 70 pass@1 (%) MBPP+ AB-MCTS (Dream-Coder+LLaDA, T=0.1) AB-MCTS (Dream-Coder, T=0.1) UMF (Dream-Coder+LLaDA) AB-MCTS (Dream-Coder+LLaDA, T=0.5) AB-MCTS (Dr… view at source ↗
Figure 8
Figure 8. Figure 8: Scaling plots (Pass@1) of ABMCTS baselines on LiveCodeBench, HumanEval+, and MBPP+. 12 [PITH_FULL_IMAGE:figures/full_fig_p012_8.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. VGB for Masked Diffusion Model: Efficient Test-time Scaling for Reward Satisfaction and Sample Editing

    cs.LG 2026-06 unverdicted novelty 7.0

    MDM-VGB augments masked diffusion with backtracking-style reward-guided remasking to achieve quadratic-complexity high-reward generation and sample editing, with proofs of noise robustness.

  2. CaRE Compute-aware Remasking Evaluation Protocol for Masked Diffusion Language Models

    cs.AI 2026-06 reject novelty 6.0

    CaRE shows that uncontrolled temperature and compute explain most MAUVE differences between MDLM remasking strategies, with high-entropy remasking reducing MAUVE under stochastic unmasking.

Reference graph

Works this paper leans on

28 extracted references · 6 linked inside Pith · cited by 2 Pith papers

  1. [1]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION format.date year duplicate empty "emp...

  2. [2]

    S., Gokaslan, A., Yang, Z., Qi, Z., Han, J., Chiu, J

    Arriola, M., Sahoo, S. S., Gokaslan, A., Yang, Z., Qi, Z., Han, J., Chiu, J. T., and Kuleshov, V. Block diffusion: Interpolating between autoregressive and diffusion language models. In The Thirteenth International Conference on Learning Representations, 2025. URL https://openreview.net/forum?id=tyEyYT267x

  3. [3]

    D., Ho, J., Tarlow, D., and van den Berg, R

    Austin, J., Johnson, D. D., Ho, J., Tarlow, D., and van den Berg, R. Structured denoising diffusion models in discrete state-spaces. In Beygelzimer, A., Dauphin, Y., Liang, P., and Vaughan, J. W. (eds.), Advances in Neural Information Processing Systems, 2021. URL https://openreview.net/forum?id=h7-XixPCAL

  4. [4]

    V., Ré, C., and Mirhoseini, A

    Brown, B., Juravsky, J., Ehrlich, R., Clark, R., Le, Q. V., Ré, C., and Mirhoseini, A. Large language monkeys: Scaling inference compute with repeated sampling, 2024. URL https://arxiv.org/abs/2407.21787

  5. [5]

    Inference-time scaling of diffusion language models with particle gibbs sampling, 2025

    Dang, M., Han, J., Xu, M., Xu, K., Srivastava, A., and Ermon, S. Inference-time scaling of diffusion language models with particle gibbs sampling, 2025. URL https://arxiv.org/abs/2507.08390

  6. [6]

    Diffucoder: Understanding and improving masked diffusion models for code generation

    Gong, S., Zhang, R., Zheng, H., Gu, J., Jaitly, N., Kong, L., and Zhang, Y. Diffucoder: Understanding and improving masked diffusion models for code generation. arXiv preprint arXiv:2506.20639, 2025

  7. [7]

    Measuring mathematical problem solving with the MATH dataset

    Hendrycks, D., Burns, C., Kadavath, S., Arora, A., Basart, S., Tang, E., Song, D., and Steinhardt, J. Measuring mathematical problem solving with the MATH dataset. In Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 2), 2021. URL https://openreview.net/forum?id=7Bywt2mQsCe

  8. [8]

    Argmax flows and multinomial diffusion: Learning categorical distributions

    Hoogeboom, E., Nielsen, D., Jaini, P., Forr \'e , P., and Welling, M. Argmax flows and multinomial diffusion: Learning categorical distributions. In Beygelzimer, A., Dauphin, Y., Liang, P., and Vaughan, J. W. (eds.), Advances in Neural Information Processing Systems, 2021. URL https://openreview.net/forum?id=6nbpPqUCIi7

  9. [9]

    Huang, Z., Ramnath, K., Chen, Y., Feng, A., Woo, S., Srinivasan, B., Xu, Z., Zhou, K., Wang, S., Ding, H., and Cheong, L. L. Diffusion language model inference with monte carlo tree search. arXiv preprint arXiv:2512.12168, 2025

  10. [10]

    Wider or deeper? scaling LLM inference-time compute with adaptive branching tree search

    Inoue, Y., Misaki, K., Imajuku, Y., Kuroki, S., Nakamura, T., and Akiba, T. Wider or deeper? scaling LLM inference-time compute with adaptive branching tree search. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2025. URL https://openreview.net/forum?id=jAsr5GHt3P

  11. [11]

    Livecodebench: Holistic and contamination free evaluation of large language models for code

    Jain, N., Han, K., Gu, A., Li, W.-D., Yan, F., Zhang, T., Wang, S., Solar-Lezama, A., Sen, K., and Stoica, I. Livecodebench: Holistic and contamination free evaluation of large language models for code. In The Thirteenth International Conference on Learning Representations, 2025 a . URL https://openreview.net/forum?id=chfJJYC3iL

  12. [12]

    Diffusion tree sampling: Scalable inference -time alignment of diffusion models

    Jain, V., Sareen, K., Pedramfar, M., and Ravanbakhsh, S. Diffusion tree sampling: Scalable inference -time alignment of diffusion models. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2025 b . URL https://openreview.net/forum?id=3D88hCO0Gd

  13. [13]

    M., and Chen, S

    Kim, J., Shah, K., Kontonis, V., Kakade, S. M., and Chen, S. Train for the worst, plan for the best: Understanding token ordering in masked diffusions. In Forty-second International Conference on Machine Learning, 2025. URL https://openreview.net/forum?id=DjJmre5IkP

  14. [14]

    and Szepesv \'a ri, C

    Kocsis, L. and Szepesv \'a ri, C. Bandit based monte-carlo planning. In F \"u rnkranz, J., Scheffer, T., and Spiliopoulou, M. (eds.), Machine Learning: ECML 2006, pp.\ 282--293, Berlin, Heidelberg, 2006. Springer Berlin Heidelberg. ISBN 978-3-540-46056-5

  15. [15]

    S., Wang, Y., and ZHANG, L

    Liu, J., Xia, C. S., Wang, Y., and ZHANG, L. Is your code generated by chat GPT really correct? rigorous evaluation of large language models for code generation. In Thirty-seventh Conference on Neural Information Processing Systems, 2023. URL https://openreview.net/forum?id=1qvx610Cu7

  16. [16]

    Discrete diffusion modeling by estimating the ratios of the data distribution

    Lou, A., Meng, C., and Ermon, S. Discrete diffusion modeling by estimating the ratios of the data distribution. In Forty-first International Conference on Machine Learning, 2024. URL https://openreview.net/forum?id=CNicRIVIPA

  17. [17]

    Large language diffusion models

    Nie, S., Zhu, F., You, Z., Zhang, X., Ou, J., Hu, J., ZHOU, J., Lin, Y., Wen, J.-R., and Li, C. Large language diffusion models. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2025. URL https://openreview.net/forum?id=KnqiC0znVF

  18. [18]

    S., Arriola, M., Gokaslan, A., Marroquin, E

    Sahoo, S. S., Arriola, M., Gokaslan, A., Marroquin, E. M., Rush, A. M., Schiff, Y., Chiu, J. T., and Kuleshov, V. Simple and effective masked diffusion language models. In The Thirty-eighth Annual Conference on Neural Information Processing Systems, 2024. URL https://openreview.net/forum?id=L4uaAR4ArM

  19. [19]

    Simplified and generalized masked diffusion for discrete data

    Shi, J., Han, K., Wang, Z., Doucet, A., and Titsias, M. Simplified and generalized masked diffusion for discrete data. In The Thirty-eighth Annual Conference on Neural Information Processing Systems, 2024. URL https://openreview.net/forum?id=xcqSOfHt4g

  20. [20]

    V., Lee, J., Xu, K., and Kumar, A

    Snell, C. V., Lee, J., Xu, K., and Kumar, A. Scaling LLM test-time compute optimally can be more effective than scaling parameters for reasoning. In The Thirteenth International Conference on Learning Representations, 2025. URL https://openreview.net/forum?id=4FWAwZtd2n

  21. [21]

    S., and Kuleshov, V

    Wang, G., Schiff, Y., Sahoo, S. S., and Kuleshov, V. Remasking discrete diffusion models with inference-time scaling. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2025. URL https://openreview.net/forum?id=IJryQAOy0p

  22. [22]

    V., Chi, E

    Wang, X., Wei, J., Schuurmans, D., Le, Q. V., Chi, E. H., Narang, S., Chowdhery, A., and Zhou, D. Self-consistency improves chain of thought reasoning in language models. In The Eleventh International Conference on Learning Representations, 2023. URL https://openreview.net/forum?id=1PL1NIMMrw

  23. [23]

    Dream-coder 7b: An open diffusion language model for code

    Xie, Z., Ye, J., Zheng, L., Gao, J., Dong, J., Wu, Z., Zhao, X., Gong, S., Jiang, X., Li, Z., and Kong, L. Dream-coder 7b: An open diffusion language model for code. arXiv preprint arXiv:2509.01142, 2025

  24. [24]

    Dream 7b: Diffusion large language models

    Ye, J., Xie, Z., Zheng, L., Gao, J., Wu, Z., Jiang, X., Li, Z., and Kong, L. Dream 7b: Diffusion large language models. arXiv preprint arXiv:2508.15487, 2025

  25. [25]

    Monte carlo tree diffusion for system 2 planning

    Yoon, J., Cho, H., Baek, D., Bengio, Y., and Ahn, S. Monte carlo tree diffusion for system 2 planning. In Forty-second International Conference on Machine Learning, 2025. URL https://openreview.net/forum?id=XrCbBdycDc

  26. [26]

    Tree reward-aligned search for treasure in masked diffusion language models

    Yu, Z., Li, M., Zhang, W., and Gao, W. Tree reward-aligned search for treasure in masked diffusion language models. arXiv preprint arXiv:2509.23146, 2025

  27. [27]

    The lessons of developing process reward models in mathematical reasoning

    Zhang, Z., Zheng, C., Wu, Y., Zhang, B., Lin, R., Yu, B., Liu, D., Zhou, J., and Lin, J. The lessons of developing process reward models in mathematical reasoning. In Che, W., Nabende, J., Shutova, E., and Pilehvar, M. T. (eds.), Findings of the Association for Computational Linguistics: ACL 2025, pp.\ 10495--10516, Vienna, Austria, July 2025. Association...

  28. [28]

    Llada 1.5: Variance-reduced preference optimization for large language diffusion models, 2025

    Zhu, F., Wang, R., Nie, S., Zhang, X., Wu, C., Hu, J., Zhou, J., Chen, J., Lin, Y., Wen, J.-R., and Li, C. Llada 1.5: Variance-reduced preference optimization for large language diffusion models, 2025. URL https://arxiv.org/abs/2505.19223