Cumulative Reasoning with Large Language Models
Authors: Yifan Zhang
Jingqin Yang
Yang Yuan
Andrew C Yao
Venue: Accepted by TMLR ()

Abstract: Recent advancements in large language models (LLMs) have shown remarkable progress, yet their ability to solve complex problems remains limited. In this work, we introduce Cumulative Reasoning (CR), a structured framework that enhances LLM problem-solving by emulating human-like iterative and cumulative thought processes. CR orchestrates LLMs in three distinct roles---Proposer, Verifier(s), and Reporter---to systematically decompose tasks, generate and validate intermediate reasoning steps, and compose them into a solution by building a dynamic Directed Acyclic Graph (DAG) of verified propositions. This approach substantially enhances problem-solving capabilities. We demonstrate CR’s advantage through several complex reasoning tasks: it outperforms existing methods in logical inference tasks with up to a 9.3% improvement, achieving 98.04% accuracy on the curated FOLIO wiki dataset. In the Game of 24, it achieves 98% accuracy, marking a 24% improvement over previous methods. In solving MATH problems, CR achieves a 4.2% increase from previous methods and a 43% relative improvement in the most challenging level 5 problems. When incorporating a code environment with CR, we further harness LLMs’ reasoning capabilities and outperform the Program of Thought (PoT) method by 38.8%. The code is available at https://github.com/iiis-ai/cumulative-reasoning.

Published in Transactions on Machine Learning Research (07/2025)
Cumulative Reasoning with Large Language Models
Yifan Zhang"
w/amshaangresurckk@mmaal.cmm
III, Tsinghua University
Jingqin Yang"
yongiq81 (rngiig22emmmisss.iinnnuuuuuu crt
I1S, Tsinghua University
Yang Yuan
Swarayang@@tsiighuuee cdu.cc.
III, Tsinghua University Shanghai Qi Zhi Institute
Andrew C Yao I11, Tsinghve University Shanghai Qi Zhi Institute
cestrewcya@lssingghne edu.
Reviewed on OpenReview: https: // operreveew..eee... net/ forum? id- grW15p4eq2
//
Abstract
Recent advancements in large language models (LLMSs) have shown remarkable progress, their ability to solve complex problems remains limited. In this work, we introduce Cu- mulative Reasoning (CR), structured framework that enhances LLM problem-solving by emulating human-like iterative and cumulative thought processes. CR orchestrates LLMss in three distinct Dolss-Proposey Verificr(s), and Reporter- systematically docompose lasks, generate and validate intermediate reasoning steps, and compose them into a solu- tion by building dynamic Directed Acyelic Graph (DAG) of verified propositions, This approach substantially enhances problem-solving capabilities. We demonstrate CR's advan- tage through several complex reasoning tasks: it outperforms existing methods in logical inference tasks with up to a 9.3% improvement, achieving 98.04% accuracy the curated FOLIO wiki dataset. In the Game of 24, it achieves 98% accuracy, marking 24% improve- ment over previous mothods. In solving MATH problems, CR achieves 4.2% increase from previous methods and a 43% relative improvement in the most challenging level 5 problems. When incorporating a code environment with CR, we further harness LLMs' reasoning ca- pabilities and outperform the Program of Thought (PoT) method by 38.8%. The code is available at https://githuub.omm /iiis-ii/eiaia
cummlative-rrasonnnng http://..ooo..iiaaammmmattteerer
1 Introduction
Large language models (LLMs) have exhibited remarkable progress across wide range of applications De-
vlin et al. 2018 Radford et al. 2018 2019 Brown et al. 2020 Raffel et al. 2020 OpenAl 2023). Despite these advancements, LLMs continue to encounter significant challenges when tasked with solving problems that require intricate, multi-step reasoning and robust logical inference. For example, empirical studies have shown that LLMs often struggle to generate correct solutions for high school mathematics problems (Light- man et al. 2023 highlighting a persistent gap between intuitive language generation and rigorous problem- solving.
Inspired by Kahneman's 's dual-process theory KKhnnmaan 2011 which distinguishes between rapid, intuitive processing (System 1) and slower, deliberative reasoning (System 2), it becomes evident that current LLMs
"Equal contribution
i "oorreppondigg authors

---

Published in Transactions on Machine Learning Research (07/2025)
primarily operate in System 1 mode. This limitation restricts their capacity to engage in the systematic, stepwise reasoning necessary for complex tasks.
Recent developments such as Chain-of Thooghh (CoT) prompting (Wei et al. 2022) and Tree-of Treo-of-Thought (ToT) methodologies (Yao et al. 2023 Long 2023 have made significant strides by guiding LLMs through sequential and hierarchical reasoning processes. However, these approaches often lack robust mechanisms for dynamically storing, verifying, and cumulatively leveraging all validated intermediate results in flexible manner-a critical aspect of human cognition that enables crror-checking, iterative refinement, and the construction of complex arguments.
In this work, we introduce Cumulative Reasoning (CR), a reasoning method that characterizes a more holistic representation of the thinking process. CR orchestrates a symphony of three LLM roles the proposer, verifier(s), and reporter- to iteratively propose, validate, and compile reasoning steps into a comprehensive solution. This decomposition and composition strategy effectively transforms complex, multifaccted problems into series of manageable tasks, substantially enhancing the problem-solving capabilities of LLMs. CR's contributions include its structured, synergistic orchestration of these roles and its dynamic construction and utilization of a Directed Acyelic Graph (DAG) of validated reasoning steps. This cumulative DAG allows CR to build upon a growing, verified knowledge base specific to the problem instance, facilitating more flexible, robust, and complex reasoning pathways. Our evaluation spans three distinct. areas:
1. Logical inference tasks: our method demonstrates superior performance on datasets like FOLIO wiki and Auto with improvements of up to 9.3% and an outstanding 98.04% accuracy on curated version of the FOLIO dataset.
2. The Game of 24: we achieved 98% accuracy, marking 24% improvement over the existing state-of-the- method ToT (Yao et al. 2023 while using only about 25% visited states.
3. Solving MATH problems: our method establishes new benchmarks with a margin of 4.2% over previous methods (Fu al.) 2022 Zheng al.) 2023) without external tools. Noteworthy, our method achieves notable 43% relative improvements
the hardest level 5 problems (22.4% - 32.1%). Morcover, by integrating CR with a Python code environment absent external aids like retrieval systems, we achieve 72.2% accuracy on the MATH dataset, outperforming previous methods such as PoT (Chen et al.) 2022) and PAL (Gao et al.
2023 with 38.8% relative improvement and demonstrating the adaptability and robustness of CR across various complex tasks.
2 Background
In this section, we review the formal foundations of logic that underpin our approach and present an illus- trative example adapted from the FOLIO dataset (Han et al. 2022).
2.1 Logic
Propositional logic is the most basic formal system in logic. It is built from atomic propositions (e.g., p. q, r) and logical connoctives such as conjunction (A), disjunction (V), implication (=), and negation (-). In this setting, the truth values are denoted by the constants (true) and 0 (false). Fundamental laws of propositional logic include:
T - VV==E, 1Ax=E, OVH=2,
along with the absorption law:
(y(VVx) = x =
and the distributive laws:
x
(* =V
In any Boolean algebra, every element æ has a complement -x, which satisfies:
x VV =,
=-==
2

---

Published in Transactions on Machine Learning Research (07 (07/2025)
Extending this framework, first-order logic (FOL) introduces quantifiers to reason about collections of ob- jects. Universal quantification (V) and existential quantification (7) allow statements such as
Ve (Dog(z) Animal(x)).
which reads "for every 4, i is a dog, then an animal." In contrast, higher-order logic (HOL) permits quantification over functions and predicates, greatly increasing expressiveness. For detailed treatment of HOT, please refer to Appendix C.T.
2.2 Illustrative Example
To illustrate these concepts, consider example adapted from the FOLIO dataset, where only natural language statements (without explicit logical formulas) are provided as context. The premises are as follows:
1. All monkeys are mammals: Vo (Monkey(1) = Mammal(x:).
Every animal is either monkey or a bird: Va (Animal(x) = (Monkey(z) V Bird()))).
3. All birds can fly: Vr (Bird(z) = Fly(x)).
Anything that can fly has wings: Væ (Fly(æ) = Wings(æ)).
5. Rock is not mammal but is an animal: -Mammal(Roc)) A Anocal(Rock).
The question is: Does Rock have wings?
A rigorous derivation proceeds as follows:
The contrapositive of (1) gives:
Vr (-Mammal(x) -Monkey(z:)).
b. Combining (a) with (5) implies that Rock not a monkey while still being an animal.
3
Premise (2) then entails that Rock
must be either a monkey or a bird.
d. Since Rock not monkey (by step
Figure 1: An illustration of the logical derivation process.
(b)), it follows that Rock is bird.
c. From (3) and the conclusion that Rock a bird, we deduce that Rock can fly.
f. Finally, applying (4) to the fact that Rock can fly, we conclude that Rock has wings.
Although the derivation appears as linear sequence of steps from (a) to (f), its underlying structure is more naturally modeled as directed acyelic graph (DAG), where each edge represents an individual inference. This DAG structure better captures the cunulative and interdependent nature of the reasoning process.
3 Cumulative Reasoning
In this soction, we introduce our method, Cumulative Reasoning (CR), a structured framework that leverages collaborative process among specialized Large Language Models (LLMs) to address complex problem- solving tasks. Unlike conventional methods that generate linear chain of thought, CR decomposes problem into manageable sub-tasks and incrementally builds a solution by cumulatively accumulating and verifying intermediate reasoning steps.
This approach is inspired by human cognitive processes that involve iterative refinement and building upon established knowlodge, as well as principles from intuitionistic logic and mathematical constructivism which emphasize the constructive nature of proofs built from validated steps (Troelstral 1973). CR aims opera- tionalizes these principles for L.M--bsed reasoning.
3

---

Published in Transactions on Machine Learning Research (07 (025)
CR orchestrates three distinct roles:
1. Proposer:
Generates candidate reasoning steps based the current context, thereby initiating
each cycle of reasoning.
Verifier(s): Critically assess and validate the proposer's suggestions. The Verifier's conceptual role is ensure logical soundness. In practice, this can be implemented by another LLM instance (acting as self-critique mechanism) or, ideally, by more formal methods such as symbolic reasoning integrated code environment (e.g.; Python interpreter for mathematical or arithmetical validation). Only verified steps are added to the DAG.
systems (e.g., theorem prover)
Reporter: Monitors the evolving state of accumulated reasoning and determines the optimal mo- ment conclude the process, outputting the definitive solution once sufficient validated information has been gathered.
Figure 2aureepreeee provides an overview of the CR process. As the figure illustrates, CR iteratively refines a solution by progressively integrating validated propositions into the reasoning DAG. While all roles be instantiated by the same underlying LLM distinguished by role-specific prompts (see Appendix F for detailed examples of prompts and role interactions), the Verifier can also be an external tool. This division of labor aims to overcome limitations of monolithic LLM outputs, where generation and verification are conflated. The specific contribution of each role is crucial: the Proposer explores, the Verifier ensures reliability, and the Reporter synthesizes, operating on the shared, growing DAG of verified knowledge.
The constructive approach of CR, by building solution from verified steps, dynamically adjusts the reason- ing trajectory. This iterative accumulation and validation of knowledge within the DAG mirrors the nuanced nature of human problem-solving and enhances the robustness of LLMs in complex tasks.
a
Verify: OK
Propose
Propose
2
3
2
3
2
3
d
d
Verify: Fail
Propose
a
c
Verify: OK
a
c
Verify: OK
a
C
Report
Propose
1
2
3
2
3
2 3
Figure 2: Overview of the Cumulative Reasoning (CR) process applied to a problem with three premises. The diagram illustrates a potential path; in general, new propositions (nodes in the DAG) can be derived by conditioning on any combination of previously validated propositions. The Reporter synthesizes the final answer from the constructed DAG.
3.1 Comparison with CoT and ToT
While CR shares the goal of improving multi-step reasoning with Chain-of-Thoughtt (CoT) (Wei al. 2022 and Tree-of- Treoghf-Thought (ToT) Yao et al. 2023 Long 2023) methodologies, its mechanism distinct. Figure offers conceptual comparison.

---

Published in Transactions on Machine Learning Research (07/2025)
CoT generates a linear sequence of reasoning steps. This approach can be prone to error propagation, incorrect intermediate step can derail the entire subsequent chain. It also lacks an explicit mechanism for exploring alternative paths or systematically verifying intermediate conclusions.
ToT extends CoT by exploring multiple reasoning paths in a tree structure, allowing for backtracking and heuristics to guide the search (e-g., breadth-first or depth-first search up to certain limits). While ToT introduces verification or voting different steps, typically explores distinct branches which might be pruned, and may not explicitly accumulate all verified knowledge from diverse branches into single, reusable structure for subsequent reasoning.
CR, in contrast, dynamically constructs a Directed Acyelic Graph (DAG) of all historically validated reason- ing steps. This DAG structure allows CR to (i) leverage a more comprehensive and interconnected context of verified information, as new propositions can be derived from any combination of existing validated nodes, not just a linear prodecessor or limited set of ancestors in a tree; (ii) systematically integrate verified knowledge, reducing redundancy and preventing re-exploration of invalid paths due to the Verifier's role. This cumulative and validated knowledge base addresses common issues like error propagation in CoT and potentially fragmented knowledge exploration in ToT.
The explicit Proposer- Verieier--iiieeieeeee Reeffter-eeereer roles in CR further contribute to a more robust process. This structured decomposition allows for specialized handling of generation, validation, and synthesis, which we hypothesize more effective than a single model attempting all simultaneously. While conditioning on an increasing number of validated nodes in the DAG can increase contextual complexity, it also provides richer foundation for subsequent reasoning steps, trade-off that CR manages through its iterative process.
Other related frameworks like Traph-of-Thoughhe (GoT) (Besta et al. 2024) also explore graph-based reason- ing structures. CR offers a specific instantiation where its defined roles iteratively build a Directed Acyclic Graph (DAG). This DAG is crucial: its inherently acyclic structure, combined with CR's focus on cumulative validation at each step, provents logical loops and ensures consistent forward progression in the deductive process, thereby avoiding reasoning dead ends. We delve deeper inlo comparisons with other advanced reasoning frameworks in Section
Detailed Comparison of CoT, ToT, and CR. To elucidate the advantages of CR over alternative methods, consider simplified two-stage reasoning process (which can naturally be extended to multiple stages). For clarity, we assume that whenever a verifier is employed, its accuracy is near- condition that can be achieved using symbolic verifier environments (e-g., a Python code interpreter or Lean). We further assume that a unique correct reasoning path exists for the problem. Undor these conditions, we define the arrival probabilily as follows. It's important to note that these assumptions, are simplifications for the purpose of this theoretical illustration and may not hold in all practical scenarios.
Definition 3.1 (Arrival Probability). For given algorithun, the arrival probabilily is defined as the prob- ability of reaching the correct conclusion from the initial state. Let PooT denote the arrival probability for CoT, and Pcor-sc that for multiple independent CoT trials (self-consistency). Similarly, denote the arrival probability of ToT as
Prot = PI PRIVT:
and that of CR as
PCR PlCk P2CR:
where P1 represents the probability of obtaining the first reasoning step correctly and P2 represents the probability of obtaining the second step correctly, conditioned on the first step being correct.
Since both ToT and CR incorporate verifiers that immediately discard erroneous paths (see Figure 3 it follows that
Poot S PiTor Prr.r
because CoT, without intermediate verification, is more likely to proceed along an invalid branch.
Note that denoting the arrival probabilities for CR simply as Pien or Płen is imprecise since CR maintains a history of visited (and validated) states within its DAG. Instead, write Pica((H) and P2ca((H)) to indicate
5

---

Published in Transactions on Machine Learning Research (07 (07/202) 2025)
breect AN
breecth I
Fale
Prentes
Racatees
(a) CoT--SC
(b) ToT
(c) CR
Figure 3: Conceptual comparison between C-T-SC (Sell-Consistency on multiple CoT chains), ToT (Tree of Thoughts exploring multiple paths), and CR (Cumulative Reasoning building a DAG of verified steps). CoT-SC generates multiple independent chains and selects the best. ToT explores a tree, potentially pruning branches. CR iteratively builds DAG, accumulating all verified intermediate steps (green nodes) and using them context for subsequent reasoning, while invalid steps (red nodes) are discarded by the Verifier.
the probability conditioned on the accumulated history of validated states H (premises for the first step, premises and validated stage-1 nodes for the second). We make the following assumption, motivated by the intuition that a richer set of verified, relevant information should improve the likelihood of deriving the next correct step, an idea supported by findings in related self-correction and refinement literature MMadaan et al. 2023 Shinn et al. 2023):
Assumption 3.2. Given the near-perfect verifier, it holds that for generating a correct step:
Pirer S Pick(()) Peter S P2cR1())
and the conditioned probabilities monotonically increase as additional nodes are incorporated:
Plaer Plcal (premis))s S P2cal (premises,stage-) node,) ) S P2CR [trremisess,tagg- node,,))
Paror S precalpremmssossaagee nodes) .... S PRCR (trae ntdes, nodes).
This assumption posits that CR, by conditioning on a potentially larger set of verified intermediate results from its DAG, at least as likely, and potentially more likely, to generate the next correct step compared to ToT (which might condition on a more limited history from a single path in its tree). The monotonicity suggests that adding more correct, verified knowledge does not harm the probability of the next step. While LLM behavior can be umpredictable and refinements are not always monotonically beneficial due to issues like hallucination, the presence of strong verifier in this idealized model helps mitigate such effects for the purpose of this analysis.
The following lemma will be useful for subsequent comparisons. Lemma 3.3. For any positive integer n and any probabilitics P1.P2 E [0, 1), the following incquality holds:
- (1 p2) < 1 - (1 p1) ) (1 p22 [1
(3.1)
6

---

Published in Transactions on Machine Learning Research (07 (025)
Please refer to Appendix A for the proof.
Theorem 3.4 (PoT--SC S Prot S PCR). Assume that CoT-SC executed with n independent trials, while both ToT and CR explore with maximum breadth of Under Assumption 3.2 the following inequality holds:
PCoT-SC S Pror S Pen-PCoT-SC- & Prot S PCR-
To further illustrate the advantages of CR, we conducted conceptual experiment on the Game of 24. In this experiment, the solution process is divided into two stages. The first stage involves randomly selecting two numbers from the four given inputs to produce a new number, and the second stage employs the remaining three numbers to form an expression that evaluates to 24. We denote the success rates of the first and second stages as P1 and P2, respectively, and let p represent the success rate when solving the Game of 24 directly with the four numbers. The results, summarized in Table [ indicate that decomposing the problem into sequential steps with intermediate verification significantly improves the overall accuracy.
Table 1: Conceptual experiment results on the Game 24.
The puzzles selected have unique solution paths
facilitate ovaluation. Each case was repeated 1000 times.
Puzzle
(%)
(%)
Pa (%)
PiP2 (%)
2, 7, 12, 13
3.0
62.3
8.0
5.0 (+2.0)
6, 11, 12, 13
0.0
64.8
8.0
5.2 (45.2)
8, 10, 12
1.8
6.9
63.9
4.4 (42.6)
CR's strategy of decomposing problems, meticulously verifying intermediate reasoning steps, and dynami- cally accumulating validated propositions within a DAG structure offers several advantages. It provides a more robust framework than linear CoT by incorporating verification. Compared to tree-based methods like ToT, CR's cumulative of all validated knowledge offers richer contextual basis for subsequent reason- ing. These structural and procedural distinctions, grounded in its Proposer-Verrfeer-RRee Verifier-Reporter architecture, contribute to CR's 's strong performance, as suggested by both this illustrative theoretical comparison and the empirical results presented in Section 4 The key insight is that the structured accumulation and reuse of verified knowledge within a flexible DAG enhances complex reasoning.
4 Experiments
Our experiments are conducted using the Microsoft Guidance library (Lundberg et al. 2023 which seam- lessly integrates generation, prompting, and logical control within language model frameworks. We evaluate method using the following LLMs: GPT-3.5-turbee plementation of Cumulative Reasoning (CR), the roles of Proposer, Verifier(s). and Reporter are instantiated using the same underlying LLM but distinguished by role-specific few-shot prompts. This design both broad- ens the applicability our approach and simplifics its deployment. Throughout the experiments, we denote by n the number of intermediate propositions generated and by l the number of majority voting iterations. For decoding, we set the temperature to 0.1 by default and t 0.7 for majority voting. Note that GPT-3.5-turbo and GPT-4 are accessed via OpenAl's chat-format APIs.
GPT-4, LLaMA-13B, and LLaMA-65B. In our im-
4.1 FOLIO Wiki
The FOLIO dataset (Han et al., 2022) is collection of first-order logical inference problems expressed in natural language. Each problem is labeled as "True", "False", or "Unknown." Figure 4 in Appendix D presents an example problem along with solutions generated by both a Chain-of-Thought (CoT) approach and our CR method.
We observe that while the CoT reasoning process may generate useful intermediate steps, it often loses tra- jectory and fails to reach the correct conclusion. By contrast, CR initially produces two valuable propositions and subsequently leverages them to solve the problem accurately.

---

Published in Transactions on Machine Learning Research (07 (225))
The FOLIO dataset is composite of 1435 examples, of which 52. 5% of these instances have been crafted based on knowledge from randomly selected Wikipedia pages. This approach guarantees the infusion of abundant linguistic variations and a rich vocabulary within the corpus. The residual 47.5% of the examples have been constructed in a hybrid style, based on various complex logical templates. Acknowledging that contemporary LLMs are pre-trained on a considerable volume of human-written corpus, we direct our exper- iments towards those examples derived from Wikipedia, hereby referred as FOLIO-wiki. Once handful of examples are moved aside for few-shot prompts and those examples without source labels for validations are excluded, we are left with testable collection of 534 examples.
Table 2 reports the performance of different methods evaluated on the FOLIO-wiki dataset. The results demonstrate that CR consistently outperforms Direct prompting, CoT, and CoT with Sell-Consistency (CoT-SC), with improvements of up to 8.62%. Notably, when paired with GPT-4, CR achieves an accuracy of 87.45 87.45%, compared 85.0 55.02% for GPT-4 with CoT-SC.
Table 2: Results for various reasoning approaches on FOLIO-wiki.
Table 3: Results for various reasoning approaches
on FOLIO-wiki-cuatted Model
Model
Method
Acc. t (%)
Method
Acc. t (%)
Random]
33.33
[Random]
33.33
Direct
44.75
Direct
49.13
CoT CoT-SC (A = 16)
49.06 (+-1.11)
CoT CoT-SC (k 16)
52.17 (43.04)
LLAMA-13B
LLaMA-13B
52.43 (+7.68)
53.70 (+4.57)
CR (n 2)
53.37 (+8.62)
CR (n = 2)
55.87 (+6.74)
Direct CoT
67.42
Direct
74.78
67.42 (+00.00)
CoT
74.13 ( (-0.65)
LLaMA-65B
LLaMA-65B
CoT-SC (A- 16) CR (n = 2)
70.79 (+33377)
CoT-SC (k: 16)
79.13 (+4.355)
72.10 (+44668)
CR (n = 2)
79.57 (+4.79)
Direct
62.92
Direct
69.57
CoT
61.61 (+1.69)
CoT
70.65 (+1.088)
GPT-3.5-turo
GPT-3.5-turbo
CoT-SC (A 16)
63.33 (+0.41)
CoT-SC (k = 16)
69.32 ( -0.25)
CR (n == 2)
73.03 (+10.11)
CR 2)
78.70 (+9.13)
Direct
80.52
Direct
89.57
CoT
84.46 (+3.94)
CoT
95.00 (+5.43)
GPT-4
GPT-4
CoT-SC (A- = 16)
85.02 (+4.50)
CoT-SC (k= 16)
96.09 (+6.52)
CR (n = 2)
87.45 (+6.93)
CR (n 2)
98.04 (+8.47)
Table 4: Experimental results on the FOLIO-wiki and FOLIO- datasets.
4.2 FOLIO Wiki Curated
A detailed review of the FOLIO-wiki datasot revealed several problematic instances, including: 1) Missing or contradictory common knowledge; 2) Overly ambiguous problems that do not yield unequivocal answers; 3) Inherent inconsistencies within the premises; 4) Vague statements typographical errors; 5) Incorrect answer annotations.
After removing 74 such problematic instances, the curated set comprises 460 examples (see Appendix E.2
for detailed examples). As shown in Table 3, when applied to this refined dataset, GPT-4 paired with CR achieves an accuracy of 98.04% (error rate: 1.96%), nearly doubling the effectiveness of GPT-4 with CoT-SC.
4.3 TNLI
Experimental Setting. The AutoTNLI dataset (umaar et al. 2022 extends the INFOTABS dataset Gupta et al. 2020) to construct challenging Tabular Natural Language Inference task. This datasct contains 1,478,666 662 table-hypothesis pairs labeled as either "Entail" or "Neutral" In our adaptation, we treat the tabular data as premises in manner analogous to the FOLIO dataset. Due the dataset's 's large scale,
8

---

Published in Transactions on Machine Learning Research (07/2025)
we limit our evaluation to the first 1,000 table-hypothesis pairs and compare the performance of LLaMA-13B and LLaMA-65B using Direct, CoT, CoT-SC, and our CR method.
Evaluation Results. Table 6 shows that CR significantly outperforms the alternative prompting strate- gies. In particular, LLaMA-65B with CR achieves a 12.8% accuracy improvement over CoT-SC, demon- strating CR's superior ability to capture structural and linguistic nuances in logical inference.
More Experiments and Ablation Studies. Regarding the computational complexity of different methods, Table 13 and Table 14 (please refer to Appendix B demonstrate the superiority of CR over COT, CoT-SC, and ToT on several logical inference tasks, including the LogiQA (Liuu et al.) 2020) and ProofWriter Taffoord et al. 2020) datasets. In addition, Table 5 presents ablation studies on the FOLIO wiki dataset using the GPT-3.5-lurbo model, quantifying the impact of individual components such as the verifier and the premises random choice mechanism on CR's performance.
Table 5: Ablation studies FOLIO wiki dataset using GPT-3.5-turbo model.
Model
Method
Acc. 1 (%)
[Random]
33.33
Direct
62.92
CoT
64.61 (+1.69)
GPT-3.5-turbo
CoT-SC (k 16)
63.33 (+0.41)
CR (ours, n = 2)
73.03 (+10.111)
CR (ours, n
w/o Verifier)
64.23 (+1.31)
CR (ours, n = 2, w/o premises random choice)
68.73 (+5.81)
CR (ours, n 2, w/o Verifier, w/o premises random choice)
67.23 (+4.31)
Table 6: Results on the Auto dataset.
Table 7: Results on the Game of 24 using GPT-4.
Model
Method
Acc. t (%)
Method
Ace. # Visited States 4
1 (%)
[Random]
50.00
Direct
7.3
COTT
4.0
1
Direct
52.6
CoT CoT-SC (k: ===10 16)
54.1 (+1.5)
CoT-SC (k=100)
9.0
100
LLaMA-13B
52.1 (-0.5)
Direct (best of 100)
33
100
CR (n 4)
57.0 (+5.4)
CoT' (best of 100)
49
100
ToT (b=5)
74
61.72
Direct
59.7
CR (b=1)
84 (+10)
11.68 (-50.04)
CoT
63.2 (+3.5)
LIaMA-65B
CR (b=2)
94 (+20)
13.70 (-48.02)
CoT-SC (I: 16)
61.7 (+2.0)
CR (b=3)
97 (+23)
14.25 (-47.47)
CR (n
72.5 (+12.8)
CR (b=4)
97 (+233
14.77 (-46.95)
CR (b=5)
98 (4)
14.86
(-46.86)
Table 8: Experimental results on the AutoTNLI and Game of 24 datasets.
4.4
Game of 24
The Game 24 a numerical puzzle in which players must combine four given integers using basic arithmetic operations (addition, subtraction, multiplication, and division) to yield 24. A puzzle considered successfully solved if the resulting equation valid and each input number is used exactly once.
Experimental Setup. We evaluate set of 100 puzzles curated by ToT Yao et al. 2023 Our primary metrics are accuracy and the average number of visited states during the scarch. In our CR algorithm, set of reachable stales, 5, is maintained. The process begins with the initial state (the four input numbers without operations), and at each iteration a state u E is selected. The Proposer chooses two numbers from and applics a basic operation to generate a new state v. After the Verifier confirms the validity of the operation, added to S. When a state representing a valid solution (i.e., an equation that evaluates to 24) is reached, the Reporter traces back the derivation and outputs the solution. The process terminates

---

Published in Transactions on Machine Learning Research (07/2025)
either when solution is reported or when the iteration count exceeds predefined limit (L 50). We run multiple parallel branches (with breadth b ranging from 1 to 5) to account for variability in the search.
Results. As summarized in Table 7 CR substantially outperforms ToT by achieving up to 98% accuracy (a 24% improvement over ToT's 74%) while exploring significantly fewer states.
Comparison with ToT. In the specific context of the Game of 24, the methodologies of Cumulative Reasoning (CR) and Tree of Thoughts (ToT) share similarities yet diverge siguificantly in their approach to state generation and exploration. A fundamental difference lies in how each iteration processes: CR is designed to introduce single new state at each step, focusing on a step-by-step progression towards the solution. Conversely, ToT is characterized by its generation of multiple candidate states during each iteration, employing a filtration mechanism to narrow down the feasible states. This operational distinction suggests that ToT engages in a broader exploration of potential, including invalid, states, compared to the more strcamlined approach of CR.
Furthermore, ToT relies on pre-defined search structure, utilizing constant width and depth within its search tree. This rigid framework contrasts with CR's more dynamic strategy, where the language model (LLM) itself influences the depth of the scarch, adapting the exploration breadth as needed across different stages of the problem-solving process. Such flexibility in CR not only optimizes the search path but also tailors the exploration to the complexity and requirements of each specific problem, potentially enhancing efficiency and efficacy in reaching the correct solution.
Table 9: Comparative performance on the MATH dataset using GPT-4 without code environment. We adopted a default temperature setting of t 0.0, consistent with prior research settings (greedy decoding). PHP denotes the application of the progressive-hint, prompting. "Iters" represents the average number of LLM interactions, and Overall reflects the overall results across MATH subtopics denotes using 500 test examples subset following Lightman et al. (0223)
MATH Dataset
w/ PHP
Precale
Geometry
NumT
Prob
PreAlg
Algebra
Overall
CeT
42.50
Complex CoT 8 shot
26.7
36.5
49.6
53.1
71.6
70.8
50.36
29.8
41.9
55.7
56.3
73.8
74.3
53.90
(Iters)
3.2435
3.2233
3.1740
2.8122
2.3226
2,4726
2.8494
Complex CoT (repro., 8-sbot)
33.9
34.1
46.8
47.4
62.1
70.7
48.80
30.4
43.9
53.2
50.0
68.5
84.1
53.80 80
(Iters)
2,4613
2. 2,7805
2.7581
2/4/74
2,3780
2.5184
2.59
CR w/o code (ours, 4-ehot))
30.4 (-3.5)
39.0 (+-4.9)
54.8 (48.0)
57.9 (+10.5)
71.8 (+9.7)
79.3 (+8.6)
54.20
(4-5.40)
35.7 (+5.33)
43.9 (+0.0)
(+6.5)
(+13.2)
71.8 (43.3)
86.8 (+2.5)
58.00 (+4.220)
(Iters)
2.4821
2.5122
2.2903
2.2105
2.2195
2.3548
2.40 (-0.19)
4.5
Solving MATH Problems
The MATH dataset. (Hendrycks et al. 2021 provides comprehensive benchmark for mathematical reasoning across diverse subdomains such as Algebra and Geometry. We compare Complex CoT and our CR method, both with and without Progressive-Hinn Prompting (PHP) (Zheng et al. 2023). Our reproduction follows the evaluation protocol of Lightman et al. (2023), using an 8-shot prompting strategy on a 500-example subset that spans all difficulty levels (Levels 1-5).
Results without Code Environment. Table g shows that CR outperforms Complex CoT by 5.4% in overall accuracy when using 4-shot strategy. In particular, CR yields substantial gains in Number Theory, Probability, PreAlgebra, and Algebra. Table 10 further demonstrates that at Level 5-the most challenging subset. CR achieves a 9.7% improvement, corresponding to a 43% relative gain over Complex CoT without PHP. The "Iters" column in Table indicates the average number of L.M interactions, providing insight into the computational effort. CR demonstrates competitive iteration counts while achieving higher accuracy.
With Code Environment. In addition to the experiments above, we extend CR by incorporating a Python code environment to emulate semi-symbolic reasoning system. In this configuration, no external
10

---

Published in Transactions on Machine Learning Research (07 (07/2025)
Comparative performance on the MATH dataset using GPT-4 without code environment for different difficulty levels. (" denotes evaluation 500-cxample subset.)
Table 10:
MATH Dataset (" denates using 500 test examples subset)
w/ PHP
Level 5
Level 4
Level 3
Level 2
Level 1
Overall
Coll (OpenAl 2023
20.50
Complex CoT'
X
22.4
38.3
62.9
72.2
79.1
48.80
(repro., 8-shot)
/
23.9
43.8
63.8
86.7
83.7
53.80
CR w/o code"
32.1 (4-9.7)
43.0
(4-4.7)
0.0)
78.9 (+-6.7)
83.7
(4-4.6)
54.20
(4-5.40)
(ours, 4-shot)
27.3 (+3.4)
50.0 (+6.2)
70.9
(+7.1)
86.7 (+0.0)
90.7 (+7.0)
58.00
(+4.20)
aids (such as memory modules, web Browse, or retrieval systems) are employed. Instead, the Python interpreter serves a highly reliable and efficient Verifier, executing and validating arithmetic or symbolic expressions generated by the LLM Proposer. This setup allows the Proposer generate hypotheses and mathematical expressions, which are then rigorously verified through code execution before being added to the CR's knowledge DAG. This highlights CR's fiexibility in integrating different types of verifiers.
Tables 11 and 12 compare our approach with state-of-the-arl methods such as PAL (Gao el al. 2023 and ToRA Gou et al. 2023). CR with code achieves an overall accuracy of 72.2% on the MATH dataset, reflecting 38.9% relative improvement over PAL and an 18.8% improvement over ToRA. Furthermore, on the hardest Level 5 problems, CR with code exhibits 66.8% relative improvement over PAL and 12.8% improvement. over ToRA.
Table 11: Comparative performance the MATH dataset using GPT-4 with Python code environment. Results are based on greedy decoding (t 0.0). Overall reflects the aggregate accuracy across MATH subtopics.
Precale
Geometry
NunT
Prob
PreAlg
Algebra
Overall
PAL
29.3
38.0
58.7
61.0
73.9
59.1
51.8
PAL (repro., 4-shot)
23.2
31.7
66.1
57.9
73.2
65.3
52.0
ToRA
37.2
68.9
61.6
ToRA" (repro., 4-shot)
44.6
49.5
66.1
67.1
71.8
60.8
w/ code' (ours, 2-shot)
51.8 (+7.2)
53.7
(+4.9)
(+22.6)
(+5.0)
(+13.4)
(+14.5)
(+111.4)
Comparative performance on the MATH dataset using GPT-4 with Python code environment across different difficulty levels.
Table 12:
Difficulty Levels
Level
Level 4
Level
Level
Level 1
Overall
PAL
51.8
PAL' (repro., 4-shot)
31.3
45.3
60.0
63.6
88.4
52.0
ToRA ToRA" (repro., 4-shot)
61.6
46.3
53.9
69.5
75.6
74.4
60.8
CR w/ code' (ouns, 2-shot)
52.2
(+5.9)
66.4 (+12.5)
81.9
(+12.4)
90.0
(+14.4)
90.7 (+2.3)
72.2 (+11.4)
5
Related Work
The quest. to imbue LLMs with robust rea- soning capabilities has spurred extensive research. Early approaches focused on generating intermediate
Reasoning with Large Language Models (LLMs).
steps (Zaidan al.] |0077] Yao et al. 2021 Hase Bansal 2021 Yang al. 2022 Wu al.) 2022 Zhou
et al. 2022). Morishita et al. (2023) enhance language models' reasoning by utilizing a synthetic corpus based
formal logic theory. [esato al.
2022 Lightman et al. (022) compare process-based and outcome-based
11

---

Published in Transactions on Machine Learning Research (07/2025)
approaches in solving mathematical reasoning tasks. Further, considerable breadth of research focuses
augmenting reasoning through symbolic systems, such code environments, knowledge graphs, and formal
theorem provers, showcasing the utility of hybrid approaches in complex reasoning tasks (Mihaylov & Frank
2018
Bauer et al. 2018
Kundu et al. 2018 Wang ct al., 2019 Lin et al.
2019 Ding et al.
2019 Feng et al.
2020
Nye et al.
2021
Wang et al. 2022a
Chen et al.
2022
Lyu et al.
2023
Chen et al.
2022 Gao et al.
2023
Gou et al.
2023 Li ct al. 2023a Jiang et al. 2022 Yang et al.
2023).
Chain-of-Thought (CoT) Prompting. Initiated by Wei et al. (0022) the CoT reasoning paradigm underscores the value of multi-step logical pathways in deriving conclusive answers. Building on this, Wang
et al. (2022b) introduce self-consistency as an advanced decoding strategy, aiming to refine the basic greedy
decoding used in COT. Zhou et al. [2022) (Least-to-Most) and Khot et al. (022) (Decomposed Prompting)
further dissect complex tasks into manageable sub-tasks. Creswell & Shanahan (2022) enhance reasoning
quality via beam search. Fu et al.
(2022) (Complex CoT) advocate for more complex few-shot prompts.
Creswell & Shanahan (2022) explore the enhancement of reasoning quality through a beam search across reasoning traces, while Fu et al. (2022) argue for increasing the complexity within few-shot prompts to improve performance. Recent developments include Li et al. (2023b) 's DIVERSE, which investigates various reasoning paths for the same question and employs verifier for accuracy through weighted voting. [uu et al.) 2023) present multi-agent debate approach with multiple LLMs. Yao et al. (2023)'s 's Troc-of- Thoughh (ToT) framework introduces deliberation in decision-making by considering multiple reasoning paths. Zheng et al. (003)) propose an iterative approach, using previous responses as contextual clues in subsequent iterations. Feng et al. (0023) highlight the thcoretical and practical implications of CoT for solving complex real-world tasks, including dynamic programming. Recently, there have also been many works on the self-criticizing process (Tyen et. al., 2023 Li et al. 2024 Zhang et al. 2024b Lin et al., 2024 Wang et al. 2024), showing that language models can have celf-correction capabilities with theoretical guarantees.
Advanced Reasoning Frameworks. Yao al. (2023 Long 2023 Tree-of- Treo-of-Thoughtt (ToT) framework
allows LLMs to explore multiple reasoning paths and seli-evaluate choices. As discussed in Section 3.1 CR differs from ToT by its cumulative DAG construction and distinct Proposer-Verifeer- Reporter roles, fost ering more integrated use of all validated knowledge. Sraph-of-Thhughe (GoT) frameworks (Besta et al. 2024
also leverage graph structures for reasoning, representing thoughts as nodes and dependencics as edges. CR
offers a specific operationalization of graph-based reasoning with its ilerative, role-based DAG construction and explicit verification at each step. Forest of Thought (FoT) methodologies (Bi et al. 2024] may explore multiple diverse reasoning trees or high-level plans concurrently. CR, while capable of exploring branches (e.g.. parameter b in Game of 24), primarily focuses on the meticulous, cumulative construction of single, coherent reasoning DAG.
Self- Self-Critique and Iterative Refinement. CR's Verifier role aligns with and extends self-critique con- cepts Madaan et al. 2023 Shinn et al. 2023 Tyen et al. 2023 Hosseini et al. 2024 Li ct al. 2024 Lin et al. 2024 Wang et al., 2024 Zhang et al. 2024b). While many self aaff-critqque methods refine single reasoning trace or select among alternatives (e.g., Reflexion (Shinn et al. 2023). Self-Refine (Madaan et al. 2023)
CR uses verification to build a persistent, growing DAG of validated knowledge that informs all subsequent reasoning steps. This iterative accumulation and reuse of verified steps is a key distinction. Zheng et al. (2023) (Progressive- Hint Prompting) also uses an iterative approach with previous responses as context, which CR incorporates in its MATH experiments.
Recent advancements focus more nuanced verifiers and verification frameworks. For example, Li et al. (0233b 's DIVERSE employs a verifier for accuracy through weighted voting over various reasoning paths; in contrast, CR's verification is more deeply integrated into the step-by-step construction of the reasoning DAG. Hosseini et al. (2024) propose V*, which improves LLM's reasoning by training a verifier on both correct and incorrect solutions generated during infroveproeeet,, which then helps select the best answer from multiple candidates at inference time. More recent approaches, such as Li et al. (2025) (PANEL), investigate detailed, stepwise natural language self-critique providing linguistic foedback, while Ma et al. 2025 Sleneral-Reasoneee introduce a generative model-based verifier. While CR's current. Verifier often
12

---

Published in Transactions on Machine Learning Research (07/2025)
makes binary (valid/invalid) decisions relies external tools like code interpreters, future work could integrate such richer feedback mechanismss into the Verifier role.
6 Conclusion
In this work, we introduce Cumulative Reasoning (CR), an approach leveraging LLMs in structured, itera- tive process that mirrors human cognitive strategies. By orchestrating the roles of proposer, verifier(s), and reporter, CR not only decomposes complex problems into manageable tasks but also effectively recomposes the validated steps into comprehensive solutions. This methodology has demonstrated superior performance across various domains, including logical inference, the Game of 24, and MATH problems, showcasing the versatility and potential of CR in advancing the capabilities LLMs in complex problem-solving scenarios.
References
Lisa Bauer, Yicheng Wang, and Mohit. Bansal. Commonsense for generative multi-hop question answering tasks. arXiv preprint WrXiu:8899066000 2018.
Maciej Besta, Nils Blach, Ales Kubicek, Robert Gerstenberger, Michal Podstawski, Lukas Gianinazzi, Joanna Gajda, Tomasz Lehmann, Hubert Niewiadomski, Piotr Nyezyk, et al. Graph of thoughts: Solving elaborate problems with large language models. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pp. 17682-17690, 2024.
Zhenni Bi, Kai Han, Chuanjian Liu, Ychui Tang, and Yunhe Wang. oorost-of:thought: Scaling test-time compute for enhancing Ilm reasoning. arXiv preprint arXie:2412. 00022242..0000 09078, 2024.
Tom Brown, Benjarin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. Advances in neural information processing systems, 33:1877-1901, 2020.
Wenhu Chen, Xueguang Ma, Xinyi Wang, and William W Cohen. Program of thoughts prompting: Dis- entangling computation from reasoning for numerical reasoning lasks. arXiv preprinl arXiv:2211.124 125888
2022.
Jonathan Okeke Chimakonam. Proof in Alonzo Church's 's and Alan Turing's Mathematical Logic: Undecid- ability of First Order Logic. Universal-rublishers, 2012.
Robin Cooper, Dick Crouch, Jan Van Eijck, Chris Fox, Johan Van Genabith, Jan Jaspars, Hans Kamp, David Milward, Manfred Pinkal, Massimo Poesio, et al. Using the framework. Technical report, Technical Report LRE 62-051 D-16, The FraCaS Consortium, 1996.
Antonia Creswell and Murray Shanahan. Faithful reasoning using large language models. arXio preprinl Stti:22008112771 2022.
Jacob Devlin, Ming- Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04800 2018.
Ming Ding, Chang Zhou, Qibin Chen, Hongxia Yang, and Jie Tang. Cognitive graph for multi-hop reading comprehension at scale. arXiv preprint NNi::1905.05400 2019.
Yilun Du, Shuang Li, Antonio Torralba, Joshua B Tenenbaum, and Tgor Mordatch. Improving factuality and reasoning in language models through multiagent debate. arXiv preprint arXim:235514322. 2023.
Guhao Feng, Yuntian Gu, Bohang Zhang, Haotian Ye, Di He, and Liwei Wang. Towards revealing the mystery behind chain of thought: a theoretical perspective. arXio preprint orXiv:2305. 15408, 2023.
Yanlin Feng, Xinyue Chen, Bill Yuchen Lin, Peifeng Wang, Jun Yan, and Xiang Ren. Scalable multi-hop relational reasoning for knowledge-aware question answering. Xi preprint ar orXio:2005.000 00646, 2020.
13

---

Published in Transactions on Machine Learning Research (07/2025)
Yao Fu, Hao Peng, Ashish Sabharwal, Peter Clark, and Tushar Khot. Complexity-basee prompting for multi-step reasoning. arXie preprint arX:022200000720, 2022.
LTF Gamut. Logic, Language, and Meaning, Volume 2: intensional logic and logical grommar. University of Chicago Press, 1990.
Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. Pal: Program-aided language models. In International Conference on Machine Learning, pp. PMLR, 2023.
Zhibin Gou, Zhihong Shao, Yeyun Gong, Yujiu Yang, Minlie Huang, Nan Duan, Weizhu Chen, et al. Tora: A tool-integrated reasoning agent for mathematical problem solving. arXiv preprint arXiv:239. 17452. 2023.
Vivek Gupta, Maitrey Mchta, Pogah Nokhiz, and Vivck Srikumar. INFOTABS: inference on tables as semi-struuttred data. CoRR, abs/2005.06117, 2020.
Simeng Han, Hailey Schoelkopf, Yilun Zhao, Zhenting Qi, Martin Riddell, Luke Benson, Lucy Sun, Ekaterina Zubova, Yujie Qiao, Malthew Burtell, et al. Folio: Natural language reasoning with first-order logic. arXiv preprint arXi::2209.008: 00840, 2022.
Peter Hase and Mohit Bansal. When can models learn from explanations? a formal framework for under- standing the roles of explanation data. arXiv preprint arxiv:202 022001 2021.
Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Mcasuring mathematical problem solving with the math dataset. arXiv preprint arXiv:2103.083: 0338774 2021.
Arian Hosseini, Xingdi Yuan, Nikolay Malkin, Aaron Courville, Alessandro Sordoni, and Rishabh Agarwal. V-star: Training verifiers for self-tanght reasoners. arXiv preprint arXiv:2402 06457, 2024.
Albert Qiaochu Jiang, Sean Welleck, Jin Peng Zhou, Wenda Li, Jiacheng Liu, Mateja Jamnik, Timothée Lacroix, Yuhuai Wu, and Guillaume Lample. Draft, sketch, and prove: Guiding formal theorem provers with informal proofs. ArXio, abs/2210.1 12210.11200 12883, 2022.
Daniel Kahneman. Thinking, fast and slow. macmillan, 2011.
Tushar Khot, Harsh Trivedi, Matthew Finlayson, Yao Fu, Kyle Richardson, Peter Clark, and Ashish Sabharwal. Decomposed prompting: modular approach for solving complex tasks, arXie preprint arXiv:2210.022 02.400 2022.
Dibyakanti Kumar, Vivek Gupta, Sounya Sharma, and Shuo Zhang, Realistic data augmentation framework for enhancing tabular reasoning. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing, Online and Abu Dhabi, December 2022. Association for Computational Linguistics.
Souvik Kundu, Tushar Khot, Ashish Sabharwal, and Peter Clark. Exploiting explicit paths for multi-hop reading comprehension. arXiv preprint arXiv: $1..1..1111 1101112 2018.
Chengshu Li, Jacky Liang, Andy Zeng, Xinyun Chen, Karol Hausman, Dorsa Sadigh, Sergey Levine, Li Fei- Fci, Fei Xia, and Brian Ichter. Chain of code: Reasoning with a language model-augmented code emulator. arXiv preprinl ar X31: 2. 0.0447, 2023a.
Loka Li, Guangyi Chen, Yusheng Su, Zhenhao Chen, Yixuan Zhang, Eric Xing, and Kun Zhang. Confi- dence matters: Revisiting intrinsic self-correction capabilities of large language models. arXiv preprint arXiv:2402.0 12563, 2024.
Yansi Li, Jiahao Xu, Tian Liang, Xingyu Chen, Zhiwei He, Qiuzhi Liu, Rui Wang, Zhuoshong Zhang, Zhaopeng Tu, Haitao Mi, et al. Dancing with critiques: Enhancing Ilm reasoning with stepwise natural language self-critique. arXiv preprint ar Xin:2003. 17963, 2025.
14

---

Published in Transactions on Machine Learning Research (07 2225))
Yifei Li, Zeqi Lin, Shizhuo Zhang, Qiang Fu, Bei Chen, Jian- MannGuung Lou, and Weizhu Chen. Making language models better reasoners with step-aware verifier. In Proceedings of the 61 Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 5315 5333, 2023b.
Hunter Lightman, Vineet Kosaraju, Yura Burda, Harri Edwards, Bowen Baker, Teddy Lec, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let's verify step by step. arXiv preprint arXiv:2305.2005 2023.
Bill Yuchen Lin, Xinyue Chen, Jamin Chen, and Xiang Ren. Kagnet: Knowledge-aware graph networks for commonsense reasoning. arXiv preprint arXiv:1999 02151, 2019.
Zicheng Lin, Zhibin Gou, Tian Liang, Ruilin Luo, Haowei Liu, and Yujiu Yang. Criticbench: Benchmarking Ilms for critique-correct reasoning. arXiv preprinl ar Xix:24402. 14809, 2024.
Jian Liu, Leyang Cui, Hanmeng Liu, Dandan Huang, Yile Wang, and Yue Zhang, Logiqa: A challenge dataset for machine reading comprehension with logical reasoning. arXiv preprint arXiv:2007.0114 2020.
Jicyi Long. Large language model guided troc-of-thought. arXiv preprint arXim:2905.0820 2023.
Leopold Löwenheim. On possibilities in the calculus relatives. Jean van Heijenoorl, pp. 1878 1931, 1967.
Scott Lundberg, Marco Tulio Correia Ribeiro, David Viggiano, Joao Rafael, Riya Amemiya, and et. al. 2023.
Microsoft guidance library.
Qing Lyu, Shreya Havaldar, Adam Stein, Li Zhang, Delip Rao, Eric Wong, Marrannna Apidianaki, and Chris Callison-Burch. Faithful chain-of-thought reasoning. arviv preprint arXin:2301.13775 2023.
Xueguang Ma, Qian Liu, Dongfu Jiang, Ge Zhang, Zejun Ma, and Wenhu Chen. General-reasoner: Advancing Ilm reasoning across all domains. arXiv preprint Xrx:222505 14652, 2025.
Aman Madaan, Niket Tandon, Prakhar Gupta, Skyler Hallinan, Layu Gao, Sarah Wiegreffe, Uri Alon, Nouha Dziri, Shrimai Prabhumoye, Yiming Yang, et al. Self-refine: Iterative refinement with belf-feedbbck. arXiv preprint Xrx::22303. 1702201...111,,, 17651, 2023.
Todor Mihaylov and Anette Frank. Knowledgeable reader: Enhancing cloze-style reading comprehension with external commonsense knowledge. arXie preprint arXim:1805.07852 2018.
Koji Mineshima, Pascual Mlatínez-Gómez, Yusuke Miyao, and Daisuke Bekki. Higher-order logical inference with compositional semantics. In Proceedings of the 2015 Conference on Empérical Methods in Natural Language Processing, pp. 2055-2061, 2015.
Terufumi Morishita, Gaku Morio, Atsuki Yamaguchi, and Yasuhiro Sogawa. Learning deductive reasoning from synthetic corpus based on formal logic. In Andreas Krause, Emma Brunskill, Kyunghyun Cho, Barbara Engelhardt, Sivan Sabato, and Jonathan Scarlett (ods.), Proceedings of the 40th International Conference on Machine Learning, volume 202 of Proceedings of Machine Learning Research, pp. 25254- 25274. PMLR, 23-29 Jul 2023.
Maxwell Nye, Anders Johan Andreassen, Guy Gur-Ari, Henryk Michalewski, Jacob Austin, David Bieber, David Dohan, Aitor Lewkowycz, Maarten Bosma, David Luan, et al. Show your work: Scratchpads for intermediate computation with language models. arXiv preprint arXiv:2112.00114 2021.
OpenAL. Gpt-4 technical report. ArXio, abs/ hts/2303.08774, 2023.
Alec Radford, Karthik Narasimhan, Tim Salimans, 1lya Sutskever, et al. Improving language understanding by gencrative pre-training. openai.com com, 2018.
Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. Language models are unsupervised multitask learners. OpenAl blog, 188):9, 2019.
15

---

Published in Transactions on Machine Learning Research (07 (225))
Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. The Journal of Machine Learning Research, 21(1):5485 5551, 2020.
Laria Reynolds and Kyle McDonell. Prompt programming for large language models: Beyond the few-shot paradigm. In Extended Abstructs of the 2021 CHI Conference on Human Factors in Computing Systems, pp. 1-7, 2021.
Noah Shinn, Federico Cassano, Beck Labash, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. Reflexion: Language agents with verbal reinforcement learning. arXiv preprint arXiv:2303. 11366, 2023.
Hongda Sun, Weikai Xu, Wei Liu, Jian Luan, Bin Wang, Shuo Shang, Ji-Rong Wen, and Rui Yan. From indeterminacy to determinacy: Augmenting logical reasoning capabilities with large language models. arXiv preprint Xim:2030. 18659, 2023.
Oyvind Tafford, Bhavana Dalvi Mishra, and Peter Clark. Proofwriter: Generating implications, proofs, and abductive statements over natural language. arXiv preprint Xix:22011 13048, 2020.
Anne Sjerp Troclstra. Metamathematical investigation of intuitionistic arithmetic and analysis. Springer, 1973.
Alan Mathison Turing et al. On computable mumbers, with an application to the entscheiduungsprolem.. J. of Math, 58(3453333)55, 1936.
Gladys Tyen, Hassan Mansoor, Peter Chen, Tony Mak, and Victor Cärbune. Lims cannot find reasoning errors, but correct them! arXiv preprint arXiv:231.008116 2023.
Jonathan Uesato, Nate Kushman, Ramana Kumar, Francis Song, Noah Siegel, Lisa Wang, Antonia Creswell, GeolTrey Irving, and Trina Higgins. Solving math word problems with process-and outcome-based feedback. arXiv preprint arXiv:2211.14270 14275, 2022.
Xiaoyan Wang, Pavan Kapanipathi, Ryan Musa, Mo Yu,, Kartik Talamadupula, Tbrahim Abdelaziz, Maria Chang, Achille Fokoue, Bassem Makni, Nicholas Mattei, et al. Improving natural language inference using external knowledge in the science questions domain. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 7208-7215, 2019.
Xiting Wang, Kunpeng Liu, Dongjie Wang, Le Wu, Yanjie Fu, and Xing Xie. Multi-level recommendation reasoning over knowledge graphs with reinforcement learning. In Proceedings of the ACM Web Conference 2022, pp. 2098 2108, 2022a.
Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoe Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. arXiv preprint wwXiw:2203.1117. 2022b.
Yifei Wang, Yuyang Wu, Zeming Wei, Stefanie Jegelka, and Yisen Wang. A theoretical understanding of self-correction through in-context alignment. XrXiv preprint ar Xiv:22400 18634, 2024.
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Fdl Chi, Quoe V Le, Denny Zhou, al. Chain-of-thought prompting elicits reasoning in large language models. Advances in Neural Information Processing Systems, 35:24824 28887777- 2022.
Tongshuang Wu, Michael Terry, and Carrie Jun Cai. Ai chains: Transparent and controllable human-ai interaction by chaining large language model prompts. In Proceedings of the 2022 CHI conference on human factors in computing systems, pp. 1-22, 2022.
Jingfeng Yang, Haoming Jiang, Qingyu Yin, Danqing Zhang, Bing Yin, and Diyi Yang. Seqzero: Few- shot compositional semantic parsing with sequential prompts and zero-shot models. arXiv preprint arXin:2205.07381, 2022.
16

---

Published in Transactions on Machine Learning Research (07/2025)
Kaiyu Yang, Aidan M Swope, Alex Gu, Rahul Chalamala, Peiyang Song, Shixing Yu, Saad Godil, Ryan Prenger, and Anima Anandkumar. Leandojo: Theorem proving with retrieval-augmented language models. arXiv preprint arXie:2306.1500 15626, 2023.
Huihan Yao, Ying Chen, Qinyuan Ye, Xisen Jin, and Xiang Ren. Refining language models with composi- tional explanations. Advances in Neural Information Processing Systems, 34:8954-8967, 2021.
Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: Deliberate problem solving with large language models. arXiv preprint orXiv:2305. 10601, 2023.
Omar Zaidan, Jason Eisner, and Christine Piatko. Using "annotator rationales" to improve machine learning for text categorization. In Human language technologies 2007: The conference of the North American chapter of the association for compatational linguistics; proceedings of the main conference, pp. 260-267, 2007.
Yifan Zhang, Yang Yuan, and Andrew Chi-Chih Yao. Meta prompting for ai systems. In ICLR 2024 Workshop on Bridging the Gap Between Practice and Theory in Deep Learning, 2024a. URL https:
wawparevveee.ne//oouunntttt beet/forumid=vxXRee //openreview.o
Yunxiang Zhang, Muhammad Khalifa, Lajanugen Logeswaran, Jaekyeom Kim, Moontae Lee, Honglak Lee, and Lu Wang. Small language models need strong verifiers to self-correct reasoning, arXie preprint arXiu:2444.17140 2024b.
Chuanyang Zheng, Zhengying Liu, Euze Xie, Zhenguo Li, and Yu Li. Progressive-hint prompting improves reasoning in large language models. arXiv preprint arXiv:2304.099 097997, 2023.
Denny Zhou, Nathanael Schärli, Le Hou, Jason Wei, Nathan Scales, Xuezhi Wang, Dale Schuurmans, Olivier Bousquet, Quoe Le, and Ed Chi. Least-to-most prompting enables complex reasoning in large language models. arxiv preprint 20X 2022.
Pei Zhou, Jay Pujara, Xiang Ren, Xinyun Chen, Heng-Tze Tze Cheng, Quoe V Le, Ed H Chi, Denny Zhou, Swaroop Mishra, and Huaixiu Steven Zheng. Self-discover: Large language models self-composo reasoning structures. Xiv preprinl 0rXin:2402.0300 03620, 2024.
17

---

Published in Transactions on Machine Learning Research (07 (07/2025)
Appendix
A Proofs of Theorems
19
B More on Experiments
19
B.1 More Experimental Results
19
Computational Considerations
20
C More on Logic
21
Illustrative example higher-order logic
21
D Appendix for Examples
22
E More Datasets
26
E.1 More FOLIO Examples
26
E.2 Curating FOLIO wiki dataset
29
E.3 More examples on problems excluded from FOLIO wiki curated
29
A Appendix for Prompts
36
18

---

Published in Transactions on Machine Learning Research (07/202) 2025)
A
Proofs of Theorems
Proof of Lemma 3.3
Proof.
1- -1 (-
(1- p2)")
+
+ - p1)" ) p2)
P2)
+ (1= -1-P1-10 -11-=1-m==+11100 + P1 P2)
Notice that
(1 - p2) -1 + pp)))ppp>>>---- (1 + p2) = 2 P1 PP,.
WLOG, let Pı 2 P2 then
(1 P1-P1 P1 -2 P2) S (1 - p1) S (1 p2) S (1 p1 P22).
From the monotonicity of function x² + (2 p1 P +00) respectively, and the symmelry of {(1 P1 P2 + P1 P22) (1 P1 p2)} and the symmetry of
r) in the interval (-o0, pp and the interval
{(1 11-Pih) p1), - }2)) correspond to y 2-p1-P2 p2 we conclude the proof.
2
Proof of Theorem 3.4
Proof.
Poor.sc 1 PCOT)" S (1 Pı p2)",
Pior (1 p1) (1 p2)"),
Combined with Lemma 3.3
now we have
POOT-SC S PIoT
From Assumption 3.2 we have
Prr < (1 - (1 - Pien (preemisss) .1)))11
P2en (peamtene, stage-1 modes) )²) PCR-
Finally, conclude that
Pcor-o & PIor S PCR.
B More Experiments
B.1 More Experimental Results
For fair comparison of different methods on the LogiQA, Proo/Writer, FOLIO (validation set), and LD datasets, we report the third-party reproduced results by Sun (023).. For details on the implementation of these experiments, please refer to their work.
19

---

Published in Transactions on Machine Learning Research (07 2025)
Table 13: Comparison results on LogiQA
Table 14: Comparison results on ProofWriter
Method
Acc.
# Visited States
Method
Acc.
# Visited States
Direct
31.69%
Standard
46.83%
CoT
38.55%
CoT
67.41%
CoT-SC 40.43%
16
CoT-SC
69.33%
16
ToT
43.02%
19.87
ToT
70.33%
24.57
CR
45.25%
17
CR
71.67%
16.76
Table 15: Comparison results on FOLIO-val
Table 16: Comparison results LD
Method
Acc.
# Visited States
Method
Acc.
# Visited States
Standard
60.29%
1
Standard
71.33%
CoT
67.65%
1
CoT
73.33%
CoT-SC
68.14%
16
CoT-SC
74.67%
16
ToT
69.12%
19.12
ToT 76.83%
21.83
CR
69.11%
15.87
CR
78.33%
16.98
Table 17: Comparison of results on different datasets.
B.2 Computational Considerations
The structured approach of CR, involving distinct Proposer, Verifier, and Reporter roles, and iterative DAG construction, may entail different computational overhead compared to simpler methods like CoT or even ToT, depending on the configuration.
If all roles are LLM-based, CR can involve more LLM calls per problem than a single CoT pass. For instance, each reasoning cycle might involve a Proposer call and a Verifier call. However, this is a deliberate design choice aiming for higher accuracy, The number of iterations is managed by the Reporter or predefined limit. As shown in experiments (e.g., "Iters" in Table 0 for MATH problems, and "VVisited States" in Table 7 for Game of 24, and additional data in Appendix B such as Table 13 and 14 CR often achieves superior accuracy. For example, in the Game of 24 (Table 7j. CR (b=5) achieved 98% accuracy with only
14.86 visited states, while ToT (b=5) achieved 74% with 61.72 states. This suggests that while individual steps in CR might be more involved due to verification, the overall search can be more efficient by avoiding unproductive paths.
A significant aspect of CR's flexibility is the Verifier (Hosseini al. 2024). When an LLM is used a Verifier (as in some of our FOLIO experiments), it adds to the LLM call count. However, demonstrated in our MATH experiments with code environment (Section 4.5 the Verifier can be non-LLM tool (e.g., a Python interpreter). Such symbolic verifiers are typically much faster and cheaper than LLM calls, significantly reducing the overhead of the verification step while increasing its reliability.
CR's approach of conditioning on previously validated steps the DAG means the context provided to the Proposer can grow. While this provides richer information, can also increase the token count for LLM calls. Future work could explore optimizing these dependencies, for instance, by selecting only the most relevant prior steps to manage context size without sacrificing much of the benefit of cumulative knowledge.
CR trades potentially increased computational steps (especially if LLM verifiers are used) for significant gains in accuracy and robustness, particularly on complex tasks. Its efficiency in terms of exploring fewer states to reach a correct solution, as seen in several benchmarks, suggests that offers a favorable balance, making suitable for sccnarios where high performance critical, potentially being more effective than exhanstive search or very wide ToT explorations for achieving similar results. The architecture uses the same underlying L.M for all roles (distinguished by prompts), avoiding the need to load multiple large
20

---

Published in Transactions on Machine Learning Research (07/2025)
models. We believe CR is particularly well-suited for test-time scaling where achieving the best possible answer justifies the additional computational steps.
C More on Logic
Limitations of First-Order Logic Systems. It is not surprising that the labels verified by FOL are still not satisfying. There are several limitations inside the FOL systems:
1. Limitations of Expressiveness (Löwenheim) 1967): FOL even lacks the expressive power to capture some properties of the real numbers. For example, properties involving uncountably many real numbers often cannot be expressed in FOL. In addition, properties requiring quantification over sets of real numbers or functions from real numbers to real numbers cannot be naturally represented in FOL.
2. Translation Misalignment: Risk of semantic discrepancies during translation, rendering resolutions inef- fective. For instance, translating statements as (z)rd(:) = CanFly(x)) and Vx((Fl(x;) = Wings(æ)) may cause misalignment between "CanFly" and "Fly", leading to flawed conclusions. It often fails to capture the full richness and ambiguity of natural language and lacks basic common knowledge (Gamul 1990).
3. Undecidability: The general problem of determining the truth a statement in FOL is undecidable (uur ing al. 1936 Chimakonam, 2012) (deeply connected the halting problem), constraining its applicability for automated reasoning in complex tasks.
C.1 Illustrative example on higher-order logic
Here we present a refined example derived from the FraCas dataset to illustrate higher-order logic inference. It is noteworthy that the FraCas dataset. (Cooper al., 1996) is dedicated to the realm of higher-order logic inference. This characterization also applies to a majority of the Natural Language Inference (NLI) datasets [Kmaar et al. 2022), which encompass their internal syntax, semantics, and logic. The intricate linguistic components such as quantifiers, plurals, adjectives, comparatives, verbs, altitudes, and so on, can be formalized with Combinatory Categorial Grammar (CCG) along with the formal compositional semanttcc [Mineshima et al. 2015).
Higher-order logic (HOL) has the following distinctive characteristics as opposed FOL Minnshhima et al, 2015):
Quantification over Functions: Higher-order logic (HOL) allows for lambda expressions, such Xy.report _attrttttttttttyttttaaata report), whereby functions themselves become the subject of quantification. An illus- tration of this is found the expression "a ropresentative who reads this report." Here, quantification spans the predicates representing both the representative and the reading of the report, phenomenon captured as a higher-order function. Unlike HOL, FOT is incapable of extending quantification to functions or predicates.
Generalized Quantifiers: The introduction of gencralized quantifiers, such as "most," serves another demarcation line between HOL and FOL. These quantifiers are capable of accepting predicates arguments, enabling the representation of relations between sets, a feat that transcends the expressive capacity of FOL.
Modal Operators: Employing modal operators like "might" signifies a transition towards HOL. These operators, applicable to propositions, give rise to multifaceted expressions that defy easy reduction to the confines of FOI..
Attitude Verbs and Veridical Predicates: The integration of attitude verbs, such as "believe," and veridical predicates like "manage," " injects an additional layer of complexity necessitating the use of HOL, These linguistic constructs can engage with propositions as arguments, interacting with the truth values of those propositions in subtle ways that demand reasoning extending beyond the capabilities of FOL.
Previously we have discussed the limitations FOL systems, what about HOL systems? Crafting HOL programs that are solvable by symbolic systems is a daunting task, even for experts. It also challenging for LLMs write these intricate programs effectively. Using formal theorem provers based on higher-order (categorical) logic and (dependent) type theory ups the ante, making it even harder. However, CR solves
21

---

Published in Transactions on Machine Learning Research (07 (07/2025)
these problems pretty well without resorting to and being restricted to symbolic systems, just like the way humans think.
[Modified Example FraCas-317)
Premises:
1. Most of the representatives who read the report have positive attitude towards it.
2. No two represenlatives have read it at the same time, and they may have different opinions about it.
3. No representative took less than half day to read the report.
There are sixteen representatives.
Hypothesis: It took the representatives than week read the report, and most found it valuable.
Label: [True]
Higher-Order Logic Premises:
mus((Xe.represenaavvvee)) A reads(er report), report, has ansilive_attitudeee roppor)))
report))
-3,, y (x # representative(2) A representativeey)/
read same time(1; same_timeer;, y, report))
V (x o representatiie(( A representative))))
peg((xedifferent_oooiiioot æ, report)))
-((((ppresentaaivvee)) took less than half day(A report))
conm((xa.epreeentativee))))) 16
Higher-Order Logic Hypothesis:
time_unit(t, (ettotal_reading.ne temeding_time(epprr)) time unit(t, day))
most((xrrrppreennaaaivee))) founo - report))
[Cumulative Reasoning by GPT-4]
Generated Propositions:
"Using P1 and P2, we can deduce Q1: Every representative read the report different time, and most representatives found the report valuable."
2. "Using P3 and Q1, deduce Q2: The total reading time must be at least 8 days. (since 16 represen- tatives each took at least half a day)."
3. "Using Q2 and P4, we deduce Q3: The representatives took at least 8 days to read the report."
Reasoning: "Based on the intermediate propositions Q1, Q2, and Q3, the hypothesis that took the representatives than week to read the report, and most found it valuable, is confirmed True."
Prediction: [True] (Correct)
Appendix for Examples
22

---

Published in Transactions on Machine Learning Research (07/202) 2025)
[Problem Description]
Premises:
(1) not true that some giant language models not have good performance.
(2) language models with good performance are used by some researchers.
(3) If language model is used by researchers, popular.
(4) BERT is giant language model, then GPT-3 is also giant language model.
(5) BERT is giant language model.
Hypothesis: GPT-3 is popular.
Label: [True]
hthougt Reasoning by GPT-4]
Reasoning: From the premises, we have:
1. (CoGantae)-GGGoPfeffmnnneeee)))
2. Va (GoodPerformance(()) + UsedByResearchers((c))
3. Vo (Useadyy)))srrrcessss( + Popular(x))
4. BERT GPT-3
5. BERT
Given that BERT is giant language model, premise (4) implies that GPT-3 is also a giant language model. However, premises do not explicitly provide information regarding GPT- 3's performance or usage by researchers, and hence no definitive conclusion on its popularity can be drawn.
Prediction: [Unknown] (Incorrect)
[Cumulative Reasoning by GPT-4]
Generated Propositions:
(1) GPT-3 is giaut language model with good performance.
(2) GPT-3 used by some researchers.
Reasoning: Since GPT-3 is a giant language model with good performance and is used by researchers, and given that any language model used by researchers is considered popular, it follows that GPT-3 is popular.
Prediction: [True] (Correct)
Figure 4: Example from the FOLIO dataset. The left panel shows a problem along with its premises, while the subsequent panels display reasoning by CoT and CR respectively. CR leverages intermediate propositions to yield the correct prediction.
[lllustrative example for Game of 24]
Numbers: [4, 6, 10)
Arithmetic Operations: [+, -, x, (6]
Solution:
(10 6) 4 24
Figure 5: An example from the Game of 24 dataset
Yao al. 2023
23

---

Published in Transactions on Machine Learning Research (07 (07/202) 2025)
[Problem Description]
Example ID: test/intermediate algebra/ 1igebra/1350..m 13500.soon
Level:
Subject: Intermediale Algebra
Problem: Consider the polynomial
((z) = a= + an-1x" n-
02æ" + aj do:
where the polynomial has integer coefficients and its roots are distinct integers.
Given an and = 66, the inquiry is to determine the least possible value of lan-1]-
[Ground Truth Solution]
Solution: Since f(x) has integer coefficients, the Integer Root Theorem asserts that any integer roots of f(x) must divide the constant term 66 = 2- 3- 11. Consequently, the polential integer roots of f(x) are
11, 12, +3, 16, +11, 122, 133, 166.
Additionally, given that all roots of f(x) integers, they are necessarily members of the aforementioned list.
We proceed to utilize Vieta's formulas. The roots of f(x) yield product of (-1)" ax which evaluates to either 33 or -33. Simultaneously, the sum of these roots is S-_ ا To minimize lan-il. we aim to reduce the absolute value of the root sum, ensuring that the product of the roots remains 33 or -33. Considering two distinct scenarios:
Case 1: One of the roots is 33 or -33. In this scenario, the only other viable roots are #1. Here, the root sum's absolute value at least 32.
Case 2:
One root is 11 or -11, and another is or -3, The only other plausible roots remain +1, leading
root sum't 's absolute value of at least 11 3 = 7. This is more optimal outcome than Case 1. For
an absolute root sum of 7, we find lan-1| 7|a.. = 14.
From our analysis, we deduce that lon-1| 2 14. Verifying this, we observe that equality is attained by
f(x) = 2(x + 11) - 3)(x 1)
= 2r 14x 82r 66,
which consistent with having integer coefficients and integer roots. Thus, the minimal achievable value
for |a..-| is 14
Answer: 14
Figure 6: An example from the MATH dataset
(endryykss et al. 2021 Lightman et al. 2023
24

---

Published in Transactions on Machine Learning Research (07 (07/2025)
[Chain-of-Thought Reasoning by GPT-4]
Reasoning: "Let's think step by step:
The roots of the polynomial are distinct integers, and the leading coefficient is 2, so the roots must be divisors of 2 33.
The divisors of are #3,
The sum of the roots of the polynomial is
9m-1 en
4. To minimize |a.-1), we should select the roots to be as close to zero as possible.
5. The smallest possible sum of the rools is -1 - 3 11 33
40,
6. Thus, the smallest possible value of [an-1] is 2 x 40 80
Answer: 80 (Wrong)
[Cumulative Reasoning by GPT-4]
Generated Hints:
1. "Hint 1: Recall Vieta's formulas, which relate the coefficients of polynomial the and
products of its roots."
2. "Hint 2:
The product of the roots of the polynomial is equal to
"Hint 3: The sum of the roots of the polynomial is equal to 9p-1
4. "Hint 4: Since the roots are distinct integers, consider the factors of and their sums."
Generated Simple Questions and Answers:
Question 1: "What is the product of the roots of the polynomial f(x)?"
Answer 1: "The product of the roots of the polynomial is -4
33."
Question 2: "What are the possible sets of distinct integer roots of the polynomial?"
Answer 2: "The possible sets of distinct integer roots are {-33, 1}, {-11,3), 3), and (-3, 11, 11,""
Question 3: "What are the sums of the roots each possible set of roots?"
- Answer 3: "The sums of the roots are -32, 8, and 7 for the sets {-33,1) 1). {-11,3), and (1,
respectively."
Q Question 4: "What is the least possible value of |an-1|?"
Answer 4: "The least possible value of lo.-1| is x 14."
Solution: "Let's think step by step. Given that a, = and dg = 66, and the roots of the polynomial
are distinct integers, the least possible value of la.-1l 14
Answer: 14 (Correct)
Solutions for the example presented in Figure from the MATH dataset, generated by CoT and CR. CoT will generate the answer directly through a chain of thought. By contrast, CR will first generate a few hints, then several simple and foundational questions, and then answer them by self, and finally conclude with the help of the generated hints and question-answer pairs.
Figure 7:
25

---

Published in Transactions on Machine Learning Research (07 (07/202) 2025)
E More on Datasets
E.1 More FOLIO Examples
[Example ID: 603]
Hypothesis: Hyraxes lay eggs.
Premises:
The only types of mammals that lay eggs are platypuses and echidnas.
2. Platypuses not hyrax.
Echidnas are not hyrax.
4. No mammals invertebrates.
5. All animals are either vertebrates or invertebrates.
6. Mammals are animals.
Hyraxcs are mammals.
8. Grebes lay eggs.
9. Grebes are not platypuses and also not echidnas.
Label: [False]
[Chain-of-Thuugh Reasoning by GPT-4]
Reasoning: "The premises state that the only types of mammals that lay eggs platypuses and echidnas. Hyraxes are mammals but are neither platypuses nor echidnas. Since the conclusion is about hyraxes laying eggs but there's no direct information in the premises on this topic, the conclusion cannot be determined with certainly."
Prediction: [Unknown] (Wrong)
[Cumulative Reasoning by GPT-4]
Generated Propositions:
1. "All mammals are either vertebrates or invertebrates." "Hyraxes do not lay eggs, as they are neither platypuses nor echidnas."
"We can deduce that the only types of mammals that lay eggs are platypuses and echidnas. Hyraxes are mammals, but they are neither platypuses nor echidnas. Therefore, hyraxes do not lay eggs."
Reasoning:
Prediction:
[Falsc] (Correct)
[Example ID: 546]
Hypothesis: Extractive models are not always faithful.
Premiscs:
1. A summarization model is always faithful if it uses content from the input documents. Extractive models are a kind of summarization modols.
3. Extractive model can only content from the input documents.
Label: [False]
26

---

Published in Transactions on Machine Learning Research (07/2025)
[Chain-of-Thoupe Reasoning by GPT-4]
Reasoning: "The premises state that summarization model is always faithful if uses content from the input documents. Extractive models are kind of summarization model, and they can only use content from the input documents. However, the premises do not provide any information about whether extractive models always faithful not."
Prediction: [Unknown] (Wrong)
[Cumulative Reasoning Reasoning by GPT-4]
Generated Propositions:
1. "All extractive models are faithful summarization models since they use content from the input documents."
"All laithful summarization models use content. from the input documents."
Reasoning: "We can infer that extractive models are always faithful because they only use content from the input documents and satisfy the condition for a summarization model to be faithful. Therefore, the conclusion that extractive models are not always faithful is incorrect."
Prediction: [False] (Correct)
[xxample ID: 404]
Hypothesis: No coursing is banned.
Premises:
1. Greyhound racing is competitive sport where spectators bet greyhounds.
Coursing is a part of Greyhound racing.
3. Some competitive sports where spectators bet on things are banned. Coursing involves spectators betting on a hare being pursued by greyhounds.
5. Hares are small game.
competitive sport involves spectators betting on small game, then it banned.
Label: [False]
(Chain-of-Thoughtt Reasoning by GPT-4]
"The premises state that coursing is part of greyhound racing, and involves spec- tators betting on a hare being pursued by greyhounds. Hares are small game, and if competitive sport involves spectators betting on small game, then it banned. It's also mentioned that some competitive sports where spectators bet on things are banned. However, the premises do not clearly state the status of coursing being banned not banned."
Reasoning:
Prediction: [Unknown] (Wrong)
27

---

Published in Transactions on Machine Learning Research (07/2025)
[Cumulative Reasoning Reasoning by GPT-4]
Generated Propositions:
"If a competitive sport involves spectators betting on hares, then it banned."
2. "Coursing is competitive sport that involves spectators betting on small game."
Reasoning: "We know that coursing competitive sport involving spectators betting small game, specifically hares. The premises also state that if competitive sport involves spectators betting on small game, then it is banned. Thus, can deduce that there is a possibility that coursing is banned. The hypothesis claims that no coursing is banned, which contradicts the deduction that coursing might be banned."
Prediction: [False] (Correct)
Examppe ID: 609]
Hypothesis: Allison has room for broccoli.
Premises:
1. If you have room for dessert, you have room for broccoli.
Everyone at Luis's dinner party has room for dessert, including Luis.
3. Mauricia does not have room for broccoli.
Luis's dinner party the first ever dinner party that Allison has attended.
5. Gustave has room for both broccoli and asparagus.
Broccoli and asparagus are both vegetables.
Label: [True]
(Chain-of-Thoughl Reasoning by GPT-4]
"The premises state that you have room for dessert, you have room for broccoli. Everyone Luis's dinner party has room for dessert, including Luis. However, we do not have information specifically about Allison having room for dessert not, even though it's her first dinner party. Thus, can't conclude with certainty if Allison has room for broccoli."
Reasoning:
Prediction: [Unknown] (Wrong)
[Cumulative Reasoning by GPT-4]
Generated Propositions:
1. "Gustave has room for vegetables."
"Everyone at Luis's dinner party, including Mauricia, has room for dessert."
Reasoning: "We know that:
1. If one has room for dessert, they have room for broccoli.
2. Everyone at Luis's dinner party, including Luis and Allison, has room for dessert.
Using these premises, we can infer that since everyone at Luis's dinner party has room for dessert, they also have room for broccoli. Therefore, Allison, who is Luis's dinner party, must have room for broccoli."
Prediction: [True] (Correct)
28

---

Published in Transactions on Machine Learning Research (07 (07/202) /025)
E.2 Curating FOLIO wiki dataset
1. Missing common knowledge contradictory to common knowledge; (9 in total, Example ID No. 34, 62,
162, 167, 228, 268, 526, 677, 679)
141, 2. Overly ambiguous problems failing provide unequivocal answers; (37 in total, Example 215, 216, 223, 252, 261, 298, 321, 330, 396, 102, 109, 411, 131, 432, 156, 157, 482, 183, 196, 563, 572, 599, 624, 629, 641, 654, 660, 673, 682, 698, 750)
3. Tnherent inconsistencies presented within the premises; (2 in total, Example TD No. 640, 643) Vague premises or typographical errors; (2 total, Example
314, 315) 5. Incorrect answers. (24 in total, Example ID No. 9, 46, 52, 84, 100, 144, 273, 276, 299, 310, 322, 345, 367, 137, 452, 453, 164, 557, 573, 578, 605, 632, 671, 715)
[Problem Description]
Example ID: 679
Premises:
1. Zaha Hadid is British-Iraqi architect, artist and designer.
2. Zaha Hadid was born on 31 October 1950 in Baghdad, Iraq.
Hadid was visiting professor of Architectural Design at the Yale School of Architecture
Max is an aspiring architecture student, and he plans to apply to Yale School of Architecture.
Hypothesis: Hadid was born 1982.
FOL Label: [Unknown]
Human Label: [False]
Explanation: We can see that Zaha Hadid was born on 31 October 1950 in Baghdad, Iraq. This directly contradicts the hoppolhesis that Hadid was born 1982. common knowledge that people are born only once, and someone can't be born in bwo different years.
Figure 8: Example 679 from the FOLIO wiki dataset, the origin label provided by the FOL, system is not correct, we choose to curate this dataset, removing these examples with wrong labels. For more examples, please refer to Appendix E.3
E.3 More examples problems excluded from FOLIO wiki curated
Type 1 Error: Missing common knowledge contradictory to common knowledge
29

---

Published in Transactions on Machine Learning Research (07 (025)
[Example ID: 34]
Premises:
The Croton River watershed is the drainage basin of the Croton River.
2. The Croton River is in southwestern New York.
Kings are male.
4. Water from the Croton River watershed flows to the Bronx.
The Bronx is in New York.
Hypothesis: Water from the Croton River flows to the Bronx.
Label: [Unknown]
Wrong Type: [Type 1: Missing common knowledge or contradictory to common knowledge in the premises]
We undersland that the Crolon River is in soullwesserr New York, and the Brona is also located in New York. It is stated that water from the Croton River watershed flows to the Bronz, and the Croton River watershed is the drainage basin of the Croton River. It is common knowledge that water from a river flows the Croton River flows the Brons.
Explanation:
drainage basin. Therefore, is true that water from
[Example ID: 268]
Premises:
1. Bernarda Bryson Shahn was painter and lithographer. Bernarda Bryson Shahn was born Athens, Ohio.
3. Bernarda Bryson Shahn was married to Ben Shahn.
People born Athens, Ohio are Americans.
Hypothesis: Bernarda Bryson Shahn was born in Greece.
Label: [Unknown]
Wrong Type: [Type 1: Missing common knowledge or contrudictory to common knowledge in the premises]
Explanation: We know that Bernarda Bryson Shahn was born in Athens, Ohio. It is common knowledge that Greece is not in Ohio. It also states that people born in Alhens, Ohio, are Americuns. Thus, it is false to conclude that Bernarda Bryson Shahn was born in Greece.
30

---

Published in Transactions on Machine Learning Research (07 (07/2025)
[Example ID: 62]
Premises:
The Golden State Warriors are a team from San Francisco.
2. The Golden State Warriors won the NBA finals.
All teams attending the NBA finals have more than thirty years of history.
4. Boston Celtics are a team that lost the NBA finals.
team wins the NBA finals, then they will have more income.
6. If team wins or loses at the NBA finals, then they are attending the finals.
Hypothesis: The Golden State Warriors will have more income for gale receipts.
Label: [True]
Wrong Type: [Type 1: Missing common knowledge contrudictory to common knowledge in the premises]
Explanation: We know that the Golden State Warriors won the NBA finals and that if a team wins the NBA finals, they will have more income. Therefore, we can infer that the Golden State Warriors will have more income. However, the hypothesis mentions 'more income for gate receipts," and there is information about gate receipts the premises.
Type 2 Error: Overly ambiguous problems failing to provide unequivocal answers
[Example ID: 496]
Premiscs:
Some fish may sting-
2. Stonefish is fish.
stings step on a stoncfish.
4. Stonefish stings cause death if not treated.
To treat stonefish stings, apply heat to the alfected area or use an antivenom.
Hypothesis:
If you step a stonefish and apply heat to the affected area, stings will cause death.
Label: [Unknown]
Wrong Type: [Type 2: Overly ambiguous problems failing to provide unequivocal answers]
The premises state that applying heat to the affected area or using antivenom treat stonefish stings. Thus, if heat is applied to the affected area, it should help treat the sting and prevent. death. However, il is not cerlain that applying heal to the affected area will prevent death, as it is possible that the sting is too severe to be treated with heat.
Explanation:
31

---

Published in Transactions on Machine Learning Research (07 (07/202) 2025)
[Example ID: 432]
Premises:
Vie DiCara plays guitar and bass.
2. The only style of music Vic DiCara plays is punk music.
Vie DiCara played in the band Inside Out.
Hypothesis: If you step on a stonefish and apply heat to the affected area, stings will cause death.
Label: [Unknown]
Wrong Type: [Type 2: Qverly ambiguous problems failing to provide unequivocal answers]
Explanation: We know that Vic DiCara played in the band Inside Out and the only style of music he plays is punk music. This information implies that Inside Out played punk music while Vic DiCara was member. However, it is not certain that Inside Out was a punk band, as it is possible that the band played a different style of music before Vic DiCara joined.
[Example ID: 673]
Premises:
1. Cancer biology is finding genetic alterations that confer selective advantage to cancer cells. Cancer researchers have frequently ranked the importance of substitutions to cancer growth by value.
3. P values are thresholds for belief, not metrics of effect.
Hypothesis: Cancer researchers tend to use the cancer effect size to determine the relative impor- tance of the genetic alterations that confer selective advantage cancer cells.
Label: [Unknown]
Wrong Type: [Type 2: Overly ambiguous problems failing to provide unequivocal answers]
Explanation: We can deduce that cancer researchers tend to use P values, not effect sizes, to rank
the importance of genetic alterations. Thus, the hypothessi contradicts the premises. However, still possible that concer researchers use the cancer effect size to determine the relative importance of the genetic alterations that confer selective advantage to concer cells.
Type 3 Error: Inherent inconsistencies presented within the premises
32

---

Published in Transactions on Machine Learning Research (07 (07/2025)
[Example ID: 640]
Premises:
William Dickinson was British politician who sat in the House of Commons.
2. William Dickinson attended Westminster school for high school and then the University of Edinburgh.
3. The University of Edinburgh is university located in the United Kingdom.
4. William Dickinson supported the Portland Whigs.
People who supported the Portland Whigs did not get scat in the Parliament.
Hypothosis: William Dickinson did not get a seat in the Parliament.
Label: [True]
Wrong Type: (Type: 3: Inherent inconsistencies presented within the premises]
Explanation: We have contradiction. On one hand, we have information that William Dickinson supported the Portland Whigs, and people who supported the Portland Whigs did not get seat in the Parliament. On the other hand, another premise states that William Dickinson was a British polilician who sat in the House of Commons, which implies that he did get a seal in the Parliament.
EEammll ID: 643]
Premises:
William Dickinson was a British politician who sat the House Commons.
2. William Dickinson attended Westminster school for high school and then the University of Edinburgh.
The University of Edinburgh is a university located in the United Kingdom.
4. William Dickinson supported the Portland Whigs.
People who supported the Portland Whigs did not get a seat the Parliament.
Hypothesis: William Dickinson sat in the House of Commons.
Label: [True]
Wrong Type: [Type 3: Inherent inconsistencies presented within the premises]
Explanation: We have contradiction. On one hand, we have information that William Dickinson supported the Portland Whigs, and people who supported the Portland Whigs did not get seut in the Parliament. On the other hand, another premise states that William Dickinson was a British politician who sat in the House of Commons, which implies that he did get a seat in the Parliament.
Type 4 Error: Vague premises typographical errors
33

---

Published in Transactions on Machine Learning Research (07 (07/2023) /025)
[Example ID: 314]
Premises:
Palstaves type of early bronze axe.
2. Commonly found in northern, western and south-western Europe, palstaves are cast in moulds.
John Evans is an archeologist who popularized the term 'palstave'.
4. A paalstab is not an axe, but rather a digging shovel.
Hypothesis: John Evans Popularized the term paalstab.
Label: [Unknown]
Wrong Type: [Type 4: Vague premáses or typographical errors]
Explanation: What is palstave and paalstab? Were they misspelled?
[Example ID: 315]
Premises:
Palstaves are type of early bronze axe.
2. Commonly found in northern, western and south-western Europe, palstaves are cast in moulds.
John Evans is an archeologist who popularized the term 'palstave'.
4. A paalstab is not an axe, but rather digging shovel.
Hypothesis: There is
that is commonly found in Western Europe.
Label: [Unknown]
Wrong Type: [Type 4: Vague premáses or typographical errors]
Explanation: We can see that palstaves are a type of early bronze aze and they are commonly
found in northern, western, and south-western Europe. Therefore, it is true that there is an aze that is commonty found in Western Europe. However, the premises also state that a paalstab is not are, but rather digging shovel. Was poalstab the same thing palstaves?
Type 5 Error:
Incorrect answers
[Example ID: 9]
Premises:
Palstaves are a type of carly bronze axe.
2. Pierre de Rigaud de Vaudreuil built Fort Carillon.
3. Fort Carillon was located in New France.
4. New France is not in Europe.
Hypothosis: Fort Carillon was located in Europe.
Label: [Unknown]
Wrong Type: [Type 5: Incorrect answers]
Explanation: We know that Fort Curillon located in New France, and New France is not in Europe. Therefore, Fort Carillon was not located in Europe.
34

---

Published in Transactions on Machine Learning Research (07 (07/202) /025)
[Example ID: 632)
Premises:
New York City is the East Coast.
2. Seattle is on the West Coast.
person from a city on the East coast traveling a city on the west coast, they will be long flight.
4. Most passengers on flights to Seatile from New York City are not in first class.
People long flights uncomfortable unless they're in first class.
Hypothosis: Some people flying from New York City to Seattle will be uncomfortable.
Label: [False]
Wrong Type: (Type 5: Incorrect answers]
Explanation: We can deduce the following: 1. A person traveling from New York City to Seatile will be on a long flight (since New York City is on the East Coast and Seattle is on the West Coast). 2. Most passengers on flights from New York City to Seattle are not in first class. 3. People on long flights are uncomfortable unless they're in first class. Given this information, we can conclude that some people flying from New York City to Senttle will be uncomfortable, as most of them are not in first class and long flights couse discomfort for those not in first class.
Example ID: 671]
Premises:
Westworld is an American science fiction-thriller TV series.
2. In 2016, new television series named Westworld debuted on HBO.
The TV series Westworld adapted from the original film in 1973, which was written and directed by Michael Crichton.
4. The 1973 film Westworld is about robots that malfunction and begin killing the human visitors.
Hypothosis: Michael Crichton has directed film about robots.
Label: [Unknown]
Wrong Type: [THpe 5: Incorrect answers]
Explanation: We can deduce that Michael Crichton wrote and divected the 1973 film Westworld, which about robots that malfunction and begin killing the hummnn visitors. Thus, is true that Michael Crichton has directed a film about robots.
35

---

Published in Transactions on Machine Learning Research (07 (025)
F Appendix for Prompts
The design of few-shot prompts is critical to guiding the behavior of each LLM role within CR. We crafted these prompls intending to encapsulate the essence of each role:
The Proposer prompt encourages the generation of plausible next steps hypotheses.
The Verifier prompt focuses on assessing the validity of these propositions.
The Reporter prompt aims at determining the sufficiency of information for concluding the reasoning process.
There have been several works (Reynolss & McDonell 2021 Zhang al. 2024a Zhou et al. 2024 show- ing that zero-shot meta-pres peta-prompts can also work well, which minimizes the bias introduced in the few-shot examples.
System: Suppose you are one of the greatest AI scientists, logicians, and mathematicians. Let us think step by step. Please use First-Order Logic (FOL) to deduce a "Proposition" from two given "Premises". Please make sure that the "Proposition" is logically correct. Please make sure that the "Proposition" is not a duplicate of the "Premises". Please make sure your reasoning directly deducod from the "Premiscs" and "Propositions" rather than introducing unsourced common knowledge and unsourced information by common sense reasoning. Please remember that your "Proposition" should be useful to determine whether the Hypothesis is True, False, or Unknown.
User:
"Premises": ('this.rremisee,
We want to deduce more propositions to determine the correctness of the following Hypothesis: "Hypothesis": "(this.hypothesis)"
Assistant:
"Proposition":
"[[to be generated]]"
Figure 9: Prompt template for CR Proposer on logical inference tasks.
System: Suppose you are one of the greatest AI scientists, logicians, and mathematicians. Let us think step by step. Please use First-Order Logic (FOL) to determine whether the deduction of two given "Premises" to a "Proposition" valid or not, and reply with True or False.
User:
"Premises": "(this. }
"Proposition": "(this. propossoop"s
Assistant:
"Judgement": "Is this deduction valid? ([True or Falsc]]"
Figure 10: Prompt template for CR Verifier on logical inference tasks.
36

---

Published in Transactions on Machine Learning Research (07 (07/2025)
System: Suppose you are one of the greatest AT scientists, logicians, and mathematicians. Let us think step by step. Read and analyze the "Premises" first, then use First-Order Logic (FOL) to judge whether the "Hypothesis" is True, False, or Unknown. Please make sure your reasoning is directly deduced from the "Premises" and "Propositions" rather than introducing unsourced common knowledge and unsourced information by common sense reasoning.
User:
"Premises": " "(this.prenn "iahiispremisss""""
"Hypothesis": "[this.hypon "hhthhhypothesss"""""
Assistant:
"Thoughts": "Let think step by step. From the premises, we can deduce propositions:
{this. p
"Recall the Hypothesis": (itthi.hypothesiss
"Judgement": "Now we know that the Hypothesis {[True or F
Figure 11: Prompt template for CR Reporter on logical inference tasks.
System: Suppose you are one of the greatest Al scientists, logicians, and mathematicians. You are very good at basic arithmetic operations. Use numbers and basic arithmetic operations obtain 24 with input numbers. In each step, You are only allowed to randomly choose arbitrary TWO of the input numbers to obtain a new number using arbitrary one basic arithmetic operation (AVOID duplicating with forbidden steps). Your calculation process musl. be correct.
* /) (+-+/)
User: Input: [a, c, d] Next Step:
Assistant: * c
User: Remaining Numbers:
Assistant:
[a, b, e]
Figure 12: Prompt template for CR Proposer on Game of 24.
System: Suppose you are one of the greatest AI scientists, logicians, and mathematicians. You are very good at basic arithmetic operations. Use numbers and basic arithmetic operations (+ /) to obtain 24 with input numbers. Evaluate if the given intermediate step is correct and only use two existing numbers.
User:
Input: 10,
Intermodiate step: 10 + 14 24
Assistant:
The intermediate step is valid.
Judgement:
Valid
User:
Input: [a, b]
Intermediate step: la op result]
Assistant:
[[reasoning to be gencrated]]
Judgement:
([Valid or Invalid]
Figure 13: Prompt template for CR Verifier (a) on Game of 24.
37

---

Published in Transactions on Machine Learning Research (07/2025)
System: Suppose you are one the greatest AI scientists, logicians, and mathematicians. You are very good al basic arithmetic operations. Use numbers and basic arithmetic operations (+- /) to obtain 24 with input numbers. Evaluate if given numbers reach 24 /likely/imm possible).
User:
Input:
10, 14
Draft:
Assistant: 14 10 4
14 10 = 140
10 14 = 5/7
/ / 10 = 1.4
+ 14 24
User:
Input: (remaining numbers)
Draft:
Assistant:
sure
10 + 14 24
User:
[[reasoning to be generated]]
Judgement:
{[Valid or Invalid]
Figure 14: Prompt template for CR Verifier (b) on Game of 24.
38

---

Published in Transactions on Machine Learning Research (07/2025)
System: Suppose you of the greatest AI scientists, logicians, and mathematicians. You are very good at basic arithmetic operations. Use nunbers and basic arithmetic operations (+ /) to obtain 24 with input numbers. You need to combine the given intermediate steps step-by-step into a complete expression.
User:
Input: 1, 1, 4, 6 Intermediate steps:
4 4 = 4 (left 1, 4, 6)
1 * * = 24
Assistant:
Drafi:
Because
1 4 24, while * 4 4. So * (1 4) 6 24.
Output:
1 (1 4) * 6 24
User:
Input: (input)
Intermediate steps: (intermediate steps)
Assistant:
Draft:
{[to be generated)
Output:
([to be generated]
Figure 15: Prompt template for CR Reporter on Game of 24.
39

---

Published in Transactions on Machine Learning Research (07 (07/2025)
сyntea
Problem: (probleal
Solottor:
late" step step. (scerucnds interpeating the origie prohlon)
Prelininary
(prslinisary
(peeliisuryy
[...]
a58 Riats
witnrr (e: (ueatel hinte
48iaa 20: lwseell hists 21
[...]
Stape:
Like
velnaver Sbotcase: (urite abetch
to queation i]
attee Code for Quaation
[call cade intergratar hare vartty and soten your ausuer seetch to quaeciion 1]
aded Asswer for Quesijus
+Adosvor** Eyour ausver ts this quessios based on the rosulto
zive code interprater presented))
Dusaticn aucond qusatiou
ginetton
[oall
sdee fnswer dor Question
this question based on the awaults glvm by soda interprater (tf grarastac)]
-Aluseer:: [your
eder Qresticn 3: [the taird question you rassed)
**insvor Skotches: Dorite a sketoh of your answer to gueation N]
rtpee Qraation
iniezpcutir buse verily your unsver quertizo
sde (uuotion ...]
Ese Final Solution:
Becoll the crizia peobles cHazaft [origis problea) </Hatals.
thisk step by stap.
your
Icall
fimul solutival
odee Fizal.
lprosent: the final insvee in latex boxed formas, $1oonet58311121 Pizal Anscor: the anszor le #lhoredt... J8.
</ayataz>
Figure 16: Meta Prompt for CR with code environment on solving MATH problems.
40


Reviews:
[{"review_id": "wrxkbbYkZF", "reviewer": "Reviewer_poJi", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "Strengths\n- Comprehensive experiments are conducted across various base models and tasks, showcasing the framework's applicability.\n- The implementation details of the framework are thoroughly explained, providing clarity and reproducibility.\n\nWeaknesses\n- The novelty of the proposed system is limited. The concept of utilizing LLMs for reasoning step generation, self-verification, and information integration to enhance reasoning performance has been extensively explored in existing literature. While the framework demonstrates performance improvements compared to traditional reasoning methods (e.g., CoT, ToT), its contribution is more technical in nature rather than a broader scientific advancement with wide-ranging impact on the research community. \n\nSuggestions\n- To enhance the novelty of this paper, I recommend that the authors delve deeper into the methodology and aim to uncover more general insights into the reasoning process. While the performance improvement is certainly an encouraging indication of the proposed framework's effectiveness, further exploration could focus on identifying the key components that drive its success and pinpointing the bottlenecks in other methods. Additionally, a comparison with other similar reasoning frameworks would provide valuable context and contribute to a more in-depth analysis. Beyond performance improvement, it would be important to include a quantitative evaluation and comparison of the computational overhead introduced by different reasoning methods, as this should be considered a critical metric.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "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": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper introduces a framework called Cumulative Reasoning (CR) aimed at improving the reasoning capabilities of large language models (LLMs). The framework explicitly assigns the LLM three distinct roles throughout the reasoning process: proposer, verifier, and reporter. As the proposer, the LLM generates intermediate reasoning steps based on the given context. In the role of verifier, the LLM (or external reasoning systems) converts these intermediate steps into formal representations. Finally, as the reporter, the LLM synthesizes the final solution by integrating information from all intermediate steps. The design of this system is intuitive, and its effectiveness in enhancing the reasoning abilities of existing LLMs has been empirically demonstrated.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "A major revision is required, as explained in my previous comments. In addition, the discussion of related work needs to be expanded to provide a more detailed comparison between the proposed framework and existing approaches in multi-agent reasoning enhancement, as well as self-critique methods in reasoning tasks.", "broader_impact_concerns": "No concern on the ethical implications of the work requires adding a Broader Impact Statement.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "WQX64LkRKE", "reviewer": "Reviewer_zVDj", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "Strengths: \n\n1. CR introduces a structured, iterative approach that mimics human-like reasoning by dynamically storing and validating intermediate results, addressing a key limitation in prior methods like CoT and ToT.\n\n2. The method achieves state-of-the-art (SOTA) performance across multiple benchmarks, including 98% accuracy in 24-game solving and 42% relative improvement in MATH Level 5 problems, demonstrating broad applicability.\n\n3. By decomposing problems into smaller steps and validating intermediate results, CR better emulates human System 2 reasoning compared to single-pass or tree-based approaches.\n\nWeaknesses:\n\n1. Lack of Comparison with Latest Reasoning Methods: The paper does not benchmark CR against more recent reasoning frameworks such as Graph-of-Thought (GoT), Self-Consistency with Voting (SCV), Forest of Throught (FoT), etc., which could provide a clearer picture of its relative advantages.\n\n2. Employing three separate LLM roles (Proposer, Verifier, Reporter) may increase computational costs compared to simpler prompting strategies (e.g., CoT-SC).", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "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": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The paper introduces Cumulative Reasoning (CR), a novel framework designed to enhance the reasoning capabilities of large language models (LLMs) by decomposing complex problems into smaller, manageable components and iteratively refining solutions through three specialized LLM roles: Proposer, Verifier, and Reporter. Inspired by Kahneman’s dual-process theory, CR shifts LLMs from fast, intuitive processing to more deliberate, stepwise reasoning. The method demonstrates strong empirical performance on several benchmarks, outperforming existing approaches like Chain-of-Thought (CoT) and Tree-of-Thought (ToT).", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "1. Currently, the innovativeness of  the proposed method is weak compared with other wokers.  \n2. More reasoner frameworks have been proposed, it is better to make some comparisions.", "broader_impact_concerns": "No.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "HF8BeLgWzo", "reviewer": "Reviewer_vNxH", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "Overall, the idea is interesting and aligned with the recent trends in the LLM research that a proposer-verifier framework leads to improved results and better consistency.\n\nThe paper is also generally well written and easy to follow. It is undeniable that with their technique the authors got interesting improvements compared with the baselines they use. This can give some insights on how to effectively prompt LLMs to improve their performance on reasoning tasks.\n\nHowever, there are several things that I find problematic (my feedback might sound harsh but I really intend it to be polite and constructive, I hope this is getting through it). Specifically:\n- The method section (Section 3) is just saying that they split the LLM prompt in three parts, then all the details are in the appendix. Moreover, the way it is described is very redundant and fuzzy. The authors refer to “intuitionistic logic” and “the philosophy of mathematical constructivism” without any reference on why these fields are making the difference for their approach compared to the baselines. A lot of it sounds like “empty words” that sounds convincing but they are not technically contributing to the method definition.\n- The verifier is defined as the part that “translate(s) the candidate steps into formal representations—using symbolic reasoning systems or an integrated code environment—to ensure logical soundness” and then in section 3.1 they “…assume that whenever a verifier is employed, its accuracy is near-perfect”. But then in practice they use just another prompt to LLMs to do the verification part, and that for sure does not ensure any logical soundness, nor satisfy the near-perfect assumption. Only for one experiment they use a real verifier. That, I believe, is the most interesting part of the paper. From the definition of the method it looked like the entire paper was focused on this (especially considering the preliminaries on logic, and the appendix on higher order logic). I highly recommend rephrasing the misleading parts, or focus on actually using reliable verifiers.\n- Section 3.1 is entitled “Comparison with CoT and ToT” but it is not really a comparison. One would expect to finish reading the section with a clear idea of how CR differs with respect to CoT and ToT, but that is not the case. The authors have a nice figure (Fig. 3) that showcases it, but they do not describe it. Many details are left to the reader to figure out (and the text is very small). For example, the distribution over the previous nodes seems to be a key aspect (they condition each step on all the previous steps, instead of keeping only “linear” dependencies), but that is not discussed at all. This also seems to increase the complexity of the method (adding variables to the conditioning set can increase exponentially the modelled distribution).\n- Moreover, still in Section 3.1, the entire point is to “prove” that CR gives correct results with higher probability with respect to CoT/ToT. The problem is that Assumption 3.2 is very strong, and once that is assumed, Theorem 3.4 is trivially satisfied. The assumption (please correct me if I’m wrong) is saying that a single step of CR is more likely to lead to a correct result than ToT, and, what is even more problematic, is that this is a monotonic property that keeps holding when new nodes are added. The authors say that this assumption has been empirically validated in various tasks but as far as I understand it: (1) they should verify that p_ToT <= p_CR, and that cannot be done by related works since *this* is the work introducing CR; (2) they would need to show that at *every* step the assumption holds, and I do not see experiments showing this. It is in fact probably not hard to see that this assumption does not hold by analysing LLMs output traces: in practice, refinements can lead to poorer results because of hallucinations or other statistical artefacts, no? Earlier in the section, they also “assume that a unique correct reasoning path exists for the problem”. Why? Isn’t this quite limiting?\n- Finally, one might wonder what are the real insights provided by the CR method. As I said, the improvements are undeniable wrt to the baselines used, but the technique of using a proposer-verifier is not really new [1,2], and the authors compare CR only with CoT/ToT. So what are the insights for the scientific community? Moreover, there are works showing the computational limitations of autoregressive models [2,3], and CR seems to provide an advantage because it trades time and memory for accuracy, like other similar works, or the most recent models do. Is this the case? What would be interesting is showing how efficient this method is compared to other similar ones in terms of tokens used, for example. If a DAG-like structure is exploited to keep the reasoning dependencies under control that could be a neat advantage.\n- It is also worth noticing that the models used in this work are quite outdated now, and one might wonder if the more recent models that are trained to mimic reasoning (eg. DeepSeek R1) already solve this problems more efficiently than using CR..?\n\n[1] Xiang et al. “Towards System 2 Reasoning in LLMs: Learning How to Think With Meta Chain-of-Thought”\n[2] Ahn et al. “Do As I Can, Not As I Say: Grounding Language in Robotic Affordances”\n[3] Peng et al. “On Limitations of the Transformer Architecture”\n[4] Hazra et al. “Can large language models reason? A characterisation via 3-SAT”", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "No", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "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": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This work introduces a new prompting technique called “Cumulative Reasoning” (CR). The idea is that it should decompose a reasoning task into smaller tasks, and re-use previous “verified” propositions to compose them to enhance the problem-solving capabilities of LLMs.\n\nThe idea is based on the fact that the reasoning logical steps are better represented by a direct acyclic graph (DAG) instead of a linear sequence of deductions. In order to enforce a DAG structure in the LLM “steps of thought” they have three subprocesses: the proposer, the verifier, and the reporter.", "claims_and_evidence_yn": "No", "claims_explanation": "", "audience_yn": "No", "audience_explanation": "", "requested_changes": "All my concerns must be tackled for me to consider the work to be ready for publication. The only exception is the last point on comparing with more modern LLMs because I do realise that it is not always easy to access the most recent models, even though I believe an effort into that direction would make the work way more solid, future-proof, and interesting for the community. At the very least, however, it is necessary to refresh the related works section.", "broader_impact_concerns": "No concerns.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Decision: Accept (poster)