Pith. sign in

REVIEW 1 major objections 6 minor 31 references

Asynchronous Collective Tree Exploration: a Distributed Algorithm, and a new Lower Bound

T0 review · 1 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read The paper proves that robot teams can explore unknown trees asynchronously with regret linear in depth, and that no asynchronous algorithm, even with central communication, beats $\Omega(\log^2 k)$ overhead.

desk verdict The algorithm half is a real advance; the lower-bound half is plausible but not yet rigorous. read the letter →

arxiv 2507.15658 v1 pith:YDLMUKA6 submitted 2025-07-21 cs.DS cs.DCcs.MA

Romain Cosson , Laurent Massoulié This is my paper · ORCID
classification cs.DScs.DCcs.MA
keywords collectivetreeexplorationasynchronousalgorithmsdistributedwhiteboardcommunicationlayeredgraphtraversalcompetitiveratiolowerboundmobileagents
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

The paper introduces DACTE, a model where an adversary decides which of $k$ robots moves next and robots learn about the tree only by reading and writing whiteboards at the nodes. It establishes two results. First, a distributed asynchronous algorithm explores any unknown tree with $n$ nodes and depth $D$ in at most $2n + O(k^2 2^k D)$ moves, and a variant achieves $O(k/\log k)(n + kD)$ moves, so the regret term is linear in $D$ and asymptotically optimal in the average case where random trees satisfy $n = \Theta(D^2)$. Second, every asynchronous collective tree exploration algorithm, even one with centralized all-to-all communication, that explores in $O(c(k)(n + kD))$ moves must have $c(k) = \Omega(\log^2 k)$, improving the earlier $\Omega(\log k)$ bound. Together these claims say that asynchrony alone does not preclude efficient distributed exploration, while the competitive overhead of any asynchronous team grows at least polylogarithmically with team size.

What carries the argument

The algorithm rests on locally-greedy exploration with targets: a moving robot always crosses an unexplored edge if one is present, otherwise it moves toward its current target node. A potential $P(t) = \sum_i d(\text{position}_i(t), \text{target}_i(t))$ converts target movement into an explored-edge count, giving the bound that after $M$ moves at least $(M - \text{total target movement})/2$ edges are explored. The targets form a single shared sequence produced by a deterministic layered graph traversal algorithm run on the layered instance $L(h)$ whose leaves are the active children of the current target; whiteboards at target nodes propagate the sequence to follower robots. The lower bound rests on fractional tree traversal: a configuration $x(t)$ is the distribution of $k$ robots over the current layer, and the paper converts any ACTE algorithm into a fractional algorithm with $(c(k)/k, c(k))$ overhead, then applies a potential $D(\delta, x, z) = \sum_u (z_u + \delta_u - 2x_u)_+$, where $\delta(t)$ is the distribution of a uniformly random depth-first search, to define a converted fractional algorithm $z(t)$ that removes the additive size term and is $O(w^2)$-competitive.

What would settle it

Search, for example by exhaustive enumeration for width $w = 3$ or $4$, for a layered tree instance in which the adversary strictly improves its outcome by forking or deleting a leaf $\ell$ at a time when $z_\ell(t) = 0$, compared with any instance that avoids such moves; finding one would invalidate the without-loss-of-generality step and could open the way to a faster ACTE algorithm. Alternatively, any ACTE algorithm with $c(k) = o(\log^2 k)$ would directly refute Theorem 3.2.

Watch

Extended reading notes

Core claim

The central claim is that the asynchronous adversary is not a barrier to distributed collective exploration. The paper proves that a locally-greedy exploration rule whose robot targets are generated by a deterministic layered graph traversal on the 'active frontier' of partially explored subtrees explores in $2n + k c_k D$ moves, where $c_k$ is the competitive ratio of the traversal subroutine; with the best known deterministic subroutine this is $2n + O(k^2 2^k D)$, and a team-splitting argument converts it into $O(k/\log k)(n + kD)$. On the negative side, the paper proves that any asynchronous collective tree exploration algorithm with cost at most $O(c(k)(n + kD))$ must satisfy $c(k) = \Omega(\log^2 k)$. The proof reduces ACTE to fractional layered graph traversal: an algorithm with sub-polylog overhead would yield fractional tree traversal with $o(w^2)$ competitive ratio, contradicting the $\Omega(w^2)$ lower bound.

Load-bearing premise

The load-bearing premise is the footnote-6 assumption in the lower-bound proof: an optimal adversary never forks or deletes a leaf at a moment when the constructed fractional algorithm $z$ gives that leaf zero probability mass; if an adversary could benefit from such moves, the inequality $L \le w \cdot L_z$ and the $\Omega(\log^2 k)$ bound could fail.

Editorial extensions

If this is right

  • A distributed, asynchronous robot team can explore with regret linear in tree depth, so the asynchronous adversary is compatible with near-optimal exploration rather than an obstacle.
  • Because a uniformly random $n$-node tree has depth $\Theta(\sqrt{n})$ with high probability, the $2n + O(k^2 2^k D)$ bound is asymptotically optimal, i.e. $1$-competitive, in average-case complexity.
  • The same linear-regret guarantees extend to weighted trees and continuous robot speeds, since linear guarantees are scale-invariant under the paper's reduction lemmas.
  • No asynchronous algorithm, centralized or distributed, can have competitive ratio $o(\log^2 k)$ when measured as $O(c(k)(n + kD))$; this improves the previous $\Omega(\log k)$ lower bound.
  • Splitting the team into $\lceil \ln k \rceil$ robots and applying the generalized pigeonhole principle yields the $O(k/\log k)$-competitive variant.

Reading between the lines

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

  • Editorial extension: the paper's conjecture that randomization cannot improve collective exploration against an adaptive adversary, while centralized communication can, frames distributed algorithms as the 'deterministic' counterpart of online algorithms; testing this parallel on other multi-agent problems, such as collective metrical task systems, is a natural next step.
  • Editorial extension: the potential-based reduction in Proposition 5.3 may transfer the $\Omega(w^2)$ fractional lower bound to other problems with additive size terms and time-varying metric spaces; the paper hints at this applicability but does not develop it.
  • Editorial extension: the gap between the $O(k/\log k)$ upper bound and the $\Omega(\log^2 k)$ lower bound leaves room for a distributed algorithm that avoids the $2^k$ factor of deterministic layered graph traversal, which would need a different target-selection mechanism.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

1 major / 6 minor

Summary. This paper studies asynchronous collective tree exploration (ACTE) and its distributed variant (DACTE). The authors present a distributed algorithm that explores any n-node tree of depth D in at most 2n + O(k^2 2^k D) moves, together with a variant achieving O(k/log k)(n + kD) moves. They also prove a lower bound of Ω(log^2 k) on the competitive ratio of any ACTE algorithm, improving over the previous Ω(log k). The lower bound is obtained via a reduction to fractional layered graph traversal, building on the recent Bubeck–Coester–Rabani lower bound. The paper contains detailed proofs of the algorithm's correctness and of the lower-bound reduction.

Significance. If correct, the algorithmic contribution is a significant advance: it is the first distributed asynchronous exploration algorithm with regret linear in D, and it draws an interesting connection to deterministic layered graph traversal. The lower bound would also be a major improvement, linking ACTE to the randomized k-server lower bound. The paper is generally well written and the algorithm part is supported by thorough claims. However, the lower-bound proof rests on an unproved and questionable ``without loss of generality'' statement (discussed below), so the advertised Ω(log^2 k) bound is not yet established. The algorithmic part alone may still be publishable, but the central lower-bound claim needs repair.

major comments (1)
  1. [Section 5.2, footnote 6] The proof of Proposition 5.3 assumes, without proof, that the adversarial layered instance never forks a leaf ℓ at a time when zℓ(t)=0, and it uses this WLOG to conclude L ≤ wLz. This assumption is load-bearing: it is the only step that bounds the tree size L in terms of the support size Lz, and it feeds directly into the inequalities that yield Cost(x(·), L(·)) ≤ 2bD. The footnote's justification ('the designer ... has no reason to make a move that diminishes its future options') is not a proof: forking a zero-mass leaf can increase future options (the new children become active leaves), it changes the minimization domain X(t) and the potential D(δ(t),x(t),z) in (7), and it can force the minimizer to move mass from other leaves into the new children, incurring real OT↑ cost in (9). Moreover, the claimed inequality L ≤ wLz can fail when zero-mass forks are allowed: for width w=3, the adversary can keep a single positive leaf b and repeatedly fork the currently active zero-mass leaf, e.g., layers {b,c}, then {b,c1,c2}, then {b,c3,c4}, ..., deleting one child at each step. The underlying tree then has L ≈ 2D nodes while Lz = O(1), so L > wLz for large D. On such an instance the chain 2^{-w}Lz ≤ Cost(x) ≤ aL + bD does not imply 2^{-w}Lz ≤ 2^{-(w+1)}Lz + bD, and the conclusion Cost(x(·), L(·)) ≤ 2bD is not obtained. Since Proposition 5.3 is the basis of Theorem 3.2, this gap must be repaired, for instance by proving that zero-mass forks can be eliminated from any instance without increasing the final bound, or by establishing a direct bound on L in terms of Lz and Cost(x).
minor comments (6)
  1. [Section 5.2, Eq. (13)] The inequality D(δ(t), x(t), z′) − D(δ(t), x(t−1), z′) ≤ OT(x(t−1), x(t)) appears to be missing a factor of 2: since a_+ − b_+ ≤ |a−b|, each summand is bounded by |(z′_u+δ_u(t)−2x_u(t)) − (z′_u+δ_u(t)−2x_u(t−1))| = 2|x_u(t)−x_u(t−1)|. The same issue occurs in the bound for B in the leaf-deletion case. This only affects the constant in the final bound (18bD would become a different constant), so the asymptotic claim is unaffected, but the proof as written is not fully correct.
  2. [Lemma 3.3] The lemma divides the robots into teams of size k′ or fewer and then applies the guarantee f(k′, n, D) to every team, including teams of size strictly smaller than k′. This implicitly requires that f(k, n, D) is non-decreasing in k, which is plausible for the algorithm presented but should be stated explicitly and justified.
  3. [Section 3.3] The assertion that any asynchronous greedy algorithm requires at least kn/2 robot moves on the comb tree is stated without proof; a short argument would improve the clarity of the claim.
  4. [Table 1] The entry 'This W ork' should read 'This work'.
  5. [Section 5.2, telescoping argument] The statement 'at all times Σu δu(t) ≤ D' is inaccurate because δ(t) is a probability configuration and its total mass over all nodes is the expected depth plus one, which can reach D+1. The telescoping argument only needs the final-minus-initial difference to be at most D, which holds; the wording should be corrected.
  6. [Footnote 5] The phrase 'consecutive branches can be forces to be explored' contains a typo: 'forces' should be 'forced'.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the upper bound rests on the external Bur96 LGT algorithm and a self-contained greedy-target argument; the lower bound is a reduction to the external BCR23 fractional LGT lower bound.

full rationale

The paper's two central claims are derived from independent external results. Theorem 3.1 is proved by showing the distributed algorithm is locally greedy (Claims 1-6, Appendix A.2), then bounding target movement via the deterministic layered-graph-traversal algorithm of Burley (Theorem 2.1); no fitted parameter or target result is used as an input. Theorem 3.2 is a reduction: Lemma 5.2 (proof sketched in Appendix B) converts an ACTE algorithm into a fractional traversal algorithm with (a,b) overhead, and Proposition 5.3 converts that overhead into an O(b)-competitive width-w fractional algorithm, contradicting the external BCR23 lower bound. The self-citations to [Cos24] and [CM24b] are used for simple transformation lemmas whose proofs are included in the text or appendix, so they are not load-bearing in a circular way. The only in-scope weakness is the WLOG in footnote 6 of Proposition 5.3, which asserts that a leaf with z_l(t)=0 is never forked or deleted because the instance designer has 'no reason to make a move that diminishes its future options, while not leading to any cost.' This is an unproved adversary-optimality assumption and a genuine correctness risk if zero-mass forks can change the potential and future z-trajectory; however, it is not a circularity, because it does not define the claimed lower bound in terms of itself, fit a parameter to the conclusion, or smuggle the conclusion in through a self-citation. Accordingly, no circular step is identified and the circularity score is zero.

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

The central theorems rely on two external landmarks (Burley's deterministic LGT and BCR23's fractional LGT lower bound), on the DACTE model definition, and on one unproven WLOG in the lower-bound proof. The only hand-picked quantity is the team size k' = ⌈ln k⌉ used to convert the regret guarantee into a competitive ratio. No entities beyond standard mathematical constructs are introduced.

free parameters (1)
  • team size k' = ⌈ln k⌉ for the competitive-ratio variant = k' = ⌈ln k⌉
    Hand-picked in Lemma 3.3 to turn the linear-regret algorithm into an O(k/log k)-competitive algorithm. It is explicit and not fitted to data, but it is a design choice on which the second guarantee depends.
assumptions (5)
  • standard math Theorem 2.1 (Burley): there is an O(w 2^w)-competitive deterministic layered graph traversal algorithm.
    Used as a black-box subroutine in Theorem A.1 to bound Σ_h d(v_h, v_{h+1}) ≤ c_k D, where c_k = O(k 2^k).
  • standard math Theorem 2.3 (Bubeck, Coester, Rabani): fractional tree traversal has competitive ratio Ω(w^2).
    Used to derive the contradiction in the lower-bound proof of Theorem 3.2.
  • ad hoc to paper WLOG in Proposition 5.3: the adversarial layered instance never extends or forks a leaf ℓ at time t with z_ℓ(t) = 0 (footnote 6).
    Load-bearing for bounding L ≤ w·L_z and hence for the Ω(log^2 k) lower bound; the justification is a one-sentence claim about the designer of L(·) having no reason to diminish future options without cost. This is the main fragility of the lower bound.
  • domain assumption Random tree model: trees sampled uniformly at random have size n = Θ(D^2) with high probability (Aldous).
    Supports the average-case optimality claim in the abstract; not used for the worst-case theorems.
  • domain assumption DACTE model assumptions: adversary picks one robot per round; robots observe adjacent nodes and read/write whiteboards at the current node only; whiteboards are unbounded.
    Definitions in Section 3.1; the algorithm's correctness is relative to this model.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Asynchronous Collective Tree Exploration: a Distributed Algorithm, and a new Lower Bound." pith.science (2026). https://pith.science/paper/YDLMUKA6

@misc{pith2026250715658,
  author       = {Pith},
  title        = {Pith review of: Asynchronous Collective Tree Exploration: a Distributed Algorithm, and a new Lower Bound},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YDLMUKA6}},
  note         = {Machine review of arXiv:2507.15658}
}
abstract

We study the problem of collective tree exploration in which a team of $k$ mobile agents must collectively visit all nodes of an unknown tree in as few moves as possible. The agents all start from the root and discover adjacent edges as they progress in the tree. Communication is distributed in the sense that agents share information by reading and writing on whiteboards located at all nodes. Movements are asynchronous, in the sense that the speeds of all agents are controlled by an adversary at all times. All previous competitive guarantees for collective tree exploration are either distributed but synchronous, or asynchronous but centralized. In contrast, we present a distributed asynchronous algorithm that explores any tree of $n$ nodes and depth $D$ in at most $2n+O(k^2 2^kD)$ moves, i.e., with a regret that is linear in $D$, and a variant algorithm with a guarantee in $O(k/\log k)(n+kD)$, i.e., with a competitive ratio in $O(k/\log k)$. We note that our regret guarantee is asymptotically optimal (i.e., $1$-competitive) from the perspective of average-case complexity. We then present a new general lower bound on the competitive ratio of asynchronous collective tree exploration, in $\Omega(\log^2 k)$. This lower bound applies to both the distributed and centralized settings, and improves upon the previous lower bound in $\Omega(\log k)$.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

31 extracted references · 26 canonical work pages

  1. [1]

    The continuum random tree iii

    David Aldous. The continuum random tree iii. The annals of probability , pages 248--289, 1993

    work page 1993

  2. [2]

    Search games with predictions

    Spyros Angelopoulos, Thomas Lidbetter, and Konstantinos Panagiotou. Search games with predictions. arXiv preprint arXiv:2401.01149 , 2024

    arXiv 2024

  3. [3]

    Graph Searching with Predictions

    Siddhartha Banerjee, Vincent Cohen-Addad, Anupam Gupta, and Zhouzi Li. Graph searching with predictions. arXiv preprint arXiv:2212.14220 , 2022

    work page Pith review arXiv 2022

  4. [4]

    Multirobot tree and graph exploration

    Peter Brass, Flavio Cabrera - Mora, Andrea Gasparri, and Jizhong Xiao. Multirobot tree and graph exploration. IEEE Trans. Robotics , 27(4):707--717, 2011

    work page 2011

  5. [5]

    Shortest paths without a map, but with an entropic regularizer

    S \'e bastien Bubeck, Christian Coester, and Yuval Rabani. Shortest paths without a map, but with an entropic regularizer. In 2022 IEEE 63rd Annual Symposium on Foundations of Computer Science (FOCS) , pages 1102--1113. IEEE, 2022

    work page 2022

  6. [6]

    The randomized k-server conjecture is false! In Proceedings of the 55th Annual ACM Symposium on Theory of Computing , pages 581--594, 2023

    S \'e bastien Bubeck, Christian Coester, and Yuval Rabani. The randomized k-server conjecture is false! In Proceedings of the 55th Annual ACM Symposium on Theory of Computing , pages 581--594, 2023

    work page 2023

  7. [7]

    On the power of randomization in on-line algorithms

    Shai Ben-David, Allan Borodin, Richard Karp, Gabor Tardos, and Avi Wigderson. On the power of randomization in on-line algorithms. Algorithmica , 11:2--14, 1994

    work page 1994

  8. [8]

    A nearly optimal randomized algorithm for explorable heap selection

    Sander Borst, Daniel Dadush, Sophie Huiberts, and Danish Kashaev. A nearly optimal randomized algorithm for explorable heap selection. Mathematical Programming , 210(1):75--96, 2025

    work page 2025

Show all 31 references
  1. [9]

    Exploration of graphs with excluded minors

    J \'u lia Balig \'a cs, Yann Disser, Irene Heinrich, and Pascal Schweitzer. Exploration of graphs with excluded minors. In 31st Annual European Symposium on Algorithms (ESA 2023) , pages 11--1. Schloss Dagstuhl--Leibniz-Zentrum f \"u r Informatik, 2023

    2023

  2. [10]

    Flex: an adaptive exploration algorithm for nonlinear systems

    Matthieu Blanke and Marc Lelarge. Flex: an adaptive exploration algorithm for nonlinear systems. In International Conference on Machine Learning , pages 2577--2591. PMLR, 2023

    2023

  3. [11]

    Traversing layered graphs using the work function algorithm

    William R Burley. Traversing layered graphs using the work function algorithm. Journal of Algorithms , 20(3):479--511, 1996

    1996

  4. [12]

    Improved analysis of a multirobot graph exploration strategy

    Peter Brass, Ivo Vigan, and Ning Xu. Improved analysis of a multirobot graph exploration strategy. In 13th International Conference on Control Automation Robotics & Vision, ICARCV , pages 1906--1910. IEEE , 2014

    1906

  5. [13]

    Barely random algorithms and collective metrical task systems

    Romain Cosson and Laurent Massouli \'e . Barely random algorithms and collective metrical task systems. Advances in Neural Information Processing Systems , 2024

    2024

  6. [14]

    Collective tree exploration via potential function method

    Romain Cosson and Laurent Massoulié. Collective tree exploration via potential function method. In 15th Innovations in Theoretical Computer Science Conference (ITCS 2024) , pages 35:1--35:22, 2024

    2024

  7. [15]

    Efficient collaborative tree exploration with breadth-first depth-next

    Romain Cosson, Laurent Massouli \'e , and Laurent Viennot. Efficient collaborative tree exploration with breadth-first depth-next. In 37th International Symposium on Distributed Computing (DISC) , 2023

    2023

  8. [16]

    Breaking the k/log k barrier in collective tree exploration via tree-mining

    Romain Cosson. Breaking the k/log k barrier in collective tree exploration via tree-mining. In Proceedings of the 2024 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA) , pages 4264--4282. SIAM, 2024

    2024

  9. [17]

    Walking down the memory maze: Beyond context limit through interactive reading

    Howard Chen, Ramakanth Pasunuru, Jason Weston, and Asli Celikyilmaz. Walking down the memory maze: Beyond context limit through interactive reading. arXiv preprint arXiv:2310.05029 , 2023

    2023 arXiv

  10. [18]

    Fast collaborative graph exploration

    Dariusz Dereniowski, Yann Disser, Adrian Kosowski, Dominik Pajak, and Przemyslaw Uznanski. Fast collaborative graph exploration. In Automata, Languages, and Programming, ICALP , Part II , 2013

    2013

  11. [19]

    Smart robot teams exploring sparse trees

    Miroslaw Dynia, Jaroslaw Kutylowski, Friedhelm Meyer auf der Heide, and Christian Schindelhauer. Smart robot teams exploring sparse trees. In Mathematical Foundations of Computer Science , volume 4162 of Lecture Notes in Computer Science , pages 327--338. Springer, 2006

    2006

  12. [20]

    Power-aware collective tree exploration

    Miroslaw Dynia, Miroslaw Korzeniowski, and Christian Schindelhauer. Power-aware collective tree exploration. In Architecture of Computing Systems - ARCS 2006 , volume 3894, pages 341--351. Springer, 2006

    2006

  13. [21]

    Why robots need maps

    Miroslaw Dynia, Jakub Lopuszanski, and Christian Schindelhauer. Why robots need maps. In Structural Information and Communication Complexity, SIROCCO Proceedings , 2007

    2007

  14. [22]

    A general lower bound for collaborative tree exploration

    Yann Disser, Frank Mousset, Andreas Noever, Nemanja Skoric, and Angelika Steger. A general lower bound for collaborative tree exploration. In Structural Information and Communication Complexity, SIROCCO , Revised Selected Papers , 2017

    2017

  15. [23]

    Competitive algorithms for layered graph traversal

    Amos Fiat, Dean P Foster, Howard Karloff, Yuval Rabani, Yiftach Ravid, and Sundar Vishwanathan. Competitive algorithms for layered graph traversal. In Proceedings of the 32nd annual symposium on Foundations of computer science , pages 288--297, 1991

    1991

  16. [24]

    Kowalski, and Andrzej Pelc

    Pierre Fraigniaud, Leszek Gasieniec, Dariusz R. Kowalski, and Andrzej Pelc. Collective tree exploration. Networks , 48(3):166--177, 2006

    2006

  17. [25]

    Online graph exploration algorithms for cycles and trees by multiple searchers

    Yuya Higashikawa, Naoki Katoh, Stefan Langerman, and Shin - ichi Tanigawa. Online graph exploration algorithms for cycles and trees by multiple searchers. J. Comb. Optim. , 28(2):480--495, 2014

    2014

  18. [26]

    A recursive approach to multi-robot exploration of trees

    Christian Ortolf and Christian Schindelhauer. A recursive approach to multi-robot exploration of trees. In International Colloquium on Structural Information and Communication Complexity , pages 343--354. Springer, 2014

    2014

  19. [27]

    Papadimitriou and Mihalis Yannakakis

    Christos H. Papadimitriou and Mihalis Yannakakis. Shortest paths without a map. Theor. Comput. Sci. , 84(1):127--150, 1991

    1991

  20. [28]

    On traversing layered graphs on-line

    Hariharan Ramesh. On traversing layered graphs on-line. J. Algorithms , 18(3):480--512, 1995

    1995

  21. [29]

    Beyond the worst-case analysis of algorithms

    Tim Roughgarden. Beyond the worst-case analysis of algorithms . Cambridge University Press, 2021

    2021

  22. [30]

    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:24824--24837, 2022

    2022

  23. [31]

    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:11809--11822, 2023

    2023

Pith tools

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