Pith. sign in

REVIEW 2 major objections 6 minor 1 cited by

Exponential Speedups by Rerooting Levin Tree Search

T0 review · 2 major / 6 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read Rerooting a Levin tree search at every visited node can cut T visits to about q times the qth root of T, and a lower bound proves this rate is near-optimal.

desk verdict Solid extension of Levin Tree Search with a correct composition theorem; the practical speedup is conditional on a rerooter nobody yet knows how to learn, but the formal contribution stands. read the letter →

arxiv 2412.05196 v2 pith:PNWDPYVM submitted 2024-12-06 cs.AI

Laurent Orseau , Marcus Hutter , Levi H.S. Lelis This is my paper · ORCID
classification cs.AI MSC 68T2068W40
keywords Levintreesearchrerootingbest-firstself-countingcostfunctionsslendernessefficiencyguaranteespolicy-guidedSokoban
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

Levin Tree Search (LTS) is a best-first search for deterministic environments that is guided by a policy and comes with a guarantee on the number of node visits before it finds a solution. This paper introduces $\sqrt{\text{LTS}}$, a rerooting variant that implicitly starts an LTS search at every visited node and divides search effort among those roots according to weights supplied by a 'rerooter'. The central result is that if plain LTS needs $T$ visits and the rerooter identifies $q$ useful rerooting points, $\sqrt{\text{LTS}}$ can get by with $O(q\sqrt[q]{T})$ visits in the best case, and the paper proves a lower bound showing no algorithm can do asymptotically better in the relevant clue environments. The reason the bound matters is that LTS's guarantee multiplies the costs of successive subtasks, while $\sqrt{\text{LTS}}$ replaces that product by a maximum, so the gain is exponential in the number of useful subtasks.

What carries the argument

The load-bearing mechanism is the composition of self-counting cost functions. A cost function $c$ is self-counting when $|\{n:c(n)\le\theta\}|\le\theta$ for every $\theta\ge0$; for a monotone self-counting cost, best-first search reaches any node $n_t$ with $t\le c(n_t)$. The paper's slenderness cost $\lambda_\pi$ is self-counting and tightens LTS's old cost by removing a $d(n)$ factor. $\sqrt{\text{LTS}}$ composes one rooted slenderness cost $\lambda_\pi(\cdot;n_t)$ for every visited node $n_t$, weighted by the rerooter weight $w_t$, into the single cost $c^r$ of Eq. (13), and a telescoping identity for $\lambda_\pi$ lets different roots be compared along one path. The subtask decomposition of Definition 10 is the analytical lens: it chooses any monotone chain of high-weight nodes ending at the solution, and the theorem reads the total visit count off the hardest weighted link in that chain.

What would settle it

On a perfect binary tree of depth $D$ (say $D=20$) with $q=8$ clue nodes whose closest clue ancestor is at relative depth $a=5$, and one solution below one of the clues, run $\sqrt{\text{LTS}}$ with a uniform policy and rerooting weight 1 at each clue node. Corollary 12 predicts the solution is visited at step $T<q\,2^{a+1}=512$; a run exceeding that on a fixed tie-breaking rule would refute the main bound. In the randomized version of the same environment, the lower-bound theorem says every algorithm must average at least $(q+1)2^{a-1}=144$ visits, so an algorithm averaging less would refute that bound.

Watch

Extended reading notes

Core claim

The paper's central discovery is that rerooting turns the multiplicative structure of LTS's guarantee into an additive one. In place of the cost $d(n)/\pi(n)$, it uses a slenderness cost $\lambda_\pi(n)=\sum_{n_1\preceq u\preceq n}1/\pi(u)$, which avoids double-counting shared ancestors, and then composes one rooted slenderness cost per visited node into a single search cost $c^r(n)=\min_{n_t\prec n}(\lambda_\pi(n;n_t)-1)/w_t$. The main guarantee, Theorem 11 with the simplified Corollary 12, states that for every subtask decomposition $n_{T_1}\prec\cdots\prec n_{T_m}=n_T$ of the solution node, the visit count satisfies $T\le \max_{i<m}(w_{<T}/w_{T_i})\,\lambda_\pi(n_{T_{i+1}};n_{T_i})$, where $w_{<T}$ is the cumulative rerooting weight. Because LTS multiplies the same subtask costs while $\sqrt{\text{LTS}}$ takes their maximum, the new bound can be exponentially smaller in the number of subtasks. In the paper's clue environments, putting rerooting weight 1 on each clue node matches the lower bound $(q+1)2^{a-1}$ within a factor of 4.

Load-bearing premise

The exponential speedup presupposes a rerooter that assigns positive weight to a chain of useful nodes leading to the solution with bounded gaps between consecutive useful nodes; the paper does not provide a procedure that produces such a rerooter for a concrete domain.

Editorial extensions

If this is right

  • If the rerooter sets positive weight on a chain of $q$ useful rerooting points in the clue environments, $\sqrt{\text{LTS}}$ visits $O(q\,2^a)$ nodes while LTS needs $\Omega(2^{m(a-1)})$; the gap grows exponentially with the number $m$ of useful clues.
  • The main bound holds for every visited node and for any stopping criterion, so anytime use of $\sqrt{\text{LTS}}$ inherits the same guarantee without modification.
  • With the reweighting of Corollary 17, $\sqrt{\text{LTS}}$ is never worse than a logarithmic factor of the LTS bound even when the number of clues is large or unbounded.
  • In the D-chain environment, $\sqrt{\text{LTS}}$ with reward-based rerooting weights stays within a log factor of breadth-first search where UCT-style algorithms can take double-exponential time, and with one aligned reward it achieves about the square root of breadth-first time.
  • The best-case rate $O(q\sqrt[q]{T})$ matches the paper's lower bound up to a constant factor, so no algorithm can asymptotically improve on it in general in these environments.

Reading between the lines

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

  • A testable extension the paper leaves implicit is to train the rerooter on solved instances by rewarding weight on nodes that belong to a good subtask decomposition; the bound then predicts that the speedup transfers to structurally similar instances.
  • The composition lemma is independent of the slenderness cost, so the same rerooting technique could combine other self-counting signals, for example one derived from an admissible heuristic, without multiplying their guarantees.
  • Mapping clues to concrete progress signals such as landmarks, shaping rewards, lemmas, or satisfied constraints, and measuring how $w_{<T}$ grows, gives a practical way to choose rerooting weights that the paper motivates but does not develop.
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

2 major / 6 minor

Summary. The paper introduces √LTS (root-LTS), a best-first tree-search algorithm that composes Levin Tree Search instances implicitly rooted at every visited node, with the effort shared according to a user-supplied rerooting weight w_t assigned to each visited node. The central theoretical claim is Theorem 11 and Corollary 12: for every subtask decomposition n_{T_1} ≺ ... ≺ n_{T_m} = n_T of the visited node n_T, the visit count satisfies T ≤ Σ_{j<m} (w_{<T_{j+1}} − w_{<T_j}) max_{j≤i<m} (1/w_{T_i}) λ_π(n_{T_{i+1}}; n_{T_i}) and, in simplified form, T ≤ max_{i<m} (w_{<T}/w_{T_i}) λ_π(n_{T_{i+1}}; n_{T_i}), where λ_π is a new self-counting cost function that tightens the previous LTS bound of 1 + d/π. In clue environments, when the rerooter assigns positive weight to q clue nodes on the solution path, this yields an O(q 2^a) visit bound against an LTS baseline of Ω(2^{m(a−1)}), an exponential speedup that matches a new lower bound (Theorem 3) within a constant factor. A weight reparameterization (Corollary 17) replaces a potentially linear factor w_{<T} by a logarithmic factor, giving robustness to an overload of misleading clues. The paper also argues (Appendix A) that A*, weighted A*, and MCTS-style algorithms cannot exploit such clues while retaining their usual guarantees.

Significance. If the results hold, this is a substantial contribution to the theory of guided tree search: it is the first to convert LTS's multiplicative-in-subtasks guarantee into a max/sum form at the price of a rerooting-weight factor, and it provides a matching lower bound for clue environments. The central proof in Appendix D is careful and, to the best of my check, correct: Lemma 33 and Lemma 35 genuinely handle the non-monotone cost, Lemma 36 supplies the self-counting base functions, and the segment partition in Eqs. (22a)–(22f) is sound, including the extraction of the −1 term. The slenderness cost function λ_π is a real (if modest) improvement over 1 + d/π, and Corollary 17's reparameterization is an elegant device. The paper ships no code or machine-checked proofs, but the derivations are detailed enough to be verified by hand, which I did for the key steps. I also judge that the main caveat flagged by a critical reader — that the advertised exponential speedup presupposes a good rerooter and no learning procedure is provided — is honestly disclosed in Sections 1 and 7 ('we expect that the rerooter may be learnt from data...

major comments (2)
  1. [Section 6, Example 15] The displayed derivation T ≤ w_{<T} max_{i<m} q_{T_i} λ_π(n_{T_{i+1}}; n_{T_i}) ≤ (1 + ln q_T) q_{T_m}^{m−1} 2^{a+1} is true but too loose to support the conclusion drawn from it. Since a subtask decomposition must satisfy n_{T_m} = n_T (Definition 10) and the example sets n_T = n*, one has T_m = T, hence q_{T_m} = q_T ≤ T; substituting back gives the circular inequality T ≤ (1 + ln T) T^{m−1} 2^{a+1}, which is vacuous for m ≥ 2. The subsequent sentence 'Since q_{T_m}^{m−1} does not depend on T' is therefore false as written, and the claimed implication T = Õ(q_{T_m}^{m−1} 2^a) with a T-independent right-hand side, as well as the conclusion that n* is necessarily eventually visited, does not follow from this argument. The example already contains a sound route to the main robustness conclusion via Eq. (16): T ≤ w_{<T} λ_π(n*) ≤ (1 + ln q_T) λ_π(n*) ≤ (1 + ln T) λ_π(n*), which with the footnote's self-bounding trick gives T = O(λ_π(n*) ln λ_π(n*)), i.e., within a log factor of LTS. I recommend restructuring Example 15 around that argument and correcting or dropping the q_{T_m}^{m−1} bound.
  2. [Theorem 11 and Definition 10] The main theorem is stated for 'every subtask decomposition', but Definition 10 permits the degenerate case m = 1 when n_T = n_1 (i.e., T = 1). For m = 1 the sum in Eq. (14) is empty, so the theorem would assert T ≤ 0, which is false for T = 1. The proof's extraction of the −1 term in Eq. (22f) requires the last segment j = m−1 to exist, i.e., m ≥ 2, and also requires w_{T_{m−1}} > 0 for the ratio (w_{<T_m} − w_{<T_{m−1}})/w_{T_{m−1}} to be well-defined and ≥ 1. This is a degenerate edge case that does not affect any application in the paper (all uses have m ≥ 2), but the statement should be corrected, e.g., by requiring m ≥ 2 in Theorem 11 and Definition 10 and by noting that the bound is infinite unless w_{T_i} > 0 for the chosen decomposition.
minor comments (6)
  1. [Section 6, proof of Corollary 17] The proof begins 'The result follows from Corollary 17', which is a self-reference; it should read 'from Corollary 12'. In the same proof, the index range of the telescoping sum should be t = 2, ..., T−1 rather than t = 2, ..., T (since w_{<T} = w_1 + Σ_{t=2}^{T−1} w_t).
  2. [Section 4.1 and Lemma 36] The claim that the rooted cost λ_π(·; n_a) is self-counting is essential for Lemma 36, which is used in the proof of Theorem 11, but it is only asserted in a footnote ('All the proofs can be readily adapted at the expense of heavier notation'). Please include the short argument (applying the complementary-policy proof of Proposition 25 within the subtree rooted at n_a with the conditional policy).
  3. [Section 2] The ancestor relation is introduced with both nodes printed as 'n' ('we write n ≺ n for n ∈ anc(n)'), which is unreadable; use distinct symbols (e.g., n ≺ n′) as in the table of notation in Appendix I.
  4. [Section 5 and Corollary 12] The paper should state explicitly the standing assumptions that rerooting weights are nonnegative, that w_1 > 0 for non-vacuous bounds, and that the bound of Corollary 12 (and Eq. (16)) is infinite unless w_{T_i} > 0 for the subtask nodes used. Currently these positivity conditions are implicit.
  5. [Algorithm 1] The pseudocode computes min_{n_k ≺ n} (1/w_k)(λ_π(n; n_k) − 1) without guarding against w_k = 0; the surrounding text handles zero weights via infinite cost, but the pseudocode should exclude ancestors with zero weight.
  6. [Appendix H] The phrase 'any state no state is visited twice' is garbled and should be reworded. Also, the final numerical bound reads T ≤ 3.83 max{733, 9 × 31, 2 × 229, 2 × 393} ≤ 3 011; the maximum is 786 and 3.83 × 786 ≈ 3 010, so the displayed value is consistent, but a quick check of the arithmetic would be good.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: Theorem 11's conditional bound follows from internal lemmas and the speedup is explicitly contingent on a user-supplied rerooter; self-citations are background, not load-bearing.

full rationale

Theorem 11 and Corollary 12 are derived from internal lemmas, not from the theorem being assumed: Lemma 33 (Tree-to-path) and Lemma 35 (SCCF composition bound) are proved in Appendix D from the definition of the composed cost function cr and the self-counting property of λπ. The slenderness cost function λπ is itself proven self-counting in Appendix B (Propositions 25 and 27) from first principles, so the bound T ≤ max_i (w_{<T} / w_{T_i}) λπ(n_{T_{i+1}}; n_{T_i}) is a genuine conditional guarantee for any user-supplied rerooter, not a fitted relation. The advertised O(q·q√T) speedup is explicitly conditional on a rerooter that assigns positive weight to useful ancestor clues; the paper states this limitation clearly ('Like the LTS policy, we expect that the rerooter may be learnt from data or designed by the user, but this is beyond the scope of this paper'), and Section 6 supplies matching lower bounds via Theorem 3, so the conditional claim is not made true by an unstated fit. The paper cites the authors' prior LTS work (Orseau et al. 2018, 2023) for background, but the needed self-counting properties are either reproved here or are independent published results; no load-bearing step reduces to a self-citation. The only textual oddity is the proof of Corollary 17 saying 'The result follows from Corollary 17', which is a typo for Corollary 12; it is not circularity because Corollary 12 is already proved. No fitted parameter is relabeled as a prediction, and no known result is merely renamed. The derivation chain is therefore self-contained with respect to the paper's claims.

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

The central theorem does not fit constants; the algorithm's two tunable inputs, the policy and the rerooter, are user-provided. The rerooter is a new algorithmic construct but no new physical entity, particle, force, or conserved quantity is introduced.

free parameters (1)
  • Rerooting weights w_t (and reparameterized \tilde w_t) = User-provided; examples include w_t=1/q for clue nodes, w_t=1/q_t, and w_t=1/M_z in the Sokoban illustration.
    The node-visit bound depends on these weights. They are not fitted to data in the paper; they are inputs to the algorithm, which is why the practical speedup is conditional on the user or a learned rerooter.
assumptions (5)
  • domain assumption Search space is a rooted tree and BFS enumerates nodes via priority queue (Eqs. (1)-(2)).
    Used throughout; solution nodes are recognized when visited, and children are generated when the parent is visited.
  • domain assumption The policy π is proper and given by the user.
    Properness (children probabilities sum to 1) is needed for the lower bound in Eq. (6) and for clean cost bounds; Section 2.
  • domain assumption Rerooting weights are nonnegative and the root receives positive weight, otherwise the bound of Theorem 11 is vacuous.
    Eq. (13) sets finite costs only under an ancestor with positive weight; the paper does not state this requirement explicitly.
  • standard math Union bound and mean value theorem.
    Union bound proves Lemma 8; mean value theorem is used in Appendix F to reparameterize weights.
  • domain assumption The lower bound of Theorem 3 assumes the solution is uniform among candidate nodes.
    This is an environment construction for the lower bound, not an assumption of the algorithm; it makes the lower bound average-case.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Exponential Speedups by Rerooting Levin Tree Search." pith.science (2026). https://pith.science/paper/PNWDPYVM

@misc{pith2026241205196,
  author       = {Pith},
  title        = {Pith review of: Exponential Speedups by Rerooting Levin Tree Search},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/PNWDPYVM}},
  note         = {Machine review of arXiv:2412.05196}
}
abstract

Levin Tree Search (LTS) (Orseau et al., 2018) is a search algorithm for deterministic environments that uses a user-specified policy to guide the search. It comes with a formal guarantee on the number of search steps (node visits) for finding a solution node that depends on the quality of the policy. In this paper, we introduce a new algorithm, called $\sqrt{\text{LTS}}$ (pronounce root-LTS), which implicitly starts an LTS search rooted at every node of the search tree. Each LTS search is assigned a rerooting weight by a (user-defined or learnt) rerooter, and the search effort is shared between all LTS searches proportionally to their weights. The rerooting mechanism implicitly decomposes the search space into subtasks, leading to significant speedups. We prove that the number of node visits that $\sqrt{\text{LTS}}$ takes is competitive with the best decomposition into subtasks, at the price of a factor that relates to the uncertainty of the rerooter. If LTS takes time $T$, in the best case with $q$ rerooting points, $\sqrt{\text{LTS}}$ only takes time $O(q\sqrt[q]{T})$. Like the policy, the rerooter can be learnt from data, and we expect $\sqrt{\text{LTS}}$ to be applicable to a wide range of domains.

Figures

Figures reproduced from arXiv: 2412.05196 by the authors.

Figure 1
Figure 1. A schematic representation of the binary tree of Example [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. The tree of Exam￾ples 6 and 7. Indeed, the factor d(n) appears in the ratio between the upper and lower bounds [Orseau et al., 2023, Theorem 2]. We develop a tighter self-counting cost function λ π (n) that avoids this double counting. The cost function λ π (n) is based on the quantity λ(n) which counts what fraction of its ancestors the node n is ‘respon￾sible’ for. If a node n holds a share λ(n) of its ancestors (… view at source ↗
Figure 3
Figure 3. See Example 14. The cost of reaching nT2 from n1 = nT1 using LTS (with λ π as the cost function) is c r T1 (nT2 ) = A. The cost of reaching nT4 from nT3 is c r T3 (nT4 ) = B, etc. c r (nT5 ) = c r T4 (T5) = A is visited before catching up entirely. Steps T5 to T6. Now c r T5 starts catching up with the rest. Once c r T5 has caught up with c r T4 , both c r T4 (dashed lines) and c r T5 catch up with the rest until nT… view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: The D-chain environment. Edge labels are actions, and node labels are rewards. The binary tree is perfect and infinite. UCT, ‘Polynomial’ UCT, AlphaZero and other MCTS variants take double exponential time (and more) with the depth of the node n ∗ of highest reward. Wh…
Figure 5
Figure 5. Figure 5: A simple level of Sokoban. The player (the pumpkin) can move in all 4 directions [PITH_FULL_IMAGE:figures/full_fig_p032_5.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Structure-Induced Information for Rerooting Levin Tree Search

    cs.AI 2026-05 unverdicted novelty 6.0 of 10

    Three rerooter designs (clustering-based, heuristic-based, hybrid) for √LTS enable scalable search in complex single-agent environments where explicit subgoal methods fail and achieve SOTA online training efficiency.

Reference graph

Works this paper leans on

23 extracted references · 21 canonical work pages · cited by 1 Pith paper

  1. [1]

    Bandit algorithms for tree search

    Pierre-Arnaud Coquelin and R\' e mi Munos. Bandit algorithms for tree search. In Proceedings of the Twenty-Third Conference on Uncertainty in Artificial Intelligence , UAI'07, page 67–74, Arlington, Virginia, USA, 2007. AUAI Press

    work page 2007

  2. [2]

    Generalized best-first search strategies and the optimality of A*

    Rina Dechter and Judea Pearl. Generalized best-first search strategies and the optimality of A* . J. ACM , 32(3):505–536, jul 1985

    work page 1985

  3. [3]

    Doran, Donald Michie, and David George Kendall

    James E. Doran, Donald Michie, and David George Kendall. Experiments with the graph traverser program. Proceedings of the Royal Society of London. Series A. Mathematical and Physical Sciences , 294(1437):235--259, 1966

    work page 1966

  4. [4]

    Hart, Nils J

    Peter E. Hart, Nils J. Nilsson, and Bertram Raphael. A formal basis for the heuristic determination of minimum cost paths. IEEE transactions on Systems Science and Cybernetics , 4(2):100--107, 1968

    work page 1968

  5. [5]

    Ordered landmarks in planning

    J\"org Hoffmann, Julie Porteous, and Laura Sebastia. Ordered landmarks in planning. Journal of Artificial Intelligence Research , 22:215--278, November 2004

    work page 2004

  6. [6]

    Bandit based monte-carlo planning

    Levente Kocsis and Csaba Szepesv \'a ri. Bandit based monte-carlo planning. In Johannes F \"u rnkranz, Tobias Scheffer, and Myra Spiliopoulou, editors, Machine Learning: ECML 2006 , pages 282--293, Berlin, Heidelberg, 2006. Springer Berlin Heidelberg

    work page 2006

  7. [7]

    Leonid A. Levin. Universal sequential search problems. Problems of Information Transmission , 9(3):265--266, 1973

    work page 1973

  8. [8]

    An introduction to kolmogorov complexity and its applications

    Ming Li and Paul M B Vit \'a nyi. An introduction to kolmogorov complexity and its applications . Texts in Computer Science. Springer International Publishing, Basel, Switzerland, 4 edition, March 2019

    work page 2019

Show all 23 references
  1. [9]

    Automated theorem proving: A logical basis

    Donald W Loveland. Automated theorem proving: A logical basis . Elsevier, 2016

    2016

  2. [10]

    Efficient tracking of a growing number of experts

    Jaouad Mourtada and Odalric-Ambrym Maillard. Efficient tracking of a growing number of experts. In Proceedings of the 28th International Conference on Algorithmic Learning Theory (ALT) , volume 76 of Proceedings of Machine Learning Research , pages 517--539, 2017

    2017

  3. [11]

    Ng, Daishi Harada, and Stuart J

    Andrew Y. Ng, Daishi Harada, and Stuart J. Russell. Policy invariance under reward transformations: Theory and application to reward shaping. In Proceedings of the Sixteenth International Conference on Machine Learning , ICML '99, page 278–287, San Francisco, CA, USA, 1999. Mo...

    1999

  4. [12]

    Laurent Orseau and Levi H. S. Lelis. Policy-guided heuristic search with guarantees. Proceedings of the AAAI Conference on Artificial Intelligence , 35(14):12382--12390, May 2021

    2021

  5. [13]

    Super-exponential regret for UCT , AlphaGo and variants

    Laurent Orseau and Remi Munos. Super-exponential regret for UCT , AlphaGo and variants. arXiv preprint arXiv:2405.04407 , 2024

    2024 arXiv

  6. [14]

    Single-agent policy tree search with guarantees

    Laurent Orseau, Levi Lelis, Tor Lattimore, and Theophane Weber. Single-agent policy tree search with guarantees. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett, editors, Advances in Neural Information Processing Systems , volume 31. Curran...

    2018

  7. [15]

    Laurent Orseau, Marcus Hutter, and Levi H. S. Lelis. Levin tree search with context models. In Proceedings of the Thirty-Second International Joint Conference on Artificial Intelligence, IJCAI-23 , pages 5622--5630. International Joint Conferences on Artificial Intelligence Or...

    2023

  8. [16]

    Heuristics: Intelligent Search Strategies for Computer Problem Solving

    Judea Pearl. Heuristics: Intelligent Search Strategies for Computer Problem Solving . Addison-Wesley Longman Publishing Co., Inc., USA, 1984

    1984

  9. [17]

    Heuristic search viewed as path finding in a graph

    Ira Pohl. Heuristic search viewed as path finding in a graph. Artificial Intelligence , 1(3):193 -- 204, 1970

    1970

  10. [18]

    David Silver, Aja Huang, Christopher J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lillicrap, ...

    2016

  11. [19]

    Mastering chess and shogi by self-play with a general reinforcement learning algorithm

    David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, et al. Mastering chess and shogi by self-play with a general reinforcement learning algorithm. arXiv preprint arXiv:17...

    2017 arXiv

  12. [20]

    Mastering the game of go without human knowledge

    David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, Yutian Chen, Timothy Lillicrap, Fan Hui, Laurent Sifre, George van den Driessche, Thore Graepel, and Demis Hassabis. Masterin...

    2017

  13. [21]

    Sutton and Andrew G

    Richard S. Sutton and Andrew G. Barto. Reinforcement Learning : An Introduction . MIT Press, 1998

    1998

  14. [22]

    Foundations of constraint satisfaction: the classic text

    Edward Tsang. Foundations of constraint satisfaction: the classic text . BoD--Books on Demand, 2014

    2014

  15. [23]

    write newline

    " write newline "" before.all 'output.state := FUNCTION fin.entry add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence '...

Pith tools

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