Forest-of-Thought: Scaling Test-Time Compute for Enhancing LLM Reasoning
Authors: Zhenni Bi
Kai Han
Chuanjian Liu
Yehui Tang
Yunhe Wang
Venue: ICML 2025 poster (2025)
Keywords: forest of thought; fot; nlp; llm
Primary area: deep_learning->large_language_models

Abstract: Large Language Models (LLMs) have demonstrated remarkable abilities across various language tasks, but solving complex reasoning problems remains a significant challenge. While existing methods, such as Chain-of-Thought (CoT) and Tree-of-Thought (ToT), enhance reasoning by decomposing problems or structuring prompts, they typically perform a single pass of reasoning and may fail to revisit flawed paths, compromising accuracy. To address this limitation, we propose a novel reasoning framework called Forest-of-Thought (FoT), which integrates multiple reasoning trees to leverage collective decision-making for solving complex logical problems. FoT employs sparse activation strategies to select the most relevant reasoning paths, improving both efficiency and accuracy. Additionally, we introduce a dynamic self-correction strategy that enables real-time error correction, along with consensus-guided decision-making strategies to optimize both correctness and computational resources. Experimental results demonstrate that the FoT framework, combined with these strategies, significantly enhances the reasoning capabilities of LLMs, enabling them to solve complex tasks with greater precision and efficiency.

forest-of-Thought: Scaling Test-Time Compute for Enhancing LLM Reasoning
Zhenni Bi Kai Han
Chuanjian Liu'
Yehui Tang
Yunhe Wang"
Abstract
LLaMA (Touvron al., 2023) can generate coherent essays, answer complex questions, and engage in multi-turn dia- logues with human-like fluency. These models excel at tasks requiring not only linguistic understanding but also basic reasoning, such as translating text, summarizing lengthy documents, and generating code from plain language in- structions. The versatility and adaptability of LLMs have made them invaluable tools in both industry and research, opening up new avenues for solving general-pun seneral-purpose prob- lems.
Large Language Models (LLMs) have demon- strated remarkable abilities across various lan- guage tasks, but solving complex reasoning prob- lems remains a significant challenge. While existing methods, such as Chain-of-Thought (CoT) and Tree-of-Thought (ToT), enhance rea- soning by decomposing problems or structuring prompts, they typically perform single pass of reasoning and may fail to revisit flawed paths, compromising accuracy. To address this lim- itation, we propose a novel reasoning frame- work called forest-of-Thoughee (FoT), which in- tegrates multiple reasoning trees to leverage col- lective decision-making for solving complex log- ical problems. FoT employs sparse activation strategies to select the most relevant reason- ing paths, improving both efficiency and accu- racy. Additionally, we introduce a dynamic self-correction strategy that enables real-time error correction, along with consensus-guie guided decision decision-making strategies to optimize both cor- rectness and computational resources. Experimen- tal results demonstrate that the FoT framework, combined with these strategies, significantly en- hances the reasoning capabilities of LLMs. en- abling them to solve complex tasks with greater precision and efficiency. Code will be avail- able at http://gittbb.com/mmmaaaaaaaa//t Thought.
Enabling LLMs to successfully solve complex reasoning problems remains a challenge. A series of works have been proposed to introduce more inference during testing based on a well-trained L.M (Wei al., 2022; Yao et al., 2024; Snell al., 2024; OpenAI, 2024). Chain-of-Thouse Thought (CoT) (Wei et al., 2022) provides a few chain-of-thoughee demonstrations in prompting as exemplars to enhance the reasoning abilities of LLMs. Tree-of- Thought (ToT) (Yao et al., 2024) allows language models to explore multiple reasoning paths and self-evaluate to make more globally informed decisions. Graph-of-Thoupg (GoT) (Besta et al., 2024b) advances LLM prompting by structuring informa- tion as graph of interconnected "thoughts", enabling syn- ergistic reasoning and feedback loops.
These methods perform reasoning by using richer prompts or by decomposing complex problem into several sim- pler sub-problems. However, they typically perform only single, complete reasoning pass on the problem, which does not guarantee that the problem will be solved correctly. For example, in a complex mathematical word problem, Tree-of-Thought approach might decompose the problem into smaller steps, such as isolating terms or simplifying expressions. However, while breaking down the problem, it may still overlook critical details or make errors in inter- mediate steps, leading to an incorrect final answer. Once it completes a single reasoning path, it typically does not revisit other possible approaches if the initial path is flawed. This lack of re-evaluation can result in solution that fails to address the full complexity of the problem, as alternative paths are often prematurely abandoned and left unexplored, thereby compromising accuracy. In contrast, humans tend to repeatedly reflect and verify from different perspectives when dealing with complex problems, which allows them to truly solve the problem and provide answers with higher
1. Introduction
Large Language Models (LLMs) have revolutionized natural language processing by demonstrating remarkable capabil- ities across a wide range of language tasks. By leverag- ing vast datasets and complex architectures, LLMs such as ChatGPT (Kojima et al., 2022; Achiam et al., 2023) and
'Equal contribution 'Huawei Noah's Ark Lab. Correspon- dence to: Yehui Tang Eychui.tang @haaweihhwwom Yunhe Wang Yunhe Wang @ huawei.com>>.
Proceedings of the 4nnd International Conference Machine Learning, Vancouver, Canada. PMLR 267, 2025. Copyright 2025 by the author(s).

---

Forest-of-Thought
Scaling Test-Time Compute for Enhancing LLM Reasoning
accuracy.
problems all at once. By decomposing complex problems into simpler tasks, Program of Thought (PoT) (Chen et al., 2023), Chain of Code (CoC) (Li et al., 2024), and Buffer of Thought (BoTT) ( (Yang et al., 2024) transform the process into a set of programmatic steps, using variable names to convey semantic information. In contrast, the Algorithm of Thought (AoT) (Sel et al., 2024) method seeks to integrate these steps into a single prompt. enabling LLMs learn how to break down problems, generate solutions, assess their feasibility, and determine the next step in the search process. This approach reduces token consumption and improves efficiency.
In this paper, propose new reasoning framework called Forest-of- Forest-of-Thought (FoTT) to scale up test-time computation and enhance the reasoning abilities of LLMs, as shown in Figure 1. FoT integrates multiple reasoning trees to leverage the advantages of collective decision-making for handling complex logical reasoning tasks. By utilizing sparse ac- tivation strategies, we select the most relevant reasoning paths for each tree, thereby improving both the efficiency and accuracy of the model. To further enhance the reason- ing process, we introduce a dynamic self- celf-correction strat- egy, which enables the model to automatically identify and correct errors during reasoning. leveraging both real-time corrections and historical learning. Additionally, we in- corporate gonsensus-guides decision-making strategies to optimize both correctness and computational resouree age, ensuring that the model only continues the reasoning process when necessary. Our experiments demonstrate that the proposed FoT framework, combined with these strate- gies, significantly improves the reasoning performance of LLMs, enabling them to solve complex tasks with greater precision and efficiency.
Tree-of- Theoughtt (ToT) (Yao et al., 2024) constructs a tree structure to explore various possible choices and their out- comes, where each node represents decision point, and the edges represent transitions between states. Typically, depth-first search (DFS) approach is used to explore each branch incrementally. Tree Prompting (Morris et al., 2023) establishes decision-tree-base prompting system, chain- ing multiple language model calls together to collaboratively complete specific task. However, for complex problems, the tree's depth may become very large, leading to an expo- nential increase in the search space and a higher computa- tional burden. Staph-offTThouhh (GoT) (Besta et al., 2024b) extends the ToT framework by introducing an aggregation process. GoT models the reasoning process of LLMs as a graph structure, allowing information units to form arbitrary dependencies, not limited to linear or tree-based arrange- ments. Through aggregaite aggregation, GoT consolidates information from multiple paths, enabling complex dynamic path selec- tion and backtracking. Skeleton-of- Thought (SoT) (Ning et al., 2023) reduces generation latency in LLMs by first generating a skeleton outline of the answer, then complet- ing the content in parallel, achieving significant speedups and potential quality improvements across various types of questions.
2. Related Works
2.1. XoT reasoning
Starting with Chain-of-Thought (CoT), XoT reasoning tech- niques (e.g., ToT and GoT) emerged as important methods for enhancing the reasoning abilities of LLMs, leading to the development of a series of XoT reasoning algorithms.
Shain-of-Thought (CoT) (Wei et al., 2022) decomposes problem into series of intermediate steps, each providing portion of the information necessary for the final answer. This approach mimics human problem-solving strategies, in- volving step-by-step reasoning to reach a conclusion. How- ever, while CoT performs well in many tasks, it has limi- tations when applied to complex mathematical and logical problems. These types of problems often require multidi- mensional, non-linear thinking rather than just sequential reasoning. Despite numerous subsequent studies aimed at improving CoT, such as Zero-Shot- Shot-CoT (Kojima et al., 2023), Self-Consistency with CoT (CoT-SC) (Wang et al., 2023), Auto-CoT (Zhang et al., 2022), VerifyCoT (Zhao et al., 2023), and CoF-CoT (Nguyen et al., 2023), further exploration and optimization are still needed to tackle highly complex tasks.
2.2. Monte Carlo Tree Search
Monte Carlo Tree Search (MCTS) (Chaslot et al., 2008), a probability- based search algorithm, has made significant progress across various domains since its introduction in computer Go in 2006. It evaluates nodes through ran- domized simulations (rollouts) and incrementally builds a local game tree to identify optimal or near-optimal so- lutions within a limited time. To enhance MCTS perfor- mance, researchers have proposed various improvements. Browne et al. (2012) surveyed extensions such as sparse activation, dynamic pruning, parallclization, and distributed computation, which have broadened MCTS applications. Srinivas et al. (2012) introduced proved exploratioo-cxploottttio strategy suited for high- dimensional spaces. Recently, integrating MCTS with large language models has advanced its use in complex reasoning
Least-to-Most Prompting (LtM) (Zhou et al., 2023) guides the model through a step-by-step process, progres- sively assisting it in constructing a solution, in contrast to methods like CoT, which attempt to solve complex problems directly. This approach effectively mitigates the reasoning errors that often occur when attempting to solve complex
an im-
2

---

Forest-of-Thouhht: Scaling Test-Time Compute for Enhancing LLM Reasoning
Input
Input
Input
Input
Lnwe Inwecorfilenn
Top-renied node
Input
Enhancement
Input
TREE
TREE
Solution
Solution
Solution
Final output
Final output
Final output
Final output
(a) Iaput-Outpul Prompting (IO)
(b) Chain of Thought Prompting (Cal
(c) Tree of Thaught Prompting (IoD
(d) Forest of Thought Prompting (FoT)
Figure 1. Schematic illustration of various L.I reasoning approaches including 10 prompting, CoT, ToT and the proposed FoT.
tasks. Sverything-of-Thougee (Ding al., 2024) employs combination of reinforcement learning and MCTS for reasoning. Methods like MCTSr (Zhang et al., 2024) com- bine MCTS with LLMs to guide decision decision-making, blending probabilistic search with linguistic reasoning. This hybrid approach enables effective multi-step logic and diverse so- lution paths.
perspective. The root node of each represents the initial state problem input, and each subsequent node represents intermediate result or step in the reasoning process. Let the input be x. Each reasoning tree will start from the input and produce a result through different reasoning steps:
= T)(((x)), E (1,2....,
3. Method
where e(x) function that enhances before used input (details in the following paragraph) and T:(-) rep- resents the reasoning process of the ith tree. FoT considers the results of these trees in a sparse activation manner and produces a high-quality response through a decision-making strategy (Sec. 3.3). Additionally, a dynamic self-correction strategy is proposed to enhance the accuracy (Sec. 3.2).
By introducing multiple reasoning trees (e.g., ToT (Yao et al., 2024) or MCTSr (Zhang et al., 2024)) for independent decision-making and employing sparse activation strategies filter the results from key trees, we can construct Forest of Thought to enhance the reasoning capabilities of LLMs, shown in Figure ((d) and Algorithm 1. This strategy leverages collective intelligence to compensate for individ- ual shortcomings, thereby improving the model's 's ability to reason from multiple perspectives. Our experimental valida- tion demonstrates that integrating the results from multiple reasoning trees through sparse activation strategies indeed enhances the reasoning capabilities of larger models significant extent. This finding not only deepens under- standing of model integration techniques but also provides new insights for improving the mathematical reasoning abil- ities of LLMs.
Sparse Activation. In the reasoning process of FoT, aim to improve both computational efficiency and answer quality by selectively activating only the most promising reasoning trees. Instead of exhaustively computing over all trees, sparse activation ensures that inference resources are allocated only to paths that demonstrate strong intermediate reasoning signals.
high level, sparse activation works by evaluating the intermediate outputs of each reasoning tree at every layer and filtering out trees that are unlikely to contribute mean- ingful information to the final decision. This is particularly crucial in multi-step reasoning tasks, where invalid or low- quality intermediate outputs can lead to cascading errors in subsequent steps. By terminating these unpromising paths
3.1. The FoT Framework
Suppose have reasoning trees T2, Tr, each of which approaches the input problem from a different
3

---

Forest-of-Thought: Scaling Test-Time Compute for Enhancing LLM Reasoning
early, we save computation and reduce noise in final output aggregation.
each tree further improve the model's performance.
Imaz arg max (Sim (ar, B))
(3)
For each reasoning tree T, at every layer, we evaluate all generated nodes and select only the top-scoring candidates (based on a task-specific scoring function, such as model log- likelihood or heuristic correctness). These selected nodes are then split into child nodes to form the next layer. If tree fails to generate any valid outputs at given layer-c.g.. due to invalid syntax, semantic contradictions, domain- specific constraints its expansion is halted prematurely. The tree is marked as inactive, and it does not participate in the final answer aggregation.
Biax $ x
(4)
where Sim(-) represents retrieving the most relevant ques- tions from B. ( means the concatenation of two text strings.
The sparse activation strategy improves both efficiency and accuracy by focusing on the most relevant reasoning paths and reducing unnecessary computations. To further opti- mize reasoning, we apply efficient search with early ter- mination. When a clear target is identified (e.g.. Game of 24, Arithmetic Puzzles and Maze Solving), the search halts immediately upon finding a solution. This avoids redundant computations: once a branch matches the ground truth (GT), further exploration of irrelevant paths is stopped, saving resources and speeding up the process. Early termination thus enhances overall efficiency by preventing unnecessary work.
Formally, the activation indicator yps for tree Ti defined as:
1 if VI, F(s:) valid output, Pi $ {0, otherwise.
(2)
Here, st is the solution or intermediate output at layer / in tree Ti and F(s)) is a validation function that determines whether the output is logically or semantically valid. The tree is considered active only if all its intermediate layers produce valid outputs; otherwise, is pruned from the final ensemble.
Algorithm Forest of Tree (FoT)
Require: Input æ, LLM po, n reasoning trees (T(O),
1, 2, ......,,. n,;
1: S. + 0
Sparse activation therefore functions as both filtering mechanism and a computational budget control strategy. It reduces inference latency and improves accuracy by:
2: for i -- 1.... do
3: obtain result of the i-th tree with input enhancement:
8i, fi < T={e()));
dynamic self-correction:
Pruning low-quality or invalid reasoning paths before they reach full depth.
5 selfoocccrreet st x) (Sec. 3.2); if activator indicator (p; == 1 then
5:
6:
update result set: S; + S U {s{};
Allowing the model concentrate its computation on smaller number of high-confidence paths.
7: else
continue; end if 10: end for
8:
Enhancing the diversity and quality of the final answer pool by removing noisy or erroneous candidates.
Return Decision Making CGFD(S,)) 3.3).
In practice, we find that sparse activation improves the trade- off between reasoning depth and breadth, leading to more robust and interpretable outputs with lower overall cost.
3.2. Dynamic Selr-Correction Strategy
Self-correction is a fundamental cognitive method that hu- mans solve complex problems (Simon, 1991; Flower, 1981; Amabile, 1983). Unlike Self-Refine (Madaan et al., 2023), which relies on a fixed number of iterations, our approach dynamically evaluates each reasoning step, specif- ically by monitoring the predicted logits scores to assess the quality of the reasoning results. When the model's ss score falls below predefined threshold, correction mechanism is automatically triggered to detect and fix errors in a timely manner. This approach enhances the flexibility and adapt- ability of the reasoning process, as it does not rely on preset iteration counts, but instead adjusts the model's 's output based on real-time feedback.
Input Data Augmentation. When faced with complex problems, our cognitive process typically shifts from rapid, intuitive "fast thinking" to deeper, more systematic "slow thinking" (Evans, 1984; Kahneman, 1). This transition not only helps us address immediate challenges but also draws on the relevant prior knowledge stored in our brains, enabling us to analyze and solve problems more compre- hensively, Slow thinking integrates and evaluates this prior knowledge, allowing us to view problems from multiple per- spectives and arrive at more reasonable solutions. Inspired by prior knowledge, we have collected and constructed a knowledge base B from publicly available datasets to sup- port the model's reasoning process. Additionally, by en- hancing the diversity of question-answe generation within
Additionally, our method incorporates predefined mathe-
4

---

Forest-of-Thought: Scaling Test-Time Compute for Enhancing LLM Reasoning
matical rules, further improving the accuracy and reliability of the reasoning process. By embedding these rules into the reasoning framework, the model can immediately cor- rect errors upon detection. For example, in Game 24, the model can verify whether the remaining numbers the output are derived from the input numbers, enabling quick error detection and correction. This immediate correction mechanism not only improves reasoning quality but also significantly reduces the risk of error propagation. Over- all, through dynamic evaluation, real-time feedback, and rule-driven correction mechanisms, our approach enables the model to quickly identify and correct errors, ultimately enhancing its overall performance and robustness.
Table 1. Ablation experiment of FoT with self-correction, input enhancement, and sparse activation.
Self- Correction
Input
Sparse Activation
LLM invoked
Method
Acc. [%]
Enhancement
FoT FoT FoT
10.58
32.32
60.24
77.98
32.32
FoT
77.98
26.99
4. Experiments
We evaluate the proposed FoT method on the widely-used LLM reasoning benchmarks including Game of 24, GSM8K and MATH.
The process details of the proposed dynamic self-correction strategy are shown in Algorithm 2.
4.1. Experimental setups
Algorithm 2 Dynamic Self-Correction Strategy
In this experimental section, we explore FoT methods based on ToT and MCTSr, conducting experiments across multiple LLMSs and datasets. For the Game of 24 (Yao et al., 2024), our FoT is built using ToT as the reasoning tree. In addition to the ToT-based FoT, we developed an MCTSr-based FoT to address mathematical problems, including those from the GSM8K (Cobbe et al., 2021a) and MATH (Hendrycks et al., 2021b) benchmarks. Furthermore, we extend our method to models such as JJama3-8B-Instruu (at Meta, 2024), Mistral- 7B (Jiang et al., 2023), and GLM-4-9B (GLM et al., 2024), testing it on the GSMSK benchmark to assess its generaliza- tion.
Require: Input context x, LM pa, mathematical rule cor- rection function F, priori knowledge sets B;
1: 8, < Po(ss zz);
2: score; < Po (score;; 8;,z);
3: if score; threshold then
4: if' F is not None then
5: 5 F(s:;:
6: else
7:
s po(s B, s;,r;;
8: end if
9:
update result: 8; f s/c
10:
end if
4.2. Game of 24
The Game of 24, from 4nums involves constructing an arithmetic expression using each of the four given numbers exactly once, such that the expression evaluates to 24. We removed the duplicate and unsolvable problems, leaving 95 problems as the test set. In our experiment, we set the sampling temperature to 0.95. We also conducted a series of ablation experiments based on 8B-nttttttt as shown in Table
3.3. Decision Making Strategy
To address complex mathematical problems, we designed the Gondendus-Guided Expert Decision (CGED) strategy to ensure high accuracy and reliability in the final answers generated by FoT. The CGED approach combines collective intelligence with expert judgment from LLMs, guiding the reasoning process from consensus-bane based decision-making to expert evaluation.
Results. Table 1 presents an ablation experiment comparing the performance of FoT and ToT, highlighting the impact of different components on reasoning accuracy. The ex- periment starts with the BoN method, which directly uses the ToT framework without input enhancement, sparse ac- tivation, or self-correction. Under this configuration, the accuracy relatively low, 10.58%, as the model relies solely on the base ToT approach, without any optimizations adjustments enhance its reasoning capabilities. In con- trast, by introducing self-correction FoT shows a significant improvement, achieving an accuracy of 60.244 60.24%. The self- correction mechanism plays pivotal role in enhancing the reasoning process. It allows real-time adjustments to the cur- rent reasoning path, ensuring errors are corrected promptly
During the reasoning process of FoT, each activated tree generates the optimal solution for its reasoning path. These solutions then undergo majority consensus voting and expert evaluation to gradually identify the best answer. Specifi- cally, for complex reasoning tasks, if the majority of trees produce inconsistent results, an LLM expert will compare the reasoning processes and outcomes of the different trees, making final decision based their professional knowl- edge and experience. This approach ensures the accuracy of the final result, effectively reduces errors and biases in the reasoning process, and enhances the robustness of the entire framework.
5

---

Forest-of-Thought: Scaling Test-Time Compute for Enhancing LLM Reasoning
as they are detected. This reduces the accumulation of er- rors that can otherwise arise when later reasoning paths depend potentially flawed earlier steps. Consequently, FoT with self-correction delivers more accurate and reliable reasoning, especially in complex problem-solving scenarios. Further improvements are observed when input enhance- ment introduced alongside self-correction, resulting in the FoT with both features. This configuration boosts the accu- racy to 77.98%, highlighting the importance of enriching the model's inputs to provide broader perspectives, which in turn supports more robust reasoning. Finally, when sparse activation is incorporated into the configuration, there is a significant reduction in the number of LLM invocations, from 32.32 to 26.99. This not only improves computational efficiency but also ensures that the model maintains its high- est accuracy yet, demonstrating the power of combining self-correction, input enhancement, and sparse activation.
Table 2. Performance Comparison on Game of 24: Our method, with 8 activated subtrees, achieved the highest average ranking across different inference frameworks.
Method
LLM invoked
Success
10
1.00
10.22%
CoT (Kojima et al., 2023)
1.00
4.38%
CoT-SC (Wang et al., 2023)
10.00
4.38%
GoT (k=1) (Besta et al., 2024a)
7.00
5.26%
ToT (b=5) (Yao al., 2024)
13.74
74.00%
BoT (Yang et al., 2024)
3.00
82.40%
XoT (w/ r) (Ding al., 2024)
1.78
85.40%
Ours
25.64
96.84%
Notably, the 4-rollouts MCTSr with 2 trees achieved 3.2 % higher accuracy compared to the 8-rollouts MCTSr. Ad- ditionally, it outperformed the 8-rollouts MCTSr with 2 trees, highlighting its distinct advantage. These findings suggest that increasing the diversity of reasoning outcomes has a more significant impact on performance than simply extending the depth of individual trees.
In Figure 5, we compare the computational cost and per- formance of the extended ToT and FoT methods. In the experiment, we progressively increase the number of se- lectable leaf nodes in ToT (b 2, 4, 8, 16, 32) to allow for greater diversity in potential reasoning outcomes. The experimental results show that simply increasing the num- ber of leaf nodes in ToT leads to a gradual improvement in accuracy, though the gains become more modest as the number of nodes increases. However, when the number of leaf nodes per layer was increased to 32, the results showed no significant improvement. This suggests that the system reached reasoning bottleneck, where further expansion of the leaf nodes did not result in substantial performance gains. Beyond certain threshold, increasing the number of available reasoning paths appears to offer diminishing returns, likely due to the inefficiencies of excessive node expansion. In contrast, the FoT method, which incorpo- rates techniques such as self-correction, input enhancement, and sparse activation, demonstrates much more signifi- cant improvement in accuracy. These findings highlight that while expanding the structure of ToT provides only limited performance gains, the integration of additional features in FoT leads to a more substantial enhancement in model performance.
GSMOK Accuracy (%0
Number Trees
Figure 2. Benefit analysis of FoT: the return on wisdom growth. The x-axis represents the number of subtrees the forest, while the y-axis indicates the accuracy on the GSMSK dataset.
Scaling laws in FoT across various base models. In ad- dition to the previously discussed research, we extended our exploration to evaluate the performance of different base models of similar size within the FoT framework. Specifically, we conducted experiments using three mod- els: Mistral-7B, Llama3-8B, and GLM-4-9B. As shown in Figure 3, the results demonstrate a clear scaling law: as the number of activated subtrees in FoT increases, model ac- curacy improves significantly. This scaling behavior aligns with theoretical expectations, which suggest that activat- ing additional subtrees enhances the diversity of reasoning paths and enables models to refine their problem-solving capabilities. Each subtree incrementally contributed to the overall performance, collectively boosting the framework's ss reasoning capacity.
4.3. GSM8K Benchmark
In addition to the Game of 24, we evaluated the benefits of integrating multiple methods into the FoT framework using the GSMSK (Cobbe et al., 2021b) dataset.
Results. As shown in Figure 2, we constructed forests using various methods, including Zero-Shot-Co'T, MCTSr with one turn, MCTSr with 4-rollouts, and MCTSr with 8-rollouts. The experimental results demonstrate that as the number of trees in the forest increases, the ad advantages of the method forest approach become more pronounced.
6

---

Sirest-f-TThoughi Scaling Test-Time Compute for Enhancing LLM Reasoning
0.20
104 bo01.11 10-9)-a22
0.24
L00 - (x/137 10 4))
0.5
(Dx) 1x 10-
0.16
0.20
0.4
0.12
0.16
Error rate
0.08
0.04
0.08
2
22
2
2a
2
2
2F Mistral-7B
2a
Uama3-88
GLM4-98
Figure 3. Comparative analysis of FoT gains across Llama, Mistral and GLM models. The x-axis represents the number of activated subtrees in FoT, while the y-axis indicates the error rate on the GSM8K dataset. The relationship between the number of activated subtrees in FoT and accuracy has been validated across multiple models, revealing trend consistent with the scaling test-time comput for enhancing LLM reasoning.
The observed trend suggests predictable and positive re- lationship between the number of activated subtrees and accuracy, consistent with scaling law principles. This high- lights that the FoT method effectively utilizes computational resources to maximize reasoning accuracy. Moreover, as computational capacity is allocated to activate more sub- trees, performance gains exhibit diminishing, yet consis- tent, trajectory-Showeee showcasing the robustness and scalability of FoT.
32.15
60
70
+7.01
$2.01
(3-
21
87.05
Scoren
4.4. MATH Benchmark
16
This section presents the results of applying the FoT method across various complexity levels on the MATH (Hendrycks et al., a021a) dataset.
15:54
30
2wre-Shtt McTiow #cT]r=2) SoT(nw))
ZersGnnt CoT
NCT5/9
[nT()=31
FOT])w4]
Results. The experimental results are shown in Figure 4, where the performance of the FoT method is compared to MCTST across different difficulty levels in the mathematics dataset. The results clearly demonstrate that the FoT method consistently outperforms MCTSr at every level, from Level 1 to Level 4. Specifically, FoT (n=4) exhibits an impressive and consistent improvement of approximately 10% in per- formance as the difficulty level increases from Level to Level This steady improvement highlights the robustness and versatility of the FoT method, which is able to adapt effectively to wide range of problem complexities. At Level 1, which consists of relatively simple problems, both methods perform reasonably well. However, as the difficulty increases, FoT shows a clear advantage, achieving higher accuracy compared to MCTSr at each subsequent level. By Level 4, the most challenging problems in the dataset, the FoT method not only maintains its performance but also demonstrates significant enhancement in problem-solving capabilities. This consistent improvement underscores the effectiveness of the FoT method in handling problems of varying complexity.
Figure 4. FoT demonstrates consistent performance across differ- ent levels of the MATH Dataset.
4.5. Ablation Studies of Stopping Strategies
In Table 3, we present detailed comparison of three for- est stopping strategies: Majority Vote, Math Expert, and CGED. The results show the performance of these strategies across varying numbers of activated subtrees in the FoT method. When only two subtrees are activated, the accuracy of the CGED strategy found to be quite similar to both the Majority Vote and Math Expert strategies, indicating that for simpler cases, all three strategies perform compara- bly. However, the number of activated subtrees increases, the differences in performance among these strategies be- come more noticeable. Specifically, when five subtrees are activated, the CGED strategy demonstrates a clear improve- ment in accuracy, surpassing the Majority Vote and Math Expert strategies by margin of 2%. This suggests that

---

Forest-of-Thought: Scaling Test-Time Compute for Enhancing LLM Reasoning
the CGED strategy becomes increasingly effective in han- dling more complex reasoning scenarios, where multiple reasoning paths are activated simultaneously. These find- ings underscore the superior adaptability and performance of the CGED strategy, particularly in tasks involving larger number of activated subtrees, where it outperforms the other two strategies in terms of accuracy and overall efficiency.
Table 4. The following summarizes the performance of FoT and other state-of- tatteoffthe-arr language models across different levels of mathematical benchmark tests. GSM-level refers to the GSM8K, MATH-level to the MATH500, and Olympiad-level to AIME 2024. Specifically, rStar-Math (Guan et al., 2025) refers to rStar-Math (7B SLM 7B PPM), and the latter denotes the Pass @ accuracy achieved when sampling trajectories.
Model
GSM-level
MATH-level Olympiad-level
FoT Accuracy
GPT-4o
92.90
76.60
9.30
80
TaT Accuracy
IStar-Math
95.00
89.40
46.70
rStar-Math
95.20
90.00
53.30
70-
Base Model: Qwwen2.5-Math-7B--nsse IIsstructt
Accuracy (%)
60
Qwen2.5-7B
88.48
82.60
6.00
FoT (n=2)
93.33
83.02
26.67
FoT (n=4)
95.00
85.80
33.33
40
FoT (n=8)
96.89
86.20
46.67
Base Model: QwQ-32BB-preview
30
QwQ
95.30
90.60
50.00
20
FoT (m==)
97.33
91.20
53.33
16
28
20
LLM Invoked Times
The results presented in Table 4 highlight the performance of the FoT method across various datasets, including GSM8K, MATH-500 (Lightman et al., 2023), and AIME 2024 (AI- MO, 2024). In the GSM8K dataset, FoT with 4 activated subtrees (FoT (n=4)) based on QwQ achieved the accu- racy of 97.33%, outperforming rStar-Math (95.20%) and GPT-4o (92.90%). FoT (n=4) with QwQ achieved a strong performance with an accuracy of 91. 91.20%, surpassing rStar- Math 64 (90.00%) On AIME 2024, FoT showed significant improvements, reaching 53.33%, which is much higher than rStar-Math at 6.66%. These results underscore the effective- ness of FoT in enhancing model performance, particularly as the number of activated subtrees increases, demonstrating its potential to improve reasoning accuracy across range of mathematical problem-solving tasks.
Figure 5. On the Game of 24, the performance comparison be- tween FoT and ToT, under the same computational cost.
Subtrees
Majority Vote
Math Expert
CGED
n=2
80.36
80.36
80.36
n=3
81.31
81.88
84.31
n=4 84.31
82.46
84.46
5=5
83.44
83.70
85.44
Table Performance comparison based on the number trees with three different stopping strategics.
4.6. Main Results
As shown Table 2, the performance comparison on the Game of 24 validates the effectiveness of the FoT in the mathematical and logical reasoning task. The experimen- tal results indicate that the FoT with 8 activated subtrees achieved the highest success rate at 96.84% significantly outperforming other methods. In contrast, single-step rea- soning methods like 10 (10.22%) and CoT (4.38%) rely solely on the model's pre-trained capabilities, showing lim- ited performance. Multi-step reasoning techniques, such as ToT (b=5) and BoT, achieved success rates 74.00% and 82.40%, respectively, demonstrating notable advantage. Additionally, XoT, after three deployments, reached suc- cess rate of 85.40% These results clearly indicate that the FoT method, particularly with a higher number of activated subtrees, enhances the model's 's self-correction capabilities and significantly improves the performance on the Game of 24 while only modestly increasing the computational cost.
5. Conclusion
This paper introduces Forest of Thought, a novel framework that significantly enhances the reasoning capabilities of large language models by combining multi-path exploration and dynamic path activation. FoT builds upon and unifies con- cepts from Tree of Thought and Monte Carlo Tree Search, enabling robust, diverse, and efficient reasoning without requiring backpropagation or fine-tuning. selectively acti- vates the most promising reasoning paths through a sparse activation mechanism, which improves computational effi- ciency while maintaining high accuracy. FoT is particularly effective in solving complex tasks, offering both perfor- mance and generalization benefits Additionally, the paper provides a systematic analysis of the scaling relationship between reasoning time and accuracy, offering a theoretical foundation for reasoning optimization in L.MMs.
8

---

Forest-of-Thought:
Scaling Test-Time Compute for Enhancing LLM Reasoning
Acknowledgements
Besta, M., Blach, N., Kubicek, A., Gerstenberger, R., Pod- stawski, M., Gianinazzi, L.,, Gajda, J., Lehmann, T. Niewiadomski, H., Nyczyk, P., et al. Graph of thoughts: Solving elaborate problems with large language models. In Proceedings of the AAAI Conference on Artificial In- telligence, volume 38, pp. 17682-17690, 2024b.
We thank the anonymous reviewers for their insightful and constructive feedback, which greatly helped improve this work. We also gratefully acknowledge the support provided by MindSpore, CANN (Compute Architecture for Neural Networks), and the Ascend Al Processor used in this re- search.
Browne, C. B., Powley, E.,, Whitehouse, D., Lucas, S. M., Cowling, P. I., Rohlfshagen, P., Tavener, S., Perez, D., Samothrakis, S., and Colton, S. A survey of monte carlo tree search methods. IEEE Transactions on Computa- tional Intelligence and Al in Games, 4(1):1-43, 2012. doi: 10.1 100/TTTIAAG.22122221550
Impact Statement
The FoT framework introduces a novel and highly effi- cient approach to improving the reasoning capabilities of LLMs. By leveraging multiple reasoning trees, dynamic self-correction strategies, and mansensus-based decision- making, FoT enables LLMs to solve complex problems with higher precision and reduced computational cost. The key innovation lies in the adaptive reasoning process that al- lows the model to explore multiple paths, detect and correct errors in real-time, and efficiently narrow down the search space. This approach has significant implications for fields that require complex decision decision-making, such as mathemat- ies, logic, and AI-driven problem solving, leading to more robust and reliable Al systems.
Chaslot, G., Bakkes, S., Szita, I., and Spronck, P. Monte- carlo tree search: a new framework for game ai. In Proceedings of the Fourth AAAI Conference on Artifi- cial Intelligence and Interactive Digital Entertainment, AlIDE 08, pp. 216-217. AAAI Press, 2008.
Chen, W., Ma, X., Wang. X., and Cohen, W. W. Program of thoughts prompting: Disentangling computation from reasoning for numerical reasoning tasks. 2023. URL https: aaaaaaiiivvoooo org/abs////bbo.....ooo.o....... http://awwwio.ooo////////o/o 2211 12588.
Cobbe, K.,, Kosaraju, V., Bavarian, M., Chen, M.. Jun, H., Kaiser, L., Plappert, M., Tworek, J., Hilton, J., Nakano, R., Hesse, C., and Schulman, J. Training verifiers to solve math word problems, 2021a. URL https: / /arxiv. org/ hlg//bb//// www.s//sl.... 14168.
References
Achiam, J., Adler, S., Agarwal, S., Ahmad, L.,, Akkaya, I., Aleman, F. L., Almeida, D., Altenschmidt, J., Altman, S., Anadkat, S., et al. Gpt-4 technical report. arXiv preprint arXiv:2303.08774. 2023.
Cobbe, K.,, Kosaraju, V., Bavarian, M., Chen, M.. Jun, H., Kaiser, L., Plappert, M., Tworek, J., Hilton, J., Nakano, R., et al. Training verifiers to solve math word problems. arXiv preprint arXiv:21 10. 14 2021b.
AI-MO. Aime 2024.
https: WattaattsAA--Ae a mo iddtionnaaini 2024. Accessed: 2025-01-29.
co/
Ding, R., Zhang, C., Wang, L., Xu, Y., Ma, M., Zhang, W., Qin, S., Rajmohan, S., Lin, Q., and Zhang, D. Everything of thoughts: Defying the law of penrose triangle for thought generation, 2024. URL https: //arxiv. org/ abs//ab///// /bs.//31..02222
Amabile, T. M. A Theoretical Framework, pp. 65-96. Springer New York, New York. NY, 1983. ISBN
doi: 10.1007/
978- 1-4612-53333--844
URL https:/ / //tp/.oo...o/../////////o 1007/978-1 1111/9978-1-462-558888
Evans, J. S. T. Heuristic and analytic processes in reason- ing. British Journal of Psychology, 75(4):451-46 1984. doi: http:://oii http:://bbooog/001111///0444.889 09t.:/204444495..9888..10999551. URL.
Meta, A. Introducing meta llama 3: The most capable openly available Ilm to date. 2024. URL aattps://al. meta. wwwmcoocccccoooo oo/lg/////oo /tt///taaaaae 11ama-3/.
ibbary............ wiley.com. http:/.c//mm//////0/.11//1 -04492 1984.bb01915.x
Besta, M., Blach, N., Kubicek, A., Gerstenberger, R., Pod- stawski, M., Gianinazzi, L., Gajda, J.. Lehmann, T., Niewiadomski, H., Nyezyk, P., and Hoefler, T. Graph of thoughts: Solving elaborate problems with large language models. Proceedings of the AAAI Confer- 1762)))768217690, March 2024a. ISSN 2159-5399.
Flower, L. A cognitive process theory writing. Composi- tion and communication, 1981.
GLM, T., Zeng, A., Xu, B., Wang. B., Zhang, C., Yin, D., Zhang, D.,. Rojas, D., Feng, G., Zhao, H., Lai, H., Yu, H., Wang, H., Sun, J., Zhang, J., Cheng, J., Gui, J., Tang, J., Zhang, J., Sun, J., Li, Zhao L., Wu, L., Zhong, I.,, Liu, M., Huang, M., Zhang, P., Zheng, Q.
ence on Artificial Intelligence,
doi: 10.1609/ aaai. aani.v38i1...9970. URL http: /ttt:://ddxx /xxxxxdooa http:/dxxxddxoo//oooo/ org/10. 1609/ wwe.ei.vvii111 29720..
9

---

Forest-of-Thought: Scaling Test-Time Compute for Enhancing LLM Reasoning
Lu, R., Duan, S., Zhang, S., Cao, S., Yang, S., Tam, W. L., Zhao, W., Liu, X., Xia, X., Zhang. X., Gu, X., Lv, X., Liu, X., Liu, X., Yang. X., Song, X., Zhang, X., An, Y. Xu, Y., Niu, Y., Yang. Y. Li, Y., Bai, Y., Dong, Y., Qi, Z., Wang, Z., Yang, Z., Du, Z., Hou, 7., and Wang. Z. Chatglm: A family of large language models from glm-130b to glm-4 all tools. 2024. URL nttps://arxxt /wtpvv/axvvvvv.a///// org/ abs//406.... 12793.
Madaan, A., Tandon, N., Gupta, P., Hallinan, S., Gao, L., Wiegreffe, S., Alon, U., Dziri, N., Prabhumoye, S., Yang, Y., Gupta, S., Majumder, B. P., Hermann, K., Welleck, S., Yazzanbakhsh, A.. and Clark, P. Self-refine: Iterative refinement with self-feedback, 2023. URL https:// arxiv. org/ab. 2303. 17651.
Morris, J. X., Singh, C., Rush, A. M., Gao, J., and Deng, Y. Tree prompting: Efficient task adaptation without fine-tuning. 2023. URL htthhtss://aat http::://axxxx.orro/ 2310 14034.
Guan, X., Zhang, L. L., Liu, Y., Shang. N., Sun, Y., Zhu, Y., Yang, F., and Yang. M. rstar-math: Small Ilms can master math reasoning with self-evolved deep thinking, 2025. URL httph:tt///aatt //rxivv org/ abs/ 2501. 04519.
Nguyen, H. H., Liu, Y., Zhang, C., Zhang, T., and Yu, P. S. Cof-cot: Enhancing large language models with coarse- to-fine chain-of-thought prompting for multi-domain nlu tasks. 2023. URL https: http://axxvvv... org/ 2310. 14623.
Hendrycks, D., Burns, C., Kadavath, S., Arora, A., Basart, S., Tang, E., Song, D., and Steinhardt, J. Measuring math- ematical problem solving with the math dataset. 2021a. URL Btthttt::/// http///axvvvv//. org. abs / 03874.
Ning, X., Lin, Z., Zhou, Z., Wang, Z., Yang, H., and Wang, Y. Skeleton-of-thouggee Large language models can do parallel decoding. Proceedings ENLSP-III, 2023.
Hendrycks, D., Burns, C., Kadavath, S., Arora, A., Basart, S., Tang, E., Song, D., and Steinhardt, J. Measuring math- ematical problem solving with the math dataset, 2021b. URL httpt: /ttp:p::////xvvv//p/a orgg abs 2103 04.74.
OpenAL. Openai ol system card. 2024. Accessed: 2024-9- 12.
Sel, B., Al-Tawaha, A., Khattar, V., Jia, R., and Jin, M. Algorithm of thoughts: Enhancing exploration of ideas in large language models. 2024. URL https: //arxiv.. org/ abs/ 2200 10379.
Jinng, A. Q., Sablayrolles, A., Mensch, A., Bamford, C., Chaplot, D. S., de las Casas, D., Bressand, F., Lengyel, G., Lample, G., Saulnier, L., Lavaud, L. R., Lachaux, M.- A., Stock, P. Scao, T. L., Lavril, T., Wang, T., Lacroix, T., and Sayed, W. Mistral 7b. 2023. URL https: //arxiv. org/
Simon, H. A. The Architecture of Complexity, pp. 457-476. Springer US, Boston, MA, 1991. ISBN 978- 1-4899-0718 9. doi: 10. / //dpi.org///ii 1007
31. URL https:
Kahneman, D. Thinking, Fast and Slow. Harvard Library e- reader collection. Farrar, Straus and Giroux, 2011. ISBN
31.
9780141033570. URL htttp:://bolke google. com hom.hkk/booksid-AA/S55
Snell, C., Lec, J., Xu, K., and Kumar, A. Scaling I1m test- time compute optimally can be more effective than scal- ing model parameters. arXiv preprint 24iv:2408.033344 2024.
Kojima, T., Gu, S. S., Reid, M., Matsuo, Y., and Iwasawa, Y. Large language models are zero-shot reasoners. Ad- vances in neural information processing systems, 35: 22199-22213, 2022.
Srinivas, N., Krause, A., Kakade, S. M., and Seeger, M. W. regret bounds for gaussian process optimization in the bandit setting. IEEE Transactions on Information Theory, 5855) May 2012. ISSN URL http:
Kojima, T., Gu, S. S., Reid, M., Matsuo, Y., and Iwasawa, Y. Large language models are zero-shot reasoners. 2023. URL https: //tpxv/avvvv//////////eee/aawvv. org/ abs 220. 11916.
1557-9654. doi: 10.11009ti.2001112182200 //dx. doix.doi.o. org 10. 110.1111990 www111199111.. 2T11://T11I11111111222222 2182033.
Li, C., Liang, J., Zeng, A., Chen, X., Hausman, K., Sadigh, D., Levine, S., Fei-Fei, L., Xia, F., and Ichter, B. Chain of code: Reasoning with a language model-augmented code emulator. 2024. URL https: /tttpp:///rxiv... //wxxvv.ogggg/////o abs/2312.042 044744
Touvron, H., Lavril, T., Izacard, G., Martinet, X., Lachaux, M.-A., Lacroix, T., Rozière, B., Goyal, N., Hambro, E., Azhar, F., et al. Llama: Open and efficient foundation lan- guage models. arXiv preprint arXiv:2302. 1397 2023.
Wang, X., Wei, J., Schuurmans, D., Le, Q., Chi, F.,, Narang, S., Chowdhery, A., and Zhou, D. Self-consistnncy im- proves chain of thought reasoning in language mod- els. 2023. URL https: /arxivi.... org/ abs/ 2203. 11171.
Lightman, H., Kosaraju, V., Burda, Y., Edwards, H., Baker, B., Lee, T., Leike, J., Schulman, J., Sutskever, I., and Cobbe, K. Let's verify step by step, 2023. URL https: a/a farxiv. org.orgaaa www.:orgg/bbsssse 20050.
10

---

Forest-of-Thought Scaling Test-Time Compute for Enhancing LLM Reasoning
Wei, J., Wang, X., Schuurmans, D., Bosma, M., Xia, F., Chi, E., Le, Q. V., Zhou, D., al. Chain-of- prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824-24888 2022.
Yang, I.., Yu, 7.,, Zhang, T., Cao, S., Xu, M., Zhang, W., Gonzalez, J. E., and Cui, B. Bufter of thoughts: Thought- augmented reasoning with large language models. 2024. URL www.thtps//.mm wttpaaixvvv.oo//..//aa org/ absaa/s/22/00 04271.
Yao, S., Yu, D., Zhao, J.. Shafran, I., Griffiths, T., Cao, Y., and Narasimban, K. Tree of thoughts: Deliberate problem solving with large language models. Advances in Neural Information Processing Systems, 36, 2024.
Zhang, D., Huang, X., Zhou, D., Li, Y., and Ouyang, W. Accessing gpt-4 level mathematical olympiad solutions via monte carlo tree self-refine with Ilama-3 8b. 2024. URL https: /tap::://axxxe aaaiiviiii...//..//.aaaa.aaiaavv org/ abs/2406 07394.
Zhang, Z., Zhang, A., Li, M., and Smola, A. Auto- matic chain of thought prompting in large language mod- els. 2022. URL http::tp////o 03493.
2210..
Zhao, R., Li, X., Joty, S., Qin, C., and Bing, L. Verify- and-edit: A Knowledge-enhanced chain-of-thought frame- work. 2023. URL https: //tp://axxiii org/ abs/ 2305. 03268.
Zhou, D., Schärli, N., Hou, L., Wei, J., Scales, N., Wang, X., Schuurmans, D., Cui, C.,, Bousquet, O., Le, Q., and Chi, E. Least-to-most prompting enables complex reasoning in large language models. 2023. URL https: : / arxiv. org //g//bb/// 2205. 10625.

---

Forest-of-Thought: Scaling Test-Time Compute for Enhancing LLM Reasoning
A. Example Prompts Game of 24
Table Game of 24 Value Prompt
In the 24-point game, we have designed three types of prompts to guide the problem-solving process:
Value Prompt:
Evaluate if given numbers (sure/iikeylimpossibee)
can
reach 24
1. Propose Prompt:
This prompt is intended assist players in breaking down the original problem in the first step. It guides players select two numbers from the given four for calculation, thereby simplifying the problem to the remaining two unused numbers.
See <<Example>> See Table 8 </Examples> Input: '4 + = (left: 6 10
Response:
impossible
Value Prompt:
Evaluate if given numbers
reach 24
2. Step-2 Prompt: Based on the result of the first step, this prompt further guides players to choose two num- bers from the remaining three for caleulation, ulti- mately simplifying the problem to just one number left.
(sure/likelyimpossibl))
See <Examples>> See Table 8 </Examples>> Input: '4- 10 = (left: -)
Response:
sure
3. Value Prompt: This prompt is used to score each step's response, ensuring that each solution is both reasonable and efficient.
Table Game of Step-2 Prompt
Step-2 Prompt:
Provide three integers as input. Randomly pick full permutations of the input numbers, perform all four basic arithmetic operations (addition, subtraction, multiplication and division), and list the results and remaining integers after each operation.
Table 5. Game of 24 Propose Prompt
Propose Prompt:
Let's play game called 24. You'll be given four integers, and your objective is to use each number only once, com- bined with any of the four arithmetic operations (addition, subtraction, multiplication, and division) and parentheses, to achieve a total of 24.
See <Examples>> See Table 8 (Step-2 Prompt) </Exam- ples>
Input: 6
Provide four integers as input. Randomly pick 2 full permutations of the 4 input numbers, perform all four basic arithmetic operations (addition, subtraction, multiplication and division), and list the results and remaining integers after each operation.
Possible next steps:
Response:
-6 + 5 -1 (left: -1)
5 6 = 30 (left: 30)
-6/ =1.2 (left: 5 -1.2)
See <Examples> See Table 8 (Propose Prompt) </Exam- ples>>
6 5 1 (left:
5 6 -1 (left: -1 5)
Input:
'456 10'
Possible next steps:
Response:
This mechanism is designed to enhance the quality of the answers generated by the model. The self-correction prompt operates in two stages: first, it assigns score to the gener- ated answer based predefined evaluation criteria, such logical consistency, accuracy, and relevance. Then, de- pending on the score, the model is prompted to revise or correct its answer if the evaluation indicates potential flaws or suboptimal reasoning.
4 5-5 9 (left: 6 10 9),
10 - 4 6 (left: 6 6),
5-6 -1 (left: -1 4 10),
4 6 24 (left: 54.5 10),
10/5 = (left: 2 6),
4-10 -6 (left: -65 6),
5-4 = (left:
10),
10 5 = 5 (left: 5 6)
By iteratively refining its output, the model learns to identify errors and generate more accurate and coherent responses, This approach not only improves the reliability of the results but also provides structured framework for integrating feedback into the reasoning process. The experiments sum- marized in Table 10 demonstrate that the self-correction prompt significantly enhances the model's performance across various tasks, reducing eттоr rates and improving overall answer quality. This highlights the potential of
B. Example Prompts- GSM8K and MATH
We present the prompts utilized for the GSM8K task, since the prompts for the MATH task are essentially the same, with only minor variations in how answers are extracted. In Table 10, we present the results of incorporating a self- correction prompt mechanism into the reasoning process.
12

---

Forest-of-Thought: Scaling Test-Time Compute for Enhancing LLM Reasoning
Table 8. Game of 24 problem decomposition example.
Table 2. Game of 24 value examples.
Propose Prompt
Value Prompt
< Examples >>
<Examples >
Input: 2 8 8 14
Input: 4 10 30
Possible next steps:
(30 + 4) 10 = 24
2 + 8 = 10 (left: 10 14)
sure
8 (left: 4 14)
Input: 4 11 9+ 11 4 20 4 24
14 2 16 (left: 8 8 16)
2 8 16 (left: 8 14 16)
sure
2 = 6 (left: 6 6 14)
Input: 578
2-8 = -6 (left: -6 8 14)
= (8 (8- 7=3*7=2
14 8 = 6 (left: 26
14 7 (left: 8)
cannot obtain 24 now, but numbers are within reason- able range
14 2= 12 (left: 8 12)
2 * =4 (left: 8 8 28)
likely
< /Examples>
Input: 566
Step-2 Prompt <Examples >
6+6+ 6- 17
(6- 6= 1 6
Input: 2 888 8
cannot obtain 24 now, but numbers are within reason- able range likely
Possible next steps:
2 = 10 (left: 10)
8/2 (left: 4 8)
Input: 10 10 11 10 10 11 =
2 8 16 (left: 8 16)
2 6 (left: 6 8)
(11 10) 10 = 10
8-8 = -6 (left: -6 8)
10 10 10 are all too big impossible Input: 133
</Examples>
Algebra Check
Input: 8 10
1*3 * 3
Output: 8 10 = 18
(1+3) * 3= 12
133 are all too small
8- 10 -2
impossible
8 10 80
Input: -1 17
80 0.8 impossible
(-1 + 7) 4 24
sure
Input: 30 30 4 10 24
</Examples>
self-correction as a powerful tool for boosting reasoning robustness in complex scenarios.
C. Evaluating the Scaling of FoT Compute Across Different Baseline Methods.
In Table 11, introduce prompt mechanism designed for expert selection, aimed at further refining the model's outputs in scenarios involving multiple plausible answers. When multiple answers align with majority consistency, a mathematics expert evaluates these responses based on domain-specific knowledge and selects the most appropriate or optimal answer.
Tabel 6 demonstrate clear trend: as the number of acti- vated subtrees grows, the error rate decreases, reflecting the enhanced reasoning capability and robustness of the FoT approach. The scaling law comparison across various meth- ods underscores the efficiency of FoT in utilizing additional computational resources, particularly when contrasted with other models that exhibit diminishing returns or slower er- ror reduction as complexity increases. This suggests that the FoT framework scales more effectively with increased subtree activation, making it a powerful tool for addressing challenging reasoning tasks like those in GSMSK.
This approach leverages expert judgment ensure the final selected answer not only adheres to logical consistency but also aligns with mathematical rigor and best practices. By integrating expert selection into the prompt design, we en- hance the reliability and precision of the model's 's reasoning process.
13

---

Forest-of- :hesuhoo-Thhoghh:: Scaling Test-Ting Time Compute for Enhancing LLM Reasoning
0.28
0.24
L(z) = (2/(1.8 10 -)-
0.20
L(m) (my/(100 10-1
0.24
0.12
0.20
0.08
0.16
0.04
0.12
2
2²
2
2a
2
29
2
2
2
2
Zero- Zero-Shot-CoT
MCTSr (one turn self refine)
0.12
0.12
L(m²) = (my/(7.99 (7.98 10 10-3)) -0000 0.06
L(mg) = (mg/(4.12 10-3))-0.00
0.08
0.04
0.04
23
24
20
24
MCTSr (4-rollouts)
MCTSr (8-rollouts)
Figure 6. The comparison of the scaling laws for FoT different methods feg.zero-shot-cot, MCTSr (one-tum-self-refinn) 4-rollouts MCTSr, 8-rollouts MCTSr) is presented, with the x-axis representing the number of activated subtrees within the FoT framework and the y-axis indicating the error rate on the GSM8K benchmark dataset.
Table 10. Self-Coreccton Prompt
Table II. Math Expert Prompt
Value Prompt:
Math Expert Prompt: "You highly specialized mathematics expert, proficient in solving mathematical problems, and always able to select the most accurate answer from the given options.
Question: {question}
Answer:(answer.
Analyze this answer Strictly and Critic. point out every flaw for ervery possible imperfect to minus every possible score! You need to be very harsh and mean calculating grades, and never give full marks ensure that the marks are authoritative. Output score between [0, ig. from 0 to 100. Response format:| format:[Analyann (Soocs)
Question: (question)
Answers: (answers. list}
Which of the following answers is the most accurate? The
response should begin with <ans format>."
Celf-Correction Prompt:
"Question: {question}
Please refine the your answer according your Reflec- tion or Feedback. The response should begin with [rea- soning (Varffss... and end with end with <ans format> Let's think step by step."
flicting answers. The "Random" strategy selects an answer randomly from all candidates, while the "Score" strategy chooses the answer with the highest confidence score. Ex- perimental results on the GSM8K benchmark show that FoT's reflective decision- makinn achieves higher accuracy than both baselines, highlighting the effectiveness lever- aging internal reflection over simple voting or scoring.
D. Evaluating multiple FoT decision-making methods.
Figure 12 compares different decision- Decision-making strategies used in FoT when multiple reasoning trees produce con-
14

---

Forest-of-Thought: Scaling Test-Time Compute for Enhancing LLM Reasoning
Table 12. FoT decision-making comparison.
Method
Accuracy
Random 77.73
Score 77.86
CGED
78.62
E. Evaluating the threshold value in dynamic self-correction.
In Table 13, evaluate the impact of the self-correctin mechanism by conducting experiments at different con- fidence threshold levels. We systematically adjusted the threshold and observed the model's 's performance in terms of accuracy. Our findings revealed that when the threshold was set to 0.5, the model achieved significantly better ac- curacy compared to other threshold values. This suggests that threshold of 0.5 strikes optimal balance, enabling the model to identify and correct errors without being too cautious or too lenient in its self-assessment.
Table The accuracy performance the dynamic self- correction strategy with different thresholds on the GSM8K dataset.
Threshold
Accuracy
0.3
87.34
0.4
88.17 17
0.5
90.14
0.6
88.02
15


Reviews:
[{"review_id": "koUdfKJjPv", "reviewer": "Reviewer_Z6BW", "summary": "This paper presents Forest-of-Thought, a reasoning framework designed to enhance the reasoning of LLMs. FoT integrates multiple reasoning trees to leverage collective decision-making for solving complex logical problems. It employs sparse activation strategies to select the most relevant reasoning paths, improving both efficiency and accuracy. Experimental results demonstrate that FoT can significantly enhance the reasoning performance of LLMs.", "questions": "", "limitations": "", "rating": 5, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We are grateful for your time and thoughtful suggestions, which will guide us in improving both the framework and its implementation in future iterations. Below please find the responses to some specific comments.\n\n---\n**Weakness 1: Computation Efficiency Compared to Single-Path Reasoning.**\n\n**A1:** We appreciate your valuable feedback regarding the computation efficiency of FoT compared to single-path reasoning. While activating multiple subtrees does increase computational overhead, FoT mitigates this by selectively focusing on the most relevant paths, rather than exhaustively exploring all possible paths. Compared to methods that rely on repeated reasoning and averaging results, FoT enhances efficiency by selectively activating only the highest-scoring paths. This selective activation helps maintain or even improve accuracy while reducing computational costs. We will continue optimizing the FoT framework to further improve inference efficiency.\n\n---\n\n**Weakness 2: Generalization and Use of FoT.**\n\n**A2:** We understand that the complexity of the framework, which includes multiple reasoning trees, dynamic correction, and consensus strategies, may pose implementation challenges for other developers. To mitigate this, we have designed the framework to be modular and well-documented. Furthermore, we are committed to offering continuous support and improving the framework's usability in future updates. With comprehensive documentation and detailed examples, we are confident that developers will be able to implement and adapt the framework efficiently.\n\n---", "claims_and_evidence": "The paper claims that FoT can enhance the reasoning of LLMs by integrating multiple reasoning trees and employing sparse activation strategies. Figure 1 shows that FoT achieves the 40%+ accuracy gain over ToT on the Game of 24 benchmark.", "methods_and_evaluation_criteria": "The paper compares the proposed method against the recent test-time reasoning methods. The evaluation and the results make sense, making it convincing.", "theoretical_claims": "There is no theoretical proof in this paper.", "experimental_designs_or_analyses": "The experiments are well organized, evaluating FoT on the diverse benchmarks, comparing against other test-time reasoning (e.g, CoT, ToT, BoN). Additionally, the method is tested on multiple LLM models to demonstrate its generalizability.", "relation_to_broader_scientific_literature": "The work builds on existing LLMs and tree-based reasoning methods, addressing their limitation of relying a single reasoning path. Deeper discussion with other reasoning frameworks could further clarify its contribution.", "essential_references_not_discussed": "No.", "other_strengths_and_weaknesses": "Strengths:\n- FoT offers a new approach for reasoning by integrating multiple reasoning trees, making it can explore diverse reasoning paths and improve decision-making accuracy.\n- The proposed sparse activation strategy allows FoT to focus on the most relevant reasoning paths, reducing unnecessary computations and improving efficiency without sacrificing accuracy.\n- The framework can be integrated with different LLMs, demonstrating its generalizability across models and datasets.\n\nWeaknesses:\n- While FoT improves efficiency through sparse activation, the overall computational cost may still be higher compared to single-path reasoning methods, when it activates multiple btrees. Please clarify this issue.\n- I have a concern about implementation. The framework's complexity, involving multiple reasoning trees, dynamic correction, and consensus strategies, could make implementation challenging for other developers.", "other_comments_or_suggestions": "None", "questions_for_authors": "None", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "R7VMU8Aq2k", "reviewer": "Reviewer_zTLg", "summary": "This paper proposes Forest-of-Thought (FoT), a new reasoning framework designed to enhance reasoning ability during test time by combining multiple reasoning trees. This method introduces three strategies (i.e., sparse activation, dynamic self-correction, and consensus-guided decision-making) to enhance both performance and efficiency. Additionally, this paper explores FoT based on two methods, namely ToT and MCTSr. Experiments across various benchmarks, including the Game of 24, GSM8K, and MATH, demonstrate that FoT significantly improves reasoning accuracy and efficiency, validating its effectiveness over existing methods.", "questions": "", "limitations": "", "rating": 4, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We sincerely appreciate the thoughtful and comprehensive feedback provided by our reviewers. We will now address the suggestions in detail.\n\n**Q1: Question 1: Data augmentation for the Game of 24 and supplementary experiments on MATH500 and GSM8K.**\n\n**A1:** The Game of 24 input consists of four numbers, and the model is sensitive to their order. Randomly altering the order encourages the model to approach the problem from different perspectives, increasing the number of reasoning paths and improving the accuracy of the solution. By exploring different permutations, the model can consider more possible calculations and solutions. Additionally, we conducted supplementary experiments on the MATH500 and GSM8K datasets. As shown in the table below, input enhancement is equally effective on both the MATH500 and GSM8K tasks.\n\n|               | **MATH500** | **GSM8K** |\n|---------------|-------------|-----------|\n| Without Enhancement | 92.8       | 89.6     |\n| With Enhancement    | 93.4       | 92.1     |\n\n---\n\n**Q2: Question 2: Ablation experiments on predefined rules in GSM8K and MATH500.**\n\n**A2:** In the math testing tasks such as Math500 and GSM8K, unlike the direct expression computation in Game24, our predefined rules primarily involve checking the correctness of basic operation results added within the text prompts. Therefore, we conducted the following ablation experiments based on Deepseek-R1-Distill-Qwen-7B.\n\n|               | **MATH500** | **GSM8K** |\n|---------------|-------------|-----------|\n| Without Predefined Rules | 92.8       | 89.6     |\n| With Predefined Rules    |  93.1   |     91.7       |\n\n---\n\n**Q3: Weakness 1: Provide a more detailed complexity analysis and comparison of FoT with other methods.** \n\n**A3:** We conducted multiple rounds of LLM calls for various methods to compare performance. Despite increasing the number of calls, accuracy showed minimal improvement. As shown in the table, even with a similar number of reasoning steps, FoT consistently outperforms other methods in accuracy. For example, FoT (n=4, b=5) achieves 96.8% success, while BoT (n=8) and XoT (w/ 3 r) (n=8) achieve 83.2% and 87.6%, respectively. This shows that, despite more LLM calls, FoT delivers higher accuracy, demonstrating its efficiency in producing quality reasoning results.\n\n\n| **Method**  | **Average number of LLM calls** | **Success** |\n|-----------------------|-----------------|-------------|\n| IO (n=2)   | 20.0       |  10.2%    |\n| CoT (n=2)   | 20.0       |  4.4%    |\n| ToT (b=5)  | 13.7      |74.0%  |\n| ToT (b=8)  | 26.3       |78.9%  |\n| BoT (n=8) |  24.0    | 83.2%   |\n| XoT (w/ 3 r) (n=8) |  31.36    | 87.6%   |\n| FoT (n=3, b=5)   | 23.64      | 91.6%  |\n| FoT (n=4, b=5)   | 25.64       | 96.8%  |\n\n---\n\n\n\n**Q4: Weakness 2: Replace Figure 6 with a table.** \n\n**A4:** We appreciate the reviewer’s constructive feedback on improving the manuscript. We will revise this into a table format in the final version.\n\n---\n\n**Q5: Question 3 & Weakness 3: Experimental results of FoT without self-correction in Table 1.** \n\n**A5:** I would like to clarify a point in the 'Results' section of Section 4.2. When FoT does not use the three strategies, it defaults to the Best of N (BoN) method. The experiment starts with BoN, directly applying the ToT framework without input enhancement, sparse activation, or self-correction. In tasks like the Game of 24, based on ToT, the outcome of each step greatly influences subsequent reasoning. Therefore, self-correction at each step is critical. If a basic computational error occurs, further steps become meaningless. We will provide clearer descriptions in the table captions in the final version to explicitly state that the BoN method is equivalent to FoT without the three strategies.\n\n---", "claims_and_evidence": "Yes. The claims made in the submission are supported by clear and convincing evidence.", "methods_and_evaluation_criteria": "Yes.", "theoretical_claims": "Yes, I think they have no issues.", "experimental_designs_or_analyses": "Yes, I checked. I think they have no issues.", "relation_to_broader_scientific_literature": "The key contributions of the paper build upon and extend prior work in reasoning frameworks, particularly in relation to Tree-of-Thought (ToT) and Monte Carlo Tree Search (MCTS). The Forest-of-Thought (FoT) approach integrates multiple reasoning trees, enhancing accuracy and efficiency through strategies like sparse activation, dynamic self-correction, and consensus-guided decision-making.\n\n\nIn comparison to ToT and MCTS which focuses on a single tree-based reasoning process, FoT generalizes this idea by incorporating multiple trees to improve robustness and performance.", "essential_references_not_discussed": "To the best of my knowledge, there are no essential related works that are missing from the citations or discussion in the paper.", "other_strengths_and_weaknesses": "Strengths: \n\n(1) This paper introduces a forest structure that integrates multiple reasoning paths by designing sparse activation, dynamic self-correction, and consensus-guided decision-making to enhance the reasoning accuracy, efficiency, and robustness of large language models (LLMs) in complex problem-solving tasks.   \n(2) This paper explores FoT on two frameworks, i.e., Tree of Thought and Monte Carlo Tree Search, and it shows an improvement compared with baseline.     \n(3) Experimental results demonstrate the effectiveness of FoT significantly improving the results on Game of 24, GSM8K and MATH.\n\n\nWeakness:\n\n(1) Please provide a more detailed complexity analysis and comparison of FoT with other methods.   \n(2) Figure 6 would be more intuitive if presented in a table format.     \n(3) Table 1 lacks a baseline of FoT, i.e., without self-correction.", "other_comments_or_suggestions": "I don't have other comments.", "questions_for_authors": "(1) The authors enhance the input to obtain different starting nodes for the reasoning trees and discuss the effectiveness of this approach in Table 1. However, for the Game of 24, where the input consists of only four simple numbers, how is the input enhanced? Additionally, I am curious about ablation experiments on input enhancement for more complex problems, such as MATH or GSM8K.  \n(2) Section 3.2 emphasizes that this method integrates pre-defined rules to improve accuracy, but it lacks ablation experiments in this regard. In addition, how are the pre-defined rules defined when testing on the GSM8K and MATH benchmarks？  \n(3) Table 1 lacks a baseline where FoT is evaluated without the three strategies, making it difficult to assess the importance of self-correction. This makes me wonder whether the improvement primarily comes from the forest structure itself or from the self-correction mechanism", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "xtZFmoLooS", "reviewer": "Reviewer_JDic", "summary": "This paper presented the Forest-of-Thought (FoT) to extend the former CoT and ToT via integrating multiple reasoning trees and making majority vote, and to avoid the computation complexity of building numerous trees and further improve the performance, the paper employed a set of sparse activation and self-correction approaches to select more possible paths. Empirical results showed the effectiveness of the proposed FoT.\n\n## update after rebuttal\nDuring the rebuttal and discussion phases, I have read all the responses from the authors carefully, there are still two major concerns remaining:\n1. This paper proposed to exchange the efficiency for performance, and such a trade-off leads the FoT to outperform previous CoT-variation with more computing cost, while underperforming the more advanced reasoning LLMs, making its applicability ambiguous.\n2. The sparse activation algorithm is quite important for understanding the pruning process of the FoT, and I have asked for the details in all rounds of rebuttal and discussion, but haven't accessed it. \n\nGiven the above unaddressed concerns, I prefer to hold my previous overall recommendation (weak reject) for this paper.", "questions": "", "limitations": "", "rating": 2, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "Thank you for your thoughtful comments and valuable suggestions. We appreciate the time spent evaluating our work, and we have carefully considered each of your points. Below are our responses to the concerns and suggestions raised.\n\n---\n\n**Question 1 & Suggestion 2: FoT's performance varies with different numbers of reasoning trees.**\n\n**A1:** As the number of reasoning trees increases, the model's accuracy improves through evaluating multiple paths, as shown in Figure 3. The accuracy gains follow a scaling law, with improvements slowing down as the number of subtrees increases. We also conducted experiments on the computational costs of different subtrees in the AIME task, using the Deepseek-R1-Distill-Qwen-7B on the v100 GPU. The results show that while accuracy increases with more subtrees, the computational cost does not increase exponentially. Additionally, we included experiments on the Game of 24 task's computational cost, as requested by Reviewer 4's Q1. These experiments demonstrate that FoT sacrifices increased inference time for higher accuracy.\n\n| **Subtree Nums** | **AIME Acc** | **Time (s)** |\n|------------------|--------------|--------------|\n| 1                | 53.33        | 13659.63   |\n| 2                | 56.67        | 25014.82  |\n| 4                | 66.66        | 25894.76  |\n\n---\n\n\n**Q2: The decision strategy when the results of the subtrees are inconsistent.**\n\n**A2:** As described in Section 3.3, when FoT cannot reach a consensus among the multiple reasoning trees, it synthesizes the results and reflects on the different reasoning paths. This approach improves accuracy by considering multiple possibilities and enhancing robustness, without depending on a single path. Experiments show that, after reconsidering all answers, FoT yields more accurate results than random selection or scoring-based methods.\n\n| **Decision Method**  | **Accuracy**  |\n|----------------------|---------------|\n| Random               | 77.73         |\n| Score                | 77.86         |\n| Re-thinking (CGED)   | **78.62**   |\n\n---\n\n**Q3: Suggestion 1 & Weakness 3: Provide additional details on the sparse activation strategies.**\n\n**A3:** Sparse activation focuses on activating the most promising paths during inference, rather than exploring all possible reasoning paths. This approach ensures accuracy while reducing computational resource consumption. The strategy improves computational efficiency by focusing on the most likely reasoning paths. The framework scores each path, activating those with higher scores and discarding the rest. We will include more detailed steps in the final version.\n\n**Q4: Weakness 1: The practicality of FoT in low-computation scenarios.**\n\n**A4:** FoT is well-suited for handling problems that involve complex logic and require detailed reasoning. By activating multiple reasoning paths simultaneously, FoT can explore problems from different perspectives and logical levels. This approach is particularly effective for solving complex scenarios that single-path methods fail to cover comprehensively. We appreciate your suggestion and are continually optimizing the framework to enhance the efficiency of thoughtful reasoning, making it suitable for low-computation scenarios.\n\n\n\n**Q5: Weakness 2: Compare the computation cost of FoT and other baselines.**\n\n**A5:** Table 2 compares the performance of FoT with other baselines in terms of accuracy and computational cost (measured by \n Average LLM calls). In addition, we supplemented experiments in response to Reviewer 2(zTLg)'s Q3, where we conducted multiple rounds of LLM calls for various methods. These results demonstrate that FoT achieves higher accuracy, even with more LLM calls, showcasing its efficiency in producing high-quality reasoning results.\n\n\n\n\n\n**Q6: Weakness 3: Theoretical justification for the sparse activation strategy.**\n\n**A6:** Sparse activation focuses on the most promising paths during inference, rather than exploring all paths. This improves accuracy while reducing computational resources. The framework scores each path, activating the highest-scoring ones and discarding the rest. We will provide more details in the supplementary materials. \n\n\n\n\n**Q7: Weakness 4: Experiments on other subjects.**\n\n**A7:** Thank you for your valuable suggestion. We have conducted additional experiments on FoT with the general task CEVAL and the coding task LiveCode. FoT demonstrated a 6% improvement on the general test set and a noticeable gain on the coding task. We will continue to enhance the framework's adaptability to other subjects in future versions.\n\n| Method|**CEVAL** |**LiveCode**| \n|--------------|-----------|---------------|\n| DeepSeek-R1-Distill-Qwen-7B|89.6|37.6| \n| FoT (N=4)|92.5|38.2 | \n\n---\n\n**Q8: About essential references not discussed.**\n\n**A8:** We believe it is important to consider these relevant references. We will further explore the methods outlined in them in our future work to enhance our approach.\n\n---", "claims_and_evidence": "The claims made in this work are all supported by the following experimental evidence.\n\nThe proposed method and evaluation criteria are reasonable for the research purpose.", "methods_and_evaluation_criteria": "The evaluation settings are common in similar research works and match the method.\n\nThere were no theoretical claims in the paper.\n\nThe experimental results are sound and seem to be reproducible.\n\nI have reviewed all the supplemental materials of this paper.", "theoretical_claims": "This paper conducted extensive experiments and analyzed results to prove superiority, but didn’t provide theoretical derivatives.", "experimental_designs_or_analyses": "I have checked the experimental designs and the results analysis.\n\nThe comparison experiments with CoT, ToT, BoT, and MCTS methods, the experimental settings are fair. \n\nHowever, the authors didn't clarify the computation cost as FoT test-time scaling up, which might consume more computation resources.", "relation_to_broader_scientific_literature": "This work discussed several related works like CoT, ToT, and GoT, as they are quite similar. This work extended the ToT, which is one single reasoning tree, to the forest of multiple reasoning trees, which is an interesting variation.", "essential_references_not_discussed": "Some related works had not been discussed in the paper.\n\n1. Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters.\n\n2. Improving LLM Reasoning through Scaling Inference Computation Time with Collaborative Verification.\n\n3. Large Language Monkeys: Scaling Inference Compute with Repeated Sampling.", "other_strengths_and_weaknesses": "Strengths:\n\n1. Integrating multiple reasoning trees with sparse activation enhances the accuracy and efficiency.\n\n2. The experiments for the proposed method and other baselines demonstrate the effectiveness.\n\n3. The LLMs employed in this work are quite enough, showing the superiority of the FoT.\n\nWeaknesses:\n\n1. Building multiple reasoning trees is essentially a test-time solution search method, demanding lots of computation resources, not applicable for low-computation scenarios.\n\n2. This work didn’t compare the computation cost of FoT and other baselines, making solely an accuracy performance comparison that is less fair.\n\n3. Lacking theoretical justification for the sparse activation strategy.\n\n4. All experiments were conducted on math problem solving tasks, limiting the generality for other tasks such as coding, logic, and reasoning for other subjects.", "other_comments_or_suggestions": "1. The authors could offer detailed explanations for the sparse activation strategies, especially how it chooses more plausible paths.\n\n2. This paper could present a simple computation/cost ratio to make the performance comparison more fair and better for illustrating the effectiveness of the proposed strategies.", "questions_for_authors": "1. How does FoT perform under different numbers of reasoning trees?\n\n2. What if we conduct the FoT on other tasks that consensus among all trees is not accessible?", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "SyjJOGIcds", "reviewer": "Reviewer_SoHo", "summary": "The paper introduces the Forest-of-Thought framework, a novel approach to enhance LLM reasoning by integrating multiple reasoning trees. The key innovations include sparse activation strategies, dynamic self-correction, and consensus-guided decision-making. Experiments suggest that FoT improves accuracy and efficiency in reasoning tasks like MATH.\n\n\n\n\n## ========update after rebuttal======\nThanks for the authors' responses. My concerns have been well addressed.", "questions": "", "limitations": "", "rating": 4, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We appreciate the reviewers' careful reading and valuable comments. We believe these constructive feedback will help improve the paper. Below are responses to some specific comments.\n\n---\n\n**Q1:  Weaknesses1: Detailed analysis of cost-accuracy trade-off compared to ToT.**\n\n**A1:** Thank you for your insightful suggestion. We have included experimental results comparing the cost-accuracy trade-off between FoT and ToT, tested on the v100 GPU:\n\n| Method                | Game24 Accuracy (%) | Cost Time (s) |\n|-----------------------|---------------------|---------------|\n| ToT (b=5)            | 56.3                | 412.2         |\n| ToT (b=8)            | 74.7                | 504.6         |\n| ToT (b=16)           | 75.3                | 567.6         |\n| ToT (b=32)           | 76.8                | 664.5         |\n| FoT (n=2, b=5)       | 77.9                | 571.2         |\n| FoT (n=4, b=5)       | 91.6                | 709.2         |\n| FoT (n=8, b=5)       | 96.8                | 769.2         |\n\n---\n\n**Q2: Weaknesses 2: Supplementary experiments based on Deepseek-R1.**\n\n**A2:** Thank you for your valuable feedback on this manuscript. We present the results of FoT based on experiments with the DeepSeek-R1-Distill-Qwen-7B model across the GSM8K, AIME2024, and Math500 datasets. Further integrating the R1 model with the FoT framework led to improvements across different datasets: a 6% improvement over the baseline model on GSM8K, a 13.3% improvement on AIME2024, and consistent performance on Math500. These findings show that introducing multiple reasoning trees (n=4) enhances the model's reasoning capability and accuracy in problem-solving tasks.\n\n\n| Method       | **GSM8K** | **AIME 2024** | **MATH500** |\n|--------------|-----------|---------------|-------------|\n| DeepSeek-R1-Distill-Qwen-7B    |    89.6  |         53.3   |     92.8        |\n| FoT (n=4)    |  95.5   | 66.6         |      93.3       |\n\n---", "claims_and_evidence": "The paper claims that FoT’s multi-tree integration improves accuracy in complex reasoning tasks by collective exploration of diverse reasoning paths. These claims are supported by experimental results that FoT achieves higher accuracy (e.g., +10% over others) by aggregating multiple trees.", "methods_and_evaluation_criteria": "The proposed FoT framework improves the reasoning accuracy by integrating multiple reasoning trees, and reduces computational redundancy by pruning low-confidence reasoning paths via sparse activation. This aligns with the paper’s goal of balancing accuracy and efficiency. The evaluation criteria is consistent to the compared methods.", "theoretical_claims": "This paper does not involve theoretical proofs. Its insight can be supported by the ensemble algorithms.", "experimental_designs_or_analyses": "The paper evaluates FoT against other sota training-free reasoning frameworks, including CoT, ToT, and BoT, on diverse tasks such as mathematical reasoning (GSM8K), logical puzzles (Game of 24). Experiments employ different models like llama-3, glm-4 and mistral, with rich ablation studies.", "relation_to_broader_scientific_literature": "The method seems to be related to ensemble algorithms in machine learning, but there is much different details and innovations in the LLM field.", "essential_references_not_discussed": "N/A", "other_strengths_and_weaknesses": "Strengths: \n1. The motivation is clear, and the proposed framework makes sense. FoT’s multi-tree scheme and decision-making strategy offer a new perspective on scaling test-time compute, addressing the critical limitation of single-path reasoning in prior methods.\n2. The paper has demonstrated the superiority of FoT on rich benchmarks and models.\n\nWeaknesses: \n1. Although the paper proposes the sparse activation strategy, scaling to multiple trees might still incur significant overhead. The paper lacks a detailed analysis of cost-accuracy trade-off analysis compared to ToT.\n2. Since the proposed framework is training-free, it inherently offers better computational efficiency compared to training-dependent methods like DeepSeek-R1. To further strengthen the contribution, it would be valuable to include experiments exploring whether FoT could integrate with trained reasoning models like R1. I'm not sure whether it works, so I’m quite interested in the results. Thanks.", "other_comments_or_suggestions": "NA", "questions_for_authors": "See above.", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Meta-review: This paper proposes Forest-of-Thought, a reasoning framework designed to enhance the reasoning of LLMs for test time. FoT integrates multiple reasoning trees to leverage collective decision-making for solving complex logical problems. It employs sparse activation strategies to select the most relevant reasoning paths, improving both efficiency and accuracy. Experiments across various benchmarks, including the Game of 24, GSM8K, and MATH, demonstrate that FoT significantly improves reasoning accuracy and efficiency, validating its effectiveness over existing methods.

There are four review: three reviewers support accept of this work (two accept, one strong accept). One reviewer insists weak reject with most initial questions are solved. The AC has checked detailed discussion between reviewer and authors and made sure that the details of Sec.3.1 (sparse activation strategy) are clearly stated. In addition, the authors have provided code.

In the final version, the authors should add more explanations on this part.
Decision: Accept (poster)