{"id":"b5b4b207-45ea-442e-b81e-cdaf79ac1105","arxiv_id":"2507.04949","paper_version":3,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":4,"one_line_summary":"Tensor Train Tree Search approximates the decision tree by a low-rank tensor train, enabling Monte Carlo tree search with much lower computation and memory, at the price of an underlying low-rank assumption.","lead":"Robot optimization tasks can be framed as tree searches, but the trees explode combinatorially. This paper proposes Tensor Train Tree Search, which squeezes the tree into a compact tensor factorization and then runs a guided Monte Carlo search, reporting speedups on inverse kinematics, motion planning, pushing, legged and bimanual manipulation.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Prop 3's global-optimality guarantee is not supported by Algorithm 1 as written: UCB is ill-defined at zero visit counts and the layer-wise top-τ + greedy-suffix selection does not ensure every leaf is visited.","rationale":"After reading the paper in good faith, I find the central idea—representing the tree as a TT and using contractions to compute aggregate statistics—plausible and the experimental breadth impressive. The authors are also honest about the low-rank limitation, explicitly stating in Section 5.3 that low rank governs speed, not convergence, and showing in Section 7.1 that obstacle-heavy IK is high-rank yet still solved after search. The reader's weakest-assumption therefore targets an efficiency premise, not the core correctness guarantee. My main concern is different: the correctness guarantee itself is not established by the stated algorithm. Proposition 3's proof is a one-paragraph invocation of standard UCB infinite-visitation, but Algorithm 1 does not perform standard UCB descent: it selects top-τ partial paths at each layer over the whole layer, stops at the first 'unexpanded' node (never defined), and completes the path greedily using the TT surrogate. Under this scheme, a leaf can be permanently protected from evaluation if the surrogate ranks it below a sibling, because UCB never applies to the greedy suffix. Asymptotic completeness requires that every leaf be evaluated at its true value; the proof does not show this. There is also a concrete internal inconsistency: the UCB formula in Eq. (2) is undefined at v=0 and at log(0) for the root (V_0←0), while Section 5.1 describes iteration 1 as 'dominated entirely by the exploitation term'. No code is released, so I could not verify whether the implementation special-cases these values. If the authors can specify the selection/expansion semantics, define handling of zero visit counts, and provide a proof that every leaf's true value is eventually evaluated, the paper would be substantially stronger. I therefore recommend keeping the CONDITIONAL verdict, with the required conditions including a corrected algorithm specification and proof, in addition to the code release and low-rank discussion the reader requested. I agree only partially with the reader's weakest-assumption: the low-rank issue is secondary; it does not affect the soundness of the global-search claim, whereas the selection-rule gap does.","tokens_in":28719,"tokens_out":15392,"duration_ms":162740,"concrete_test":"Run Algorithm 1 verbatim on a depth-2 tree with two choices per layer, exact TT of any reward tensor, τ=1, c=3, V_0←0. At iteration 1, line 16 must compute q/v for a node with v=0 and log(v_parent) with v_parent=0, giving 0/0 and log 0, so the pseudocode is not executable without an unspecified convention. Then, for any explicitly stated zero-visit convention and expansion rule, trace the algorithm on a tree where the TT surrogate ranks a sibling of the true optimum higher (e.g., J(1,1)=3, J(1,2)=1 but Q(1,2)>Q(1,1) for a repeatedly selected prefix i1=1); check whether the true optimum leaf is ever evaluated. If not, Proposition 3's 'every leaf is eventually visited' is false for that specification.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"The central claim of the paper is that TTTS preserves MCTS's global-optimality guarantee while reducing per-iteration cost to O(N d r^2). Proposition 3 is the load-bearing result for the 'global' part, but its proof does not apply to the algorithm actually specified. In Algorithm 1, line 16 selects the top-τ elements over the entire set I[j] of partial paths at depth j, rather than over children of the node selected at depth j−1 as in standard MCTS. Line 17 then breaks to a greedy suffix (lines 19–22) whenever the selected node 'is not expanded', and the expansion rule is never defined. A consequence is that leaves under a repeatedly selected prefix are completed by argmax of the TT value Q (line 21), not by UCB; if Q ranks the true optimum below a sibling, that leaf is never evaluated even with infinite iterations. The proof of Proposition 3 assumes the standard UCB property that every node is visited infinitely often; that property concerns the nodes actually selected by UCB, and here the suffix selection is greedy, so the assumption does not cover it. Separately, Eq. (2) is ill-defined in this algorithm: Algorithm 1 initializes the root visit count to V_0 ← 0 (line 12), so for j=1 the parent term log v_i[0] = log 0 is undefined, and any unvisited node has v_i[j] = 0, making q_i[j]/v_i[j] a division by zero. Section 5.1's statement that 'all visit counts are zero, so the UCB score is dominated entirely by the exploitation term' is inconsistent with Eq. (2). These are internal correctness gaps, not efficiency caveats: they hold even for an exactly low-rank tree. The low-rank concern identified by the reader is real but secondary, because the paper explicitly argues low rank affects speed of convergence, not convergence itself; the selection-rule gap affects the convergence itself.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes Tensor Train Tree Search (TTTS), a method that represents the decision tree arising from discretized robot optimization as a high-dimensional tensor, approximates it in tensor-train (TT) format via TT-Cross, and then runs an MCTS-like search with UCB statistics computed through tensor contractions. The central claims are: (i) Proposition 1, exact MCTS node values can be computed in O(N d r^2); (ii) Proposition 2, the TT surrogate's best solution is within 2ε of the true optimum; and (iii) Proposition 3, TTTS is asymptotically complete and converges to the global optimum. The paper also reports experiments on inverse kinematics, motion planning around obstacles, legged manipulation, multi-stage planar pushing, and bimanual whole-body manipulation, including real-robot trials. The authors argue that TTTS combines the global-search behavior of MCTS with linear storage/computation, avoiding problem-specific engineering and pre-trained neural heuristics.","tokens_in":29054,"tokens_out":8136,"duration_ms":95697,"significance":"If the theoretical claims were correct and the algorithm were precisely specified, this would be a useful contribution: it would give a general, model-based alternative to TTGO, neural-guided MCTS, and sampling-based optimizers for a broad class of robot optimization problems, with a compact global surrogate and potential for parallel search. The experimental suite is broad and includes a real-robot validation, and the paper is honest about several limitations (low-rank behavior, TT-Cross scalability in high dimensions, deterministic-dynamics assumption). However, the theoretical foundation as written is not sound: the algorithm's own selection rule is undefined at unvisited nodes, the global-convergence proof does not cover the greedy suffix selection actually specified, and Proposition 1 conflates subtree sums with MCTS action values. Those issues are load-bearing for the paper's central claim that TTTS preserves MCTS global optimality at linear complexity.","major_comments":[{"comment":"The UCB selection rule is ill-defined at the initial and unvisited nodes specified by the algorithm. Algorithm 1 line 12 sets V_0 ← 0, so at depth j=1 Eq. (2) requires log v_i[0] = log 0, and for any node not yet visited v_i[j]=0 makes q_i[j]/v_i[j] = 0/0. Section 5.1's statement that 'all visit counts are zero, so the UCB score is dominated entirely by the exploitation term' is not a consequence of Eq. (2) but rather contradicts it. The algorithm needs an explicit initialization or tie-breaking rule (for example treating v_i[j]=0 as an infinite exploration bonus) and a definition of when a node counts as 'expanded' before any of the subsequent convergence claims can be evaluated.","section":"§5, Algorithm 1, Eq. (2)"},{"comment":"Proposition 3's global-convergence proof does not apply to Algorithm 1 as written. Line 16 selects the top-τ partial paths over the entire set I[j], not over children of the node selected at depth j−1, so the standard recursive UCB property that every node is visited infinitely often is not established. Lines 19–22 then complete selected prefixes by argmax of the TT model Q, so leaves are reached greedily rather than by UCB; if Q ranks the true optimum below a sibling, that leaf is never evaluated even as L→∞. The proof of Proposition 3 assumes every leaf is eventually evaluated at its true value, which is exactly what the greedy suffix can prevent. The expansion rule referenced in line 17 ('if i_j is not expanded') is never defined, leaving the algorithm underspecified. The algorithm or the proof must be revised so that the visitation guarantee covers the actual selection procedure.","section":"§5, Algorithm 1 lines 16–22 and Proposition 3"},{"comment":"Proposition 1's complexity and equivalence claims are not supported. If 'node values at every layer' means all O(N^j) nodes at each layer, then the claimed O(N d r^2) bound cannot hold because there are exponentially many nodes; if it means only the nodes along one selected root-to-leaf path, then the statement 'at every layer' is misleading and the result does not provide exact MCTS node values for the search tree as MCTS normally explores it. Moreover, q_i[j] in Eq. (5) is defined as the unnormalized sum of leaf values over all completions of the prefix, whereas the UCB rule in Eq. (2) uses an average reward q_i[j]/v_i[j]; these are not interchangeable. A layerwise argmax of subtree sums does not recover the maximum-value leaf of T (a subtree containing many moderately good leaves can have a larger sum than a subtree containing the single global optimum), so the proof's claim that one greedy pass 'recovers the solution that standard MCTS would identify in the limit of infinite simulations' does not follow from the preceding equations. The proposition needs a precise definition of 'MCTS node value' and a correct complexity count.","section":"§5.2, Proposition 1 and Eq. (5)"},{"comment":"Corollary 1 states that Proposition 1 provides 'exact MCTS node value computation in O(N d r^2) per iteration', but Proposition 1 as stated does not mention a per-iteration cost; this is an additional, unsupported reading. More importantly, the paper's own Remark on the low-rank approximation says that low-rankness governs speed rather than convergence, and the experiments in §7.1 admit that obstacle avoidance introduces high-rank behavior. That is a reasonable and honest position, but it makes the theoretical section's emphasis on exactness and global optimality particularly dependent on the correctness of Proposition 3, which currently fails. The paper should either prove the convergence claim for the actual algorithm or state a weaker claim about warm-start efficiency, and then adjust the abstract and introduction accordingly.","section":"§5.2, Corollary 1 and §5.3 Remark on the low-rank approximation"}],"minor_comments":[{"comment":"The summation indices in Eqs. (5) and (6) run from i_{j+1}=0 to N, while the index sets defined earlier are {1,…,N_j}; this off-by-one notation should be corrected.","section":"§5, Eqs. (5)–(6)"},{"comment":"Section 5.2 refers to 'toy examples in Section 5.2', but the toy examples appear in Section 5.3; likewise, equations (17) and (18) are referenced in Section 5.3.1 but are only defined in Appendix A.2. The cross-references should be fixed.","section":"§5.2 and §5.3"},{"comment":"There is a typo in 'Rivi`ereet al.addresses this issue' — the citation should be formatted as 'Rivière et al. address this issue'.","section":"§2.3"},{"comment":"The exploration constant c and the number of maintained solutions τ are listed as defaults in Algorithm 1 line 7, but Table 1 does not report τ or c for the individual tasks, which makes the experiments difficult to reproduce exactly.","section":"Table 1 and Algorithm 1"}],"recommendation":"major_revision","confidential_remarks":"The paper fits the journal's scope and I do not see citation or novelty-disclosure problems: TTGO is cited and positioned as a special case. The main risk is that the theoretical section overclaims what the algorithm actually does. The fixes needed are substantial but local: define the expansion/visitation rules, repair or weaken Proposition 3, and restate Proposition 1 with an honest complexity statement. With those corrections the paper could merit reconsideration; as submitted, the central global-convergence claim is not supported by the presented algorithm."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Quick take on 2507.04949. The actual contribution is a new combination: TTTS wraps the TT-Cross surrogate from the same group's TTGO in a UCB tree-search layer, with parallel top-tau selection and CMA-ES refinement. That combination is new, and the experimental sweep is genuinely broad: IK, obstacle motion planning, planar pushing with mode switches, legged manipulation, and real bimanual whole-body MPC. The ablations and baselines (TTGO, MCTS, CMA-ES, neural-guided MCTS, differential evolution) are honest, and the real-robot experiment is a real plus. On the evidence, the method works on these tasks, and the speed-ups over vanilla MCTS look credible.\n\nThe soft spots are in the theory, and they are not just minor. Proposition 1 is fine if read as computing exact sums over completions from an exact TT, though calling that \"MCTS node values\" is a bit generous. Proposition 2 is a standard 2epsilon perturbation bound, fine. Proposition 3 is the real problem. The proof assumes UCB visits every node infinitely often, but Algorithm 1 as written does not implement standard UCB. Line 16 selects top-tau over all partial paths at depth j, not over children of the previously selected node. Line 17 breaks on an undefined \"not expanded\" condition. Lines 19-22 complete the suffix greedily by argmax of the TT value, not by UCB. So a leaf whose true value is high but whose TT rank is low can be systematically skipped forever. The zero-visit initialization also breaks Eq. (2): V0=0 makes log v_i[0] undefined, and unvisited nodes give a division by zero. Section 5.1's statement that \"all visit counts are zero, so the UCB score is dominated by exploitation\" contradicts the formula as written. These are internal correctness gaps, not just unproven efficiency gains. The reader's low-rank concern is secondary and the paper itself acknowledges low rank governs speed, not convergence; unfortunately the selection-rule gap governs convergence itself.\n\nReproducibility is also a bit thin: no code released, only a website, and runtime comparisons exclude rollout evaluations. That choice is understandable but should be stated more prominently.\n\nBottom line: this is a useful paper for robotics practitioners, and the empirical case is strong. But the theoretical claims need substantial repair. I'd send it to peer review with the expectation of major revision, not desk reject it. I would cite it as related work, but I wouldn't hold it up as a model of formal rigor.","headline":"TTTS is a useful, broad experimental optimizer, but the asymptotic-global-convergence proof does not match Algorithm 1 as written; the paper needs a major theory revision.","tokens_in":29666,"tokens_out":3424,"would_cite":true,"duration_ms":39700,"reading_group":"maybe","serious_thinker":"no","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["90C26","90C11","15A69","68T40"],"pacs":[],"model":"deepseek-v4-flash","headline":"By encoding a discretized decision tree as a tensor train, Tensor Train Tree Search cuts Monte Carlo Tree Search from exponential to linear cost per iteration while keeping asymptotic convergence to the global optimum.","keywords":["Monte Carlo Tree Search","Tensor Train","Tensor factorization","Robot optimization","Contact-rich manipulation","Mixed-integer programming","Global optimization","Motion planning"],"falsifier":"Construct a synthetic corridor tree in which a leaf is feasible only when each layer's index stays within a window of the previous layer's choice ($|i_{k+1}-i_k|\\le w$); this banded dependency forces high TT rank, so TT-Cross at $r_{\\max} \\le 50$ should fail to localize the corridor and TTTS should degenerate into plain MCTS. The empirical version: rerun the MP1 narrow-passage task while increasing obstacle clutter and record the minimal rank TT-Cross needs to reach its $\\epsilon=10^{-3}$ tolerance; if that rank scales with the number of obstacles times the branching factor and the number of objective evaluations approaches the $N^d$ leaves, the linear-complexity claim is falsified for exactly the scenes the method targets.","tokens_in":28496,"feed_emoji":"🤖","tokens_out":13998,"duration_ms":140990,"temperature":0.7,"pith_summary":"Monte Carlo Tree Search is a general, gradient-free way to optimize robot behavior, but on discretized high-dimensional problems its tree explodes exponentially. This paper proposes Tensor Train Tree Search (TTTS), which writes the entire decision tree as a high-dimensional tensor and compresses it into a tensor train — a chain of small matrix slices — so that the value and visit statistics of every branch are obtained by cheap tensor contractions rather than by touching nodes one by one. The paper claims this brings computation and storage to linear complexity per iteration, supplies an informative global prior from the first iteration, and still converges asymptotically to the global optimum, all with a single recipe applied to inverse kinematics, motion planning around obstacles, hybrid planar pushing, legged manipulation, and bimanual whole-body tasks. A general reader should care because it promises to replace a zoo of problem-specific robot solvers with one search method that needs no gradients, no training data, and no per-task reformulation.","feed_headline":"Tensor-train trick cuts robot tree search to linear cost","feed_subtitle":"One MCTS-style search now handles inverse kinematics, planning, and contact-rich manipulation in linear time","key_machinery":"The tensor-train (TT) decomposition of the decision tree is the load-bearing object. Every root-to-leaf path is an index tuple $(i_1,\\dots,i_d)$, and the stacked leaf values form a tensor of size $N^d$; TT writes any entry as a product of small third-order cores, $Q^1_{:,i_1,:} Q^2_{:,i_2,:} \\cdots Q^d_{:,i_d,:}$, storing the whole tree in linearly many parameters. TT-Cross builds this surrogate from an adaptively chosen, small set of leaf evaluations via the maximum-volume principle, after which the model can be evaluated at any leaf — a global surrogate, not a tabulated subset. The argument then rests on three operations: Eq. (5) marginalizes the value cores over all completions to obtain a node's exploitation term, Eq. (6) does the same for visit counts, and a guided variant of TT-Cross updates the visit-count tensor in one pass per iteration. The UCB (upper confidence bound) rule, the exploration–exploitation score that decides which node MCTS expands next, selects the top-$\\tau$ nodes at every layer in parallel, and CMA-ES refines the discrete candidates into continuous solutions.","core_discovery":"The central claim is that decision trees arising from discretized robot optimization are not arbitrary objects: shared kinematics, dynamics, and environmental constraints make their leaf-value tensors low-rank in the tensor-train sense, and that redundancy can be exploited algorithmically. TTTS builds a TT approximation of the reward tensor and the visit-count tensor using TT-Cross, which adaptively queries a small set of leaf evaluations, then computes node statistics via tensor contractions, Eqs. (5)–(6), instead of touching nodes one by one. Three propositions carry the argument: MCTS node values on the surrogate are computed exactly in $O(N d r^2)$ per iteration rather than $O(N^d)$ (Proposition 1); the surrogate's best solution deviates from the true global optimum by at most $2\\epsilon$, where $\\epsilon$ is the TT approximation error (Proposition 2); and the retained upper-confidence-bound selection visits every node infinitely often, so TTTS converges asymptotically to the global optimum, the same guarantee as MCTS (Proposition 3). The step beyond the earlier TTGO baseline, which samples the TT directly, is keeping the tree search, which corrects the cases where a low-rank prior alone misses the optimum.","pith_inferences":["The rank that TT-Cross needs to reach the $\\epsilon=10^{-3}$ tolerance is, in effect, a measure of a task's structural difficulty; plotting that rank against clutter level would quantify where the linear-complexity advantage survives, since the paper's own Section 7.1 notes that obstacle avoidance pushes trees toward high rank.","The deterministic-objective assumption stated in Section 8 is the main scope boundary; replacing the single value tensor with a tensor of expectations or quantiles over stochastic rollouts would give belief-space or robust search with the same contraction machinery.","Augmenting the tensor with task variables $z$ already amortizes the expensive TT-Cross step across task instances (10.5 seconds of pretraining versus 4.77 hours for a neural policy); indexing over an entire task distribution rather than a scalar $z$ is a natural extension along the same line.","The QTT (quantized tensor train) reshaping named in the conclusion turns each dimension into binary modes, which would give a coarse-to-fine ladder of surrogates; if the rank behavior transfers, the $2\\epsilon$ warm-start becomes a certificate that could drive branch-and-bound at every resolution."],"forward_implications":["Search problems previously prohibitive, such as the $4^4 \\times 30^4$ hybrid pushing problem, become tractable because per-node bookkeeping is replaced by contractions over cores.","The first iteration already concentrates search near the optimum whenever the landscape is low-rank: Proposition 2 bounds the warm-start gap by $2\\epsilon$.","Selection, simulation, and backpropagation parallelize without lock contention, because UCB scores for all nodes at a layer are computed simultaneously from the cores.","One formulation covers continuous (NLP), high-dimensional continuous (via basis-function weights), and mixed-integer (MINLP) problems with the same algorithm, eliminating per-task solver engineering.","The offline–online trade is controllable: heavier TT-Cross pretraining (larger rank) converges in fewer online iterations, and even a light rank-5 budget reaches the same accuracy given enough iterations."],"supporting_citations":[{"why":"Defines the tensor-train decomposition and TT-SVD, the representation format that turns the $N^d$ decision tree into a chain of third-order cores.","marker":"Oseledets 2011"},{"why":"Introduces TT-Cross, the adaptive maximum-volume sampling algorithm that builds the compact surrogate from a small set of leaf evaluations.","marker":"Oseledets and Tyrtyshnikov 2010"},{"why":"Provides the fast adaptive cross interpolation in TT format that the guided visit-count update relies on.","marker":"Savostyanov and Oseledets 2011"},{"why":"TTGO maps the objective to an unnormalized density and optimizes it via TT; TTTS inherits this approximation step and adds UCB tree search to fix its failure cases.","marker":"Shetty et al. 2024"},{"why":"Origin of MCTS, the search framework whose exponential complexity TTTS attacks and whose asymptotic completeness Proposition 3 preserves.","marker":"Coulom 2006"},{"why":"Survey that supplies the UCB selection rule and the standard node-based MCTS formulation that Eqs. (5)–(6) replace.","marker":"Browne et al. 2012"},{"why":"Identifies the root-convergence and lock-contention problems of parallel MCTS that the layer-wise separable TT structure is claimed to remove.","marker":"Chaslot et al. 2008"},{"why":"The neural-guided MCTS baseline (AlphaZero-style) whose large training cost motivates TTTS's data-free TT approximation.","marker":"Silver et al. 2017"}],"fun_headline_variants":["Tensor-factorized MCTS speeds robot optimization to linear time","TTTS: low-rank MCTS for robot optimization with global guarantee","Linear-time MCTS via tensor trains: robot tasks unified","Tensor-train MCTS: linear cost, global solution for robotics","Robot optimization in linear time via tensor-train MCTS"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The whole efficiency claim rests on real robot decision trees being low-rank enough that a TT-Cross fit at rank 21–50 with error tolerance $10^{-3}$ still shows where the good solutions are; the paper itself notes in Sections 5.3 and 7.1 that obstacle-heavy tasks drift toward high rank, and if a task's required rank grows with its branching factor, the linear-complexity advantage over standard MCTS largely disappears.","fun_headline_variants_meta":{"raw":{"variants":["Tensor-factorized MCTS speeds robot optimization to linear time","TTTS: low-rank MCTS for robot optimization with global guarantee","Linear-time MCTS via tensor trains: robot tasks unified","Tensor-train MCTS: linear cost, global solution for robotics","Robot optimization in linear time via tensor-train MCTS"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000895,"raw_usage":{"total_tokens":3891,"prompt_tokens":1012,"completion_tokens":2879,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":628,"completion_tokens_details":{"reasoning_tokens":2794}},"tokens_in":628,"tokens_out":2879,"duration_ms":24079,"temperature":1.0,"reasoning_tokens":2794,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-06T19:35:42.351160+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Construct a synthetic corridor tree in which a leaf is feasible only when each layer's index stays within a window of the previous layer's choice ($|i_{k+1}-i_k|\\le w$); this banded dependency forces high TT rank, so TT-Cross at $r_{\\max} \\le 50$ should fail to localize the corridor and TTTS should degenerate into plain MCTS. The empirical version: rerun the MP1 narrow-passage task while increasing obstacle clutter and record the minimal rank TT-Cross needs to reach its $\\epsilon=10^{-3}$ tolerance; if that rank scales with the number of obstacles times the branching factor and the number of objective evaluations approaches the $N^d$ leaves, the linear-complexity claim is falsified for exactly the scenes the method targets.","supporting_citations":[{"cited_title":"TT -cross approximation for multidimensional arrays","cited_arxiv_id":null,"evidence_quote":"Introduces TT-Cross, the adaptive maximum-volume sampling algorithm that builds the compact surrogate from a small set of leaf evaluations."},{"cited_title":"A survey of monte carlo tree search methods","cited_arxiv_id":null,"evidence_quote":"Survey that supplies the UCB selection rule and the standard node-based MCTS formulation that Eqs. (5)–(6) replace."},{"cited_title":"Parallel monte-carlo tree search","cited_arxiv_id":null,"evidence_quote":"Identifies the root-convergence and lock-contention problems of parallel MCTS that the layer-wise separable TT structure is claimed to remove."},{"cited_title":"Lillicrap, Fan Hui, Laurent Sifre, George van den Driessche, Thore Graepel, and Demis Hassabis","cited_arxiv_id":null,"evidence_quote":"The neural-guided MCTS baseline (AlphaZero-style) whose large training cost motivates TTTS's data-free TT approximation."}],"review_version":1}