acceptodds
Under review as a conference paper at ICLR 2027

PRICE: Learning What to Recompute for Reasoning in Diffusion Language Models

Abstract

Diffusion language models can revise outputs, but choosing what to recompute is difficult. Local repair may leave inconsistent downstream results. Recomputing all descendants may waste useful work. We propose PRICE (Predictive Repair via Intervention-trained Candidate Evaluation). It chooses semantic repair scopes using learned estimates of final reward and remaining cost. A predicted dependency graph proposes a bounded pool of executable actions. Offline continuations from the same partial state train estimates of reward and cost differences. Inference runs one action without trying alternative continuations. The executor hides predicted affected text from the model. Cached values return only after a check without reference answers; its cost is counted. Our analysis shows when selective repair beats full closure and when learned selection preserves this gain. It bounds regret from missing candidates and value errors. Across three instruction-tuned diffusion backbones and four reasoning benchmarks, evaluated settings improve scores over full closure with fewer model evaluations. Gains depend on candidate coverage, value accuracy, and the reliability and full cost of checked reuse.

Primary area:
generative models
Keywords:
diffusion language models, reasoning, repair scope selection, action-value learning, computation allocation, efficient inference

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_NzxWOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes PRICE, a framework for learning what to recompute in diffusion language models. It formulates repair-scope selection as a state-conditioned action selection problem, using a predicted dependency graph to construct a bounded pool of candidate repair scopes. The method learns reward–cost values of complete repair actions from matched offline continuations and selects a single action during inference without online branching. A selective retention executor further combines quarantine and verification-gated reuse to avoid unnecessary recomputation. The paper also provides theoretical analyses of selective-repair advantages and regret bounds related to candidate coverage and value estimation errors. Experiments across three diffusion language models and four reasoning benchmarks demonstrate improvements in reasoning performance over full-closure repair, while reducing model evaluations by approximately 12%.

Critical strengths
  1. Novel Graph-Based Perspective on Recomputation. The paper provides a novel perspective on recomputation in diffusion language models by modeling dependencies among reasoning units through a graph. It formulates repair-scope selection as a state-conditioned action selection problem and learns to balance expected reward and computational cost, enabling more selective recomputation and reuse of intermediate results.

  2. Relatively Comprehensive Experimental Evaluation. The experiments cover multiple diffusion language models and reasoning benchmarks. The paper also includes budget-matched comparisons and detailed ablation studies on major components, providing useful evidence for the effectiveness of the proposed framework.

Critical weaknesses
  1. Unclear mechanism behind recomputation gains. Although recomputation improves performance, it remains unclear why remasking previously generated tokens leads to more accurate reasoning, especially when the upstream context remains unchanged. The paper lacks controlled ablations distinguishing the effects of changed masking contexts, stochastic regeneration, and corrected dependencies.

  2. Presentation and reproducibility issues. Some parts of the paper are difficult to follow due to dense notation and explanations. Figure 1 is overly complicated, with small text and crowded arrows, while several experimental tables are too compact. Furthermore, the provided code appears to be a simplified implementation, lacking key components such as automatic DAG construction and complete benchmark evaluation scripts, making the reported results difficult to reproduce.

Questions for authors
  1. What is the main source of improvement from recomputation? It remains unclear why remasking previously generated reasoning units improves accuracy, particularly when the upstream context remains unchanged. Could the authors clarify or experimentally distinguish the effects of changed masking contexts, stochastic regeneration, and corrected upstream dependencies?

  2. How effective is PRICE at correcting errors in early reasoning steps? The paper seems to lack an analysis of how repair effectiveness varies with the position or dependency depth of erroneous reasoning units. Could the authors report correction success rates and downstream regeneration/reuse statistics for early-stage errors, particularly in longer reasoning sequences?

3 comments
AuthorsOpenReview ↗

Response to Reviewer NzxW

We thank the reviewer for recognizing graph-based recomputation and our evaluation.

W1 / Q1. “Unclear mechanism behind recomputation gains.”

Stale downstream text can reinforce an earlier error in bidirectional denoising; hiding it enables revision even when upstream values stay unchanged.

We compare four branches from 300 unrepaired states (150 GSM8K/150 MATH; one/question), selected before outcomes with auditable target/ancestor errors. Branches share snapshot, target slot, prior costs and local budget: one replacement call under a 48-NFE total cap, identical KV rules and separately rebuilt visible inputs.

BranchUpstreamOld downstreamReplacementCorrected
AGeneratedVisibleGreedy87/300 (29.0%)
BGeneratedVisibleSampling, T=1.094/300 (31.3%)
CGeneratedHiddenGreedy108/300 (36.0%)
DOne ancestor correctedHiddenGreedy131/300 (43.7%)

A→C isolates visibility (+21 net corrections; 7.0 points), A→B sampling (+7; 2.3), and C→D ancestor correction (+23; 7.7). D uses a reference intermediate value only offline. These conditional effects do not add up to the total system gain.

The separate native-termination control (Table 3b; Appendix B.15) matches states/scopes/continuations/budgets: accuracy/NFE is 79.8%/34.6 with stale text visible, 80.4%/40.9 with full regeneration and 82.6%/36.0 with selective reuse.

W2 (code). “lacking key components such as automatic DAG construction and complete benchmark evaluation scripts”

We are submitting updated code with this response, including automatic DAG construction, matched interventions, scorer training, repair execution and a runner for selected backbones/tasks comparing PRICE, native decoding, Confidence and Full closure.

A frozen question-only planner produces a validated DAG with fixed slots. The lowest-confidence eligible stored unit seeds six scopes: no repair, target, depth-1/2, closure and global. Duplicate/infeasible actions are removed; the eligible frontier stays fixed within each control interval. From the current trace and budget, the scorer predicts each action's terminal-reward gain and normalized full remaining-cost change versus no repair, including later checks/regeneration. One action executes without online branching.

Selected values are discarded; other affected values stay externally cached and hidden. Inputs are rebuilt with KV reuse disabled. Once current parents resolve, a greedy forward probes the hidden slot. External token/termination matching gates reuse with current parent-version records; rejection discards the probe and generates afresh. All forwards count, and fallback retains prior costs.

Problems are split before collection. Candidates share state, remaining budget and continuation. Slot draws pair problem/slot/position/local update/repeat seed; native fallback shares the repeat seed. Reference answers only score terminal rewards. Accuracy/pass@1 denominators include failures and exhausted budgets (Appendix C).

W2 (presentation). “dense notation and explanations”

We redrew Figure 1 and explain operations before formal notation.

The figure separates four online stages from offline learning. The text first explains discard scope RR, hidden affected region Ds(R)D_s(R) and eligible updates UU. Core equations/key comparisons stay in the main text; detailed tables/state fields move to appendices.

Q2. “How effective is PRICE at correcting errors in early reasoning steps?”

PRICE locally corrects 36/100 early errors and 7/26 early errors in the longest-trace quartile.

This separate audit uses 300 baseline-error events (150/task; one/question), 100 per early/middle/late third of original unit-completion order. PRICE resumes at the next legal checkpoint under a 48-NFE total cap, retaining prior costs and its ordinary selector without target forcing. Targets are independently assessed after their first completed regeneration.

GroupRegen./auditedCorrect/auditedCorrect/regen.Downstream regen./reuse
Early61/10036/10059.0%3.8/2.2
Middle68/10044/10064.7%2.3/1.4
Late73/10051/10069.9%0.8/0.4
Longest 25%43/7525/7558.1%4.4/2.7
Remaining 75%159/225106/22566.7%1.6/0.9
Early, longest 25%14/267/2650.0%5.1/3.0

Rows regroup the same events; the last is an intersection. Original trace length excludes padding/post-termination tokens. Downstream means count distinct units per category, conditional on target regeneration. Of 26 long/early errors, 12 have no completed regeneration and 7 remain wrong.

Shortest root distance is the shortest directed path's edge count from any root to the audited unit (root=0):

DistanceAuditedRegeneratedCorrectedCorrect/regen.
0–1104755370.7%
2–3119845565.5%
≥477432353.5%
Total30020213164.9%

Observed correction declines across these distance groups.

Thank you for the additional experiments and clarifications, including the controlled analysis of recomputation, the error-position experiments, and the revised method figure and explanations, which help address my earlier concerns. I appreciate the novel perspective presented in this work. However, I still have concerns about the overall clarity of the presentation and the effectiveness of the method on more complex reasoning tasks. I therefore maintain my original rating.

AuthorsOpenReview ↗

Response to Reviewer NzxW

Thank you for giving the revised figure and error analyses another careful read.

Section 3 and the revised Figure 1 separate the learned choice of what to recompute from the fixed check for reusing a stored result.

Consider an intermediate number that changes from 4 to 5. Its double changes and its sign stays positive. If the predicted graph contains both dependencies, full-closure repair discards both stored results. PRICE can retain a value outside the model’s input and check it against the updated context before restoring it. In Figure 1, the scoring panel shows the scope choice and the verification panel shows the check before reuse.

PRICE used fewer model evaluations on the longest MATH traces in both comparisons. The small accuracy differences favored different methods.

We examined trace length as one aspect of reasoning difficulty. Before comparing the methods, we divided all 5,000 MATH problems into four groups of 1,250 by the effective length of independently generated native traces. Both methods used LLaDA’s native stopping rule and the same three evaluation seeds.

Native trace lengthFull closure accuracyPRICE accuracyFull closure mean NFEPRICE mean NFE
Shortest 25%47.2%49.5%40.135.9
Second quartile45.8%48.6%41.136.8
Third quartile44.0%47.5%42.637.7
Longest 25%41.0%41.6%44.638.8
All 5,00044.5%46.8%42.137.3

With native stopping, PRICE’s accuracy advantage was 2.3–3.5 percentage points in the three shorter groups and 0.6 points in the longest, where it used 13.0% fewer model evaluations. In the separate 48-NFE MATH subset, PRICE also saved evaluations in the longest group, where full closure was slightly more accurate.

Reviewer_1ooKOpenReview ↗
Rating
2
Confidence
3
Informativeness
3
Presentation
2
Soundness
3
Read review
Paper summary

PRICE addresses the problem of repairing intermediate reasoning traces in diffusion language models. Local recomputation may leave stale downstream units, while recomputing the entire dependency closure wastes computation. PRICE constructs a bounded set of repair actions and learns their expected reward improvement and computational cost through offline intervention rollouts. It then uses a joint action scorer, together with quarantine and verification-gated cache reuse, to dynamically select the most cost-effective repair scope.

Critical strengths
  1. The state-conditioned selector is more flexible than fixed-scope heuristics because the best repair scope depends on the current trace state, dependency structure, and remaining computation budget.
  2. The joint scorer is well motivated because repair units can interact non-additively; the value of repairing several units together cannot always be decomposed into independent unit-level scores.
Critical weaknesses
  1. The bounded candidate pool limits the achievable performance. If the optimal repair scope is omitted, a perfect scorer still cannot recover it, and the experiments show a nontrivial candidate-omission gap.
  2. The verification mechanism mainly checks surface consistency through exact matching and formatting. Passing verification does not establish semantic correctness under the updated reasoning context.
  3. A key limitation is that PRICE relies on preallocated fixed-length token slots for each reasoning unit, without an explicit mechanism for dynamically expanding, shrinking, or re-segmenting a slot after repair. If the corrected unit requires substantially more tokens than its original allocation, the method falls back to budgeted native generation, which may reduce efficiency and limits its robustness to variable-length reasoning traces.
Questions for authors
  1. PRICE relies heavily on an initial DAG construction step, but the paper does not sufficiently characterize the model’s capability or accuracy in constructing this DAG. Errors introduced at this stage may propagate through candidate construction, quarantine, and repair selection, and could be difficult or impossible to recover from.

  2. The proposed DAG structure appears to be most suitable for relatively simple tasks, such as arithmetic problems and short code generation. Because PRICE relies on a highly structured and carefully engineered repair process, it is unclear whether it can generalize to long-horizon tasks, such as interactive agentic tasks.

4 comments
AuthorsOpenReview ↗

Response to Reviewer 1ooK

We thank the reviewer for recognizing state-conditioned selection and joint modeling of repair interactions.

W1. “The bounded candidate pool limits the achievable performance.”

A finite pool limits checkpoint-level repair value even with perfect scoring; six candidates are the efficiency default.

For each of 1,000 snapshots (B.7), we execute each scope and continue to a final answer, recording correctness and remaining cost. Utility is reward minus weighted relative remaining cost normalized by no repair, not accuracy (B.4). Reference evaluates the offline estimated best-in-pool action; Selected evaluates the scorer's choice. Reference selection/evaluation use independent continuations.

Pool capReference utilitySelected utilityms/state
60.7780.7650.49
120.7940.7760.86
240.8030.7841.47
Finite enumeration0.806——

With scorer/executor fixed, the finite-reference gap at cap 6 is 0.041: 0.028 omission + 0.013 selection. At cap 24: 0.003/0.019. Expansion improves utility but costs scoring time.

W2. “Passing verification does not establish semantic correctness under the updated reasoning context.”

Passing the probe does not certify semantic correctness; the accepted-cache audit measures this risk.

We audit 100 accepted units/task, at most one/question. Assessors see the question, current parents, unit role and value, blinded to final-task and paired-regeneration outcomes.

TaskAuditedCorrectIncorrectIndeterminate
GSM8K1009235
MATH10085105

Affected values stay outside model inputs. Once parents resolve, a probe predicts the hidden unit from updated context; external comparison gates reuse. Paired continuations find reuse failure with regeneration success in 36/2,734 accepted GSM8K checks (1.32%) and 257/8,750 MATH checks (2.94%). Terminal outcomes differ from unit correctness: later repairs and both-failed branches can conceal local errors.

Our native-termination study (Table 3b; B.15) gives GSM8K accuracy/NFE of 80.4%/40.9 (full regeneration), 82.6%/36.0 (PRICE) and 82.8%/37.2 (task-aware checks). Symbolic/numerical checks and public code tests use no reference answers or hidden tests. Acceptance falls from 63.8% to 55.4%; checks and rejected-check regeneration count.

W3. “preallocated fixed-length token slots for each reasoning unit”

Slots do not resize; fallback uses remaining budget for native generation.

We use the transfer study's fixed 500 MATH questions, a MATH-trained scorer and a 48-NFE total cap:

MeasureProblemsRate
First fallback, any cause18/5003.6%
Overflow-triggered fallback9/5001.8%
Overflow, longest quartile6/1254.8%
Overflow, remaining problems3/3750.8%
Correct after overflow fallback4/944.4%

Other first triggers: planning/structural (6), parsing (3). Length uses independent native traces without padding/post-termination text. Fallback retains prior costs; five overflow cases remain wrong. All failures stay in evaluation.

Q1. “the model’s capability or accuracy in constructing this DAG”

96/100 plans are structurally valid; 392/480 predicted edges have semantic support (81.7%).

GSM8K plans use fixed problem-ID hash selection. Two annotators assess edges in valid plans: support means upstream use or a plausible effect of changing it; 62 are unsupported and 26 indeterminate.

Missing paths can expose stale values; extra edges enlarge quarantine/checking. Original graph controls (B.9–B.10) give GSM8K accuracy of 82.6%/80.4%/83.0% for predicted/matched random/trace-derived approximate graphs. Removing/adding 20% of edges gives 81.4%/81.7%. Across four tasks, affected-region precision/recall against intervention-derived references is 86.1%–89.2%/82.9%–86.7%.

Q2. “generalize to long-horizon tasks, such as interactive agentic tasks”

A single-feedback pilot supports fixed-dependency recovery, without establishing general long-horizon capability.

We test 40 ToolSandbox-derived instances from 10 templates: 30 change values within existing dependencies; 10 add prerequisites. Methods share frozen LLaDA, model/environment snapshots and scripted feedback; PRICE's GSM8K scorer is frozen. Observations are read-only; executed actions persist. The 80-NFE post-feedback/eight-call cap counts all forwards, including replanning and failed calls; only the shared prefix is excluded (E.7). Success requires the target state, execution preconditions and no prohibited side effects.

FeedbackMethodSuccessesMean recovery NFE
Same dependenciesLocal-only15/3034.8
Same dependenciesFull closure18/3043.0
Same dependenciesPRICE19/3037.2
Same dependenciesReplan-all19/3047.5
New prerequisitesPRICE3/1038.4
New prerequisitesReplan-all6/1046.2

On fixed dependencies PRICE saves 21.7% NFE at equal success counts; new prerequisites favor replanning.

Thank you for the additional experiments and clarifications. The new analyses address several of my concerns, particularly regarding candidate coverage, verification errors, and slot overflow. However, my main concerns remain: the method’s generalization to longer and more complex tasks is still insufficiently demonstrated, while the DAG-quality analysis is largely limited to GSM8K and does not establish whether errors introduced during DAG construction can be reliably detected or recovered from. I therefore maintain my rating.

AuthorsOpenReview ↗

Response to Reviewer 1ooK

We appreciate your follow-up on the candidate and cache audits.

A missing edge can leave an affected result unchecked throughout decoding. A run can also end correctly with the graph still incomplete.

We tested 100 MATH and 100 MBPP repair states. From each state we ran two continuations, one with the predicted graph and one with 20% of its edges removed at random. Both used the same scorer, execution rules, and remaining budget. Final successes went from 46 to 43 on MATH and from 42 to 43 on MBPP.

In 34 of the 200 perturbed states, the predicted region missed at least one affected unit. In 26 of those 34, the missed units stayed outside quarantine and bypassed verification for the rest of the run. In the other eight, a later repair reached the missed work or decoding fell back to the native procedure. Three of those eight runs ended correctly, with the deleted edges still absent. The reuse check only examines values set aside for possible reuse. A stale value left outside quarantine can remain visible to the decoder.

Under the 48-evaluation cap, PRICE used fewer model calls on the longest MATH traces and solved two fewer problems than full-closure repair.

We grouped 500 MATH problems by the effective length of independently generated native traces. PRICE solved 11 more problems than full closure across all 500. In the longest group, PRICE solved 50 of 125 and full closure solved 52. Mean model evaluations per problem were 39.8 for PRICE and 44.6 for full closure.

Thank you for your explanation. I'll maintain my score.

Reviewer_aG5XOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
1
Soundness
3
Read review
Paper summary

This paper studies which spans a dLLM should remask and decode again when an earlier reasoning step changes. Before decoding, the model is prompted to write a plan: a dependency DAG over reasoning steps, with a fixed token span for each step. During decoding, PRICE takes a span flagged for remasking and builds a small set of candidates for what to remask with it: nothing, the span alone, the span plus its DAG descendants up to depth 1 or 2, all descendants, or the whole output. A learned scorer predicts each candidate’s gain in final accuracy minus its extra NFE, and PRICE runs the best candidate. Experiments on LLaDA, iLLaDA, and Dream show 1.1–3.1 pp gains over a confidence-based remasking baseline at similar NFE.

Critical strengths
  1. The paper treats “which spans to remask” as a choice among a few candidates.
  2. A learned model scores each candidate by predicted accuracy gain minus NFE cost.
  3. The analyses are thorough, and the results hold on three backbones.
Critical weaknesses
  1. Competing methods are only evaluated as the authors’ own reimplementations under PRICE’s protocol, and against the strongest of them PRICE gains are modest.
  2. The scorer needs hundreds of GPU-hours of rollouts on the same benchmarks it is tested on, plus ~12% more NFE at inference, so PRICE should also be compared against plain decoding that spends the same extra compute (e.g., more denoising steps or majority voting).
Questions for authors
  1. How does PRICE compare with plain decoding that uses the same extra compute (more denoising steps, or majority voting)?
  2. Does a scorer trained on one benchmark transfer to another?
4 comments
AuthorsOpenReview ↗

Response to Reviewer aG5X

We thank the reviewer for recognizing PRICE's candidate-action formulation, learned reward–cost scoring, and multi-backbone analyses.

W1. “Competing methods are only evaluated as the authors’ own reimplementations under PRICE’s protocol, and against the strongest of them PRICE gains are modest.”

After retuning, PRICE retains comparable accuracy with 6.7% lower four-task mean NFE. These comparisons evaluate controlled adaptations.

UnMaskFork-style's branch count, branch-advancement horizon and scoring timing are tuned on development data and frozen before testing. All controls share the frozen backbone, decoding/termination rules, and 40-NFE cap. Every dense backbone forward counts, including discarded branches, auxiliary scoring, and verification; latency includes scorer computation and state management.

MethodGSM8K (%)MATH (%)HumanEval (%)MBPP (%)Four-task mean NFE
T2M-style80.844.952.643.537.6
UnMaskFork-style, original81.245.453.044.039.1
UnMaskFork-style, development-tuned81.345.553.344.039.0
PRICE81.545.753.544.236.4

Retuned HumanEval passes 262/492 completions (53.3%). UnMaskFork-style evaluates branched continuations online; PRICE predicts complete-action values and executes one selected action. Appendices B.1–B.2 distinguish source protocols from our controlled adaptations.

W2 / Q1. “How does PRICE compare with plain decoding that uses the same extra compute (more denoising steps, or majority voting)?”

PRICE exceeds 36-step native decoding by 2.1 percentage points at comparable actual NFE and latency.

We use LLaDA-8B-Instruct on all 1,319 GSM8K test questions with the same three seeds, prompts, answer extraction and hardware, under Table 2's 40-NFE per-example total cap. Native decoding changes only the denoising steps; PRICE retains its 32-step base configuration. All forwards, including planning, verification, and regeneration, count; latency includes scoring and cache management.

MethodGSM8K accuracy (%)GSM8K mean NFERelative latency
Original, 32 steps78.132.01.00
Native, 36 steps79.436.01.13
Native, 40 steps80.040.01.24
PRICE81.535.91.12

These are GSM8K means. PRICE gains 1.5 points with 4.1 fewer NFE than 40-step decoding. Two complete 32-step trajectories require 64 NFE, beyond this cap; shorter-trajectory ensembles remain untested.

Offline training learns a reusable scorer of complete repair actions, conditioned on trace and budget. Matched rollouts from the same state supervise changes in final reward and full remaining cost relative to no repair, including reuse checks and regeneration after rejection. Inference selects one action without trial continuations. Its cost effectiveness depends on deployment scale and task gains.

With the candidate pool fixed, revised Table 3a (Appendix B.8) compares additive-logit, joint, and joint-plus-paired scoring under native termination, separately from the 40-NFE-cap experiment. GSM8K/MATH accuracy is 81.7%/45.8%, 82.2%/46.4%, and 82.6%/46.8%, with two-task mean NFE of 36.9, 36.8, and 36.7, respectively. The 0.9/1.0-point gains over additive-logit scoring show better selection at comparable compute with the same actions.

Q2. “Does a scorer trained on one benchmark transfer to another?”

Yes. A frozen GSM8K-trained scorer improves MATH accuracy by 1.2 points over Confidence at similar compute.

We train a separate scorer using states from 1,000 GSM8K training questions and select parameters on 200 development questions. We then freeze weights, selection parameters (including cost weight and threshold), and feature-normalization statistics. Evaluation uses a fixed 500-question subset of the paper's 5,000-question MATH test set, seed 42, and a 48-NFE per-example total cap. The MATH-trained control matches training-state counts, architecture, and optimization settings. Problems are split before collecting states.

MethodCorrectAccuracy (%)Mean NFE
Full closure224/50044.841.7
Confidence222/50044.437.5
PRICE: GSM8K-trained, frozen228/50045.637.8
PRICE: MATH-trained235/50047.037.2

Frozen transfer yields six additional correct answers over Confidence; MATH-specific training adds seven more (1.4 points). This shows cross-benchmark reuse and the further benefit of target-task supervision.

Presentation. “Difficult to follow despite careful reading.”

The method now follows four online stages: construct candidates, score actions, execute repair, and verify/update.

Revised Figure 1 separates these stages from offline learning. We explain RR, Ds(R)D_s(R), and UU operationally before formal definitions. Core equations and key comparisons remain in the main text; detailed tables and state-field definitions move to the appendices.

I thank the authors for the additional experiments. The compute-matched comparison and cross-benchmark transfer experiments partially address my questions, but I still have concerns about trading the cost of collecting data to train the scorer for modest improvements and generalization. Overall, the rebuttal does not fully resolve my concerns regarding its practical effectiveness and novelty.

AuthorsOpenReview ↗

Response to Reviewer aG5X

Thank you for pressing us on what the offline rollouts buy at inference.

PRICE solved 13 more of the 500 MATH problems than confidence-based remasking, with about the same number of model evaluations per problem.

Under the same cap of 48 model evaluations (NFE) per problem, PRICE trained on all 120,000 states solved 235/500 problems and the confidence baseline solved 222/500. The accuracy difference was 2.6 percentage points, with mean NFE of 37.2 for PRICE and 37.5 for the baseline (Appendix E.3). Initial rollout collection and scorer training took 231 GPU-hours (Appendix B.13). Whether inference savings cover that investment depends on query volume and each method’s end-to-end GPU time per query on the same hardware.

With half the training states, PRICE still solved nine more problems than the confidence baseline.

We kept the scorer architecture fixed and drew the smaller training sets from existing rollouts. At 60,000 states, the gain over the baseline cost an additional 0.6 model evaluations per problem on average.

Training statesCorrect out of 500Mean NFE
30,000 (25%)22538.8
60,000 (50%)23138.1
90,000 (75%)22938.3
120,000 (100%)23537.2

Predicting the full remaining cost improved accuracy and reduced mean NFE compared with predicting only the immediate repair cost.

With the same 120,000 training states and scorer architecture, changing only the cost target increased the correct count from 232 to 235 and reduced mean NFE from 37.8 to 37.2. In the original analysis, the candidate with the highest estimated reward–cost utility differed from full closure in 79.0% of sampled states, averaged equally across the four tasks (Appendix B.5). Paired offline continuations capture the verification and regeneration each repair may trigger later. At inference, the trained scorer chooses one scope to execute.

AuthorsOpenReview ↗

Response to Reviewer aG5X

What demonstrates PRICE’s “practical effectiveness and novelty”?

PRICE learns which dependent steps to recompute together. Paired offline continuations teach the scorer how a whole repair affects the final answer and the work needed to finish. At inference, it scores the alternatives and executes one repair.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.