Learning with a Single Rollout via Monte Carlo Pass@k Critic
Abstract: Estimating token-level advantages in reinforcement learning (RL) for LLMs remains challenging because scaling up episodic experience collection is expensive. The difficulty intensifies for baseline advantage estimation methods, where repeated sampling causes trajectories to diverge into substantially different reasoning prefixes. In this context, RL algorithms such as GRPO prove limited: an outcome reward is too sparse to be attributed to specific actions like intermediate steps, and comparisons across sampled traces are non-trivial because they are heterogeneous. To mitigate both the computational cost of repeated sampling and the difficulty of credit assignment, we study single-rollout proximal policy optimization (SR-PPO) featuring token-level credit assignment in RL for LLMs. Instead of estimating advantages by normalizing episodic returns within the candidate group, we train a calibrated token-level credit critic using Monte Carlo outcomes from one rollout per prompt. Specifically, we use the critic to predict the Pass@k success probability at the prompt prefix, which is derived from a Pass@1 attempt. This choice yields a more selective learning signal than Pass@1: it discounts easily solved prefixes while prioritizing hard ones whose success probability remains marginal. We show that as $k$ increases, Pass@k converges to a reachability indicator, reflecting whether a prefix can lead to at least one successful continuation. In an explicit state graph, the limit ($k \rightarrow \infty$) can be computed in $O(|V|+|E|)$ time, offering a promising surrogate for direct credit assignment without the need to sample contrastive traces. As an initial validation, SR-PPO exhibits stable learning dynamics, along with consistent gains in Pass@128 success rates on mathematical reasoning benchmarks such as HMMT26 and AIME24.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
What this paper is about
This paper introduces a new way to train LLMs (like those that explain math problems) using reinforcement learning when you’re only allowed to watch one attempt per question. The method is called SR-PPO. It teaches the model to tell which parts of its own step-by-step reasoning helped or hurt the final answer, even if the only feedback it gets is “correct” or “wrong” at the end.
Think of it like solving a maze: you only see one run through the maze, but you still want to learn which turns were good and which were bad so you can do better next time.
The big questions the paper asks
- How can we train a model to improve its reasoning when we can only afford to generate one solution attempt (one “rollout”) per question?
- How can we fairly give “credit” (or blame) to individual words/steps in a long solution when the only clear signal we get is whether the final answer was right or wrong?
- Can we build a better training signal by predicting the chance that a partial solution could still lead to a correct answer if we tried again a few times?
How the method works (with simple analogies)
Picture a student writing out a math solution step by step (tokens are like words). After the whole solution, a checker says “right” or “wrong.” The challenge: how do we know which earlier words helped?
Here’s the idea in everyday terms:
- A “critic” that scores partial work:
- The authors train a second model (the critic) that looks at a partial solution and predicts how likely that solution is to eventually be correct if the model tries finishing it multiple times.
- This is called Pass@k. Pass@1 means “if we finish this partial solution once, what’s the chance it ends up correct?” Pass@4 means “if we finish it four times, is at least one of those likely to be correct?”
- Analogy: Pass@k is like asking, “If you had k chances to finish this problem from here, how likely is it that one of those tries would succeed?”
- Why Pass@k instead of just Pass@1:
- Pass@k naturally focuses learning on “hard but still solvable” partial solutions. If something is already easy (very high chance of success), bumping it up more doesn’t help much. If something is hopeless, it also doesn’t grab attention.
- This makes the training signal more selective and less noisy.
- Turning one answer into many training signals:
- During one attempt, every partial prefix of the solution gets labeled with the final outcome (right or wrong). The critic learns to predict success probabilities for these prefixes.
- Then, we compare the critic’s predicted success before and after each token (word). If adding a token increases the predicted chance of success, that token gets positive credit; if it decreases, negative credit.
- A final “correction term” keeps the per-token scores consistent with the final result (so a totally wrong solution doesn’t accidentally give lots of positive credit somewhere).
- Single-rollout PPO:
- PPO is a standard method for nudging a model to make good actions (here, tokens) more likely.
- Many existing systems (like GRPO) compare several different full answers per question to judge which tokens were better—this is expensive and messy because different answers can take totally different routes.
- SR-PPO avoids that by using only one attempt per question and a learned critic to assign per-token credit inside that single attempt.
- A neat theory connection: reachability
- As k gets very large, Pass@k becomes almost a yes/no question: “Is there any way to finish from here that works?” That’s called reachability.
- In a simple graph of states (nodes) and moves (edges), reachability can be computed quickly by scanning backward from success states. That makes Pass@k feel like a bridge between “how likely are we to succeed?” and “is success even possible from here?”
What they tested and found
The authors trained and evaluated on challenging math benchmarks (like AIME 2024/2025 and HMMT 2026) using a 1.7B-parameter model. They compared their single-rollout method (SR-PPO with Pass@4 credit) to:
- GRPO, which uses multiple sampled answers per prompt during training (more costly).
- GAE-PPO, a more classic method that struggled in this single-rollout, long-reasoning setting.
Key results:
- With the same rollout budget, SR-PPO achieved stable learning and competitive success rates compared to GRPO—even though GRPO used many more training samples per question.
- GAE-PPO barely improved under the single-rollout setup, suggesting traditional value bootstrapping isn’t well-suited when only the final outcome is known and the reasoning is long.
- SR-PPO’s Pass@4 credit produced a more selective training signal: many tokens got near-zero “advantage,” which reduced noise and stabilized training.
- Performance improved as the number of evaluation samples increased (e.g., Pass@8, Pass@128), meaning training improved not just the first guess but the overall quality of sampled solutions.
- There is a trade-off: optimizing for Pass@k can be slightly less focused on Pass@1 (single-try success), but it leads to stronger multi-try success and more stable training.
Why this matters
- Cheaper training: Many modern reasoning systems are expensive to run, especially if you need multiple full solutions per question to train. SR-PPO learns effectively with only one attempt per question.
- Better credit assignment: Instead of guessing which steps helped, the critic provides token-level feedback based on how each step changes the probability of eventual success.
- Focus on what’s fixable: Pass@k naturally trains the model to improve where improvement is still possible, rather than over-tuning already-easy parts.
- A step toward long-horizon agents: In real-world “agent” tasks (using tools, browsing, multi-step plans), getting multiple independent runs is expensive. A single-rollout approach is more practical.
Final takeaways and future impact
This work shows a promising path to train reasoning models with far fewer samples per question by:
- Learning a “progress sense” (Pass@k) that tells whether a partial solution is on track.
- Assigning token-level credit inside one attempt, which is both efficient and stable.
- Connecting the training signal to “reachability,” a simple and intuitive measure of whether success is even possible from a given state.
While the experiments are limited to specific datasets, a single model, and a small set of settings, the approach could help future systems that must learn from long, varied tasks where extra sampling is costly. If expanded, it may lead to more capable and efficient reasoning agents in math, coding, and beyond.
Knowledge Gaps
Unresolved Knowledge Gaps, Limitations, and Open Questions
Below is a concise list of concrete gaps and questions the paper leaves open, intended to guide follow-up research.
- External validity across domains and scales:
- Does SR-PPO generalize beyond competition math to code generation, tool-using agents, dialogue, or long-horizon interactive tasks?
- How does performance and stability change with larger base models and different architectures (decoder-only vs. MoE, reasoning-mode vs. standard decoding)?
- How sensitive is SR-PPO to dataset domain shift (e.g., non-DeepScaleR math distributions, noisy verifiers)?
- Statistical robustness and experimental rigor:
- Results are reported for a single seed; what is the variance across seeds and runs, and are improvements statistically significant?
- How sensitive are outcomes to key hyperparameters (learning rates, KL coefficient, PPO clip ratio, temperature, batch size, gradient accumulation, length limits)?
- Baseline completeness and fairness:
- No comparisons to strong process-reward baselines (e.g., PRIME, Math-Shepherd/PRM, SPA-RL/AgentPRM) or tree-structured credit methods (TreePO, TEMPO) at matched wall-clock/compute.
- Lack of wall-clock and memory profiling: does one-rollout SR-PPO with a fully finetuned critic actually offer better time/compute efficiency than GRPO under realistic training budgets?
- Theoretical properties of the advantage estimator:
- Bias/variance analysis for the “difference-in-value + terminal correction” advantage is missing; under what conditions does it approximate a valid policy gradient?
- How does the terminal correction weight X affect bias, variance, and convergence (X is fixed to 1 without justification)?
- Are there monotonic improvement or stability guarantees for SR-PPO with a learned Pass@k critic under function approximation drift?
- Learning the Pass@k critic from single-rollout labels:
- The critic is trained with a single binary outcome for every prefix; how does this correlated supervision affect sample efficiency, overfitting, and gradient leakage to earlier tokens?
- The method assumes conditional independence for Pass@k, but real continuations are correlated; what is the impact of this misspecification on critic calibration and actor updates?
- The paper maps the Pass@k prediction back to an induced Pass@1 for BCE/Brier loss; is this identifiable and well-conditioned given only Pass@1 labels? What failure modes arise from this reparameterization?
- Choice and scheduling of k:
- Why is Pass@4 the best operating point, and how should k be selected or adapted across states/training phases?
- Can a curriculum on k (e.g., increasing k to approach reachability or mixing multiple k values) improve stability and preserve Pass@1 performance?
- Critic calibration and reliability:
- No quantitative calibration assessment (e.g., ECE, reliability diagrams, calibration under distribution shift) for the prefix-level critic; do BCE+Brier losses actually produce calibrated probabilities?
- How robust is the critic to label noise (e.g., imperfect verifiers, partial credit) and to long sequences with sparse successes?
- Dominance of the terminal correction term:
- The authors note the terminal term often dominates token-level credit; how can the method ensure local, causally meaningful token-level credit rather than global reward smearing?
- Would counterfactual credit or prefix perturbation (e.g., small edits, contrastive tokens) improve local credit fidelity under single-rollout constraints?
- Stability and off-policy effects:
- Gradient accumulation caused instability in Pass@1 SR-PPO; what mitigations (e.g., lagged targets, importance weights, conservative updates, target networks) restore stability?
- Does unclipped PPO (inactive clipping branch due to sampling schedule) remain safe as training scales or under batched/multi-step updates?
- Exploration and decoding control:
- Entropy regularization is zero and temperature fixed at 1.2; what is the exploration-exploitation trade-off in single-rollout training, and can adaptive entropy or temperature schedules improve learning?
- Does the method induce length bias or verbosity as a side effect of Pass@k emphasis? How to control for excessive generation length under long horizons?
- Pass@k–reachability connection in practice:
- The reachability limit assumes an explicit state graph, which is unavailable for LMs; what practical approximators (e.g., implicit graph construction, beam/DFS, support estimators) can approximate reachability at scale?
- Can hybrid objectives mix soft Pass@k values with estimated reachability to improve credit in sparse-reward regimes?
- Evaluation completeness:
- No fine-grained error analysis (per-problem difficulty, prefix hardness, causal alignment between high-advantage tokens and step correctness).
- Only Pass@k metrics are reported; how does SR-PPO affect other qualities (formatting reliability, brevity, faithfulness, step correctness) and human evaluation outcomes?
- Compute and systems considerations:
- Training a full-sized critic model doubles finetuning cost; can lighter critics (adapters, smaller backbones, parameter sharing with the actor) retain performance?
- What is the end-to-end throughput and GPU memory footprint relative to GRPO or PRM-based pipelines?
- Generality beyond binary terminal rewards:
- How does SR-PPO extend to partial credit, continuous rewards, or multi-objective settings (e.g., correctness, cost, safety)?
- Can the approach incorporate noisy or delayed rewards (e.g., stochastic tools, flaky compilers) while remaining stable?
- Data and verifier dependencies:
- The method relies on auto-verification of math answers; how sensitive is training to verifier errors, formatting constraints, or adversarial prompt formatting?
- Does SR-PPO maintain performance under OOD tasks where verifiers struggle or partial-credit rubrics are required?
- Replay and data reuse in single-rollout regimes:
- Can experience replay or prioritized prefix replay be integrated without harming on-policy assumptions, to improve sample efficiency with a single rollout per prompt?
- Safety and failure modes:
- Does Pass@k credit encourage gaming (e.g., hedging, verbose enumerations, repeated trials) that inflate multi-sample success at the expense of single-sample quality or truthfulness?
- Are there safeguards (KL control, reward shaping) to prevent degenerate strategies while preserving the benefits of Pass@k?
- Decoding and inference-time policy alignment:
- How sensitive are gains to inference-time sampling parameters (temperature, nucleus/top-k, repetition penalties)? Are training-time credit signals consistent with intended inference-time decoding?
- Curriculum and multi-task strategies:
- Can curricula over problem difficulty or per-prefix hardness (as hypothesized by Pass@k’s emphasis on hard-but-reachable states) lead to better data efficiency?
- Would multi-task training (e.g., combining Pass@1 and Pass@k critics) mitigate the observed trade-off where Pass@k de-emphasizes Pass@1?
Practical Applications
Immediate Applications
These applications can be deployed now with modest engineering effort, especially in domains with verifiable rewards (e.g., math, coding, structured tasks).
- Compute-efficient RL post-training for reasoning LMs
- Sector: AI/ML infrastructure; software
- What: Replace GRPO-like group-normalized methods with SR-PPO to cut rollout cost (1 rollout per prompt) while maintaining/improving Pass@k performance on reasoning tasks.
- Tools/products/workflows:
- Add an SR-PPO “single-rollout” trainer to existing RLHF/RLAIF pipelines (e.g., plugins for TRL/TRLX, Ray AIR, Kubeflow).
- Ship small/mid-size checkpoints fine-tuned with SR-PPO for math/code benchmarks.
- Assumptions/dependencies:
- Binary or automatically verifiable outcome labels (e.g., unit tests, math verifiers).
- A separate prefix credit model (critic) trained with BCE+Brier; extra GPU memory/compute for actor+critic.
- Calibrated temperature/sampling to avoid shift between training and deployment.
- Step/process supervision without manual PRM labeling
- Sector: Education (math tutoring), software engineering (code synthesis), scientific computing
- What: Use the learned prefix Pass@k critic to supply token/step-level progress rewards derived purely from final outcomes; no manual step annotations required.
- Tools/products/workflows:
- “Progress-rewarded” math tutors that learn from checker outputs.
- Code generation fine-tuning where unit-test pass/fail is the outcome and token-level credit drives improvement.
- Assumptions/dependencies:
- Reliable verifiers or test suites; low false positives/negatives.
- Stability of the critic on out-of-distribution prefixes.
- Difficulty-weighted curriculum and data selection
- Sector: ML training & data engineering
- What: Use Pass@k to downweight easy prefixes and emphasize “hard but reachable” ones; reweight samples or mine prefixes with marginal success probability.
- Tools/products/workflows:
- Data samplers that score prefixes via the critic and prioritize training batches accordingly.
- Assumptions/dependencies:
- Pass@k calibration quality; k chosen to balance selectivity (e.g., k≈4) vs coverage.
- Single-trajectory agent fine-tuning where rollouts are expensive
- Sector: Agentic systems, RPA, tool-using LLMs
- What: Train multi-tool or API-calling agents with SR-PPO to avoid sampling many heterogeneous traces per prompt.
- Tools/products/workflows:
- Integrate SR-PPO into orchestration frameworks (e.g., LangChain, Haystack) using binary task success as reward.
- Assumptions/dependencies:
- Task success must be automatically detectable; logging of prefixes/actions for credit assignment.
- On-device or budget-constrained adaptation
- Sector: Edge AI; enterprise fine-tuning
- What: Fine-tune small LMs locally with limited compute by leveraging single-rollout training and outcome labels.
- Tools/products/workflows:
- LoRA/QLoRA adapters trained with SR-PPO using in-house verifiers (e.g., schema validators).
- Assumptions/dependencies:
- Availability of lightweight verifiers; memory for both actor and critic (or parameter sharing).
- Token-level “credit maps” for debugging and interpretability
- Sector: MLOps; model quality assurance
- What: Visualize token-level advantages to diagnose reasoning failures, prefix “traps,” and instability.
- Tools/products/workflows:
- Dashboard plugins that color tokens by advantage sign/magnitude for model developers.
- Assumptions/dependencies:
- Stable critic calibration; interpretability guardrails to avoid over-trusting noisy local signals.
- Adaptive inference-time sampling policies
- Sector: Serving/platforms
- What: Empirically, success increases with more samples; use the critic to decide when to draw more samples (e.g., stop early for high Pass@k prefixes).
- Tools/products/workflows:
- Budget-aware decoders that query a lightweight critic head to allocate sampling budget per prompt.
- Assumptions/dependencies:
- Online calibration of Pass@k under deployment distributions; latency constraints.
- Dataset curation and filtering by reachability
- Sector: Data engineering
- What: Use critic-estimated Pass@k to label prefixes as likely reachable vs dead-ends; filter low-yield training segments.
- Tools/products/workflows:
- Preprocessing stage that prunes or annotates unproductive prefixes in reasoning traces.
- Assumptions/dependencies:
- Acceptable false pruning risk; periodic recalibration as policy shifts.
- Compliance and safety fine-tuning with verifiable constraints
- Sector: Policy/compliance, platform governance
- What: Treat policy violations as “failures” and assign pervasive negative credit to reduce violation-prone patterns.
- Tools/products/workflows:
- SR-PPO with automated policy checkers (e.g., content filters, PII detectors) as verifiers.
- Assumptions/dependencies:
- High-precision detectors; care to prevent reward hacking and false-negative drift.
- Low-cost baselines for academic research
- Sector: Academia
- What: Provide a stable, compute-efficient baseline for token-level credit assignment in single-rollout settings, enabling controlled comparisons without large rollout budgets.
- Tools/products/workflows:
- Reproducible training recipes and ablation harnesses for Pass@k SR-PPO on standard datasets.
- Assumptions/dependencies:
- Adoption of shared verifiers and seeds for fair comparisons.
Long-Term Applications
These opportunities require further research, domain adaptation, scaling, or stronger verification infrastructure.
- Reachability-guided planning and pruning
- Sector: Software (program synthesis), formal methods, theorem proving
- What: Use the k→∞ limit (reachability) to prune unsolvable prefixes in search/planning; combine with symbolic analyzers or graph abstractions.
- Tools/products/workflows:
- Hybrid planners that fuse learned Pass@k with static analysis for early pruning.
- Assumptions/dependencies:
- Approximate prefix-state graphs or reliable surrogates; methods to relax the independence assumption behind Pass@k.
- General agent training with partial/weak verifiers
- Sector: Multi-turn agents, tool use in enterprise workflows
- What: Extend SR-PPO to tasks with multi-objective or delayed, partly verifiable rewards (e.g., milestone checkers, proxy PRMs).
- Tools/products/workflows:
- Milestone-based critics that mix binary outcomes with proxy signals (e.g., retrieval quality).
- Assumptions/dependencies:
- Designing trustworthy proxies that correlate with end goals; avoiding reward misspecification.
- Safety-critical gating and “only-proceed-if-reachable” assistants
- Sector: Healthcare, finance, legal
- What: Gate high-risk actions on predicted Pass@k thresholds (e.g., require supervisor escalation if Pass@k is low).
- Tools/products/workflows:
- Calibrated Pass@k services embedded in clinical/financial assistants to defer or escalate uncertain cases.
- Assumptions/dependencies:
- Rigorous calibration, monitoring, and regulatory validation; human-in-the-loop workflows.
- Robotics and control: single-trajectory credit assignment
- Sector: Robotics, autonomous systems
- What: Adapt Pass@k critics to action trajectories (state-action prefixes) to assign dense credit from sparse task success.
- Tools/products/workflows:
- Policy-gradient variants that replace token prefixes with state-action sequences; viability/reachability sets.
- Assumptions/dependencies:
- High-fidelity simulators or verifiable success; handling continuous dynamics and partial observability.
- Self-curriculum and synthetic data generation
- Sector: Education, autonomous research agents
- What: Use Pass@k signals to automatically mine “hard but solvable” problems and generate variants that expand reasoning boundaries.
- Tools/products/workflows:
- Data generators that upsample prefixes with marginal Pass@k; iterative self-play loops.
- Assumptions/dependencies:
- Avoiding mode collapse and curriculum overfitting; controlling data quality.
- Cost-aware, real-time inference managers
- Sector: Serving; cloud platforms
- What: Online Pass@k estimation to dynamically choose the number of samples, temperature, or tools; SLA- and cost-driven control policies.
- Tools/products/workflows:
- Controllers that trade latency vs accuracy by querying a small critic head or cached prefix features.
- Assumptions/dependencies:
- Fast, low-overhead critic inference; robust generalization across tasks.
- Multi-agent coordination without heavy grouping
- Sector: Collaborative agents, software engineering teams of LLMs
- What: Attribute credit within each agent’s single trajectory using Pass@k, reducing the need for synchronized multi-trajectory groupings.
- Tools/products/workflows:
- Decentralized training where each agent maintains its own critic; occasional global consistency checks.
- Assumptions/dependencies:
- Non-binary team rewards require aggregation schemes; credit assignment across agents remains an open problem.
- Greener RL training and policy guidance
- Sector: Policy/governance; sustainability
- What: Use single-rollout RL methods to reduce compute and energy for post-training; inform best practices and standards.
- Tools/products/workflows:
- Benchmarked CO2/energy dashboards comparing GRPO vs SR-PPO; procurement guidelines favoring compute-efficient RL.
- Assumptions/dependencies:
- Independent validation across tasks and model sizes; transparency in reporting.
- “Credit-assignment-as-a-service” platforms
- Sector: AI tooling; SaaS
- What: Offer hosted Pass@k critic APIs that plug into customers’ RL pipelines and verifiers.
- Tools/products/workflows:
- SDKs for logging prefixes and outcomes; calibration tools; visualization suites.
- Assumptions/dependencies:
- Data privacy and security; domain-specific adapters for verifiers.
- Personalized stepwise tutoring and assessment
- Sector: Education technology
- What: Use Pass@k-driven token/step feedback to adaptively guide learners, focus hints on reachable steps, and assess progress.
- Tools/products/workflows:
- Tutors that adjust hint granularity based on predicted reachability of next steps.
- Assumptions/dependencies:
- Robustness to diverse learner inputs; ethical and privacy considerations.
Notes on cross-cutting assumptions and dependencies:
- Verifiable outcomes are central. For non-verifiable tasks, you’ll need proxy rewards (e.g., PRMs, likelihood-based rewards), which may affect calibration and stability.
- The Pass@k formulation assumes conditionally independent continuations; in practice, decoding correlations and policy shifts may violate this, affecting probability calibration.
- Two-model training (actor + critic) increases memory; parameter sharing or lightweight critic heads can mitigate this but may reduce fidelity.
- Results were validated on a 1.7B model and math datasets; generality to large models and other domains (e.g., open-ended dialog) requires further evidence.
- Choice of k trades stability and selectivity: small k preserves sensitivity; moderate k (e.g., 4–8) emphasizes “hard but reachable” prefixes; very large k approximates binary reachability but can be too coarse for optimization.
Glossary
- Advantage estimation: Methods for computing how much better an action (or token) is compared to a baseline at a state. "The difficulty intensifies for baseline advantage estimation methods"
- Agentic systems: Complex, multi-component LLM setups that use tools, memory, sub-agents, and long-horizon interactions. "These problems intensify within the landscape of contemporary agentic systems."
- Bootstrapping (value): Estimating values using predictions of future values instead of only final outcomes. "bootstrapping from future value predictions"
- Brier score: A proper scoring rule measuring the mean squared error of probabilistic predictions; used for probability calibration. "The Brier-score term improves probability calibration"
- Calibration (probability): The alignment between predicted success probabilities and empirical success frequencies. "improves probability calibration"
- Clipped surrogate objective: PPO’s objective that limits policy update magnitude to stabilize training. "its clipped surrogate objective constrains policy updates"
- Credit assignment: Determining which actions or tokens deserve credit or blame for outcomes. "This poses a credit-assignment challenge"
- Credit critic: A learned model that predicts success probability at prefixes to provide token-level learning signals. "we train a calibrated token-level credit critic using Monte Carlo outcomes from one rollout per prompt."
- Difference-in-value advantage: An advantage formed from the change in predicted value across a token transition. "utilizing a difference-in-value advantage accompanied by a critical terminal correction term"
- Episodic returns: The total return accumulated over a full trajectory/episode. "Instead of estimating advantages by normalizing episodic returns within the candidate group"
- Generalized Advantage Estimation (GAE): A technique that computes advantages from TD errors with a learned value function. "Standard PPO is usually paired with generalized advantage estimation (GAE), which computes advantages from temporal-difference (TD) errors"
- GRPO (Group Relative Policy Optimization): A critic-free PPO variant normalizing rewards within groups of sampled completions. "Group Relative Policy Optimization (GRPO), a critic-free PPO variant that normalizes rewards within a group of sampled completions"
- Group-based policy optimization: Methods that compare and normalize scores across multiple completions of the same prompt. "group-based policy optimization methods such as GRPO"
- KL-regularized RL: Reinforcement learning with a KL divergence term to regularize policy updates. "from the optimality conditions of KL-regularized RL"
- Monte Carlo (outcomes): Using sampled rollouts’ final outcomes as unbiased labels for learning. "using Monte Carlo outcomes from one rollout per prompt."
- Multi-sample success: The probability that at least one of several independent completions succeeds. "To capture multi-sample success, we define the Pass@k value as the probability that at least one of k independent continuations succeeds"
- On-policy: Using data sampled from the current policy for updates. "equivalent to an on-policy single-step policy-gradient update"
- Outcome reward: A reward based solely on the final correctness of a solution. "An outcome reward is too sparse to be attributed to specific actions"
- Outcome supervision: Training signals derived from final outcomes rather than intermediate steps. "the distinction between outcome supervision and process supervision."
- Pass@1: The probability that a single sampled continuation solves the problem. "Pass@1 measures the probability that one continuation succeeds"
- Pass@k: The probability that at least one of k sampled continuations succeeds. "Pass@k converges to a reachability indicator"
- Policy gradient: Methods that update the policy directly via gradients of expected returns. "token-level policy-gradient credit"
- Prefix state: The state consisting of the prompt and the tokens generated so far. "We define the prefix state as st = (x, y1:t)"
- Prefix trap: The phenomenon where early misleading steps bias later reasoning. "giving rise to the 'prefix trap' problem"
- Prefix value: The success probability conditioned on the current prefix under the policy. "The prefix value qT (St) corresponds to the expected success probability"
- Process reward model (PRM): A model that scores intermediate reasoning steps instead of only final answers. "process reward models (PRMs) score intermediate reasoning steps"
- Process supervision: Supervision that evaluates and trains models on intermediate steps. "the distinction between outcome supervision and process supervision."
- Proximal Policy Optimization (PPO): A popular policy-gradient algorithm with constrained updates. "PPO remains the standard starting point for policy-gradient fine-tuning of LMs because its clipped surrogate objective constrains policy updates"
- Reachability indicator: A binary signal of whether any successful continuation exists from a prefix. "Pass@k converges to a reachability indicator"
- Reachability target: The formal binary target 1{success is possible} used in analysis. "the reachability target Tt(s) = 1{pt(s) > 0},"
- Reverse graph traversal: A backward graph search from goal states to mark reachable prefixes. "can be computed exactly by a reverse graph traversal from the successful terminals"
- Rollout: A sampled trajectory/completion generated by the policy. "the rollout budget remains one sample per prompt."
- Single-rollout: A training regime where only one trajectory per prompt is available. "These challenges motivate single-rollout (SR) learning."
- Support graph: The graph capturing which transitions have nonzero probability. "If the successful terminal states are known and the support graph is available"
- Temporal-difference (TD) errors: Prediction errors used to compute advantages in GAE. "computes advantages from temporal-difference (TD) errors"
- Terminal correction term: An adjustment aligning dense credit with the observed final outcome. "accompanied by a critical terminal correction term"
- Token-level advantage: Advantage assigned per generated token to guide policy updates. "The token-level advantage is set to be AT(St) = ..."
- Value bootstrapping: Estimating values by recursively relying on predicted future values. "value bootstrapping may accumulate errors along many intermediate steps"
- Value function: A model estimating expected return/success from a state or prefix. "using a learned value function"
- Verifiable rewards: Automatically checkable rewards based on correctness (e.g., math answers). "post-trained with reinforcement learning (RL) from verifiable rewards"
Collections
Sign up for free to add this paper to one or more collections.