Pith. sign in

REVIEW 4 major objections 5 minor 29 references

A foundation framework for LLM reasoning lets schemes adapt their structure mid-run and execute, on average, an order of magnitude faster.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

T0 review · deepseek-v4-flash

2026-08-02 22:29 UTC pith:WJYWGVC4

load-bearing objection Solid engineering paper with a released codebase, but the order-of-magnitude speedups rest on a critical-path model rather than wall-clock; the dynamic-graph selling point is also undemonstrated. the 4 major comments →

arxiv 2602.16512 v2 pith:WJYWGVC4 submitted 2026-02-18 cs.AI

Framework of Thoughts: A Foundation Framework for Dynamic and Optimized Reasoning based on Chains, Trees, and Graphs

Felix Fricke , Simon Malberg , Georg Groh This is my paper
classification cs.AI
keywords LLM reasoningprompting schemesdynamic execution graphparallel executioncachingprompt optimizationhyperparameter optimizationadaptive reasoning
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

The paper argues that the main bottleneck for chain-, tree-, and graph-based prompting schemes is the static, hand-tuned infrastructure around them, not the schemes themselves. It introduces Framework of Thoughts (FoT), a helper framework in which a reasoning process is modeled as an execution graph: nodes are operations (LLM calls, tools, retrieval), and edges carry thoughts between them. Operations can add and remove nodes and edges while the graph is running, so the reasoning structure can adapt to each problem instance. FoT also adds safe parallel execution, two levels of caching, and built-in hyperparameter and prompt optimization. The authors show that re-implementing established schemes in FoT yields average per-instance speedups of about 10.7x, cuts inference costs by up to 46 percent on tasks with repeat calls, and produces better task scores after optimization.

Core claim

The paper's central claim is that a dynamic execution graph, together with scheduling constraints that preserve the graph's logic during concurrent edits, persistent caching of operation outputs, and integrated tuning of prompts and hyperparameters, is enough to make a broad class of existing prompting schemes both adaptive and much cheaper to run. FoT embodies this by letting operations rewrite the execution graph while reasoning is underway. Re-implementing three published schemes in FoT, the paper measures speedups between 1.9x and 35.4x per instance (average 10.7x), cost reductions of 14-46 percent from caching on tasks with repeated operations, and improved task scores after optimizatio

What carries the argument

The central object is the execution graph: a directed multigraph whose nodes are operations and whose edges carry thoughts, defined per execution step. Unlike static frameworks, this graph may be modified by the operations themselves, which lets the reasoning structure grow, split, or rewire during a run. Safety during parallel execution is enforced by constraining each operation's edits to its exclusive descendants (nodes reachable only through it), preventing race conditions. A process cache memoizes operation outputs within one run, a persistent cache reuses outputs across samples, and an integrated optimizer tunes hyperparameters and prompts.

Load-bearing premise

The reported speedups assume parallel execution has no overhead: runtime is measured as the sum of operation durations along the longest serial path, so if real scheduling, communication, and memory overhead is significant, the 10x average speedup would be overstated.

What would settle it

Run the same FoT schemes on the same benchmark tasks using end-to-end wall-clock timing, with a realistic number of worker threads and no infinite parallelism. If the wall-clock speedup over a sequential baseline falls below roughly half the reported parallel speedup (e.g., if a reported 10x runs at <2x), the efficiency claim fails.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

Share X Bluesky LinkedIn Reddit HN

If this is right

  • Existing static prompting schemes can be re-implemented in FoT without changing their reasoning logic and gain 1.9x-35.4x speedups from parallel scheduling.
  • With caching, optimization runs become viable: total optimization cost drops to 9-36 percent of the uncached cost, making hyperparameter and prompt search practical for more schemes.
  • Because the execution graph is mutable at runtime, new fully automatic schemes can discover the decomposition approach per problem instance, potentially handling problem types whose ideal reasoning structure is not known ahead of time.
  • Persistent caching avoids repeating identical LLM calls across samples, so multi-hop QA and other tasks with shared subquestions should see meaningful cost savings at scale.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • If dynamic reasoning graphs prove robust, the next step is to learn the graph-mutation policy itself: the structure of reasoning would become an explicit learned variable rather than a hand-designed template.
  • The reported runtimes are critical-path sums, not wall-clock times; real deployments with limited concurrency or heavy scheduling overhead may not see the full speedups. A reader could verify by timing the same runs on a single machine.
  • Caching gains are task-dependent: sorting shows no benefit because its operations are one-off, while document merging and the arithmetic puzzle benefit heavily. Counting repeated operation inputs per instance could predict when caching will pay off.
  • The safe-parallel-editing rules (edit only exclusive descendants) are a general recipe for any dynamic dataflow system, for example agentic tool-use workflows that spawn and retract sub-agents.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper introduces Framework of Thoughts (FoT), a general-purpose framework for implementing multi-prompt LLM reasoning schemes. FoT supports dynamic execution graphs, safe parallel scheduling, process/persistent caching, and built-in hyperparameter and prompt optimization. The authors re-implement Tree of Thoughts, Graph of Thoughts, and ProbTree within FoT and evaluate them on Game of 24, Sorting, Document Merging, HotpotQA, and MuSiQue. The main empirical claims are that FoT's parallelization and caching accelerate runtime by up to 35.4× (10.7× on average across tasks), reduce API costs by up to 46%, and that optimization improves task scores (e.g., Go24 accuracy from 63% to 66%, DM F1 from 8.4 to 8.8) while also reducing cost. The conclusion states that FoT can 'accelerate existing schemes by an order of magnitude and cut cost nearly in half in some cases.'

Significance. If substantiated, FoT would be a useful contribution to the growing ecosystem of reasoning frameworks: it addresses real limitations of static Graph-of-Thoughts-style executions, provides a clean abstraction between execution graphs and reasoning graphs, and ships with reproducibility-friendly tooling. The paper's strengths include a released codebase, a clean train/test split for optimization (so reported test metrics are not directly circular), and internal comparisons that are directionally consistent. The central efficiency claim, however, is not yet empirically validated: the runtime metric is a critical-path proxy, not measured wall-clock time, and no variance or significance information is reported. The framework's flagship dynamic-graph capability is also not evaluated in the empirical section, as the authors acknowledge in the Limitations. These gaps are load-bearing for the paper's headline claims, though they are addressable with additional experiments.

major comments (4)
  1. [Section 4, Metrics; Table 3] The runtime reported in Table 3 is defined as 'the sum of the durations of all operations on the longest sequentially executed path.' This is a critical-path model, not an end-to-end wall-clock measurement. It assumes parallel execution has zero scheduling, communication, cache-management, or concurrency overhead and effectively unlimited parallelism. The largest speedups (25.2–35.4× on Go24) come from parallelizing many LLM calls, so even modest controller overhead or API concurrency limits could materially reduce real speedups. Since the headline conclusion—'accelerate existing schemes by an order of magnitude'—rests on these numbers, the paper needs measured wall-clock runtimes for at least the sequential and parallel configurations, ideally including variance over runs and comparison against the original ToT/GoT implementations rather than FoT's own sequential baseline.
  2. [Tables 3, 4, and 5] All efficiency and score results are reported as single averages with no standard deviation, confidence intervals, number of runs, or significance tests. This is problematic because many of the claimed improvements are small: Go24 accuracy goes 63.0%→66.0%, Sorting mistakes 18.4→18.2 and 12.7→12.1, DM F1 8.4→8.8. Table 5 even shows that optimized ToT on Sorting with parallel execution is 119% of the unoptimized runtime, indicating the efficiency benefit is not uniform. With only 50 test instances for Sorting/DM and 100 for Go24, these differences could be within noise. The authors should report repeated-run statistics, error bars, and significance tests (or justify why they are unnecessary) for both scores and runtimes.
  3. [Appendix A.5, Table 6] The optimization section relies on 25 iterations for Go24 and 50 for the Sorting tasks, using TPE and COPRO. While the train/test split correctly prevents direct selection on the test set, the number of trials is small and no multiple-seed or repeated-optimization results are reported. The optimized hyperparameters and prompts may be overfit to the specific training folds. Given that the claimed score gains are modest and the optimization cost is substantial, the authors should report either the distribution of optimization outcomes across seeds or at least the best-vs-mean test performance, to establish that the reported improvements are not artifacts of a single noisy optimization run.
  4. [Conclusion, Limitations & Future Work] The paper lists dynamic graph structures as Contribution #1(a) and states that FoT 'paves the way for a new generation of adaptive prompting schemes.' However, the empirical evaluation only implements one static scheme (GoT) and two semi-automatic schemes (ToT, ProbTree); the Limitations explicitly say that the dynamic-graph advantage is not demonstrated and encourage future work to show it. Because the dynamic graph capability is the paper's central architectural novelty, the current evidence does not substantiate a core part of the contribution. The authors should either add an experiment with a fully automatic/dynamic scheme or explicitly reframe the contribution as enabling infrastructure rather than as an empirically demonstrated advantage.
minor comments (5)
  1. [Section 4, LLMs paragraph] 'On Sorting and NDA, we use GPT-3.5-Turbo' — the task is called Document Merging (DM), not NDA. Please fix the naming.
  2. [Appendix A.7, GoT on Document Merging] The text says the prompts 'were taken from the original implementation of Sorting'; this should be the original GoT/Document Merging implementation.
  3. [Table 1] The caption says schemes in bold are new additions, but the bold formatting is not visible in the plain text. Please make the added rows explicit in the table.
  4. [Table 2, Exclusive Descendants] The definition '∀ directed pathsp: l⇝d, pgoes througho' is confusingly worded. Clarify the quantifier and the notion of 'going through' — the current text reads like a sentence fragment.
  5. [Section 3.2, Safe Parallel Execution] The sentence 'When operations are allowed to modify the execution graph, parallel execution poses a risk of race conditions...' is a good summary, but the bullet list could benefit from a compact formal statement of the invariants (e.g., the exact conditions under which two operations' modifications commute).

Circularity Check

0 steps flagged

No circularity found. The paper's optimization/train-test splits and ablations are self-contained; the critical-path runtime metric is a measurement-validity concern, not a circular reduction.

full rationale

The paper's central claims are an engineering framework plus empirical evaluations, and I find no load-bearing circular step. There are no self-citations: the reference list contains no prior Fricke/Malberg/Groh papers, so patterns 3, 4, and 5 do not apply. The optimization experiments use explicit train/test splits (Go24: 200 train vs. the 100 Yao et al. test instances; Sorting/DM: 50/50; HotpotQA/MuSiQue: 1,000/1,000), with optimization performed only on training sets and all reported scores on test sets. Thus the 'better task scores through optimization' claim is not a fitted input renamed as a prediction. The efficiency results are ablations of FoT's own baseline ('S+No cache' vs. 'P+Persistent') using measured per-operation durations, not predictions derived from fitted parameters. The stated runtime metric in Section 4 ('the sum of the durations of all operations on the longest sequentially executed path') is a modeling choice that abstracts away scheduling/communication/API-concurrency overhead; this is a legitimate external-validity concern about whether the reported 1.9x-35.4x speedups correspond to real wall-clock time, but it is not circularity: the speedup numbers are computed from the metric, not assumed as the metric's conclusion. Similarly, caching cost reductions follow from skipping LLM API calls, which is the intended mechanism rather than a circular definition. The paper's Limitations section candidly notes that the dynamic-graph advantage is not demonstrated, further indicating that the authors are not masking missing evidence as a forced result. Therefore: no significant circularity.

Axiom & Free-Parameter Ledger

9 free parameters · 4 axioms · 0 invented entities

The framework itself adds no free parameters, but the empirical demonstration depends on task-specific hyperparameters and choices (see Table 6). The runtime model, generalization of optimization, and model substitutions are background assumptions that could affect conclusions.

free parameters (9)
  • ToT Go24 number of examples = 11
    Optimized on Go24 training set; affects number of proposals per step.
  • ToT Go24 samples per proposal (layers) = (3,2,2)
    Optimized on Go24 training set; number of Value evaluations per thought.
  • ToT Go24 keep top N (layers 1,2) = (5,3)
    Optimized on Go24 training set; pruning threshold.
  • ToT Sorting number of branches = 14
    Optimized on Sorting training set.
  • ToT Sorting improvement levels = 6
    Optimized on Sorting training set.
  • GoT Sorting sort branches = 2
    Optimized on Sorting training set.
  • GoT Sorting merge branches = 13
    Optimized on Sorting training set.
  • GoT Sorting global improvement rounds = 2
    Optimized on Sorting training set.
  • COPRO parameters (depth, keep top, breadth) = (6,8,8)
    Chosen for prompt optimization on DM; not reported as tuned.
axioms (4)
  • domain assumption LLM API response times and costs are stable and additive
    The runtime metric sums operation durations; this ignores queueing, network variance, etc.
  • domain assumption Critical-path duration is a valid proxy for real wall-clock runtime of a parallel schedule
    Used to compute speedups; no wall-clock measurements are reported.
  • domain assumption Hyperparameter/prompt optimization on training sets generalizes to the reported test sets
    Standard supervised assumption; no cross-validation or repeated trials reported.
  • domain assumption The model substitutions (GPT-4o, GPT-3.5-Turbo, GPT-4.1-mini) preserve the relative comparison of schemes
    Original schemes used different models; authors use cheaper models, potentially changing task scores.

pith-pipeline@v1.3.0-alltime-deepseek · 21117 in / 10526 out tokens · 86179 ms · 2026-08-02T22:29:09.012211+00:00 · methodology

0 comments
Cite this review

Pith. "Pith review of Framework of Thoughts: A Foundation Framework for Dynamic and Optimized Reasoning based on Chains, Trees, and Graphs." pith.science (2026). https://pith.science/paper/WJYWGVC4

@misc{pith2026260216512,
  author       = {Pith},
  title        = {Pith review of: Framework of Thoughts: A Foundation Framework for Dynamic and Optimized Reasoning based on Chains, Trees, and Graphs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/WJYWGVC4}},
  note         = {Machine review of arXiv:2602.16512}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

Prompting schemes such as Chain of Thought, Tree of Thoughts, and Graph of Thoughts can significantly enhance the reasoning capabilities of large language models. However, most existing schemes require users to define static, problem-specific reasoning structures that lack adaptability to dynamic or unseen problem types. Additionally, these schemes are often under-optimized in terms of hyperparameters, prompts, runtime, and prompting cost. To address these limitations, we introduce Framework of Thoughts (FoT)--a general-purpose foundation framework for building and optimizing dynamic reasoning schemes. FoT comes with built-in features for hyperparameter tuning, prompt optimization, parallel execution, and intelligent caching, unlocking the latent performance potential of reasoning schemes. We demonstrate FoT's capabilities by implementing three popular schemes--Tree of Thoughts, Graph of Thoughts, and ProbTree--within FoT. We empirically show that FoT enables significantly faster execution, reduces costs, and achieves better task scores through optimization. We release our codebase to facilitate the development of future dynamic and efficient reasoning schemes.

Figures

Figures reproduced from arXiv: 2602.16512 by Felix Fricke, Georg Groh, Simon Malberg.

Figure 1
Figure 1. Figure 1: The execution graphs of a static prompting scheme implemented in the GoT framework [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: In the execution graph, nodes are operations and edges are connections that can carry [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Non-exhaustive list with three example operations. Operations can generate new thoughts [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Illustration of graph regions defined in Table 2. [PITH_FULL_IMAGE:figures/full_fig_p007_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Exemplary evolution of the execution graph in an implementation of the [PITH_FULL_IMAGE:figures/full_fig_p013_5.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

29 extracted references · 5 linked inside Pith

  1. [1]

    Dimakis, Ion Stoica, Dan Klein, Matei Zaharia, and Omar Khattab

    Lakshya A Agrawal, Shangyin Tan, Dilara Soylu, Noah Ziems, Rishi Khare, Krista Opsahl-Ong, Arnav Singhvi, Herumb Shandilya, Michael J Ryan, Meng Jiang, Christopher Potts, Koushik Sen, Alexandros G. Dimakis, Ion Stoica, Dan Klein, Matei Zaharia, and Omar Khattab. Gepa: Reflective prompt evolution can outperform reinforcement learning, 2025. URL https://arx...

    Pith/arXiv arXiv 2025

  2. [2]

    Optuna: A next-generation hyperparameter optimization framework

    Takuya Akiba, Shotaro Sano, Toshihiko Yanase, Takeru Ohta, and Masanori Koyama. Optuna: A next-generation hyperparameter optimization framework. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD '19, pp.\ 2623–2631, New York, NY, USA, 2019. Association for Computing Machinery. ISBN 9781450362016. doi:...

    arXiv 2019

  3. [3]

    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, 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 a

    2024

  4. [4]

    u rgen M \

    Maciej Besta, Florim Memedi, Zhenyu Zhang, Robert Gerstenberger, Guangyuan Piao, Nils Blach, Piotr Nyczyk, Marcin Copik, Grzegorz Kwa \'s niewski, J \"u rgen M \"u ller, et al. Demystifying chains, trees, and graphs of thoughts. arXiv preprint arXiv:2401.14295, 2024 b

    arXiv 2024

  5. [5]

    Forest-of-thought: Scaling test-time compute for enhancing llm reasoning

    Zhenni Bi, Kai Han, Chuanjian Liu, Yehui Tang, and Yunhe Wang. Forest-of-thought: Scaling test-time compute for enhancing llm reasoning. arXiv preprint arXiv:2412.09078, 2024

    Pith/arXiv arXiv 2024

  6. [6]

    Probabilistic tree-of-thought reasoning for answering knowledge-intensive complex questions

    Shulin Cao, Jiajie Zhang, Jiaxin Shi, Xin Lv, Zijun Yao, Qi Tian, Lei Hou, and Juanzi Li. Probabilistic tree-of-thought reasoning for answering knowledge-intensive complex questions. In Findings of the Association for Computational Linguistics: EMNLP 2023, pp.\ 12541--12560, 2023

    2023

  7. [7]

    Training verifiers to solve math word problems, 2021

    Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems, 2021. URL https://arxiv.org/abs/2110.14168

    Pith/arXiv arXiv 2021

  8. [8]

    a rli, Ekin Aky \

    Andrew Drozdov, Nathanael Sch \"a rli, Ekin Aky \"u rek, Nathan Scales, Xinying Song, Xinyun Chen, Olivier Bousquet, and Denny Zhou. Compositional semantic parsing with large language models. In The Eleventh International Conference on Learning Representations, 2023. URL https://openreview.net/forum?id=gJW8hSGBys8

    2023

  9. [9]

    Langchain

    LangChain Inc. Langchain. https://github.com/langchain-ai/langchain, 2022. Accessed: 2025-05-16

    2022

  10. [10]

    Langgraph

    LangChain Inc. Langgraph. https://github.com/langchain-ai/langgraph, 2024. Accessed: 2025-05-16

    2024

  11. [11]

    Joshi, Hanna Moazam, Heather Miller, Matei Zaharia, and Christopher Potts

    Omar Khattab, Arnav Singhvi, Paridhi Maheshwari, Zhiyuan Zhang, Keshav Santhanam, Sri Vardhamanan A, Saiful Haq, Ashutosh Sharma, Thomas T. Joshi, Hanna Moazam, Heather Miller, Matei Zaharia, and Christopher Potts. DSP y: Compiling declarative language model calls into self-improving pipelines. In R0-FoMo:Robustness of Few-shot and Zero-shot Learning in L...

    2023

  12. [12]

    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, 2023. URL https://openreview.net/forum?id=_nGgzQjzaRy

    2023

  13. [13]

    Large language models are zero-shot reasoners

    Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa. Large language models are zero-shot reasoners. Advances in neural information processing systems, 35: 0 22199--22213, 2022

    2022

  14. [14]

    Skeleton-of-thought: Prompting LLM s for efficient parallel generation

    Xuefei Ning, Zinan Lin, Zixuan Zhou, Zifu Wang, Huazhong Yang, and Yu Wang. Skeleton-of-thought: Prompting LLM s for efficient parallel generation. In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=mqVgBbNCm9

    2024

  15. [15]

    Adaptive graph of thoughts: Test-time adaptive reasoning unifying chain, tree, and graph structures

    Tushar Pandey, Ara Ghukasyan, Oktay Goktas, and Santosh Kumar Radha. Adaptive graph of thoughts: Test-time adaptive reasoning unifying chain, tree, and graph structures. arXiv preprint arXiv:2502.05078, 2025

    Pith/arXiv arXiv 2025

  16. [16]

    The art of SOCRATIC QUESTIONING : Recursive thinking with large language models

    Jingyuan Qi, Zhiyang Xu, Ying Shen, Minqian Liu, Di Jin, Qifan Wang, and Lifu Huang. The art of SOCRATIC QUESTIONING : Recursive thinking with large language models. In Houda Bouamor, Juan Pino, and Kalika Bali (eds.), Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pp.\ 4177--4199, Singapore, December 2023. Associa...

    doi:10.18653/v1/2023.emnlp-main.255 2023

  17. [17]

    \ ALFW \ orld: Aligning text and embodied environments for interactive learning

    Mohit Shridhar, Xingdi Yuan, Marc-Alexandre Cote, Yonatan Bisk, Adam Trischler, and Matthew Hausknecht. \ ALFW \ orld: Aligning text and embodied environments for interactive learning. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=0IOX0YcCdTn

    2021

  18. [18]

    M u S i Q ue: Multihop questions via single-hop question composition

    Harsh Trivedi, Niranjan Balasubramanian, Tushar Khot, and Ashish Sabharwal. M u S i Q ue: Multihop questions via single-hop question composition. Transactions of the Association for Computational Linguistics, 10: 0 539--554, 2022. doi:10.1162/tacl_a_00475. URL https://aclanthology.org/2022.tacl-1.31/

    doi:10.1162/tacl_a_00475 2022

  19. [19]

    Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou

    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, 2023. URL https://openreview.net/forum?id=1PL1NIMMrw

    2023

  20. [20]

    Tree-structured parzen estimator: Understanding its algorithm components and their roles for better empirical performance

    Shuhei Watanabe. Tree-structured parzen estimator: Understanding its algorithm components and their roles for better empirical performance. arXiv preprint arXiv:2304.11127, 2023

    Pith/arXiv arXiv 2023

  21. [21]

    Chain-of-thought prompting elicits reasoning in large language models

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

    2022

  22. [22]

    Decompose, analyze and rethink: Solving intricate problems with human-like reasoning cycle

    Shangzi Xue, Zhenya Huang, Jiayu Liu, Xin lin, Yuting Ning, Binbin Jin, Xin Li, and Qi Liu. Decompose, analyze and rethink: Solving intricate problems with human-like reasoning cycle. In A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. Tomczak, and C. Zhang (eds.), Advances in Neural Information Processing Systems, volume 37, pp.\ 357--385. Cur...

    2024

  23. [23]

    Zhilin Yang, Peng Qi, Saizheng Zhang, Yoshua Bengio, William Cohen, Ruslan Salakhutdinov, and Christopher D. Manning. H otpot QA : A dataset for diverse, explainable multi-hop question answering. In Ellen Riloff, David Chiang, Julia Hockenmaier, and Jun ' ichi Tsujii (eds.), Proceedings of the 2018 Conference on Empirical Methods in Natural Language Proce...

    doi:10.18653/v1/d18-1259 2018

  24. [24]

    Tree of thoughts: Deliberate problem solving with large language models

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

    2023

  25. [25]

    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 Learning Representations, 2023. URL https://openreview.net/forum?id=WZH7099tgfM

    2023

  26. [26]

    Chi, Denny Zhou, Swaroop Mishra, and Steven Zheng

    Pei Zhou, Jay Pujara, Xiang Ren, Xinyun Chen, Heng-Tze Cheng, Quoc V Le, Ed H. Chi, Denny Zhou, Swaroop Mishra, and Steven Zheng. SELF - DISCOVER : Large language models self-compose reasoning structures. In The Thirty-eighth Annual Conference on Neural Information Processing Systems, 2024. URL https://openreview.net/forum?id=BROvXhmzYK

    2024

  27. [27]

    @esa (Ref

    \@ifxundefined[1] #1\@undefined \@firstoftwo \@secondoftwo \@ifnum[1] #1 \@firstoftwo \@secondoftwo \@ifx[1] #1 \@firstoftwo \@secondoftwo [2] @ #1 \@temptokena #2 #1 @ \@temptokena \@ifclassloaded agu2001 natbib The agu2001 class already includes natbib coding, so you should not add it explicitly Type <Return> for now, but then later remove the command n...

  28. [28]

    \@lbibitem[] @bibitem@first@sw\@secondoftwo \@lbibitem[#1]#2 \@extra@b@citeb \@ifundefined br@#2\@extra@b@citeb \@namedef br@#2 \@nameuse br@#2\@extra@b@citeb \@ifundefined b@#2\@extra@b@citeb @num @parse #2 @tmp #1 NAT@b@open@#2 NAT@b@shut@#2 \@ifnum @merge>\@ne @bibitem@first@sw \@firstoftwo \@ifundefined NAT@b*@#2 \@firstoftwo @num @NAT@ctr \@secondoft...

  29. [29]

    @open @close @open @close and [1] URL: #1 \@ifundefined chapter * \@mkboth \@ifxundefined @sectionbib * \@mkboth * \@mkboth\@gobbletwo \@ifclassloaded amsart * \@ifclassloaded amsbook * \@ifxundefined @heading @heading NAT@ctr thebibliography [1] @ \@biblabel @NAT@ctr \@bibsetup #1 @NAT@ctr @ @openbib .11em \@plus.33em \@minus.07em 4000 4000 `\.\@m @bibit...