Pith. sign in

REVIEW 4 major objections 6 minor 30 references

Recursive Decomposition with Dependencies for Generic Divide-and-Conquer Reasoning

T0 review · 4 major / 6 minor · reviewed 2026-08-16 · deepseek-v4-flash

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

Pith's one-line read A task-agnostic recursive splitting method lets LLMs beat step-by-step reasoning on hard problems while doing less work.

desk verdict A genuinely useful decomposition method, but the compute-matched headline claim is not supported by the paper's own resource tables; the evaluation needs another pass before publication. read the letter →

arxiv 2505.02576 v1 pith:VNH4QVM3 submitted 2025-05-05 cs.AI cs.LG

Sergio Hernández-Gutiérrez , Minttu Alakuijala , Alexander V. Nikitin , Pekka Marttinen This is my paper · ORCID
classification cs.AIcs.LG
keywords recursivedecompositiondivide-and-conquerreasoninglargelanguagemodelschain-of-thoughtpromptingleast-to-mostself-consistencysub-taskdependenciesdirectedacyclicgraph
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

Recursive Decomposition with Dependencies (RDD) is a prompting method that repeatedly asks a large language model to split a reasoning problem into smaller sub-problems, solve each one (or split again), and merge the answers. The paper's central claim is that this generic split–solve–merge loop improves accuracy on complex problems relative to chain-of-thought and least-to-most prompting with self-consistency, once the problem passes a certain difficulty threshold, and that it does so while generating fewer tokens and running faster. RDD needs no task-specific examples: the same fixed set of generic demonstration decompositions works on unseen problem classes. The method also lets the model mark dependencies between sub-problems with identifiers, so the decomposition graph becomes a directed acyclic graph rather than a simple tree, and the merge step is told it may fix mistakes found in sub-solutions.

What carries the argument

The load-bearing mechanism is the recursive decomposition pipeline with three fixed meta-tasks—decompose, unit-solve, and merge—plus a scheduler that executes them (breadth-first decomposition until an unsatisfied dependency is found, then depth-first unit-solving and merging). A prompt-level convention gives each sub-problem an identifier such as P-1 and lets other sub-problems reference its solution through placeholders like {P-1}, turning the decomposition tree into a directed acyclic graph. The accuracy recursion $\phi_{RDD}(X_0) = \phi_d(X_0)\phi_m(X_0)\prod_i [1[C(X_i)]\phi_u(X_i) + 1[\neg C(X_i)]\phi_{RDD}(X_i)]$ carries the argument: it shows that recursion beats direct solving when decomposing and merging are jointly more reliable than solving the root directly, and when each sub-problem is easier than the root.

What would settle it

Run RDD and CoT+SC on the letter-concatenation benchmark at list size 90 on identical hardware and compare total wall-clock time per solved instance, counting every decomposition, unit-solving, merging, and self-consistency call; if CoT+SC matches or beats RDD's time per correct answer under this direct cost measure, the paper's efficiency and compute-matched claims are falsified.

Watch

Extended reading notes

Core claim

On the paper's own terms, the core discovery is a performance transition point. For a problem class with within-class difficulty $n_0$, direct unit solving has accuracy $\phi_u$, while recursively decomposing has overall accuracy $\phi_{RDD}$; the authors prove that decomposition helps only when $\phi_d(X_0)\phi_m(X_0) > \phi_u(X_0)$ and each sub-problem's unit accuracy exceeds the root's. Empirically, on the letter-concatenation and length-reversal benchmarks with six difficulty levels each, they observe such a transition: below $n^*$ the baselines CoT+SC or LtM+SC win, and above it RDD wins, with the margin growing as difficulty increases. In the generic setting with no task-specific examples, RDD+CoT overtakes CoT+SC after a transition point, and the length-reversal task, which benefits from dependency modeling, also shows RDD ahead after a transition point. The authors further report that RDD uses fewer output tokens and less wall-clock time, and that its merge step can recover from errors made in sub-solutions.

Load-bearing premise

The load-bearing premise is that the token-count formula $n_{\text{context}} + 3\,n_{\text{output}}$ creates a fair compute budget between RDD's many small calls and the baselines' fewer large calls; if that formula undercounts the real cost of RDD's extra calls, the compute-matched performance conclusion collapses.

Editorial extensions

If this is right

  • On problems harder than the transition point, RDD gives higher exact-match accuracy than CoT+SC and LtM+SC under the paper's compute-matched budget; on easier problems the baselines remain preferable.
  • RDD can be applied to a new problem class with no task-specific demonstrations, so its decomposition prompts do not have to be rewritten per domain.
  • Because it outputs fewer tokens per problem, RDD reduces context-window pressure and wall-clock time, and its independent sub-problems are parallelizable by design.
  • The dependency mechanism extends decomposition from trees to DAGs, so tasks where one intermediate result feeds several later steps can be handled, with sub-problems executed in dependency order.
  • The merge step can correct errors from earlier steps, making the system more tolerant of imperfect sub-solutions.

Reading between the lines

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

  • If the transition-point theorem is right, an adaptive router could estimate $\phi_d$, $\phi_m$, and $\phi_u$ for each problem instance and apply recursion only when $\phi_d\phi_m > \phi_u$ holds, instead of choosing by difficulty alone.
  • The compute-matched comparison uses the formula $n_{\text{context}} + 3\,n_{\text{output}}$ to pick self-consistency sample counts; since RDD makes many small calls, its wall-clock advantage may shrink or grow depending on per-call overhead, which the paper does not quantify.
  • A stress test that injects known errors into sub-solutions and measures how often the merge step repairs them would isolate the error-recovery mechanism from the decomposition's baseline accuracy.
  • The DAG mechanism suggests testable applications to multi-hop question answering or program synthesis with shared intermediate results, though the paper itself only evaluates synthetic list tasks.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 6 minor

Summary. The paper introduces Recursive Decomposition with Dependencies (RDD), a divide-and-conquer prompting framework for LLMs that recursively decomposes a reasoning problem into sub-problems, optionally models dependencies between them, and merges solutions. The method is intended to be task-agnostic, requiring no task-specific demonstrations beyond a fixed set of generic meta-task examples. The authors evaluate RDD on letter concatenation (with and without task-specific examples) and length reversal (with dependencies), comparing against chain-of-thought (CoT) and least-to-most (LtM) prompting with self-consistency (SC). They claim that RDD outperforms these baselines in a compute-matched setting as task complexity increases, while also reducing time and token usage. The theoretical contribution (Appendix A) consists of two theorems stating conditions for recursive decomposition to improve accuracy.

Significance. If the empirical claims hold, RDD would be a practical and scalable method for improving LLM accuracy on complex reasoning tasks while reducing computational cost, and its support for dependencies and error recovery is a genuine extension over prior decomposition methods such as least-to-most and Tree-of-Thoughts. The paper provides complete prompt templates and a detailed error analysis, which are useful for replication. However, the strength of the evidence is substantially weakened by the lack of a properly compute-matched comparison, the absence of error bars or significance tests, and the use of a non-standard self-consistency aggregation procedure. The theoretical results in Appendix A are mathematically trivial and do not contribute predictive content. The core idea is plausible and worth pursuing, but the current empirical support for the headline claim (Hypothesis 1) is not convincing as reported.

major comments (4)
  1. [Appendix E, Tables 1–3; Section 3, Hypothesis 1] The compute-matched claim is not supported by the reported resource-usage data. The paper states in Appendix E that SC sample counts were chosen using the formula n_context_tokens + 3 * n_output_tokens. Applying this formula to the row totals in Table 1 for the task-specific letter-concatenation experiment yields CoT+SC budgets of 1.50M at n=5 and 7.66M at n=90, LtM+SC budgets of 1.14M at n=5 and 10.05M at n=90, versus RDD+LtM budgets of 0.51M at n=5 and 3.11M at n=90. The same discrepancy appears in Tables 2 and 3 (e.g., Table 2, n=90: CoT+SC 6.93M vs. RDD+CoT 3.75M). Thus, under the paper's own cost metric, the baselines are allocated roughly 2–3 times more compute than RDD, so the comparison is not compute-matched and Hypothesis 1 is not validated. The authors should either re-run the comparison with matched budgets or report accuracy as a function of compute (e.g., budget–accuracy curves) to substantiate the compute-matched claim.
  2. [Section 3, Figures 3–4] The empirical evaluation reports only point estimates of accuracy, averaged over 100 instances per difficulty level, with no error bars, confidence intervals, or significance tests. Without uncertainty quantification, the claimed performance advantages—especially around the observed 'transition points' (e.g., 20 < n* < 50 in Fig. 3, 10 < n* < 20 in Fig. 4a)—may be within sampling noise. The authors should provide bootstrap confidence intervals or pairwise significance tests (e.g., McNemar's test) for the comparisons at each difficulty level.
  3. [Section 3, Self-Consistency implementation] The self-consistency baseline deviates from the standard SC procedure (Wang et al., 2022b) in two ways: the paper states that 'we employ the LLM itself to decide the most consistent answer given the set of sampled solutions' and that a binary-search procedure is used to find the most consistent answer instead of a majority vote over sampled chains. This non-standard aggregation may behave differently from standard SC, and no evidence is provided that it preserves SC's accuracy or is comparable to the original method. Because SC is the mechanism used to give the baselines their compute budget, this deviation should be validated (e.g., by comparing the modified SC against majority-vote SC on a subset of problems).
  4. [Appendix A, Theorems 1–2] The two theorems restate immediate consequences of the recursive accuracy formula in Eq. (1). Theorem 1 follows directly from the bound ϕ_RDD(X0) ≤ ϕ_d(X0)ϕ_m(X0) in Eq. (5), and Theorem 2 follows from the analogous bound ϕ_RDD(X0) ≤ ϕ_u(Xi). These observations are correct but tautological; they add no predictive or prescriptive content and are not used elsewhere in the paper. The authors should either remove these theorems or re-frame them as simple observations rather than formal results.
minor comments (6)
  1. [Section 2.1] There is a typo: 'ϕRDD to be the overall accuracy of RRD applied' should read 'RDD' instead of 'RRD'.
  2. [Section 5] The sentence 'Moreover, RDD is allows for ordered execution of subtasks' contains a grammatical error; it should be 'RDD allows for ordered execution of subtasks'.
  3. [Appendix E, Table 1] The time value for LtM+SC at n=70 is recorded as '12,18h' with a comma as decimal separator, while all other entries use a period; this should be made consistent.
  4. [Section 2.1, Algorithm 1] The indentation in Algorithm 1 suggests that 'SCHEDULE DFS(problem, [ ])' is inside the 'while unsolved is not empty' loop, which is likely incorrect; the indentation should be clarified.
  5. [Section 3.4, Figure 5] The error analysis averages ϕ_d, ϕ_m, and ϕ_u over all sub-problems that appear recursively; the paper notes this, but it is worth stating explicitly in the figure caption that ϕ_u is not the accuracy at the root difficulty n0, to avoid misinterpretation.
  6. [Section 2.1] The width parameter w (max branching factor) is treated as a fixed constant throughout, but no value is reported and no sensitivity analysis is provided. Since w directly controls the decomposition, its value should be given for each experiment, or at least a default should be stated.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: RDD's empirical claims are evaluated against external baselines, and the formal requirements in Appendix A are logical consequences of the paper's own definition rather than predictions recycled as inputs.

full rationale

The paper's central claim is empirical: RDD's accuracy, time, and token efficiency are measured against CoT and LtM baselines on two benchmarks with fixed prompts and reported resource tables in Appendix E. No parameter is fitted to the test data and then renamed a prediction; the self-consistency sample counts are chosen by an explicit resource-matching formula, which is a methodological choice rather than a derivation. The theoretical section (Section 2.1 and Appendix A) defines φRDD by the recursive product formula in Eq. (1); Theorems 1 and 2 state necessary conditions for the desideratum φRDD > φu that follow directly from this definition and from all accuracies lying in [0,1]. These are valid logical consequences, not circular restatements used to prove the empirical results, and they add no predictive content that is then claimed as a finding. The comparisons to external methods and the error analysis are independent of any author self-citation: the reference list contains no prior work by this author team, and no uniqueness theorem or ansatz is imported from the authors' own publications. The compute-matching formula can be debated on fairness grounds, but that is an evaluation-design issue, not a circularity in the derivation chain. The limitations section also honestly acknowledges that CoT can outperform RDD on easier problems and that some problems are not readily decomposable, further indicating that the reported advantages are not forced by construction.

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

The paper does not fit a mathematical model to data; the only free design parameter is the branch width. The main implicit assumptions are about LLM reliability and the fairness of the SC baseline, plus transferability of generic examples. No new physical or conceptual entities are introduced.

free parameters (1)
  • width w (max branching factor) = not reported
    The decomposition prompt instructs the model to use up to w workers; w shapes the recursion tree and is a manual design choice whose value is never stated in the main text.
assumptions (4)
  • domain assumption LLM step accuracies multiply independently as in Eq. (1).
    Section 2.1 and Appendix A define phi_RDD as a product of phi_d, phi_m, and per-subproblem terms, ignoring correlations and the error-recovery behavior described in Section 3.4, which explicitly says merging can become independent of unit-solving accuracy.
  • domain assumption The LLM always produces self-contained sub-problem descriptions.
    Section 2.2 (Information flow) requires the model to include all necessary data in each sub-problem; the error-recovery example in Appendix H shows what happens when this fails, so the method's accuracy depends on this property.
  • domain assumption Generic in-context decomposition/merging demonstrations transfer to unseen task classes.
    Section 3.2 tests this transfer for one letter task, but it is an empirical assumption about LLM behavior that is not guaranteed, and it underlies the 'no task-specific examples' claim.
  • ad hoc to paper Self-consistency implemented with binary-search answer selection preserves SC's accuracy and is comparable to standard SC.
    Section 3 states 'Given that each SC sample will produce a large number of generated tokens... we propose to use binary search to find the most consistent answer.' The paper does not validate this modified SC against standard majority-vote SC, yet uses it as the main baseline.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Recursive Decomposition with Dependencies for Generic Divide-and-Conquer Reasoning." pith.science (2026). https://pith.science/paper/VNH4QVM3

@misc{pith2026250502576,
  author       = {Pith},
  title        = {Pith review of: Recursive Decomposition with Dependencies for Generic Divide-and-Conquer Reasoning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/VNH4QVM3}},
  note         = {Machine review of arXiv:2505.02576}
}
read the original abstract

Reasoning tasks are crucial in many domains, especially in science and engineering. Although large language models (LLMs) have made progress in reasoning tasks using techniques such as chain-of-thought and least-to-most prompting, these approaches still do not effectively scale to complex problems in either their performance or execution time. Moreover, they often require additional supervision for each new task, such as in-context examples. In this work, we introduce Recursive Decomposition with Dependencies (RDD), a scalable divide-and-conquer method for solving reasoning problems that requires less supervision than prior approaches. Our method can be directly applied to a new problem class even in the absence of any task-specific guidance. Furthermore, RDD supports sub-task dependencies, allowing for ordered execution of sub-tasks, as well as an error recovery mechanism that can correct mistakes made in previous steps. We evaluate our approach on two benchmarks with six difficulty levels each and in two in-context settings: one with task-specific examples and one without. Our results demonstrate that RDD outperforms other methods in a compute-matched setting as task complexity increases, while also being more computationally efficient.

Figures

Figures reproduced from arXiv: 2505.02576 by the authors.

Figure 1
Figure 1. The decomposition methodology pipeline: decomposing, unit-solving, and merging. Nodes [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. An example of the decomposition graph generated by the RDD method. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. An evaluation of RDD against CoT (Wei et al., 2022) and LtM (Zhou et al., 2022) with self-consistency (SC; Wang et al. (2022b)) on the letter concatenation benchmark in the task-specific few-shot setting. Our system uses LtM at the unit￾solving step; we refer to it as RDD+LtM. We first experiment with task-specific examples to validate our approach. Each call to the model (i.e., all baseline calls, as well as the de… view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: An evaluation of RDD against CoT with self-consistency (SC) the generic few-shot setting. [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: The error sources of the recursive decomposition approach in the letter concatenation [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 6
Figure 6. Figure 6: Example of error propagation behavior during the execution of RDD. Green nodes cor [PITH_FULL_IMAGE:figures/full_fig_p033_6.png]
Figure 7
Figure 7. Figure 7: Example of error recovery behavior during the execution of RDD. Green nodes correspond [PITH_FULL_IMAGE:figures/full_fig_p034_7.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

30 extracted references · 19 canonical work pages

  1. [1]

    write newline

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

  2. [2]

    Dai, Anja Hauth, Katie Millican, David Silver, et al

    Rohan Anil, Sebastian Borgeaud, Yonghui Wu, Jean-Baptiste Alayrac, Jiahui Yu, Radu Soricut, Johan Schalkwyk, Andrew M. Dai, Anja Hauth, Katie Millican, David Silver, et al. Gemini: A family of highly capable multimodal models. CoRR, abs/2312.11805, 2023. URL https://doi.org/10.48550/arXiv.2312.11805

    arXiv doi:10.48550/arxiv.2312.11805 2023

  3. [3]

    Introducing the next generation of Claude , 2024

    Anthropic. Introducing the next generation of Claude , 2024. URL https://www.anthropic.com/news/claude-3-family

    work page 2024

  4. [4]

    Graph of Thoughts : Solving Elaborate Problems with Large Language Models

    Maciej Besta, Nils Blach, Ales Kubicek, Robert Gerstenberger, Michal Podstawski, Lukas Gianinazzi, Joanna Gajda, Tomasz Lehmann, Hubert Niewiadomski, Piotr Nyczyk, and Torsten Hoefler. Graph of Thoughts : Solving Elaborate Problems with Large Language Models . In AAAI , January 2024. URL https://openreview.net/forum?id=VMBWEYzmeU&referrer=

    work page 2024

  5. [5]

    Language Models are Few-Shot Learners

    Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss , Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel Ziegler, Jeffrey Wu, Clemens Winter, Chris Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott G...

    work page 1901

  6. [6]

    Wenhu Chen, Xueguang Ma, Xinyi Wang, and William W. Cohen. Program of Thoughts Prompting : Disentangling Computation from Reasoning for Numerical Reasoning Tasks . Transactions on Machine Learning Research, June 2023. ISSN 2835-8856. URL https://openreview.net/forum?id=YfZ4ZPt8zd

    work page 2023

  7. [7]

    PaLM : Scaling Language Modeling with Pathways

    Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. PaLM : Scaling Language Modeling with Pathways . Journal of Machine Learning Research, 24 0 (240): 0 1--113, 2023. ISSN 1533-7928. URL http://jmlr.org/papers/v24/22-1144.html

    work page 2023

  8. [8]

    Gregoire Deletang, Anian Ruoss, Jordi Grau-Moya , Tim Genewein, Li Kevin Wenliang, Elliot Catt, Chris Cundy, Marcus Hutter, Shane Legg, Joel Veness, and Pedro A. Ortega. Neural Networks and the Chomsky Hierarchy . In The Eleventh International Conference on Learning Representations , September 2022. URL https://openreview.net/forum?id=WbxHAzkeQcn

    work page 2022

Show all 30 references
  1. [9]

    Hwang, Soumya Sanyal, Xiang Ren, Allyson Ettinger, Zaid Harchaoui, and Yejin Choi

    Nouha Dziri, Ximing Lu, Melanie Sclar, Xiang Lorraine Li, Liwei Jiang, Bill Yuchen Lin, Sean Welleck, Peter West, Chandra Bhagavatula, Ronan Le Bras, Jena D. Hwang, Soumya Sanyal, Xiang Ren, Allyson Ettinger, Zaid Harchaoui, and Yejin Choi. Faith and Fate : Limits of Transform...

    2023

  2. [10]

    PAL : Program-aided Language Models

    Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. PAL : Program-aided Language Models . In Proceedings of the 40th International Conference on Machine Learning , pp.\ 10764--10799. PMLR, July 2023. URL https://proceedings....

    2023

  3. [11]

    Decomposed Prompting : A Modular Approach for Solving Complex Tasks

    Tushar Khot, Harsh Trivedi, Matthew Finlayson, Yao Fu, Kyle Richardson, Peter Clark, and Ashish Sabharwal. Decomposed Prompting : A Modular Approach for Solving Complex Tasks . In The Eleventh International Conference on Learning Representations , September 2022. URL https://o...

    2022

  4. [12]

    A Comparison of Most-to-Least and Least-to-Most Prompting on the Acquisition of Solitary Play Skills

    Myrna E Libby, Julie S Weiss, Stacie Bancroft, and William H Ahearn. A Comparison of Most-to-Least and Least-to-Most Prompting on the Acquisition of Solitary Play Skills . Behavior Analysis in Practice, 1 0 (1): 0 37--43, 2008. ISSN 1998-1929. doi:10.1007/BF03391719. URL https...

    2008 doi

  5. [13]

    Introducing Meta Llama 3: The most capable openly available LLM to date, 2024

    Meta. Introducing Meta Llama 3: The most capable openly available LLM to date, 2024. URL https://ai.meta.com/blog/meta-llama-3/

    2024

  6. [14]

    Large Language Models as General Pattern Machines

    Suvir Mirchandani, Fei Xia, Pete Florence, Brian Ichter, Danny Driess, Montserrat Gonzalez Arenas, Kanishka Rao, Dorsa Sadigh, and Andy Zeng. Large Language Models as General Pattern Machines . In 7th Annual Conference on Robot Learning , August 2023. URL https://openreview.ne...

    2023

  7. [15]

    Skeleton-of- Thought : Prompting LLMs for Efficient Parallel Generation

    Xuefei Ning, Zinan Lin, Zixuan Zhou, Zifu Wang, Huazhong Yang, and Yu Wang. Skeleton-of- Thought : Prompting LLMs for Efficient Parallel Generation . In The Twelfth International Conference on Learning Representations , October 2023. URL https://openreview.net/forum?id=mqVgBbNCm9

    2023

  8. [16]

    Investigating the Limitations of Transformers with Simple Arithmetic Tasks , April 2021

    Rodrigo Nogueira, Zhiying Jiang, and Jimmy Lin. Investigating the Limitations of Transformers with Simple Arithmetic Tasks , April 2021. URL http://arxiv.org/abs/2102.13019

    2021 arXiv

  9. [17]

    Introducing ChatGPT , November 2022

    OpenAI. Introducing ChatGPT , November 2022. URL https://openai.com/index/chatgpt/

    2022

  10. [18]

    GPT-4 Technical Report , March 2024

    OpenAI. GPT-4 Technical Report , March 2024. URL http://arxiv.org/abs/2303.08774

    2024 arXiv

  11. [19]

    Unsupervised Question Decomposition for Question Answering

    Ethan Perez, Patrick Lewis, Wen-tau Yih, Kyunghyun Cho, and Douwe Kiela. Unsupervised Question Decomposition for Question Answering . In Bonnie Webber, Trevor Cohn, Yulan He, and Yang Liu (eds.), Proceedings of the 2020 Conference on Empirical Methods in Natural Language Proce...

    2020 doi

  12. [20]

    Child, D

    Alec Radford, Jeff Wu, R. Child, D. Luan, Dario Amodei, and I. Sutskever. Language Models are Unsupervised Multitask Learners . 2019. URL https://www.semanticscholar.org/paper/Language-Models-are-Unsupervised-Multitask-Learners-Radford-Wu/9405cc0d6169988371b2755e573cc28650d14dfe

    2019

  13. [21]

    Distilling Reasoning Capabilities into Smaller Language Models

    Kumar Shridhar, Alessandro Stolfo, and Mrinmaya Sachan. Distilling Reasoning Capabilities into Smaller Language Models . In Anna Rogers, Jordan Boyd-Graber , and Naoaki Okazaki (eds.), Findings of the Association for Computational Linguistics : ACL 2023 , pp.\ 7059--7073, Toro...

    2023 doi

  14. [22]

    LLaMA : Open and Efficient Foundation Language Models , February 2023

    Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timoth \'e e Lacroix, Baptiste Rozi \`e re, Naman Goyal, Eric Hambro, Faisal Azhar, Aurelien Rodriguez, Armand Joulin, Edouard Grave, and Guillaume Lample. LLaMA : Open and Efficient Foundation...

    2023 arXiv

  15. [23]

    Iteratively Prompt Pre-trained Language Models for Chain of Thought

    Boshi Wang, Xiang Deng, and Huan Sun. Iteratively Prompt Pre-trained Language Models for Chain of Thought . In Yoav Goldberg, Zornitsa Kozareva, and Yue Zhang (eds.), Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing , pp.\ 2714--2730, Abu ...

    2022 doi

  16. [24]

    Plan-and- Solve Prompting : Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models

    Lei Wang, Wanyu Xu, Yihuai Lan, Zhiqiang Hu, Yunshi Lan, Roy Ka-Wei Lee, and Ee-Peng Lim. Plan-and- Solve Prompting : Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models . In Anna Rogers, Jordan Boyd-Graber , and Naoaki Okazaki (eds.), Proceedings of the 61...

    2023 doi

  17. [25]

    Le, Ed H

    Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc V. Le, Ed H. Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self- Consistency Improves Chain of Thought Reasoning in Language Models . In The Eleventh International Conference on Learning Representations , September 2022 ...

    2022

  18. [26]

    Chi, Quoc V

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed H. Chi, Quoc V. Le, and Denny Zhou. Chain-of- Thought Prompting Elicits Reasoning in Large Language Models . In Advances in Neural Information Processing Systems , October 2022. URL https://openr...

    2022

  19. [27]

    Griffiths, Yuan Cao, and Karthik R

    Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas L. Griffiths, Yuan Cao, and Karthik R. Narasimhan. Tree of Thoughts : Deliberate Problem Solving with Large Language Models . In Thirty-Seventh Conference on Neural Information Processing Systems , November 2023. URL htt...

    2023

  20. [28]

    Parsel : Algorithmic Reasoning with Language Models by Composing Decompositions

    Eric Zelikman, Qian Huang, Gabriel Poesia, Noah Goodman, and Nick Haber. Parsel : Algorithmic Reasoning with Language Models by Composing Decompositions . In Thirty-Seventh Conference on Neural Information Processing Systems , November 2023. URL https://openreview.net/forum?id...

    2023

  21. [29]

    An examination on the effectiveness of divide-and-conquer prompting in large language models, 2024

    Yizhou Zhang, Lun Du, Defu Cao, Qiang Fu, and Yan Liu. An examination on the effectiveness of divide-and-conquer prompting in large language models, 2024. URL https://arxiv.org/abs/2402.05359

    2024 arXiv

  22. [30]

    Le, and Ed H

    Denny Zhou, Nathanael Sch \"a rli, Le Hou, Jason Wei, Nathan Scales, Xuezhi Wang, Dale Schuurmans, Claire Cui, Olivier Bousquet, Quoc V. Le, and Ed H. Chi. Least-to- Most Prompting Enables Complex Reasoning in Large Language Models . In The Eleventh International Conference on...

    2022

Pith tools

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