Caterpillar of Thoughts: The Optimal Test-Time Algorithm for Large Language Models
Abstract: LLMs can often produce substantially better outputs when allowed to use additional test-time computation, such as sampling, chain of thought, backtracking, or revising partial solutions. Despite the growing empirical success of such techniques, there is limited theoretical understanding of how inference time computation should be structured, or what constitutes an optimal use of a fixed computation budget. We model test-time computation as an algorithm interacting with a Markov chain: at any point, the algorithm may resume generation from any previously observed state. That is, unlike standard Markov chains where the states are drawn passively, we allow the algorithm to backtrack to any previously observed state of the Markov chain at any time. Many of the existing test-time algorithms, such as Chain-of-Thought (CoT) (Wei et al., 2023), Tree-of-Thoughts (ToT) (Yao et al., 2023), or Best-of-$k$ (Brown et al., 2024) could be seen as specific algorithms in this model. We prove that while backtracking can reduce the number of generations exponentially, a very limited form of backtracking is theoretically sufficient. Namely, we show that the optimal algorithm always generates a caterpillar tree. That is, if we remove the leaves of the state tree generated by the optimal algorithm, we obtain a path. Motivated by our characterization of the optimal algorithm, we present Caterpillar of Thoughts (CaT), a new test-time computation algorithm, reducing the number of token/state generations. Our empirical evaluation shows that CaT, compared to ToT, achieves a better success rate while also reducing the number of token generations.
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 is this paper about?
This paper asks a simple question: if you give a LLM extra “thinking time” when it’s answering a question, what’s the smartest way to use that time? The authors build a mathematical model of “test-time thinking” and prove a surprising result: the best way to explore possible answers looks like a caterpillar—one main path with tiny side branches—rather than a big branching tree. They turn this idea into a practical method called Caterpillar of Thoughts (CaT), which solves problems more often and with fewer tokens than popular alternatives.
What questions does the paper try to answer?
- Given a fixed budget of extra computation at test time, how should an LLM spend it to maximize the chance of getting a correct answer?
- Do we really need complex, branching searches (like big trees), or is a much simpler pattern enough?
- How much can “rewinding” (going back to earlier partial answers) help?
- If we can’t know everything about the model’s behavior, can we still use a good strategy with only rough estimates?
How do the authors study the problem?
They use a simple, everyday analogy: navigating a maze with the ability to rewind.
- Think of generating an answer as moving through a “choose-your-own-adventure” maze. Each point (a “state”) is a partial answer. From there, the model can take different next steps.
- “Rewinding” means you’re allowed to jump back to any earlier point and try a different path, instead of being forced to keep going forward.
In math terms, they model this as a Markov chain (a system where the next step depends only on where you are now, not on how you got there). The “rewinding” rule lets the algorithm resume from any previously seen state. The set of states you’ve explored forms a tree.
They introduce a key idea: O(x)
- O(x) is the average number of steps still needed to reach a correct answer if you start from state x. You can think of it as “distance to the finish, on average.”
- If you knew O(x) for every state, you could always pick the best place to continue.
They also show how to:
- Compute O(x) exactly if you have the full map (using a shortest-path-like procedure similar to Dijkstra’s algorithm).
- Handle realistic settings where O(x) is unknown and noisy, by using robust estimates and a “stable” version of their strategy that still performs well.
What did they find?
1) The optimal search looks like a caterpillar
- The best possible algorithm doesn’t build a big, bushy search tree. Instead, it keeps a main path and only creates small side branches when needed.
- Practically, that means you mostly continue from your current best partial answer. If a newly sampled step looks better (has a smaller O value), you switch to it; otherwise, you quickly backtrack to the most promising spot.
- In other words, you only ever backtrack to the most recent “best” state or stay where you are—no complex backtracking to faraway states is needed.
Why this matters: It simplifies how we should structure test-time thinking—no need for elaborate, wide trees. A skinny “caterpillar” is enough to be optimal.
2) Rewinding can save you an exponential amount of work
- The paper gives a clear example where, without rewinding, your chance of finishing is tiny (like 1 in 2n), so you’d need an enormous amount of exploration.
- With rewinding, you can keep retrying from the furthest good state and progress steadily, reaching the goal in about 2n steps. That’s a huge win.
3) A practical algorithm: Caterpillar of Thoughts (CaT)
- Inspired by the theory, the authors build CaT, which follows the caterpillar strategy at test time.
- In practice, we don’t know O(x) exactly. So the practical CaT uses estimated scores (how promising a partial solution is) and a softmax rule that puts most effort on better-looking states while still exploring others occasionally.
Results on two benchmarks:
- Game of 24 (make 24 using four numbers and operations):
- CaT achieved ~81% success vs. Tree-of-Thoughts (ToT) at ~74%.
- CaT used over 20% fewer tokens on average.
- 5×5 Crosswords:
- CaT had higher word and letter accuracy and solved more puzzles than a cost-matched ToT setting, again with fewer tokens.
4) When O(x) is noisy or unknown
- With reasonable, random noise in the O(x) estimates, a “stable” CaT still reaches the answer in a number of steps that’s only moderately larger than the theoretical best.
- But if an adversary can distort the estimates (even within a small error factor) in a worst-case way, then no method can avoid bad performance. This shows you need some assumptions (like independent noise) for reliable gains.
Why is this important?
- It gives a clear, simple blueprint for how to spend extra test-time compute: focus deeply on your current best partial solution, and only make small side explorations.
- This can make LLMs cheaper and faster to run while improving accuracy—especially for reasoning tasks like puzzles, planning, and multi-step problem solving.
- It also provides a solid theory behind test-time strategies (like Chain-of-Thought and Tree-of-Thoughts), showing when and why they work, and how to improve them.
Takeaways and potential impact
- For practitioners: When adding “deliberation” to LLMs, lean toward a caterpillar strategy: mostly extend the most promising solution, occasionally try small alternatives, and quickly return to the best path. CaT is a practical way to do this with noisy scores.
- For researchers: The paper offers a unified model for test-time compute and a clean optimality result. It sets a foundation for future work on better scoring, verification, and robust backtracking in large, complex search spaces.
- Overall: Smarter test-time thinking can significantly boost LLM performance without retraining—CaT shows how to do it simply and effectively.
Knowledge Gaps
Unresolved gaps, limitations, and open questions
Below is a single, actionable list of what remains missing, uncertain, or unexplored in the paper.
- Modeling assumptions vs. LLM reality: How to incorporate realistic costs of rewinding (re-prompting, KV-cache reconstruction, long-context re-feeding) into the objective, beyond counting “steps,” and reconcile step-based optimality with token-, wall‑clock-, and memory-based costs actually incurred by LLM inference.
- Full observability requirement: The theory assumes access to a fully observable finite Markov chain; how to extend the caterpillar optimality and algorithms to partially observable or infinite state spaces induced by LLMs with very long or unbounded contexts.
- Computing O(x) at scale: The Dijkstra-like algorithm requires full knowledge of transition probabilities and all states; no practical procedure is provided to estimate O(x) in huge LLM state spaces with tractable sample complexity or convergence guarantees.
- Circular recursion in O(x): The recursion requires ordering states by true O(·), but the paper does not provide an online estimation scheme that provably recovers this order (or a good surrogate) from rollouts, nor bounds on the number of samples needed to correctly rank states.
- Noise model realism: The Laplacian noise model assumes independent, unbiased estimates with known variance; real LLM-derived scores are typically biased, heavy‑tailed, and temporally/cross‑state correlated. Guarantees under sub-Gaussian, heavy‑tailed, or dependent noise remain open.
- Estimator bias and calibration: How sensitive is CaT to monotone transformations, miscalibration, or systematic biases in the O(x) estimator produced by an LLM or verifier; what bias/variance conditions suffice for near‑optimal performance.
- Adversarial-noise lower bound tightness: The negative result covers adversarial (1±ε) noise; what positive guarantees are achievable under weaker but realistic assumptions (e.g., bounded bias, correlation decay, sub-Gaussian tails) beyond i.i.d. Laplace.
- Need for a practical upper bound N: The stable algorithm requires an a priori upper bound N on O(x₀); no method is provided to estimate or adaptively refine N in practice without compromising guarantees.
- Gap between “stable” and “softmax” algorithms: The practical softmax variant used in experiments has no theoretical analysis; conditions under which softmax selection approximates the stable algorithm (or the optimal caterpillar policy) are not established.
- Finite-budget/anytime performance: Results optimize expected hitting time without explicit budgets; no guarantees on success probability within a fixed step/token budget, tail bounds, or anytime performance curves.
- Alternative objectives: Optimality is proved for minimizing expected hitting time to a single target; extensions to maximizing success probability under a budget, risk-sensitive criteria (CVaR), or general reward maximization are not analyzed.
- Multiple targets or graded quality: Many LLM tasks involve multiple acceptable solutions or graded rewards rather than a single absorbing target state; how to adapt the framework and caterpillar optimality to such settings is open.
- Costs for rewinding vs. forward sampling: The model treats all steps equally; real systems have asymmetric costs (e.g., moving to a deeper state may be cheaper than reconstructing a long prompt). How to handle non-uniform, state-dependent action costs.
- Parallelism and wall-clock optimality: The result is sequential; does caterpillar structure remain optimal when the objective is wall-clock time with parallel rollouts or distributed search.
- Verifier integration: The paper notes connections to verifier-guided search but does not instantiate or evaluate CaT with explicit verifiers; how verifier reliability and cost affect O(x) estimates and algorithmic optimality remains untested.
- Handling loops and non-absorbing regions: Although Markov chains may contain cycles and traps, the practical algorithms do not discuss detection/avoidance strategies or guarantees in highly loopy or deceptive chains.
- Sensitivity to temperature/decoding parameters: Transition probabilities in LLMs depend on decoding settings (temperature, top‑p); how changes in these settings affect O(x), caterpillar optimality, and empirical performance is not studied.
- Memory and selection overhead: Selecting a parent via softmax over an ever-growing set of states adds overhead; no analysis or mitigation (e.g., pruning, reservoir sampling) is provided for large observed sets.
- Estimating O(x) from rollouts: The paper uses LLM heuristic scoring to proxy O(x) but provides no method to estimate O(x) via Monte Carlo rollouts with confidence intervals or to trade off rollout depth vs. estimator variance.
- Generalization beyond two small benchmarks: Only Game of 24 and 5×5 crosswords are tested; applicability to longer-horizon reasoning (math proofs, code synthesis, planning) and to diverse domains remains unvalidated.
- Baseline coverage and fairness: Comparisons are limited (primarily ToT), with differing run configurations (e.g., CaT best‑of‑2, ToT beam size); a thorough, compute‑matched comparison to MCTS, best‑of‑k, verifier‑guided methods, and ablations (beam/steps/temperature) is missing.
- Statistical rigor: No confidence intervals, variance across seeds, or significance tests are reported; robustness of observed gains is uncertain.
- Mapping steps to tokens: Theoretically optimal in “steps,” but experiments report tokens; a principled mapping from steps to token/wall‑clock cost and how CaT’s optimality degrades under this mapping is not provided.
- State definition and target detection: In real tasks, detecting that a state is a true “target” depends on a verifier or evaluator; how evaluator errors (false positives/negatives) affect O(x) and the optimality of CaT is unaddressed.
- Handling unknown/absent targets: The framework assumes a reachable target; there is no mechanism for early stopping, detection of infeasibility, or graceful degradation when no correct solution exists within budget.
- Hyperparameter sensitivity: The softmax temperature, number of children per expansion, and scoring prompts can materially affect performance; no systematic sensitivity analysis or tuning guidelines are provided.
- Learning to predict O(x): A promising direction—training an auxiliary model to predict O(x) (or a shaped value function) from state features—is not explored; no data collection or learning framework is proposed.
- Extending caterpillar optimality: The structural optimality proof applies to fully observable chains minimizing expected hitting time; whether similar structural results hold under other objectives, partial observability, or noisy/biased rewinding feedback is open.
- Integration with caching/replay: Practical systems use KV‑cache reuse and state replay; how to leverage these to reduce rewinding costs within CaT is unexplored.
- Scalability of state management: The paper does not address memory limits, deduplication of equivalent states, canonicalization of partial solutions, or state hashing—all crucial for large-scale deployments.
- Theoretical–empirical gap: There is no bridge connecting theoretical O(x) to the heuristic LLM scores used in practice; conditions under which these scores are order-preserving or correlated with true O(x) are unknown.
Practical Applications
Immediate Applications
Below are practical ways to use the paper’s “Caterpillar of Thoughts” (CaT) strategy now, leveraging its key insight: optimal test-time compute for LLMs can be organized as a “caterpillar” tree that maintains a current best partial solution and only backtracks to it, cutting tokens and latency while improving success rates.
- Industry (Software, Developer Tools): Verifier-guided code generation and debugging
- What to do: Replace Best-of-k/ToT loops with CaT in code assistants. Maintain a single “best” partial program (x*) and iteratively extend it; only switch to a new partial when unit tests/linters indicate a real improvement in “distance to passing tests” (an estimate of O(x)).
- Tools/workflows: Integrate CaT as a planning policy in LangChain/LlamaIndex agents; use unit tests, type-checkers, static analyzers, or sandboxes to score partials; implement the paper’s softmax-CaT when O(x) is noisy.
- Assumptions/dependencies: Requires verifiers or reliable heuristics to estimate O(x) (non-adversarial noise is assumed in the paper’s guarantees). Must be able to resume generation from a stored prefix.
- Industry (Search/RAG, Knowledge Work): Token-efficient retrieval-augmented generation
- What to do: Iteratively refine a single draft answer; use retrieval confidence/coverage as O(x) proxy; only adopt a new draft when it improves that score. This yields fewer branches than ToT while preserving exploration.
- Tools/workflows: “Caterpillar retrieval” policy in RAG pipelines; scoring via calibrated answer confidence, coverage of key facts, or verifier LMs.
- Assumptions/dependencies: Requires a monotone-ish scoring function; success is easier when tasks have verifiable states (e.g., citation coverage).
- Industry (Agents/Orchestration): Budgeted test-time compute policy
- What to do: Use CaT as the default inference-time policy for tool-using agents (search, browse, execute). Maintain one best partial plan; expand it until “expected steps to success” decreases, subject to a budget.
- Tools/workflows: Add a CaT executor to agent frameworks; telemetry for “improvement thresholds” (paper’s stable algorithm) to prevent thrashing.
- Assumptions/dependencies: Needs a scalar progress signal (O(x) estimate) per partial plan.
- Education (Tutoring, Assessment): Structured reasoning with minimal branching
- What to do: For math proofs, word problems, crosswords, or symbolic puzzles, replace BFS-like exploration with CaT. Use scoring prompts (as in the paper) to estimate remaining steps to a correct answer.
- Tools/workflows: Build CaT-based tutors that track one best reasoning chain and revise only on measured improvement; include solution checkers where possible.
- Assumptions/dependencies: Availability of checkers or reliable rubric-based scoring to approximate O(x).
- Finance (Analyst Copilots, Reporting): Controlled scenario exploration
- What to do: Treat scenario narratives as states. Use CaT to extend the best scenario explanation; adopt a new path only if risk/consistency metrics improve (proxy for O(x)).
- Tools/workflows: Integrate model risk checks, constraint validation, or metric dashboards as verifiers; token budgets enforced by CaT thresholds.
- Assumptions/dependencies: Must define clear, auditable improvement signals; governance must approve heuristic scoring.
- Healthcare (Clinical Documentation, Triage Drafting): Verifier-aided drafting
- What to do: For non-diagnostic, document-centric tasks (e.g., SOAP notes), apply CaT with structure/consistency verifiers. Only pivot drafts when structure/coverage improves.
- Tools/workflows: Style/structure checkers, terminology consistency, template coverage; EHR-integrated CaT drafters.
- Assumptions/dependencies: Avoids diagnostic claims; improvement signals may rely on heuristic checklists; compliance and privacy constraints apply.
- Product/Platform (API & UX): “Deliberate mode” with lower cost
- What to do: Offer a CaT-based “efficient reasoning” toggle that yields ToT-like quality at reduced tokens/latency. Expose thresholds and budget sliders.
- Tools/workflows: API-level CaT middleware that stores partial states and implements softmax selection over estimated O(x).
- Assumptions/dependencies: Requires persistent prefix/state management and monitoring to guard against adversarial scoring.
- Operations/Policy (Sustainability & Cost): Compute- and carbon-aware inference
- What to do: Adopt CaT to reduce average tokens per solution (paper reports >20% reduction), lowering cost and energy per request. Use telemetry to allocate budgets dynamically.
- Tools/workflows: Cost/carbon dashboards; budget policies tied to CaT improvement rates.
- Assumptions/dependencies: Measurement pipelines for token and energy usage; management buy-in for new default policies.
- Academia (Methodology & Benchmarking): Unified framework for test-time compute
- What to do: Use the paper’s Markov-with-rewinding model to compare CoT, ToT, MCTS, and CaT; employ the Dijkstra-like solver on small graphs to compute true O(x) and evaluate approximate policies.
- Tools/workflows: Open-source CaT evaluators; synthetic tasks with known Markov structures; noise models to test robustness.
- Assumptions/dependencies: Small or simulated chains for exact O(x); otherwise use the paper’s noise-tolerant stable algorithm.
Long-Term Applications
These build on the paper’s theoretical results (optimality of “caterpillar” structures, stable performance under non-adversarial noise) and require further research, scaling, or development.
- Cross-domain verifiers (Industry, Academia; Healthcare, Finance, Legal): Standardized O(x) estimators
- Potential outcome: Domain verifier ecosystems (APIs/services) that produce calibrated “distance-to-success” signals usable by CaT across tasks.
- Dependencies: High-quality, trustworthy verifiers (the paper shows adversarial approximations break efficiency); regulatory approval for sensitive domains.
- Training-time integration (ML Research, Platforms): Models that learn to predict O(x)
- Potential outcome: LLMs with auxiliary heads trained to estimate O(x) (cost-to-go), enabling stronger CaT decisions and less overhead from resampling/scoring.
- Dependencies: Datasets with reliable progress labels; multi-task training; calibration methods.
- Runtime schedulers (Systems, Hardware): OS-level test-time compute allocation
- Potential outcome: Inference schedulers that implement CaT budgets system-wide (e.g., on-device assistants), trading off latency and accuracy with formal guarantees.
- Dependencies: Platform-level state management and caching; fairness policies; monitoring for regressions.
- Robotics and Planning (Robotics, Autonomy): CaT-style plan search with backtracking
- Potential outcome: Hierarchical planners that treat plans as states and apply CaT to extend the current best plan; switch only on meaningful improvement in risk/cost-to-go.
- Dependencies: Reliable forward models and risk estimators; mapping text/state tokens to control policies; real-time constraints.
- Safety-critical decision support (Healthcare, Aviation, Industrial): Minimal-branch reasoning with verifiable guarantees
- Potential outcome: CaT reduces spurious branches, making verification and auditing simpler in safety pipelines (e.g., checkable care-pathway steps).
- Dependencies: Strong verifiers and guardrails; formal validation; clear escalation paths to humans.
- Finance & Operations Research: Scenario planning with calibrated cost-to-go
- Potential outcome: CaT-guided scenario generation where cost-to-go is derived from constraint satisfaction, risk models, or optimization duals.
- Dependencies: Reliable quantitative metrics; integration with OR solvers and simulators.
- New benchmarks and theory (Academia): Optimality and noise models for massive chains
- Potential outcome: Benchmarks that measure compute–performance trade-offs using CaT; extensions to partially observable or non-Markovian settings; better noise models.
- Dependencies: Community datasets, shared evaluators; agreement on scoring and noise standards.
- Agent ecosystems (Platforms): Memory-efficient “caterpillar” search as a service
- Potential outcome: Agent frameworks that default to non-branching search with soft branching for robustness; lower memory, simpler logging, easier audits.
- Dependencies: Ecosystem changes in agent frameworks; developer adoption; tooling for replay and provenance.
- Green AI and governance (Policy, Sustainability): Standards for budgeted reasoning
- Potential outcome: Guidelines or standards encouraging CaT-like budgeted test-time compute for enterprise and public sector deployments to reduce footprint.
- Dependencies: Measurement standards; agreement on acceptable quality–compute trade-offs; procurement requirements.
Notes on feasibility and assumptions across applications:
- The approach is most effective when tasks have well-defined “target states” and verifiable success (e.g., code passes tests, puzzles solved, constraints satisfied).
- Practical deployments depend on having O(x) estimates with bounded, non-adversarial noise. The paper proves polynomial overhead under Laplacian-like noise and shows exponential slowdowns with adversarial errors.
- Rewinding requires the ability to resume generation from saved partial states (prefixes) and to score new states cheaply relative to generation cost.
- The softmax-CaT variant is preferable when O(x) is noisy, as it reduces the risk of committing to a mis-scored path while keeping exploration focused.
- For open-ended creative tasks without clear verifiers, progress signals will be heuristic and may weaken guarantees; careful calibration and human-in-the-loop review are recommended.
Glossary
- Adversarial noise: Noise chosen by an adversary to mislead algorithms, rather than random statistical noise. "we present a lower bound for adversarial noise in partially observable (i.e., massive) Markov chains"
- Auxiliary algorithm: A supporting procedure used in analysis to approximate or bound the behavior of the main (optimal) method. "we describe an auxiliary algorithm which is used in the analysis."
- Backtracking: A strategy that returns to earlier states to explore alternative continuations when current paths seem unpromising. "such as sampling, chain of thought, backtracking, or revising partial solutions."
- Beam size: The number of candidate states retained at each expansion step in a beam-style search. "Tree-of-Thoughts uses a beam size of $5$."
- Best-of-: An inference strategy that samples candidate outputs and selects the best according to a criterion. "Many of the existing test-time algorithms such as Chain-of-Thought (CoT) \cite{wei2023chainofthoughtpromptingelicitsreasoning}, Tree-of-Thoughts (ToT) \cite{yao2023treethoughtsdeliberateproblem}, or Best-of- \cite{brown2024largelanguagemonkeysscaling} could be seen as specific algorithms in this model."
- Caterpillar of Thoughts (CaT): The paper’s proposed test-time algorithm that explores a caterpillar-shaped tree using minimal rewinding. "we present Caterpillar of Thoughts (CaT), a new test-time computation algorithm"
- Caterpillar tree: A tree in which all nodes are within distance 1 of a central path. "we show that the optimal algorithm always generates a ``caterpillar'' tree."
- Chain-of-Thought (CoT): A prompting technique that elicits step-by-step reasoning from LLMs. "Many of the existing test-time algorithms such as Chain-of-Thought (CoT) \cite{wei2023chainofthoughtpromptingelicitsreasoning}, Tree-of-Thoughts (ToT) \cite{yao2023treethoughtsdeliberateproblem}, or Best-of- \cite{brown2024largelanguagemonkeysscaling} could be seen as specific algorithms in this model."
- Dijkstra-like algorithm: A procedure analogous to Dijkstra’s shortest-path method, here used to compute optimal expected hitting times. "We present a Dijkstra-like algorithm for computing the value of for every state ."
- Δ-regular tree: A tree where each non-leaf vertex has exactly Δ neighbors (regular branching factor). "we use a -regular tree of depth $10 d$."
- Downward induction: A proof technique that proceeds by decreasing a parameter (the opposite direction of standard induction). "We prove the statement by a downward induction on $|#1|{S}$."
- Fully observable Markov chain: A Markov chain in which the algorithm can observe the current state completely at each step. "We consider a finite-state fully observable Markov chain"
- Hitting time: The expected number of steps required for a stochastic process to reach a designated target state. "We use to denote the expected hitting time of such an optimal algorithm."
- Laplacian noise: Noise drawn from a Laplace distribution, often used to model heavy-tailed errors or robust perturbations. "independent approximations of with Laplacian noise"
- Mean-median technique: A robust estimation method that combines multiple samples (via mean-of-medians or related tricks) to tighten approximation guarantees. "the mean-median technique can be used to strengthen the approximation guarantee"
- Monte Carlo Tree Search (MCTS): A stochastic tree search algorithm that balances exploration and exploitation to navigate large decision spaces. "Other approaches such as Tree of Thoughts (ToT)~\cite{yao2023treethoughtsdeliberateproblem} and Monte Carlo Tree Search (MCTS) \cite{daineseMTCS, park2024ensemblinglargelanguagemodels, LiuMCTS} employ more intricate methods for exploring the tree."
- Non-branching algorithm: A rewinding policy that only continues from the newest state or its parent, producing a caterpillar-shaped exploration tree. "A rewinding algorithm is non-branching if in any step , it either rewinds to the most recently obtained state , or to "
- Oracle access: Idealized ability to query exact values from a hidden function or process; here, exact values. "\cref{thm:optimal-non-branching} shows that an optimal strategy can be devised given oracle access to the exact values of ."
- Partially observable Markov chain: A Markov process where the algorithm lacks full information about states or transitions (here, only noisy estimates are available). "we construct a partially observable Markov chain "
- Rewinding algorithm: An algorithm that can reset to any previously visited state in the Markov chain before sampling the next transition. "in every step , a rewinding algorithm chooses a rewinding time "
- Self-consistency: An ensemble reasoning method that samples multiple reasoning chains and aggregates them to choose consistent answers. "self consistency \cite{wang2023selfconsistencyimproveschainthought}"
- Softmax distribution: A probability distribution over options proportional to exponentiated scores, biasing selection toward lower estimated cost here. "selects one via the {\em softmax} distribution."
- Target state: The designated goal state corresponding to a correct or high-quality final output. "a designated target state representing, for example, a correct answer or a sufficiently high-quality output"
- Tree-of-Thoughts (ToT): A search framework that expands a tree of intermediate thoughts/solutions to improve reasoning in LLMs. "Many of the existing test-time algorithms such as Chain-of-Thought (CoT) \cite{wei2023chainofthoughtpromptingelicitsreasoning}, Tree-of-Thoughts (ToT) \cite{yao2023treethoughtsdeliberateproblem}, or Best-of- \cite{brown2024largelanguagemonkeysscaling} could be seen as specific algorithms in this model."
- Verifier-guided search: A search procedure that uses a verifier to evaluate and guide exploration over partial solutions. "verifier guided search \cite{lightman2023verify, botta2025querycomplexityverifierassistedlanguage, snell2024scalingllmtesttimecompute, wang2025valueguidedsearchefficientchainofthought}"
Collections
Sign up for free to add this paper to one or more collections.