EquivPruner: Boosting Efficiency and Quality in LLM-Based Search via Action Pruning

Defu Lian; Jianshu Zhang; Jiawei Liu; Qisi Chen; Quan Liu

REVIEW 4 major objections 5 minor 31 references

EquivPruner: Boosting Efficiency and Quality in LLM-Based Search via Action Pruning

T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Search-step equivalence pruning cuts LLM math-reasoning tokens by up to 48%.

desk verdict A practical token-reduction method for LLM search with a genuinely useful new dataset, but the efficiency claim needs end-to-end measurements before it holds. read the letter →

arxiv 2505.16312 v2 pith:ADGWT56J submitted 2025-05-22 cs.AI cs.CL

Jiawei Liu , Qisi Chen , Jianshu Zhang , Quan Liu , Defu Lian This is my paper

classification cs.AIcs.CL

keywords LLMreasoningsearchactionpruningsemanticequivalencemathematicaltokenefficiencyMonteCarlotreebeamdetection

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

The paper tries to show that a large part of the token cost of LLM search-based reasoning is avoidable: many reasoning steps an LLM generates during tree search say the same mathematical thing in different words, and the search explores each as a separate branch. It proposes a lightweight detector of mathematical statement equivalence, trained on a new dataset of labeled step pairs, that can be inserted into search and collapse equivalent branches before they are expanded. The central evidence is that applying this pruner to Monte Carlo tree search cuts token use by roughly 22 to 48 percent across three models and two benchmarks while accuracy stays flat or improves. The proposed dataset and detector are offered as reusable resources for future work on semantic redundancy in reasoning. If the claim holds, making search cheaper could change when it is worth paying for deeper reasoning.

What carries the argument

The load-bearing mechanism is the two-stage pruner: a fast Levenshtein-ratio filter forwards only pairs with ratio above 0.75 to a lightweight equivalence detector, a fine-tuned Longformer (an efficient transformer for long documents) that outputs an equivalence probability, and equivalent sibling nodes are collapsed to one representative before expansion. The detector is trained with expectation-maximization on MathEquiv, a new dataset of 100,000 annotated step pairs derived from MATH problems by Qwen2.5-Math-7B-Instruct, so that latent equivalences among sub-sentences inside longer steps are removed during training. This machinery converts search-tree redundancy into a simple pairwise classification problem that can run in real time.

What would settle it

Take a labeled sample of human-annotated equivalent step pairs, compute their Levenshtein ratios, and count how many fall below 0.75; if a substantial fraction are equivalent, the fast filter is discarding the very redundancy the method promises to remove, and EquivPruner's measured token savings would shrink under an oracle filter.

Watch

Extended reading notes

Core claim

The central discovery is that textually distinct reasoning steps with the same mathematical content are common in LLM search, and they can be recognized cheaply enough to prune at inference time. EquivPruner treats two steps as equivalent when they agree on concept, logical structure, notation, and method; a fine-tuned Longformer, trained with expectation-maximization on the MathEquiv dataset, makes this call, gated by a Levenshtein-ratio fast filter that only invokes the model for surface-similar pairs. Collapsing equivalent siblings to one representative reduced tokens by 22 to 48 percent while keeping or slightly raising accuracy, for example from 96.44% to 96.59% on GSM8K with Qwen2.5-Math-7B-Instruct. The same pruner also improves the diversity of selected branches in step-level beam search, and ablations show both the task-specific fine-tuning and the EM procedure are needed for the best result.

Load-bearing premise

The method assumes that any two genuinely equivalent reasoning steps will look at least 75% similar on the surface, since pairs below that threshold are never sent to the equivalence detector.

Editorial extensions

If this is right

On every model and benchmark tested, EquivPruner reduced token consumption, with the largest savings (48.1%) on GSM8K with Qwen2.5-Math-7B-Instruct.
Accuracy was maintained or improved in most cases, including out-of-distribution settings where neither the model nor the dataset was seen in training.
In step-level beam search, pruning before top-k selection raises accuracy slightly, showing the mechanism improves search diversity rather than only saving tokens.
The ablation shows that task-specific fine-tuning and the EM training procedure are both necessary: the off-the-shelf Longformer prunes tokens but hurts accuracy, while the full method improves both.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The 0.75 Levenshtein gate is a place where the method could silently discard equivalent pairs that look different on the surface; a natural extension would measure the gate's recall and replace it with a learned surface-similarity filter if needed.
If the pruner's equivalence predictions are reliable, the same signal could be used to clean preference-pair construction in search algorithms that learn from intermediate steps, reducing noisy training examples.
The token savings at fixed accuracy suggest a concrete economic consequence: search-based reasoning becomes more affordable at inference time, so the optimal allocation between model size and test-time compute should shift toward more search.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

The paper does something useful: it identifies a real source of waste in LLM-based search—semantically equivalent reasoning steps being expanded as separate branches—and builds a lightweight pruner to remove them. The new MathEquiv dataset is the most solid contribution; it fills an actual gap, and the EM-based training that handles sub-sentence equivalence is a sensible idea. The experiments span three models, two datasets, and two search algorithms, and the ablations show each component (fine-tuning, EM) matters. Token savings of 30-50% are consistent and mechanistically expected. The released code and data deserve credit.

The soft spots are real, and the stress-test note lands. Efficiency is defined only as LLM-generated tokens. The pruner's own compute—Longformer forward passes, Levenshtein checks—is never measured, so the headline "boosting efficiency" is not established end-to-end. For API-based usage, token counts may be the dominant cost, and the paper would be fine if it explicitly scoped the claim to LLM token reduction. But as written, it overreaches. There is also no wall-clock or FLOPs comparison, and no count of how often the pruner is invoked. That is a load-bearing gap for a paper whose main claim is efficiency.

The accuracy results are weak but not problematic on their own: gains are small (+0.15 to +1.28 points), and one configuration drops by 0.30. With single runs and no error bars, these should be described as "accuracy is roughly maintained," not "often bolstering reasoning accuracy." The Levenshtein gate (ratio > 0.75) is another concern: pairs below the threshold are never considered equivalent, so the method cannot catch true equivalences with low surface similarity. The paper's own Figure 1 shows exactly this failure mode, yet there is no sensitivity analysis or recall measurement for the gate. Finally, the comparison is not equal-budget—token savings are reported without matching compute or accuracy—but that is a secondary issue.

Who is this for? People building inference-time search for LLM reasoning who care about API token costs, and anyone working on semantic equivalence for mathematical text. The dataset alone makes it worth a serious referee. I would like to see a revision that measures end-to-end latency or FLOPs, reports pruner call counts, adds error bars or multiple seeds, and analyzes the Levenshtein threshold. Even without those, the paper is not fatally flawed; it just needs its claims narrowed. Send it to review.

Referee Report

4 major / 5 minor

Summary. The paper proposes EquivPruner, a method that prunes semantically equivalent reasoning steps during LLM tree search (MCTS and step-level beam search) to reduce token consumption and, the authors claim, often improve accuracy. The approach consists of a new dataset, MathEquiv, for mathematical statement equivalence, a fine-tuned Longformer-based equivalence detector trained with an EM procedure, and a two-stage pruning gate that first applies a Levenshtein-ratio filter (threshold 0.75) and then invokes the Longformer detector on surviving pairs. Experiments on MATH-500 and GSM8K with Qwen2.5-Math-7B-Instruct, Mistral-7B-SFT, and Qwen2.5-Math-1.5B-Instruct show token reductions of roughly 22–48% in MCTS, with small accuracy changes of −0.30 to +1.28 percentage points, plus a smaller evaluation with SBS.

Significance. The direction is well motivated: redundant exploration of semantically equivalent steps in LLM search is a real source of wasted computation. The token-reduction numbers are large and mechanistically consistent with the pruning mechanism, and the paper ships code and a new dataset, which are useful community assets. If the efficiency claim is validated end-to-end, the contribution would be practically relevant for LLM inference-time search. However, the paper's central efficiency claim is currently supported only for the narrow metric of LLM-generated tokens, not for wall-clock search time or total compute, which is what "searching efficiency" should mean for practitioners.

major comments (4)

[§4.3 and Table 1] The efficiency metric is defined exclusively as the total number of tokens generated by the LLM (Tokens and Ratio). The computational cost of the pruning machinery itself is never measured: for every node expansion with width 10, up to 45 sibling pairs pass the Levenshtein filter and each surviving pair is fed through a fine-tuned Longformer-base forward pass. Since Longformer-base has roughly 149M parameters and the paper provides no wall-clock time, FLOPs, or latency comparison between the vanilla and EquivPruner pipelines, the headline claim that EquivPruner "improves searching efficiency" is not supported. It is possible that end-to-end compute actually increases. This is load-bearing because the paper's main contribution is efficiency, so the authors should report end-to-end time or an explicit computational-cost model.
[§4.4, Table 1] The accuracy improvements are small (ranging from −0.30 to +1.28 percentage points) and are reported as single numbers without error bars, multiple runs, or statistical tests. For example, Qwen2.5-Math-7B-Instruct on GSM8K goes from 96.44% to 96.59% (+0.15), and Qwen2.5-Math-1.5B-Instruct on GSM8K goes from 91.05% to 90.75% (−0.30); both are within typical sampling noise for a 1319-problem test set. The abstract's claim that EquivPruner "often bolster[s] reasoning accuracy" is therefore not established. At minimum, the authors should report variance across multiple runs with different seeds or provide a statistical significance test, and they should tone down the accuracy claim accordingly.
[§4.2.2 and §A.1] The Levenshtein-ratio threshold of 0.75 acts as a hard filter before the Longformer detector: pairs with ratio ≤ 0.75 are never evaluated by the learned model. The paper provides no sensitivity analysis for this threshold and no recall measurement for the gate, even though the MathEquiv test set (10,000 annotated pairs) could support such an evaluation. If the gate misses a substantial fraction of true equivalences, the reported token savings are underestimated (or the accuracy effects are misattributed); if it passes many non-equivalent pairs, the Longformer's precision is the only safeguard. Reporting the pruner's precision/recall and the gate's recall on the MathEquiv test set would make the mechanism more transparent.
[§3.2 and Figure 4] The MathEquiv labels are produced by GPT-4o with iterative human adjudication, but no inter-annotator agreement is reported, and the final dataset is not evaluated directly (e.g., accuracy of the fine-tuned Longformer on the MathEquiv test set is not given). Since the pruner's quality is central to the method's behavior, the paper should include a basic evaluation of the trained detector itself on the held-out MathEquiv split, including how the five-tier labels are collapsed into the binary decision used for pruning.

minor comments (5)

[§3.3.2] Typo: "handing the unobserved equivalence status" should be "handling the unobserved equivalence status."
[Figure 4] In the prompt template, "semanticly" should be "semantically," and the explanation of the 0–4 scale is slightly confusing because the example output uses "result: 0" for a non-equivalent pair, which matches the scale but reads awkwardly next to "return 0: Not equivalent at all."
[Figure 3] The axis label "T oken Consumption" contains a stray space, and the bar labels use inconsistent phrasing ("T okens Consumed" versus "Token Consumption").
[§4.4 and Table 1] The text says EquivPruner "significantly reduces token consumption" and then cites the ratio numbers, but the statement "Qwen2.5-Math-7B-Instruct on GSM8K, tokens were reduced by approximately 48.11%" is consistent with the table (Ratio 51.89%); the small discrepancy between the abstract's 48.1% and the table's 48.11% is fine, but the authors should use one decimal place consistently.
[§3.1] The definition of semantic equivalence requires "Methodological Congruence," meaning two steps that reach the same result via different derivations are not equivalent. This is a strong assumption for a pruning criterion, and it is not empirically validated (e.g., by showing that pruning such pairs hurts or helps downstream accuracy). A brief discussion of the design choice would help.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the pruning policy is trained on externally labeled equivalence pairs and evaluated on held-out benchmarks, with no target result used as a fitting input.

full rationale

EquivPruner's derivation chain is self-contained with respect to its efficiency and accuracy claims. The equivalence detector is trained on MathEquiv, whose labels come from GPT-4o with iterative human adjudication (Section 3.2), not from the downstream MCTS token counts or final accuracies that the paper reports. The Levenshtein ratio filter (Section 4.2.2) is a fixed design choice, and the same 0.75 threshold was also used when constructing the training data (Appendix A.1), so the inference-time gate is consistent with the training distribution rather than fitted to the evaluation results. The headline results on GSM8K and MATH-500 use held-out benchmarks, and the paper explicitly treats GSM8K as out-of-distribution for the pruner (Section 4.2.1). The fact that the pruner was trained on steps generated by Qwen2.5-Math-7B-Instruct and then evaluated with that same model is a generalization concern, not circularity, because the trained parameters do not encode the evaluation target values. The skeptic's point that efficiency is measured only by LLM-generated tokens, excluding the Longformer and Levenshtein overhead, is an empirical validity concern about the efficiency metric, not a circularity of the form where a prediction is equivalent to an input by construction. No self-citations are load-bearing: the MCTS/SBS baselines and PRM are cited from external groups, and no uniqueness theorem or prior work by the same authors is invoked to justify the pruning choice. Accordingly, the appropriate finding is no significant circularity.

Assumptions & free parameters 4 free parameters · 5 assumptions · 0 invented entities

The main free choices are thresholds, training hyperparameters, and search parameters; the axioms are domain assumptions about label quality, PRM reliability, and the Levenshtein gate. No new physical or ontological entities are introduced: MathEquiv is a dataset, and the five-level equivalence scale is a label scheme rather than a postulated entity.

free parameters (4)

Levenshtein ratio threshold = 0.75
Hand-chosen filter in Section 4.2.2 and Appendix A.1; only pairs with ratio above 0.75 are sent to the pruner, directly controlling what is pruned. No sensitivity analysis is reported.
EM high-confidence probability threshold = not specified
Used in the E-step to decide which sub-sentence pairs are treated as high-confidence equivalents and removed from training samples (Section 3.3.2). The value is not reported, so the training procedure is under-specified.
Longformer fine-tuning hyperparameters = Bayesian-optimized learning rate, epochs, weight decay
Selected by Bayesian optimization over eval/f1 (Appendix A.2.1). These affect detector quality but are not central to the pruning concept.
MCTS and SBS search hyperparameters = simulations=20, width=10, depth=50, PUCT=1.25, beam=3
Held equal across baseline and pruned runs, so they do not favor EquivPruner, but they are chosen by the authors and define the evaluation regime.

assumptions (5)

domain assumption Math-Shepherd PRM scores are reliable guides for MCTS value estimates on both MATH and GSM8K.
The evaluation uses Math-Shepherd-Mistral-7B-PRM for all models (Section 4.2.1); if PRM quality varies by model or dataset, both baselines are affected, but the comparison is still fair.
domain assumption GPT-4o plus human refinement yields correct labels for mathematical statement equivalence.
The MathEquiv dataset and the trained pruner inherit the quality of these labels (Section 3.2); no inter-annotator agreement or label validation against an external benchmark is reported.
domain assumption Equivalence can be detected from the text of individual reasoning steps without access to the full problem state or future steps.
The pruner is applied per node using candidate step text (Section 3.3 and Figure 2); if two steps are equivalent only with respect to their position in the tree, this method would miss them.
ad hoc to paper Levenshtein ratio greater than 0.75 is a necessary condition for semantic equivalence.
Only pairs above this threshold are considered for pruning, and MathEquiv training pairs are filtered the same way (Appendix A.1); this imposes a surface-similarity precondition that is not derived from any theory.
domain assumption Search hyperparameters tuned for vanilla MCTS remain appropriate when the search tree is pruned.
The same MCTS parameters are used in both settings (Appendix A.2.2), so pruning changes the tree dynamics without re-tuning.

how reviews work

0 comments

Cite this review

Pith. "Pith review of EquivPruner: Boosting Efficiency and Quality in LLM-Based Search via Action Pruning." pith.science (2026). https://pith.science/paper/ADGWT56J

@misc{pith2026250516312,
  author       = {Pith},
  title        = {Pith review of: EquivPruner: Boosting Efficiency and Quality in LLM-Based Search via Action Pruning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ADGWT56J}},
  note         = {Machine review of arXiv:2505.16312}
}

read the original abstract

Large Language Models (LLMs) excel at complex reasoning through search algorithms, yet current strategies often suffer from massive token consumption due to redundant exploration of semantically equivalent steps. Existing semantic similarity methods struggle to accurately identify such equivalence in domain-specific contexts like mathematical reasoning. To address this, we propose EquivPruner, a simple yet effective approach that identifies and prunes semantically equivalent actions during LLM reasoning search. We also introduce MathEquiv, the first dataset we created for mathematical statement equivalence, which enables the training of a lightweight equivalence detector. Extensive experiments across various models and tasks demonstrate that EquivPruner significantly reduces token consumption, improving searching efficiency and often bolstering reasoning accuracy. For instance, when applied to Qwen2.5-Math-7B-Instruct on GSM8K, EquivPruner reduced token consumption by 48.1\% while also improving accuracy. Our code is available at https://github.com/Lolo1222/EquivPruner.

Figures

Figures reproduced from arXiv: 2505.16312 by the authors.

**Figure 2.** The EquivPruner framework. Top: Training the lightweight equivalence pruner from labeled step-level [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗

**Figure 3.** Ablation study of EquivPruner components. [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗

Figures from the paper (1 more)

**Figure 4.** Figure 4: Complete prompt for labeling. 11 [PITH_FULL_IMAGE:figures/full_fig_p011_4.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

31 extracted references · 7 canonical work pages

[1]

Iz Beltagy, Matthew E Peters, and Arman Cohan. 2020. Longformer: The long-document transformer. arXiv preprint arXiv:2004.05150

arXiv 2020
[2]

Maciej Besta, Nils Blach, Ales Kubicek, Robert Gerstenberger, Michal Podstawski, Lukas Gianinazzi, Joanna Gajda, Tomasz Lehmann, Hubert Niewiadomski, Piotr Nyczyk, and 1 others. 2024. Graph of thoughts: Solving elaborate problems with large language models. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pages 17682--17690

2024
[3]

Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, and 1 others. 2020. Language models are few-shot learners. Advances in neural information processing systems, 33:1877--1901

2020
[4]

Guoxin Chen, Minpeng Liao, Chengxi Li, and Kai Fan. 2024. Alphamath almost zero: Process supervision without process. In The Thirty-eighth Annual Conference on Neural Information Processing Systems

work page 2024
[5]

Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, and 1 others. 2021. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168

arXiv 2021
[6]

Nicola Dainese, Matteo Merler, Minttu Alakuijala, and Pekka Marttinen. 2024. Generating code world models with large language models guided by monte carlo tree search. In The Thirty-eighth Annual Conference on Neural Information Processing Systems

work page 2024
[7]

Mehul Damani, Idan Shenfeld, Andi Peng, Andreea Bobu, and Jacob Andreas. 2024. Learning how hard to think: Input-adaptive allocation of lm computation. arXiv preprint arXiv:2410.04707

arXiv 2024
[8]

Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. 2021. Measuring mathematical problem solving with the math dataset. arXiv preprint arXiv:2103.03874

arXiv 2021

Show all 31 references

[9]

Aaron Hurst, Adam Lerer, Adam P Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Ostrow, Akila Welihinda, Alan Hayes, Alec Radford, and 1 others. 2024. Gpt-4o system card. arXiv preprint arXiv:2410.21276

2024 arXiv
[10]

Jinhao Jiang, Zhipeng Chen, Yingqian Min, Jie Chen, Xiaoxue Cheng, Jiapeng Wang, Yiru Tang, Haoxiang Sun, Jia Deng, Wayne Xin Zhao, and 1 others. 2024. Technical report: Enhancing llm reasoning with reward-guided tree search. arXiv preprint arXiv:2411.11694

2024 arXiv
[11]

Jikun Kang, Xin Zhe Li, Xi Chen, Amirreza Kazemi, Qianyi Sun, Boxing Chen, Dong Li, Xu He, Quan He, Feng Wen, and 1 others. 2024. Mindstar: Enhancing math reasoning in pre-trained llms at inference time. arXiv preprint arXiv:2405.16265

2024 arXiv
[12]

Zixuan Ke, Fangkai Jiao, Yifei Ming, Xuan-Phi Nguyen, Austin Xu, Do Xuan Long, Minzhi Li, Chengwei Qin, Peifeng Wang, Silvio Savarese, and 1 others. 2025. A survey of frontiers in llm reasoning: Inference scaling, learning to reason, and agentic systems. arXiv preprint arXiv:2...

2025
[13]

Hunter Lightman, Vineet Kosaraju, Yuri Burda, Harrison Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. 2023. Let's verify step by step. In The Twelfth International Conference on Learning Representations

2023
[14]

Jieyi Long. 2023. Large language model guided tree-of-thought. arXiv preprint arXiv:2305.08291

2023 arXiv
[15]

Liangchen Luo, Yinxiao Liu, Rosanne Liu, Samrat Phatale, Meiqi Guo, Harsh Lara, Yunxuan Li, Lei Shu, Yun Zhu, Lei Meng, and 1 others. 2024. Improve mathematical reasoning in language models by automated process supervision. arXiv preprint arXiv:2406.06592

2024 arXiv
[16]

Goutam Majumder, Partha Pakray, Alexander Gelbukh, and David Pinto. 2016. Semantic textual similarity methods, tools, and applications: A survey. Computaci \'o n y Sistemas , 20(4):647--665

2016
[17]

Shuai Peng, Ke Yuan, Liangcai Gao, and Zhi Tang. 2021. Mathbert: A pre-trained model for mathematical formula understanding. arXiv preprint arXiv:2105.00377

2021 arXiv
[18]

Nils Reimers and Iryna Gurevych. 2019. Sentence-bert: Sentence embeddings using siamese bert-networks. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJC...

2019
[19]

Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Y Wu, and 1 others. 2024. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300

2024 arXiv
[20]

Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. 2024. Scaling llm test-time compute optimally can be more effective than scaling model parameters. arXiv preprint arXiv:2408.03314

2024 arXiv
[21]

Christian Steinfeldt and Helena Mihaljevi \'c . 2024. Evaluation and domain adaptation of similarity models for short mathematical texts. In International Conference on Intelligent Computer Mathematics, pages 241--260. Springer

2024
[22]

Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, and 1 others. 2022. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824--24837

2022
[23]

Yuxi Xie, Anirudh Goyal, Wenyue Zheng, Min-Yen Kan, Timothy P Lillicrap, Kenji Kawaguchi, and Michael Shieh. 2024. Monte carlo tree search boosts reasoning via iterative preference learning. arXiv preprint arXiv:2405.00451

2024 arXiv
[24]

An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Haoran Wei, and 1 others. 2024. Qwen2. 5 technical report. arXiv preprint arXiv:2412.15115

2024 arXiv
[25]

Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Tom Griffiths, Yuan Cao, and Karthik Narasimhan. 2023. Tree of thoughts: Deliberate problem solving with large language models. Advances in neural information processing systems, 36:11809--11822

2023
[26]

Li Yujian and Liu Bo. 2007. A normalized levenshtein distance metric. IEEE transactions on pattern analysis and machine intelligence, 29(6):1091--1095

2007
[27]

Dan Zhang, Sining Zhoubian, Ziniu Hu, Yisong Yue, Yuxiao Dong, and Jie Tang. 2024 a . Rest-mcts*: Llm self-training via process reward guided tree search. Advances in Neural Information Processing Systems, 37:64735--64772

2024
[28]

Di Zhang, Jianbo Wu, Jingdi Lei, Tong Che, Jiatong Li, Tong Xie, Xiaoshui Huang, Shufei Zhang, Marco Pavone, Yuqiang Li, and 1 others. 2024 b . Llama-berry: Pairwise optimization for o1-like olympiad-level mathematical reasoning. arXiv preprint arXiv:2410.02884

2024 arXiv
[29]

Shun Zhang, Zhenfang Chen, Yikang Shen, Mingyu Ding, Joshua B Tenenbaum, and Chuang Gan. 2023. Planning with large language models for code generation. In The Eleventh International Conference on Learning Representations

2023
[30]

online" 'onlinestring :=

ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list...
[31]

write newline

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

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [1]

Iz Beltagy, Matthew E Peters, and Arman Cohan. 2020. Longformer: The long-document transformer. arXiv preprint arXiv:2004.05150

arXiv 2020

[2] [2]

Maciej Besta, Nils Blach, Ales Kubicek, Robert Gerstenberger, Michal Podstawski, Lukas Gianinazzi, Joanna Gajda, Tomasz Lehmann, Hubert Niewiadomski, Piotr Nyczyk, and 1 others. 2024. Graph of thoughts: Solving elaborate problems with large language models. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pages 17682--17690

2024

[3] [3]

Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, and 1 others. 2020. Language models are few-shot learners. Advances in neural information processing systems, 33:1877--1901

2020

[4] [4]

Guoxin Chen, Minpeng Liao, Chengxi Li, and Kai Fan. 2024. Alphamath almost zero: Process supervision without process. In The Thirty-eighth Annual Conference on Neural Information Processing Systems

work page 2024

[5] [5]

Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, and 1 others. 2021. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168

arXiv 2021

[6] [6]

Nicola Dainese, Matteo Merler, Minttu Alakuijala, and Pekka Marttinen. 2024. Generating code world models with large language models guided by monte carlo tree search. In The Thirty-eighth Annual Conference on Neural Information Processing Systems

work page 2024

[7] [7]

Mehul Damani, Idan Shenfeld, Andi Peng, Andreea Bobu, and Jacob Andreas. 2024. Learning how hard to think: Input-adaptive allocation of lm computation. arXiv preprint arXiv:2410.04707

arXiv 2024

[8] [8]

Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. 2021. Measuring mathematical problem solving with the math dataset. arXiv preprint arXiv:2103.03874

arXiv 2021