WorksComputer Science
Learning When Diffusion Language Models Should Regenerate
Abstract
Remasking allows diffusion language models to revisit generated text, but effective correction requires knowing when and what to revise. Our diagnosis on Sudoku reveals two gaps. Hidden states contain error information that token confidence does not reliably expose, and remasking an isolated error usually reproduces it when the surrounding context remains fixed. These findings motivate DiVR , a verifier that predicts whether a partially generated sequence will reach a correct answer. Trained on the final correctness of the model's own trajectories, DiVR decides when to regenerate a block and which alternative to retain, while the generator itself stays unchanged. On five reasoning benchmarks with LLaDA-8B-Base, DiVR raises the average accuracy of the fine-tuned generator from 35.3% to 43.4% at - the cost of greedy decoding, above search baselines that use -. It also complements post-training such as supervised fine-tuning and reinforcement learning, and generalizes to other generators, including Dream.
Introduction
Masked diffusion language models (MDLMs) generate text by repeatedly filling in the masked positions of a partially completed canvas, predicting every position with the whole response in view ([27, 22, 34]). This joint generation helps on planning tasks such as Sudoku and Countdown ([33]), reduces the number of sequential steps ([11, 31]), and in principle allows generated tokens to be masked again and revised ([29]).
In practice, standard MDLM decoding never revisits a committed token ([22]), so a wrong answer committed early with high confidence tends to remain ([39]). Remasking samplers and search methods add revision, but decide what to revise by a schedule, the model’s confidence or likelihood, a planner or prompted self-verification ([29, 8, 25, 18, 2]), none of which is trained to predict whether the final answer is correct. Learned alternatives act on individual tokens, through scorers trained against a reference sequence, unmasking policies or uniform-noise training ([14, 10, 38, 12, 28]), although in free-form reasoning a token that departs from the reference may still belong to a correct solution. Others borrow an external process reward model trained on autoregressive solutions ([21, 6, 20, 19]), a second large model that never sees the generator’s states.
Recent work shows that MDLM hidden states carry correctness information about the sequence as a whole. The final answer is often identifiable before decoding ends ([15]), correct intermediate answers are sometimes overwritten ([30]), and hidden states predict whether the output will be correct ([4, 39]). It remains open whether this information pinpoints which tokens are wrong, and whether locating an error is enough to repair it.
We answer both questions on Sudoku, where the unique solution labels every cell, and find two gaps. Error information is present at the level of individual cells, but confidence does not expose it, as a linear probe on hidden states separates wrong cells from correct ones better than confidence does (AUROC 0.838 versus 0.685). Locating an error, in turn, does not repair it. Re-predicting exactly the wrong cells fixes only 6 of 77 failures because the retained context keeps supporting the mistake, and reopening part of the preceding reasoning raises this only to 13. Repair therefore requires revising the context together with the error.
Guided by this diagnosis, we propose DiVR (Diffusion Verifier for Regeneration).1 DiVR shares the generator’s backbone, scores the partially masked canvas after each block, and regenerates the whole block when the score is low, keeping the best-scoring alternative or the original. It is trained only on the generator’s own decodes labelled by final-answer correctness, so it needs answer checks but no token-level labels ([5, 35]). Our contributions are as follows.
A diagnosis on Sudoku showing that MDLM errors are readable from hidden states but persist when only the erroneous tokens are re-predicted (§ 2).
DiVR, an outcome-supervised verifier that shares the generator’s weights and decides when to regenerate a block and which alternative to keep (§ 3).
Experiments on five math and code benchmarks and three generators, in which DiVR outperforms the search baselines SR-SMC and Prism at a fraction of their cost, transfers to benchmarks and generators it was not trained on, and adds to supervised and reinforcement-learning post-training. Most of its repairs begin in the first block of a solution, as the diagnosis predicts (§ 4).
Diagnosis: Readable Errors, Persistent Mistakes
We ask whether an MDLM’s errors are represented in its hidden states, whether its confidence exposes them, and whether reopening an erroneous position repairs it. Sudoku answers these questions with token-level ground truth, because every cell of a uniquely solvable puzzle has exactly one correct digit.
Setup. We study LLaDA-8B-Instruct after one epoch of supervised training on Sudoku propagation traces, on the 190 uniquely solvable evaluation puzzles of d1 ([41]), with a 128-token canvas, 128 steps and temperature zero. We analyze two decoders. Commit-once fills masked positions in confidence order and never changes them, and confidence-based remasking may mask filled positions again, so that the model can revise a committed mistake. Linear probes on answer-position hidden states are compared with confidence, scored as , on the same observations (Appendix § 8).
Finding 1. Representations expose errors more reliably than confidence. On remasking trajectories, the final-layer probe separates wrong from correct cells with AUROC 0.838 at the final state, against 0.685 for confidence (Figure 1a). The information is already present when a digit is first chosen. At the forward pass that first fills a cell, while the cell is still masked, the probe reaches 0.866 against 0.732. Commit-once trajectories show the same ordering, and the probe also ranks the wrong cells of a puzzle above its correct ones, so it locates errors rather than only recognizing difficult puzzles.
Figure 1. Diagnosis on uniquely solvable 4 × 4 Sudoku. (a) Wrongness AUROC of hidden-state probes and confidence on matched observations. (b) After re-masking a wrong cell, the original digit stays highly probable and the gold digit rarely outranks it. (c) Gold-guided repair on 77 failures: reopening the wrong cells alone fixes few, and the per-puzzle best setting is an oracle upper bound.
Finding 2. Locating an error does not guarantee repair under its context. We mask one committed wrong cell, keep the rest of the canvas, and let the model predict it again. The original wrong digit keeps a mean probability of 0.869, rising to 0.962 when the cell is masked sixteen steps after its commit, and the gold digit rarely outranks it (Figure 1b). On 77 failed puzzles, a gold oracle that reopens every wrong answer cell repairs only 6 (Figure 1c). Reopening the reasoning written after the first error as well helps, but the best fixed rollback depth repairs 13, and even the best depth chosen for each puzzle with the gold answer repairs 15.
Implication. Error information can be read from the model’s states, but re-predicting the erroneous tokens under their context rarely repairs them. Instead of locating an error and fixing it in place, a method should regenerate a region jointly and judge the alternatives by their eventual outcome, which is what DiVR does.
Method
Learning an outcome criterion on masked states
The diagnosis motivates two design choices. The criterion for revision should be learned rather than read from token confidence, and the unit of revision should be a region regenerated jointly rather than an isolated token. DiVR implements both with an outcome-supervised verifier and block re-decoding, as Figure 2 illustrates.
Figure 2. DiVR-guided block re-decoding. DiVR scores the canvas, masked suffix included, after each block ( here, 32 in the experiments). A score below triggers four alternatives of the block from the same prefix, and the best-scoring state (, 0.91) replaces the original. Text and scores are illustrative.
Let be a prompt, the response-canvas length, and the block length. For a sampled response , the state after block (numbered from one) is
We label every block-boundary state of a sampled response with the binary outcome of the completed response. Following outcome-supervised verification (Cobbe et al., [5]), this needs only an answer check on the finished response, not gold reasoning steps or token-level labels. A negative label says that the trajectory through a state failed, not that the state itself is wrong. The training states are block prefixes with masked suffixes, exactly the states that decoding visits, and they come from the generator’s own samples, so the verifier learns the error modes of the generator it guides.
A verifier that shares the generator's weights
The verifier runs the generator’s backbone on a state and maps the pooled final-layer states to a score with a small head. Its own parameters are this head and a low-rank adapter (LoRA) on the backbone’s attention and feed-forward projections (Hu et al., [9]), trained together as one model, while the backbone weights stay frozen and shared with the generator. For a state , the verifier computes
where is the generator’s backbone with frozen weights , is the adapter’s low-rank update, and is the final-layer state at response position . Pooling averages all response positions, including those still masked, and excludes the prompt. The head is a two-layer perceptron, and is the logistic function. Training the adapter and the head together on the outcome objective lets the verifier reshape the backbone’s representation of a state so that its information about the outcome is easier to use. The verifier’s trainable parameters amount to about 1% of the backbone.
Classification and within-question ranking
Each training step draws one question and one block index and forms the state of each of its four sampled trajectories, using the final boundary of a trajectory that ended earlier. The loss has one term for each decision of § 3.4. A class-balanced binary cross-entropy trains each score to predict its trajectory’s outcome, and a pairwise logistic loss trains correct trajectories to score above incorrect ones. With , we minimize
where and give correct and incorrect trajectories equal total weight, is the fraction of correct trajectories in the sampled pool, and contains the correct–incorrect pairs of the question. The classification term places the scores on an absolute scale, on which asks whether a state is less promising than an average sampled trajectory. The ranking term trains the within-question ordering that selecting among alternatives requires.
Selection and block re-decoding
For best-of-, the generator samples complete responses, and we return the one whose final state scores highest. For guided decoding, the generator fills each block in its ordinary way and the verifier scores the canvas. If the score is below and the regeneration budget is not exhausted, we remask the whole block, sample alternatives from the same prefix, and keep the original unless an alternative scores higher. Decoding then continues, and every regeneration event counts against the budget. Because the whole block is resampled, its tokens change together, as the diagnosis requires, and the procedure needs neither to locate the error nor to know what caused it.
Experiments
Experimental setup and baselines
Models and benchmarks. We evaluate three models, LLaDA-8B-Base and LLaDA-8B-Instruct ([22]) and Dream-v0-Instruct-7B ([34]). LLaDA-8B-Base is evaluated both untuned (Base) and after supervised fine-tuning on GSM8K (SFT). The instruction-tuned models are used as released, and Appendix Table 6 reports them after the same fine-tuning. We use three math benchmarks, GSM8K (1,319 problems) ([5]), MATH-500 (500) ([7, 17]) and Countdown (500 three-number tasks) ([24]), and two code benchmarks, HumanEval (164) ([3]) and MBPP (500) ([1]), and report their unweighted average. The prompts are listed in Appendix § 14. Each generator has one verifier per domain, trained on four of its own responses, sampled at temperature 0.7, for each of 2,000 GSM8K training questions for math and for each MBPP training and validation problem for code. A verifier serves every benchmark of its domain, and the untuned Base model is guided by the SFT generator’s verifiers. The epoch and the threshold are chosen on development data, and the remaining hyperparameters are given in Appendix § 9.
Decoding and baselines. Canvases contain 256 tokens, or 512 for MATH-500, decoded in 32-token blocks with 16 steps per block. Guided decoding uses and alternatives at temperature 0.7, with at most three regeneration events per problem. Cost counts forward passes, verifier reads included, relative to a greedy decode of the same problems, which is also the reference for accuracy. We compare against two search methods for diffusion decoding, reimplemented on the same generators and decoder (Appendix § 10). SR-SMC (Luo et al., [18]) keeps four particles and resamples them after each block by their accumulated log-confidence, and Prism (Bai et al., [2]) starts sixteen trajectories, prunes them to four with the generator’s own prompted Yes/No judgment, and answers by majority vote, as in its paper (Appendix Table 5 reports its released top-score rule). Both search with the generator’s own judgment and keep several trajectories for every problem, whereas guided decoding branches only at flagged blocks. DiVR best-of-4 reranks four complete samples by the verifier’s score at about the baselines’ budget, which isolates the verifier’s selection quality from block regeneration.
Main results
Table 1 summarizes the results. Across the three generators, guided decoding is the most accurate method on average for every generator, and with best-of-4, which uses about the search baselines’ budget, DiVR is the most accurate on every math and code benchmark. On the SFT generator, guided decoding raises GSM8K from 68.7% to 78.8% and MBPP from 24.2% to 33.6%, and best-of-4 raises GSM8K further to 82.2%. On GSM8K with the SFT generator, guided decoding is also more accurate than the search baselines at a lower cost, reaching 78.8% at 2.1× the cost of greedy decoding against 72.6% at 4.0× for SR-SMC and 71.9% at 5.9× for Prism. On LLaDA-8B-Instruct, guided decoding raises the five-benchmark average from 39.4% to 44.8%, and best-of-4 reaches 49.8%, 10.4 points above greedy decoding. These results show that DiVR is an effective inference-time revision method for MDLMs.
| Model / method | GSM8K Acc. | GSM8K Cost | MATH-500 Acc. | MATH-500 Cost | Countdown Acc. | Countdown Cost | HumanEval Acc. | HumanEval Cost | MBPP Acc. | MBPP Cost | Avg. Acc. |
| LLaDA-8B-Base | |||||||||||
| Greedy | 61.8 | 24.2 | 10.6 | 19.5 | 30.2 | 29.3 | |||||
| + DiVR-guided* | 71.7 | 26.8 | 30.2 | 23.8 | 37.6 | 38.0 | |||||
| + SFT | 68.7 | 24.6 | 35.6 | 23.2 | 24.2 | 35.3 | |||||
| + SFT + SR-SMC (4) | 72.6 | 28.4 | 43.0 | 25.0 | 26.6 | 39.1 | |||||
| + SFT + Prism | 71.9 | 32.4 | 39.8 | 20.1 | 22.4 | 37.3 | |||||
| + SFT + DiVR-guided | 78.8 | 33.8 | 47.2 | 23.8 | 33.6 | 43.4 | |||||
| + SFT + DiVR best-of-4 | 82.2 | 34.2 | 49.2 | 26.2 | 32.6 | 44.9 | |||||
| LLaDA-8B-Instruct | |||||||||||
| Greedy | 79.2 | 35.0 | 15.6 | 34.1 | 33.2 | 39.4 | |||||
| + SR-SMC (4) | 81.5 | 41.2 | 20.0 | 32.3 | 34.0 | 41.8 | |||||
| + Prism | 83.5 | 43.4 | 21.2 | 28.0 | 31.6 | 41.5 | |||||
| + DiVR-guided | 83.0 | 38.2 | 23.0 | 39.0 | 40.8 | 44.8 | |||||
| + DiVR best-of-4 | 87.6 | 45.6 | 35.4 | 40.2 | 40.2 | 49.8 | |||||
| + diffu-GRPO‡ | 77.4 | 39.4 | 17.0 | 31.1 | 35.4 | 40.1 | |||||
| + diffu-GRPO + DiVR-guided‡ | 83.4 | 39.2 | 28.2 | 34.8 | 41.4 | 45.4 | |||||
| + diffu-GRPO + DiVR best-of-4‡ | 87.4 | 44.8 | 42.0 | 36.0 | 42.0 | 50.4 | |||||
| Dream-v0-Instruct-7B | |||||||||||
| Greedy | 77.3 | 40.8 | 18.0 | 45.1 | 43.8 | 45.0 | |||||
| + SR-SMC (4) | 81.5 | 45.8 | 23.6 | 53.0 | 50.2 | 50.8 | |||||
| + Prism | 85.1 | 48.2 | 29.2 | 42.7 | 46.4 | 50.3 | |||||
| + DiVR-guided | 84.4 | 44.4 | 37.2 | 53.0 | 55.2 | 54.8 | |||||
| + DiVR best-of-4 | 89.6 | 50.8 | 42.4 | 57.3 | 55.0 | 59.0 |
Table 1. Table 1: Main results across three generators. Each panel is one model and each block one generator (untuned or SFT for LLaDA-8B-Base, released or diffu-GRPO for LLaDA-8B-Instruct); every method in a block runs on that generator, with one verifier for the math columns and one for the code columns. Cost is forwards relative to the generator’s paired greedy run, verification included. Bold marks the best decoding method of a generator; the best-of-4 rows use about four times the greedy budget and are not ranked. *Verified by the verifiers of the SFT generator. ‡After 3,800 steps of d1’s diffu-GRPO recipe on GSM8K ([41]), with verifiers trained on its own decodes (Table 7).
DiVR is cost-effective. Over the five benchmarks of the SFT generator, guided decoding raises the average from 35.3% to 43.4% at 1.9–3.5× the cost of greedy decoding, whereas SR-SMC reaches 39.1% at 3.8–4.0× and Prism 37.3% at 5.2–7.4×. On average, guided decoding thus uses about 70% of SR-SMC’s computation and less than half of Prism’s. Best-of-4 with the same verifier is the most accurate row on most benchmarks, and guided decoding comes close to it at as little as 40% of its cost. Guided decoding retains most of the gain of best-of-4 because it samples alternatives only for the blocks the verifier flags, which Table 2 shows to be concentrated at the start of a solution. The gap between the two DiVR rows is small next to the gap between either of them and the baselines, so the benefit comes from the verifier’s judgment rather than from the amount of sampling.
| Benchmark | Fixed | 0 | 1 | 2 | 3 | TPR | FPR |
| GSM8K | 154 | 114 | 28 | 7 | 5 | 76% | 22% |
| MATH-500 | 52 | 25 | 15 | 9 | 3 | 50% | 14% |
| Countdown | 59 | 58 | 1 | 0 | 0 | 99% | 1% |
Table 2. Where guided decoding repairs the greedy answer. SFT generator on the math benchmarks. Fixed counts the greedy errors that guided decoding corrects, out of 413 on GSM8K, 377 on MATH-500 and 322 on Countdown, and the repair block is the first block at which an alternative replaced the original. TPR and FPR treat a wrong greedy answer as positive and a first-block score below as a flag. Most repairs begin in the first block.
DiVR complements post-training. We test whether DiVR adds to post-training of the generator on two post-trained variants, supervised fine-tuning of LLaDA-8B-Base and diffu-GRPO reinforcement learning of LLaDA-8B-Instruct, the model for which d1 published its recipe (Zhao et al., [41]), trained at about one eighth of d1’s GSM8K budget. DiVR improves both. Fine-tuning raises Countdown from 10.6% to 35.6%, and guided decoding raises it further to 47.2%. For the RL generator, guided decoding raises the five-benchmark average from 40.1% to 47.2%. RL training moved the Instruct run’s reward, with its correctness term rising from 0.76 to 1.35 of a possible 2, but greedy accuracy moved little (the rows marked ‡). With guidance, the RL generator gains 6.0 points on GSM8K and 11.2 on Countdown over its own greedy decoding, more than the verifier adds to Instruct itself (3.8 and 7.4). RL changes what the generator writes, the verifier decides when a block is discarded, and the two gains add. Appendix Table 7 gives the training details.
DiVR generalizes across benchmarks and generators. Each verifier is trained on a single benchmark per domain, GSM8K for math and MBPP for code, yet it also improves benchmarks it never saw. The GSM8K-trained verifier raises the SFT generator on MATH-500 from 24.6% to 33.8% and on Countdown from 35.6% to 47.2%, and the MBPP-trained verifier raises HumanEval, which has no training split, for LLaDA-8B-Instruct and Dream (34.1% to 39.0% and 45.1% to 53.0%) (Appendix Table 8 compares the math and code verifiers on code). The verifiers also transfer across generators. Without any training on the untuned Base model’s decodes, the SFT generator’s verifiers raise its average from 29.3% to 38.0%, above the 35.3% of fine-tuning alone. Trained on its own decodes, the same recipe raises Dream-v0-Instruct-7B, a second model family with a different tokenizer, from 45.0% to 54.8%. The gains are largest where the generator’s own signals are least reliable, as on Countdown, where Dream’s accuracy doubles from 18.0% to 37.2%.
DiVR repairs errors early. To see where DiVR triggers the regenerations that repair an answer, we locate the repairs on the three math benchmarks. For every problem that greedy decoding gets wrong and guided decoding gets right, we record the block at which an alternative first replaced the original, which is where the guided trajectory departs from the greedy one. As Table 2 shows, the repairs are concentrated at the start of the solution. On GSM8K, 74% of the 154 repaired problems depart in the first block and 92% within the first two. On Countdown, 58 of the 59 repairs start in the first block, because the generator writes its whole candidate expression there and the next block only copies it into the answer. Appendix § 13 shows three such repairs.
This concentration has two sources, and the table separates them. The first is detection. Among greedy decodes, the first-block score falls below for 76% of the eventually wrong GSM8K solutions and 22% of the eventually right ones, for 99% and 1% on Countdown, and for 50% and 14% on MATH-500. One block is therefore enough for the verifier to separate most trajectories by their eventual outcome. The second source is repairability, which the diagnosis predicted. The first block fixes the interpretation of the problem, such as which quantity is asked for or how the equation is set up, and later tokens are predicted from that context and tend to confirm it. A fresh sample of the first block starts from the prompt alone and can take a different route, whereas a fresh sample of a later block inherits the mistaken setup.
Analysis
Controlling the evaluation signal. The main results combine a learned score with a regeneration procedure, so we first ask whether the improvement comes from the verifier or from the opportunity to regenerate. On GSM8K with the SFT generator, we hold the regeneration procedure and its budget fixed and replace only the signal that decides when to regenerate and which block to keep. As shown in Table 3, three signals serve as controls. Commitment confidence is the geometric mean of the probabilities with which the visible tokens were placed, the signal on which confidence-based remasking relies. Prompted Yes/No asks the generator itself, through a judgment prompt, whether the partial solution is correct, the signal that Prism uses to prune its search. A head-only verifier (V0) is DiVR without its adapter, so its head is trained with the same outcome labels on the generator’s unchanged hidden states. Each signal uses the threshold that maximizes its accuracy on the development split.
| Evaluation signal | Success (%) | |
| Commit confidence | 72.2 | 2.45 |
| Prompted Yes/No | 67.9 | 3.62 |
| Head-only verifier (V0) | 74.2 | 3.07 |
| DiVR | 78.8 | 2.10 |
Table 3. Same block re-decoding, different scores. GSM8K test with the SFT generator (paired greedy 68.7). All signals share , the temperature and the redo cap, and each threshold is the best on the development split. is the verification-inclusive cost relative to greedy.
The ordering of the signals mirrors the diagnosis. Confidence and self-judgment reach 72.2% and 67.9%, so regenerating on the generator’s own signals recovers a small part of the gain over the 68.7% of greedy decoding or none of it. The head-only verifier reaches 74.2%, so an outcome-trained score helps even on the generator’s unchanged states. The full verifier reaches 78.8% at the lowest cost, 2.10 against 2.45–3.62, which is consistent with a sharper signal spending fewer regeneration events on blocks that were already adequate. The improvement therefore comes from the verifier’s learned criterion. The gap between the head-only verifier and DiVR also shows that reshaping the representation with the adapter, so that the outcome information is easier to use, matters.
Selection and ranking on fixed candidates. To separate the verifier’s ranking quality from the regeneration procedure, Table 4 compares selectors on the same four sampled responses per problem, so that every selector chooses from an identical pool. DiVR exceeds majority voting on GSM8K (82.2% against 75.7%), MATH-500 (34.2% against 28.8%) and Countdown (49.2% against 38.2%). Mean log-probability reaches only 68.5%, 23.6% and 34.6%, close to picking a candidate uniformly at random (68.7%, 24.6% and 33.7%), so the generator’s likelihood carries almost no information about which of its own samples is correct. On Countdown, where voting groups equivalent expressions, DiVR approaches the pool’s oracle ceiling of 49.8%, which means that it recognizes a correct expression whenever the pool contains one.
| Selector | GSM8K | MATH-500 | Countdown |
| Majority vote | 75.7 | 28.8 | 38.2 |
| Mean log-probability | 68.5 | 23.6 | 34.6 |
| DiVR best-of-4 | 82.2 | 34.2 | 49.2 |
| Oracle pass@4 | 85.4 | 43.4 | 49.8 |
| DiVR pair accuracy | |||
| After block 1 | 0.705 | 0.665 | 0.957 |
| After block 2 | 0.830 | 0.735 | 0.971 |
| After block 3 | 0.879 | 0.760 | 0.971 |
| Finished | 0.919 | 0.796 | 0.971 |
Table 4. Selection and ranking on a fixed candidate pool. Success (%) on the same four SFT-generator responses per problem. Oracle pass@4 is the pool’s ceiling, and a uniformly chosen candidate scores 68.7, 24.6 and 33.7. Pair accuracy is the share of correct–incorrect candidate pairs of a question that DiVR ranks correctly from their states after each block.
Guiding decoding requires a score that ranks partial solutions, not only finished ones. On the same candidates, DiVR’s pair accuracy on GSM8K is already 0.705 after the first block and rises to 0.919 for the finished responses, and on Countdown it reaches 0.957 after the first block (Table 4). Useful discrimination thus appears after the first block, where most repairs begin (Table 2).
Sensitivity to the threshold. The threshold was chosen on the GSM8K development split, and Figure 3 varies it on the test sets with everything else fixed. On GSM8K, accuracy stays within 77.5–79.2% for every from 0.1 to 0.9 while the cost rises from to , so the threshold is primarily a cost control. On MATH-500, which lies outside the domain the threshold was chosen on, accuracy nonetheless peaks at the development-chosen . A low threshold misses errors, and a high threshold regenerates correct work more often. The threshold chosen on in-domain development data is thus also the best setting out of domain. Appendix § 12 evaluates the scores as probabilities of success and the regenerate-or-continue decision at each threshold on paired states.
Figure 3. Sensitivity to the regeneration threshold. SFT generator, , at most three regenerations, on the full test sets. Solid lines give success (%) and dashed lines the verification-inclusive cost relative to greedy (square). The vertical line is , chosen on the GSM8K development set beforehand, and * marks a paired McNemar difference from it at .
Related Work
Refinement and search in MDLMs. MDLMs can revise intermediate states during iterative unmasking ([22, 34]). ReMDM remasks generated tokens to spend additional inference computation on refinement ([29]), and PRISM learns token-quality estimates to choose which positions to remask ([14]). Search methods weight and resample trajectories by their accumulated log-probabilities ([18]) or prune them with prompted self-verification ([2]). Others bring an external process reward model into diffusion decoding to remask low-scoring blocks ([21]), resample particles ([6]), guide a tree search over unmasking actions ([20]) or stitch high-scoring steps across traces ([19]). Reinforcement learning with outcome or denoising-process rewards also improves reasoning in these models ([41, 32]), and § 4 shows that DiVR’s gains add to d1’s recipe. DiVR differs from these methods in its signal, an outcome criterion learned on the generator’s own partially masked states.
Error signals in MDLMs. In autoregressive LLMs, hidden states encode the correctness of outputs beyond what output probabilities reveal ([23]). For MDLMs, corrective post-training supervises incorrect tokens directly so that confidence-guided refinement targets them ([38]), linear probes on hidden states predict whether the final output will be correct ([4]), and LOCKR detects answers that settle early on a wrong value from hidden-state trajectories and repairs them by remasking an answer region ([39]). Concurrently, Zhan et al. [37] train a verifier of a similar form, a LoRA-adapted MDLM backbone with an MLP head, and use it to prune candidates at every scoring step. Our work differs in three respects. Our diagnosis shows that a correctly located error is rarely repaired while its context is kept, which motivates regenerating whole blocks rather than answer tokens. Our verifier triggers regeneration only below a threshold and keeps the original block unless an alternative scores higher. Finally, we evaluate one procedure across three generators and five math and code benchmarks against confidence, self-verification and search baselines.
Outcome supervision and verifier-guided reasoning. Cobbe et al. [5] train verifiers on sampled solutions labelled by final-answer correctness and use them to select among candidates, and process supervision labels individual steps instead (Lightman et al., [17]). Outcome labels also support evaluating partial solutions, through values learned for step-level planning (Yu et al., [35]) or process rewards derived from outcome supervision (Yuan et al., [36]), and verifiers can steer generation before a solution is complete (Liao et al., [16]). For masked diffusion outside text, MDM-VGB regresses a verifier of masked states onto the terminal rewards of the model’s own rollouts to guide unmasking and remasking (Jeon et al., [13]). DiVR brings such a state evaluator to partially masked text, trained on the generator’s own decodes instead of a reward model trained on complete solutions, and uses it to decide block regeneration.
Conclusion
Our diagnosis shows that an MDLM can carry information about its errors and still fail to repair them in place, because the surrounding context keeps reproducing the mistake. DiVR therefore decides when a block should be written again, using a verifier learned from the generator’s own outcomes. This single decision, made after each block, improves three generators on five math and code benchmarks, outperforms search at a fraction of its cost, and adds to supervised and reinforcement-learning post-training. Revision in MDLMs needs a learned criterion of when to start over more than a way to find the error.
Diagnosis Details
All Sudoku results in the main text use the 190 uniquely solvable puzzles from a fixed 256-puzzle sample of the d1 test set [41]. Overall solve rates, probe datasets, localization subsets, and repair-eligible failures have different denominators. The final-state probe analyses contain 1,416 eligible cells for remasking and 1,279 for commit-once, distinct from the 190-puzzle solve-rate denominator. Single-layer probes use standardization, PCA, and class-balanced logistic regression with five-fold cross-validation grouped by puzzle. Bootstrap intervals resample puzzles rather than cells, because repeated cell observations from one puzzle are not independent. The reported bootstrap intervals condition on fitted out-of-fold probe predictions, and they do not rerun probe training in each resample. For the remasking probe they are [0.793, 0.881] at the final state and [0.836, 0.892] at first commit, from 500 resamples. Probes read answer-position hidden states at layers 8, 16, 24 and 32 at every step, excluding given clues and echoed blank digits, and reported AUROCs pool out-of-fold cell scores. The within-puzzle detector of Finding 1 is trained with puzzle-grouped folds on decoding states from the first quarter of decoding onward and is distinct from the single-layer probes. On the 73 remasking final states that contain both correct and incorrect eligible cells, it reaches a mean within-puzzle AUROC of 0.817, against 0.489 for confidence, and its median number of correct cells ranked before the last erroneous cell is one, against three for confidence. The gold-guided repair of Finding 2 uses the 77 of the 84 unsolved remasking outputs that have eligible erroneous answer cells. Rollback depth additionally reopens the non-answer tokens first committed at or after step , where is the earliest first-commit step among the final wrong cells. The one-cell re-prediction summary of Finding 2 pools 1,292 wrong-commit observations from three balanced rounds at offset zero, not 1,292 independent puzzles, and observation counts vary across offsets, so the comparison across offsets is descriptive rather than a paired estimate of how each error evolves.
Verifier Training and Evaluation
Verification and generation. The primary verifier uses four samples for each of 2,000 GSM8K training questions, decoded with the canvas, block length and step schedule of the main experiments. Every verifier uses a rank-32 adapter with scaling on the attention and feed-forward projections, and its head maps the hidden dimension through 1,024 SiLU units to a single logit. Training runs for two epochs with gradients accumulated over four questions. It pools the full response canvas, including unresolved masks. An already-terminated sample contributes its final boundary when a later training index is drawn. For the SFT generator, the SFT adapter is merged into the backbone before the verifier adapter is added, so that disabling the verifier adapter leaves exactly the SFT generator. Pair accuracy averages correct–incorrect ranking accuracy within each problem, then across problems with both outcomes, and ties receive half credit. After block , a candidate that has already terminated contributes its final state, and 488 of the 1,319 GSM8K test problems have both outcomes among their four candidates. For each guided run, the paired greedy baseline uses the same process and decoding configuration. Cost counts forward passes weighted by batch rows.
Seed sensitivity. The primary GSM8K run fixes 154 failures and breaks 20 correct answers. Changing only the verifier-training seed gives 77.5% success, and changing only the re-decoding seed gives 77.6%, against 78.8% in the primary run and 68.7% for paired greedy decoding. These are separate sensitivity checks rather than independent end-to-end replications.
Evaluation subsets. MATH-500 is the 500-problem subset of MATH used in process-verification research [7, 17], and the implementation loads its public dataset release. For Countdown, the sampler filters three-number tasks from the training partition of the public Countdown-Tasks-3to4 collection [24] and selects 500 for evaluation.
Code evaluation. The code results use all 500 MBPP test tasks and 164 HumanEval tasks. MBPP prompts expose the same tests used by its grader. HumanEval runs its test harness on the prompt and extracted program. Programs have a 10-second timeout and a 2-GiB address-space limit, and extraction or execution failures count as incorrect.
Regeneration locations. The repair block of Table 2 is the first block at which the guided decode’s recorded score departs from the paired greedy decode’s, which identifies the first accepted alternative exactly.
Baselines
Baseline implementations. SR-SMC is a local blockwise implementation with four particles at temperature 1.0, resampled after a block when the effective sample size falls below two, with the answer taken from the particle of highest total commitment log-confidence.
The Prism port keeps the paper’s hierarchical search, self-verified pruning and remasking.
Search. Sixteen initial trajectories are pruned to within the first block’s 10–60% step window, every three steps (decay 1.8). Two survivors branch with two low-confidence tokens remasked. The generator’s own Yes/No judgment scores the trajectories.
Answer. As in the main results of Bai et al. [2] (their Algorithm 1), the answer is a majority vote over the final trajectories, for every benchmark including code. The released code instead returns the final trajectory with the highest judgment score, and Table 5 reports that variant.
Cost. Rows count every judgment read used for pruning. The final judgment reads that the vote does not need are excluded.
| Benchmark | \multicolumn{4}{c}{LLaDA-8B-Base + SFT} | \multicolumn{4}{c}{LLaDA-8B-Instruct} | \multicolumn{4}{c}{Dream-v0-Instruct-7B} | |||||||||
| Greedy | Vote | Top | Cost | Greedy | Vote | Top | Cost | Greedy | Vote | Top | Cost | |
| GSM8K | 68.7 | 71.9 | 67.6 | ×5.9 | 79.2 | 83.5 | 82.8 | ×5.0 | 77.3 | 85.1 | 83.1 | ×5.5 |
| MATH-500 | 24.6 | 32.4 | 29.0 | ×6.0 | 35.0 | 43.4 | 38.0 | ×4.8 | 40.8 | 48.2 | 49.6 | ×5.4 |
| Countdown | 35.6 | 39.8 | 40.8 | ×7.0 | 15.6 | 21.2 | 27.4 | ×4.9 | 18.0 | 29.2 | 46.2 | ×5.0 |
| HumanEval | 23.2 | 20.1 | 25.0 | ×5.2 | 34.1 | 28.0 | 36.0 | ×5.1 | 45.1 | 42.7 | 53.7 | ×5.9 |
| MBPP | 24.2 | 22.4 | 28.4 | ×7.4 | 33.2 | 31.6 | 36.6 | ×5.6 | 43.8 | 46.4 | 53.2 | ×7.5 |
Table 5. Prism answer selection. Vote is the majority over the final trajectories, as in Bai et al. [2], and is the number in Table 1. Top is the released code’s choice, the trajectory with the highest self-verification score. Cost is that of the vote, including every pruning judgment.
Signal-control details. Commitment confidence is the geometric mean of token probabilities recorded when the visible tokens were placed. Prompted self-verification uses the same generator, a judgment prompt and a masked readout position, scoring Yes against No token variants. Each signal’s threshold maximizes accuracy on its 252-problem development evaluation, namely 0.85 for confidence, 0.98 for Yes/No, 0.7 for V0, and 0.5 for DiVR. All test runs cover 1,319 GSM8K problems.
Selection baselines. The completed mean-log-probability selector re-reads samples with their response tokens visible, so it is not a normalized joint sequence likelihood. Countdown majority voting groups boxed expressions after whitespace removal rather than by their value, which would merge distinct expressions.
Additional Generators and Verifiers
GSM8K SFT of the instruction-tuned generators. Table 6 applies the LLaDA-8B-Base SFT recipe unchanged to LLaDA-8B-Instruct and Dream-v0-Instruct-7B (for Dream, the loss reads each position’s prediction from the previous output, matching its decoding convention). SFT lowers both generators. GSM8K greedy accuracy falls from 79.2% to 74.7% for Instruct and from 77.3% to 67.1% for Dream, and the responses shorten, consistent with imitation of the shorter reference solutions. Guidance with each SFT generator’s own verifier brings it to within 1.8 points of the released greedy accuracy or above it on nine of the ten generator–benchmark pairs (the exception is Instruct on HumanEval), but the released generator with its verifier stays ahead on all five benchmarks for Dream and on four of five for Instruct, where only Countdown favors the SFT generator (42.2% against 23.0%). Table 1 therefore uses the released checkpoints for these two generators.
| Generator / method | GSM8K Acc. | GSM8K Cost | MATH-500 Acc. | MATH-500 Cost | Countdown Acc. | Countdown Cost | HumanEval Acc. | HumanEval Cost | MBPP Acc. | MBPP Cost |
| LLaDA-8B-Instruct | ||||||||||
| Released, greedy | 79.2 | ×1.0 | 35.0 | ×1.0 | 15.6 | ×1.0 | 34.1 | ×1.0 | 33.2 | ×1.0 |
| Released + DiVR | 83.0 | ×1.6 | 38.2 | ×1.8 | 23.0 | ×2.6 | 34.8 | ×2.6 | 38.0 | ×2.6 |
| + GSM8K SFT, greedy | 74.7 | ×1.0 | 30.8 | ×1.0 | 11.4 | ×1.0 | 26.2 | ×1.0 | 28.8 | ×1.0 |
| + GSM8K SFT + DiVR | 81.6 | ×1.9 | 37.0 | ×1.8 | 42.2 | ×2.7 | 26.8 | ×2.3 | 31.6 | ×2.2 |
| Dream-v0-Instruct-7B | ||||||||||
| Released, greedy | 77.3 | ×1.0 | 40.8 | ×1.0 | 18.0 | ×1.0 | 45.1 | ×1.0 | 43.8 | ×1.0 |
| Released + DiVR | 84.4 | ×1.7 | 44.4 | ×1.9 | 37.2 | ×2.4 | 49.4 | ×2.6 | 50.0 | ×3.4 |
| + GSM8K SFT, greedy | 67.1 | ×1.0 | 33.2 | ×1.0 | 20.8 | ×1.0 | 41.5 | ×1.0 | 44.8 | ×1.0 |
| + GSM8K SFT + DiVR | 79.6 | ×1.8 | 40.4 | ×1.7 | 31.0 | ×2.7 | 43.3 | ×1.7 | 44.2 | ×2.1 |
Table 6. GSM8K SFT of the instruction-tuned generators. Same SFT data and recipe as the LLaDA-8B-Base SFT generator, each with a verifier trained on its own decodes. All verifiers here are GSM8K-trained, code columns included.
diffu-GRPO reproduction. The Instruct RL generator of Table 1 and Table 7 is LLaDA-8B-Instruct trained with d1’s released diffu-GRPO code and GSM8K reward functions [41], with LoRA rank 128 (, dropout 0.05) on the attention and feed-forward projections over a 4-bit base, six generations per prompt at temperature 0.9, 256-token completions in blocks of 32 with 128 diffusion steps, twelve inner updates per batch, learning rate , KL coefficient 0.04, clipping 0.5, seed 42, and 3,800 optimizer steps with one prompt per GPU and no gradient accumulation on four RTX A6000 GPUs (12.0 hours). d1 trains its GSM8K model for 7,700 steps on eight A100 GPUs with two accumulation steps, so our training uses about one eighth as many generations, and its correctness reward was still rising slowly at the end.
| Model / method | GSM8K Acc. | GSM8K Cost | MATH-500 Acc. | MATH-500 Cost | Countdown Acc. | Countdown Cost | HumanEval Acc. | HumanEval Cost | MBPP Acc. | MBPP Cost | Avg. Acc. |
| LLaDA-8B-Instruct | |||||||||||
| Greedy (Table 1) | 79.2 | ×1.0 | 35.0 | ×1.0 | 15.6 | ×1.0 | 34.1 | ×1.0 | 33.2 | ×1.0 | 39.4 |
| + diffu-GRPO | 77.4 | ×1.0 | 39.4 | ×1.0 | 17.0 | ×1.0 | 31.1 | ×1.0 | 35.4 | ×1.0 | 40.1 |
| + diffu-GRPO + SR-SMC (4)† | 81.2 | ×4.1 | 37.2 | ×4.0 | 23.6 | ×3.9 | 32.3 | ×4.0 | 37.6 | ×4.1 | 42.4 |
| + diffu-GRPO + Prism† | 84.4 | ×5.2 | 41.4 | ×4.9 | 22.6 | ×5.1 | 28.0 | ×5.1 | 33.4 | ×5.6 | 42.0 |
| + diffu-GRPO + DiVR-guided | 83.4 | ×1.6 | 39.2 | ×1.8 | 28.2 | ×2.7 | 34.8 | ×2.7 | 41.4 | ×2.3 | 45.4 |
| + diffu-GRPO + DiVR best-of-4 | 87.4 | ×4.0 | 44.8 | ×3.9 | 42.0 | ×4.0 | 36.0 | ×4.0 | 42.0 | ×4.0 | 50.4 |
| LLaDA-8B-Base | |||||||||||
| Greedy (Table 1) | 61.8 | ×1.0 | 24.2 | ×1.0 | 10.6 | ×1.0 | 19.5 | ×1.0 | 30.2 | ×1.0 | 29.3 |
| + diffu-GRPO | 61.7 | ×1.0 | 21.6 | ×1.0 | 15.6 | ×1.0 | 23.8 | ×1.0 | 26.0 | ×1.0 | 29.7 |
| + diffu-GRPO + DiVR-guided | 76.2 | ×1.8 | 26.4 | ×1.8 | 31.6 | ×2.6 | 26.8 | ×2.1 | 35.6 | ×2.0 | 39.3 |
| + diffu-GRPO + DiVR best-of-4 | 82.7 | ×4.0 | 31.6 | ×4.0 | 38.0 | ×4.0 | 31.1 | ×4.0 | 35.8 | ×4.4 | 43.8 |
Table 7. diffu-GRPO generators under every method. LLaDA-8B-Instruct and the untuned LLaDA-8B-Base after 3,800 steps of d1’s diffu-GRPO recipe on GSM8K, each with DiVR verifiers trained on its own decodes. The greedy rows of the untrained generators repeat Table 1. †Local reimplementations.
_Greedy accuracy._ With the single-problem greedy decoder used for the released checkpoints, the trained generator scores 78.8%, 36.4% and 18.8% on GSM8K, MATH-500 and Countdown against 78.5%, 35.6% and 17.6% for Instruct (, 0.76 and 0.66). In the paired decoder of the guided runs it scores 77.4%, 39.4% and 17.0% against 79.2%, 35.0% and 15.6% (Table 7). The two greedy decoders differ by up to 3.0 points on MATH-500 for the same adapter, which is why every comparison in this paper is paired within one decoder.
_Comparison with d1._ In d1’s own evaluation (512 tokens, 256 steps, d1’s prompt and parser) it scores 80.1% against 79.0% for Instruct (). A second run of the same recipe and seed scored 81.1% in that evaluation (), and the two runs differ on 195 problems with no net direction (). d1’s authors released no LLaDA checkpoint. The public third-party adapter dLLM-data-selection/LlaDA-8B-Instruct-grpo-gsm8k-pass-rate-step-1000 (diffu-GRPO, 1,000 steps) scores 78.8%, 36.0% and 15.2% in our evaluation.
_Reward._ Re-grading the samples generated during training, d1’s exact-string correctness rose from 24% to 71% of samples over training while our numeric grader rose from 76% to 79%, so much of the reward increase reflects the answer format that d1’s reward and parser require.
_Verifiers._ Its verifiers repeat the Instruct recipes on its own decodes (82.3% of the GSM8K samples correct, held-out pair accuracy 0.833 and 0.885 with the second epoch kept, final-state pair accuracy 0.881 on the test pools, and for MBPP 35.8% passing with 0.822 and 0.844).
_Results._ Table 7 runs every method of Table 1 on this generator. Against Instruct’s greedy decoding, its greedy decoding differs by −1.8, +4.4, +1.4, −3.0 and +2.2 points on the five benchmarks (McNemar , 0.025, 0.57, 0.23 and 0.14). SR-SMC and Prism move it by about as much as they move Instruct. With the same method on both generators, the only significant differences are SR-SMC on MATH-500 (−4.0, ) and MBPP (+3.6, ) and best-of-4 on Countdown (+6.6, ).
diffu-GRPO from the untuned Base model. The Base RL generator applies the same recipe, seed and step count to the untuned LLaDA-8B-Base with two changes that its cold start requires.
_Prompt prefix._ The prompt ends with the <reasoning> prefix that every Base decode in this paper uses (Appendix § 14), passed to d1’s trainer as an opening assistant turn so that the rendered prompt is identical to ours. Without the prefix the untuned model does not produce d1’s answer tags and receives no correctness reward.
_Correctness reward._ The correctness reward is our numeric grader (the first <answer> block, else a #### line, else the last boxed expression, else the last number, compared numerically) in place of d1’s exact string match, with d1’s four format rewards unchanged. The untuned model writes sentences inside the answer tags, so the exact match rewards 4% of its samples where our grader scores 53% right, and groups of six generations then carry almost no reward variance for the policy gradient to use.
_Training._ Training took 52 GPU-hours on the same four GPUs, its correctness reward rose from 1.03 to 1.19 of 2, and its completions fill the 256-token canvas because the Base model writes no end token, as in every untuned-Base decode of the paper. The Instruct run keeps d1’s reward.
_Results._ The Base RL generator’s greedy accuracy stays at the untuned level, 29.7% against 29.3% averaged over the five benchmarks and 61.7% against 61.8% on GSM8K (199 problems gained and 200 lost), with
+5.0 on Countdown (), +4.3 on HumanEval (), on MATH-500 and on MBPP (), and 5.6 points below one GPU-hour of GSM8K SFT on average (Table 7).
Verifiers. Its verifiers repeat the recipes of this appendix on its own decodes (65.1% of the GSM8K samples correct, held-out pair accuracy 0.938 and 0.949, final-state pair accuracy 0.927 on the test pools against 0.919 for the SFT generator’s verifier, and for MBPP 24.4% passing with 0.776 and 0.908).
Guidance. With guidance it gains 14.5 points on GSM8K, 16.0 on Countdown, 4.8 on MATH-500 (), 9.6 on MBPP and 3.0 on HumanEval (), its GSM8K guidance is 4.5 points above the SFT verifier’s guidance of the untuned generator (), and best-of-4 reaches 82.7% on GSM8K, the level of the SFT generator with its verifier (82.2%). The lenient reward function is included with our code.
Code verifiers. Each generator’s code verifier repeats the recipe of its GSM8K verifier on four samples at temperature 0.7 for each of the 464 MBPP training and validation problems. Sixty-four problems are held out, and the epoch with the higher held-out pair accuracy is kept (0.918, 0.909 and 0.953 for the SFT generator, Instruct and Dream). On the four-sample test pools of the three generators with their own verifiers, the GSM8K verifiers rank passing above failing programs with pair accuracy 0.759–0.859 and the MBPP verifiers with 0.838–0.944 (Table 8). On the untuned generator, whose decodes neither verifier saw in training, the same verifiers reach 0.62–0.78. In guided decoding on MBPP, the MBPP verifier is ahead of the GSM8K verifier for every generator, by 7.4 points for untuned Base, 9.4 for the SFT generator, 2.8 for Instruct and 5.2 for Dream (McNemar , , and ). On HumanEval, which contributes no training data, the differences are smaller, +1.8 points for untuned Base, for the SFT generator, +4.3 for Instruct () and +3.7 for Dream (). On the SFT generator’s HumanEval decodes the code verifier scores the first block below for 98% of the eventually wrong solutions and 58% of the eventually right ones (87% and 21% on MBPP), and 73 of the 148 first regeneration events accept an alternative, so most of the budget is spent without changing the canvas.
| Generator / verifier | Guided | Cost | Best-of-4 | Pair | Guided | Cost | Best-of-4 | Pair |
| HumanEval | MBPP | |||||||
| LLaDA-8B-Base, untuned* (greedy 19.5 / 30.2) | ||||||||
| GSM8K verifier | 22.0 | 27.4 | 0.778 | 30.2 | 30.2 | 0.659 | ||
| MBPP verifier | 23.8 | 20.7 | 0.616 | 37.6 | 33.4 | 0.757 | ||
| LLaDA-8B-Base + SFT (greedy 23.2 / 24.2) | ||||||||
| GSM8K verifier | 24.4 | 24.4 | 0.813 | 24.2 | 26.8 | 0.759 | ||
| MBPP verifier | 23.8 | 26.2 | 0.838 | 33.6 | 32.6 | 0.936 | ||
| LLaDA-8B-Instruct (greedy 34.1 / 33.2) | ||||||||
| GSM8K verifier | 34.8 | 36.6 | 0.774 | 38.0 | 40.0 | 0.823 | ||
| MBPP verifier | 39.0 | 40.2 | 0.944 | 40.8 | 40.2 | 0.867 | ||
| Dream-v0-Instruct-7B (greedy 45.1 / 43.8) | ||||||||
| GSM8K verifier | 49.4 | 53.7 | 0.859 | 50.0 | 51.2 | 0.839 | ||
| MBPP verifier | 53.0 | 57.3 | 0.942 | 55.2 | 55.0 | 0.943 |
Table 8. Code benchmarks with the GSM8K-trained and the MBPP-trained verifier. The two verifiers of a generator differ only in their training decodes, and Table 1 reports the MBPP verifier in its code columns. Pair is the within-problem accuracy of ranking a passing finished sample above a failing one. *Verified by the verifiers of the SFT generator.
Calibration and Paired Intervention Analysis
We evaluate the probability of final-answer success under the continuation policy that generated each trajectory. Every observed block boundary inherits that trajectory’s outcome. Sampled-policy evaluation uses 20,744 states from four responses per GSM8K test problem (5,276 responses in total, temperature 0.7). Greedy-policy evaluation uses 1,209 states from a 300-problem test subset. Commitment confidence, prompted Yes/No, and DiVR are evaluated on the same greedy states with the same outcome labels.
For each policy and signal separately, we fit positive-slope affine-logit Platt scaling (Platt [26]) by unweighted NLL on development states, with 7,671 states for the sampled-policy verifier and 957 for each greedy-policy signal. Fitted parameters are frozen for test evaluation. ECE uses ten equal-width bins, and Brier score and NLL retain the natural class ratio. We report state-weighted metrics, so longer trajectories contribute more observations. Final states form a separate group, and block-index groups contain only non-final states. No terminated trajectory is padded into later groups, unlike the pair-accuracy analysis in § 5.
On sampled-policy states, DiVR’s ECE decreases from 0.095 to 0.021. The corresponding 95% percentile intervals are [0.084, 0.106] and [0.014, 0.033], from 500 bootstrap resamples at the problem level, conditional on the fitted calibrator. After the first block, ECE falls from 0.116 to 0.031, and at completion from 0.071 to 0.019. On greedy states, first-block ECE falls from 0.136 to 0.067 and final-state ECE from 0.071 to 0.032 (Figure 4). A single global map does not guarantee calibration at each block. Calibrated confidence and Yes/No retain ECE 0.226 and 0.265 on late non-final states despite smaller pooled errors. Calibration and discrimination therefore need separate evaluation.
Figure 4. Verifier reliability on greedy GSM8K states. Mean score versus empirical success at the first non-final block and the final state (300 observations each), and markers are bins with at least ten observations. Platt parameters are fitted on development states.
Positive-slope rescaling preserves candidate ordering. It changes a threshold’s numeric interpretation, not which candidate is ranked highest. The main experiments retain the original scores and threshold, and no accuracy improvement is attributed to post-hoc calibration. This analysis does not establish calibration after adaptive regeneration or across benchmarks.
For the paired intervention study, we take a 150-problem test subset and save 436 greedy states from the first three blocks. At each state, we compare its original greedy outcome with one regeneration event, namely four alternatives at temperature 0.7, one selection against the original by raw verifier score, and then greedy continuation. Each state is tested independently, rather than following the sequential three-event policy. Below score 0.1, success rises from 13.9% to 26.1% on 115 states, with 16 fixes and two regressions. At scores of at least 0.9, it rises from 92.4% to 93.4% on 211 states, with five fixes and three regressions. The threshold 0.5 selects 33.7% of states, whose average gain is 9.5 points, versus 1.7 points for the remaining states. Each state uses one sampled alternative set. Problem-level bootstrap intervals (1,000 resamples) put the gain at threshold 0.5 at 9.5 points [4.2, 15.3].
Decision calibration. Zhao et al. [40] call predictions decision-calibrated for a family of decision rules if, for every rule, the loss the predictions anticipate for the chosen action equals the realized loss. Their predictions concern an outcome that the decision does not change. Here each action leads to a different state, so we predict the outcome of each action separately and require the prediction for the chosen action to match its realized outcome. We consider rules that regenerate when the raw score is below .
Predicted success of an action. We apply the greedy-policy Platt map, fitted on development states (Table 9), to the raw score of the state the action leads to, which is the current block when continuing and the retained block when regenerating.
Realized success. The outcome of the greedy continuation after that action.
| State source / signal | Calibration | AUROC ↑ | ECE ↓ | Brier ↓ | NLL ↓ |
| Sampled policy (20,744 states, 1,319 problems) | |||||
| DiVR | Raw | 0.913 | 0.095 | 0.130 | 0.464 |
| DiVR | Platt | 0.913 | 0.021 | 0.111 | 0.359 |
| Greedy policy (1,209 states, 300 problems) | |||||
| Commit confidence | Raw | 0.625 | 0.186 | 0.253 | 0.736 |
| Commit confidence | Platt | 0.625 | 0.033 | 0.219 | 0.628 |
| Prompted Yes/No | Raw | 0.589 | 0.288 | 0.305 | 1.068 |
| Prompted Yes/No | Platt | 0.589 | 0.079 | 0.229 | 0.652 |
| DiVR | Raw | 0.909 | 0.093 | 0.125 | 0.447 |
| DiVR | Platt | 0.909 | 0.027 | 0.110 | 0.358 |
Table 9. Outcome prediction and post-hoc calibration. GSM8K test states at observed block boundaries. Each signal has its own Platt map fitted on development states. Calibration preserves the ordering, so raw and calibrated AUROC agree.
Table 10 compares the two on the 436 paired states.
Table 10. Decision calibration for regenerate-or-continue. 436 paired greedy states from 150 GSM8K test problems. A rule regenerates when the raw score is below , and predictions apply the development-fitted Platt map to the state each action leads to. The gap is predicted minus realized success of the chosen action, with a 95% bootstrap interval.
| Regen. | Gain (pred. / real.) | Chosen-action gap | |
| 0.1 | 26% | 11.0 / 12.2 | +1.7 [−3.4, +7.0] |
| 0.3 | 30% | 10.9 / 10.6 | +2.0 [−2.6, +7.0] |
| 0.5 | 34% | 10.3 / 9.5 | +2.2 [−2.4, +7.8] |
| 0.7 | 38% | 9.6 / 8.4 | +2.4 [−2.4, +7.3] |
| 0.9 | 52% | 7.8 / 7.6 | +2.1 [−2.5, +6.8] |
Chosen action. Predicted and realized success differ by at most 2.4 points at every threshold.
Regeneration gain. The predicted gain matches the realized gain. At the difference is 0.8 points, with interval .
Selection. Choosing the best of five candidates by score adds no optimism beyond a shared 2-point offset. After regenerating everywhere, predicted success is 72.1% versus 70.2% realized, and when continuing everywhere it is 67.8% versus 65.8%. The offset reflects the development-fitted map on this test subset, not selection.
All intervals are 95% problem-level bootstrap intervals. The test covers one regeneration event per state, with candidates selected by raw score. It does not cover the sequential three-event policy or per-state repair probabilities.
Qualitative Examples
Table 11 shows three GSM8K test problems on which a single regeneration corrects the SFT generator’s greedy answer. The alternatives are reproduced from the recorded random state of each run.
Table 11: Regenerations that fix greedy errors. GSM8K test problems on which the SFT generator’s greedy answer is wrong and one regeneration corrects it. Each panel shows the block that fell below (Original), the four alternatives decoded from the same state, and their scores. The highest-scoring candidate (bold) is kept. marks a line break.
| Candidate | Score | Decoded block |
| (a) Regeneration of the first block. Jillian’s handbag cost $20 less than 3 times as much as her shoes cost. If her shoes cost $80, how much did her bag cost? (Answer 220, greedy answer 200.) | ||
| Original | 0.019 | Three times the cost of her shoes is 3*$80 =$220 $20 less than 220 is 22 |
| Resample 1 | 0.395 | Three times as much as her shoes cost is 3*$80=$240 $20 less than $80 is $84 |
| Resample 2 | 0.990 | Let x be the cost of the bag. x = 3 * 80 = 240. x = 240 |
| Resample 3 | 0.018 | Three times the cost of her shoes is 3*$80 = $20 $20 less than $20 is $20-$ |
| Resample 4 | 0.016 | Three times the cost of her shoes is 3 * $80 = $200 Jillian’s handbag cost $200 - $ |
| Final DiVR reasoning. | Let x be the cost of the bag. x = 3 * 80 = 240. x = 240 - 20 = 220. answer 220 (correct). | |
| (b) Regeneration of the second block, with the first kept. Mulan has $40. Her father gave her $100. She buys two pairs of jeans at $30 each and a bag for $20. How much money does Mulan have left? (Answer 60, greedy answer 220.) | ||
| Kept | 0.985 | Mulan has $40 + $100 = $140. She spends $30 x 2 = $60 on |
| Original | 0.039 | jeans. She has a total of $140 + $60 + $20 = $220. </reasoning> |
| Resample 1 | 0.997 | jeans. She spends $60 + $20 = $80 in total. Mulan has $140 - $80 = |
| Resample 2 | 0.035 | jeans. She has a total of $140 + $60 + $20 = $220. </reasoning> |
| Resample 3 | 0.035 | jeans. She has a total of $140 + $60 + $20 = $220. </reasoning> |
| Resample 4 | 0.997 | jeans. She spends $60 + $20 = $80 in total. Mulan has $140 - $80 = |
| Final DiVR reasoning. | Mulan has $40 + $100 = $140. She spends $30 x 2 = $60 on jeans. She spends $60 + $20 = $80 in total. Mulan has $140 - $80 = $60 left. answer 60 (correct). | |
| (c) Regeneration of the second block, with the first kept. Eight more than four times the number of coffee mugs in the teacher’s lounge is 40. How many coffee mugs are in the teacher’s lounge? (Answer 8, greedy answer 0.) | ||
| Kept | 0.966 | Let x be the number of coffee mugs in the teacher’s lounge. Eight more than four times the number of coffee mugs in the teacher’s lounge is |
| Original | 0.034 | 40+8x. Eight more than four times the number of coffee mugs in the teacher’s lounge is 40, or 40 |
| Resample 1 | 0.984 | 4x + 8. We know that 8 more than four times the number of coffee mugs in the teacher’s lounge is 40, |
| Resample 2 | 0.997 | 4x+8. We know that 4x+8=40. Subtracting 8 from both sides, we get 4 |
| Resample 3 | 0.029 | 40+8x. Thus four times the number of coffee mugs in the teacher’s lounge is=40+x 8x=40 |
| Resample 4 | 0.997 | 4x+8. We know that 4x+8=40. Subtracting 8 from both sides, we get 4 |
| Final DiVR reasoning. | Let x be the number of coffee mugs in the teacher’s lounge. Eight more than four times the number of coffee mugs in the teacher’s lounge is 4x+8. We know that 4x+8=40. Subtracting 8 from both sides, we get 4x=32. Dividing both sides by 4, we get x=8. answer 8 (correct). |
Table 11.
Prompt Templates
Every prompt is a single user turn in the generator’s own chat template, with the generation prompt appended. A fixed response prefix follows it and belongs to the prompt, not to the decoded canvas. Line breaks are as used, and long lines are wrapped for display (). Braces mark inserted fields. LLaDA-8B-Base, LLaDA-8B-Instruct and their SFT adapters share one template. Dream-v0-Instruct-7B uses its ChatML template with the default system message, as listed below.
LLaDA: <|startoftext|><|start_header_id|>user<|end_header_id|>\n\n{content}<|eot_id|><|start_header_id|>
$\rightarrow$ assistant<|end_header_id|>\n\n{prefix}
Dream: <|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n{content}<|im_end|>\n<|
$\rightarrow$ im_start|>assistant\n{prefix}
The verifier adds no prompt of its own. It reads the same prompt followed by the current canvas. SR-SMC also uses only the generation prompt.
GSM8K and MATH-500. The d1 instruction [41] precedes the question, and the prefix is <reasoning>. The same content is used for the verifiers’ training decodes.
You are a math expert. You will be given a question to solve. Solve it step by step. Wrap the final answer in
→ a \boxed{}.
Respond in the following format:
<reasoning>
Your reasoning here
</reasoning>
<answer>
\boxed{...}
</answer>
{question}
Countdown. The d1 Countdown instruction, verbatim, including its missing space before “Respond”. The question lists the three numbers and the target. The prefix is <reasoning>.
Using only the provided numbers, create an arithmetic expression that evaluates to exactly the provided target
→ number. You may use the operations +, -, *, and / as needed, but each number must be used exactly
→ once. Think step-by-step. After reasoning, provide only your final expression inside \boxed{} tags
→ without including an equals sign or the target number. For example: \boxed{a + b * c}Respond in the
→ following format:
<reasoning>
Your reasoning here
</reasoning>
<answer>
\boxed{...}
</answer>
Numbers: [{n1}, {n2}, {n3}]
Target: {target}
HumanEval and MBPP. The prefix opens a Python code fence followed by a newline. The program is the response up to the closing fence. HumanEval appends its prompt field, the function signature and docstring. MBPP lists the task text and its test assertions.
Complete the following Python function. Write the complete function, including its signature, inside a single
→ ‘‘‘python code block.
{HumanEval prompt}
You are an expert Python programmer. Write a Python function for the task below. Your code must pass the given
→ tests. Put the complete code inside a single ‘‘‘python code block.
Task: {text}
Tests:
{test_list, one assertion per line}
Sudoku diagnosis. The d1 4×4 instruction, verbatim, which begins with a newline. The trace SFT used the same prompt. The prefix is <reasoning>.
Please solve the following 4x4 Sudoku puzzle. The puzzle is provided as a 16-character string reading left-to-
→ right, top-to-bottom, where ’0’ represents empty cells.
Rules:
- Fill empty cells with digits 1-4
- Each row must contain digits 1-4 exactly once
- Each column must contain digits 1-4 exactly once
- Each 2x2 box must contain digits 1-4 exactly once
Important: Your solution must be a COMPLETE 16-character string with only the digits 1-4, representing your
↪ final solved grid.
Respond in this exact format:
<reasoning>
Your step-by-step solving process
</reasoning>
<answer>
[16-character solution string with no spaces or separators]
</answer>
Solve the following Sudoku puzzle: {puzzle}
Prompted Yes/No and Prism’s verifier. Both use the generator itself as judge.
Fields. The judge prompt is filled with the question and the solution decoded so far. A solution longer than 2,000 characters keeps its first 500 and last 1,500 characters around a . . . [truncated] . . . marker.
Readout. The prompt is wrapped in the chat template and one mask token is appended. The score is the two-way softmax of the largest Yes-variant logit (Yes, Yes, YES) against the largest No-variant logit, both read at that mask position.
Prompts. Mathematical tasks use Prism’s judgment prompt. Code tasks use our shorter reviewer adaptation, the second listing.
You are an expert mathematician and competition judge. Your task is to evaluate a proposed mathematical
↪ solution for a given problem based on its logical rigor and accuracy.
[Math Problem]
{prompt}
[/Math Problem]
[Proposed Mathematical Solution]
{solution}
[/Proposed Mathematical Solution]
**Analysis Steps:**
1. Reasoning Validity: Are the logical steps and mathematical properties applied correctly?
2. Calculation Accuracy: Are the intermediate calculations or algebraic manipulations accurate?
3. Goal Alignment: Does the current reasoning path directly lead toward the final answer required by the
↪ problem?
**Conclusion**: Based on your analysis, is this solution path sound and likely to result in the correct final
↪ answer? Answer with a single word: Yes or No.
**Answer:**
You are an expert code reviewer. Your task is to evaluate whether a proposed Python solution correctly solves
↪ the task.
[Task]
{prompt}
[/Task]
[Proposed Solution]
{solution}
[/Proposed Solution]
**Conclusion**: Based on your analysis, is the solution likely to be fully correct? Answer with a single word:
↪ Yes or No.
**Answer:**References
- [1]Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, et al. 2021. Program synthesis with large language models. arXiv preprint arXiv:2108.07732.arxiv.org/abs/2108.07732
- [2]Jinbin Bai, Yixuan Li, Yuchen Zhu, Yi Xin, Qingyu Shi, Aosong Feng, Xiaohong Liu, Molei Tao, Jianru Xue, Xiangtai Li, and Ming-Hsuan Yang. 2026. Prism: Efficient test-time scaling via hierarchical search and self-verification for discrete diffusion language models. In International Conference on Machine Learning.arxiv.org/abs/2602.01842
- [3]Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, and 39 others. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374.arxiv.org/abs/2107.03374
- [4]Guan-Ming Chiu and Jeng-Yue Liu. 2026. Probing functional correctness in diffusion language models. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 4: Student Research Workshop), pages 163–172.
- [5]Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. 2021. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168.arxiv.org/abs/2110.14168
- [6]Meihua Dang, Jiaqi Han, Minkai Xu, Kai Xu, Akash Srivastava, and Stefano Ermon. 2026. Inference-time scaling of diffusion language models via trajectory refinement. In Conference on Language Modeling.arxiv.org/abs/2507.08390
- [7]Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. 2021. Measuring mathematical problem solving with the MATH dataset. In Proceedings of the Neural Information Processing Systems Track on Datasets and Benchmarks.
- [8]Feng Hong, Geng Yu, Yushi Ye, Haicheng Huang, Huangjie Zheng, Ya Zhang, Yanfeng Wang, and Jiangchao Yao. 2026. Wide-in, narrow-out: Revokable decoding for efficient and effective DLLMs. In International Conference on Learning Representations.arxiv.org/abs/2507.18578
- [9]Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2022. LoRA: Low-rank adaptation of large language models. In International Conference on Learning Representations.arxiv.org/abs/2106.09685
- [10]Zemin Huang, Yuhang Wang, Zhiyang Chen, and Guo-Jun Qi. 2026. Don’t settle too early: Self-reflective remasking for diffusion language models. In International Conference on Learning Representations.arxiv.org/abs/2509.23653
- [11]Inception Labs, Samar Khanna, Siddhant Kharbanda, Shufan Li, Harshit Varma, Eric Wang, Sawyer Birnbaum, Ziyang Luo, Yanis Miraoui, Akash Palrecha, Stefano Ermon, Aditya Grover, and Volodymyr Kuleshov. 2025. Mercury: Ultra-fast language models based on diffusion. arXiv preprint arXiv:2506.17298.arxiv.org/abs/2506.17298
- [12]Metod Jazbec, Theo X. Olausson, Louis Béthune, Pierre Ablin, Michael Kirchhof, João Monteiro, Victor Turrisi, Jason Ramapuram, and Marco Cuturi. 2026. Learning unmasking policies for diffusion language models. In International Conference on Machine Learning.arxiv.org/abs/2512.09106
- [13]Kijung Jeon, Thuy-Duong Vuong, and Molei Tao. 2026. VGB for masked diffusion model: Efficient test-time scaling for reward satisfaction and sample editing. arXiv preprint arXiv:2606.28301.arxiv.org/abs/2606.28301
- [14]Jaeyeon Kim, Seunggeun Kim, Taekyun Lee, David Z. Pan, Hyeji Kim, Sham M. Kakade, and Sitan Chen. 2026. Fine-tuning masked diffusion for provable self-correction. In International Conference on Machine Learning.arxiv.org/abs/2510.01384
- [15]Pengxiang Li, Yefan Zhou, Dilxat Muhtar, Lu Yin, Shilin Yan, Li Shen, Yi Liang, Soroush Vosoughi, and Shiwei Liu. 2026. Diffusion language model knows the answer before it decodes. In International Conference on Learning Representations.
- [16]Baohao Liao, Yuhui Xu, Hanze Dong, Junnan Li, Christof Monz, Silvio Savarese, Doyen Sahoo, and Caiming Xiong. 2025. Reward-guided speculative decoding for efficient LLM reasoning. In International Conference on Machine Learning.arxiv.org/abs/2501.19324
- [17]Hunter Lightman, Vineet Kosaraju, Yura Burda, Harri Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. 2024. Let’s verify step by step. In International Conference on Learning Representations.arxiv.org/abs/2305.20050
- [18]Ziwei Luo, Ziqi Jin, Lei Wang, Lidong Bing, and Thomas B. Schön. 2026. Self-rewarding sequential Monte Carlo for masked diffusion language models. arXiv preprint arXiv:2602.01849.arxiv.org/abs/2602.01849
- [19]Roy Miles, Aysim Toker, Andreea-Maria Oncescu, Jiankang Deng, and Ismail Elezi. 2026. Test-time scaling with diffusion language models via reward-guided stitching. In Advances in Neural Information Processing Systems.arxiv.org/abs/2602.22871
- [20]Kou Misaki and Takuya Akiba. 2026. UnMaskFork: Test-time scaling for masked diffusion via deterministic action branching. In International Conference on Machine Learning.
- [21]Nikita Mounier and Parsa Idehpour. 2025. Review, remask, refine (R3): Process-guided block diffusion for text generation. In ICML 2025 Workshop on Methods and Opportunities at Small Scale.arxiv.org/abs/2507.08018
- [22]Shen Nie, Fengqi Zhu, Zebin You, Xiaolu Zhang, Jingyang Ou, Jun Hu, Jun Zhou, Yankai Lin, Ji-Rong Wen, and Chongxuan Li. 2025. Large language diffusion models. In Advances in Neural Information Processing Systems.arxiv.org/abs/2502.09992
- [23]Hadas Orgad, Michael Toker, Zorik Gekhman, Roi Reichart, Idan Szpektor, Hadas Kotek, and Yonatan Belinkov. 2025. LLMs know more than they show: On the intrinsic representation of LLM hallucinations. In International Conference on Learning Representations.arxiv.org/abs/2410.02707
- [24]Jiayi Pan, Junjie Zhang, Xingyao Wang, Lifan Yuan, Hao Peng, and Alane Suhr. 2025. TinyZero. https://github.com/Jiayi-Pan/TinyZero.
- [25]Fred Zhangzhi Peng, Zachary Bezemek, Sawan Patel, Jarrid Rector-Brooks, Sherwood Yao, Avishek Joey Bose, Alexander Tong, and Pranam Chatterjee. 2025. Path planning for masked diffusion model sampling. arXiv preprint arXiv:2502.03540.arxiv.org/abs/2502.03540
- [26]John C. Platt. 1999. Probabilistic outputs for support vector machines and comparisons to regularized likelihood methods. In Alexander J. Smola, Peter L. Bartlett, Bernhard Schölkopf, and Dale Schuurmans, editors, Advances in Large Margin Classifiers, pages 61–74. MIT Press.
- [27]Subham Sekhar Sahoo, Marianne Arriola, Yair Schiff, Aaron Gokaslan, Edgar Marroquin, Justin T Chiu, Alexander Rush, and Volodymyr Kuleshov. 2024. Simple and effective masked diffusion language models. In Advances in Neural Information Processing Systems.arxiv.org/abs/2406.07524
- [28]Dimitri von Rütte, Janis Fluri, Yuhui Ding, Antonio Orvieto, Bernhard Schölkopf, and Thomas Hofmann. 2025. Generalized interpolating discrete diffusion. In International Conference on Machine Learning.arxiv.org/abs/2503.04482
- [29]Guanghan Wang, Yair Schiff, Subham Sekhar Sahoo, and Volodymyr Kuleshov. 2025. Remasking discrete diffusion models with inference-time scaling. In Advances in Neural Information Processing Systems.arxiv.org/abs/2503.00307
- [30]Wen Wang, Bozhen Fang, Chenchen Jing, Yongliang Shen, Yangyi Shen, Qiuyu Wang, Hao Ouyang, Hao Chen, and Chunhua Shen. 2026. Time is a feature: Exploiting temporal dynamics in diffusion language models. In International Conference on Learning Representations.arxiv.org/abs/2508.09138
- [31]Chengyue Wu, Hao Zhang, Shuchen Xue, Zhijian Liu, Shizhe Diao, Ligeng Zhu, Ping Luo, Song Han, and Enze Xie. 2026. Fast-dLLM: Training-free acceleration of diffusion LLM by enabling KV cache and parallel decoding. In International Conference on Learning Representations.arxiv.org/abs/2505.22618
- [32]Shaoan Xie, Lingjing Kong, Xiangchen Song, Xinshuai Dong, Guangyi Chen, Eric P. Xing, and Kun Zhang. 2026. Advancing reasoning in diffusion language models with denoising process rewards. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 42703–42720.
- [33]Jiacheng Ye, Jiahui Gao, Shansan Gong, Lin Zheng, Xin Jiang, Zhenguo Li, and Lingpeng Kong. 2025a. Beyond autoregression: Discrete diffusion for complex reasoning and planning. In International Conference on Learning Representations.arxiv.org/abs/2410.14157
- [34]Jiacheng Ye, Zhihui Xie, Lin Zheng, Jiahui Gao, Zirui Wu, Xin Jiang, Zhenguo Li, and Lingpeng Kong. 2025b. Dream 7B: Diffusion large language models. arXiv preprint arXiv:2508.15487.arxiv.org/abs/2508.15487
- [35]Fei Yu, Anningzhe Gao, and Benyou Wang. 2024. OVM, outcome-supervised value models for planning in mathematical reasoning. In Findings of the Association for Computational Linguistics: NAACL 2024, pages 858–875.arxiv.org/abs/2311.09724
- [36]Lifan Yuan, Wendi Li, Huayu Chen, Ganqu Cui, Ning Ding, Kaiyan Zhang, Bowen Zhou, Zhiyuan Liu, and Hao Peng. 2025. Free process rewards without process labels. In International Conference on Machine Learning.arxiv.org/abs/2412.01981
- [37]Yan Zhan, Shaobo Liu, and Zhijun Gao. 2026. Why deterministic PRM guidance underperforms in discrete diffusion reasoning. In Advances in Neural Information Processing Systems.arxiv.org/abs/2609.35472
- [38]Shuibai Zhang, Fred Zhangzhi Peng, Yiheng Zhang, Jin Pan, and Grigorios G. Chrysos. 2026. Corrective diffusion language models. In Advances in Neural Information Processing Systems.arxiv.org/abs/2512.15596
- [40]Shengjia Zhao, Michael P. Kim, Roshni Sahoo, Tengyu Ma, and Stefano Ermon. 2021. Calibrating predictions to decisions: A novel approach to multi-class calibration. In Advances in Neural Information Processing Systems, volume 34.arxiv.org/abs/2107.05719
- [41]Siyan Zhao, Devaansh Gupta, Qinqing Zheng, and Aditya Grover. 2025. d1: Scaling reasoning in diffusion large language models via reinforcement learning. In Advances in Neural Information Processing Systems.arxiv.org/abs/2504.12216



