Pith. sign in

REVIEW 2 major objections 4 minor 45 references

Global Tensor Motion Planning

T0 review · 2 major / 4 minor · reviewed 2026-08-12 · deepseek-v4-flash

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

Pith's one-line read A motion planner that represents the discretized configuration space as a fixed-shape random multipartite graph can run entirely as tensor operations, vectorize over batches of planning instances, and carries a probabilistic-completeness…

desk verdict GTMP's tensor multipartite-graph planner is a genuinely useful batch-planning contribution with plausible speedups, but the appendix's probabilistic completeness proof is broken as written and needs repair. read the letter →

arxiv 2411.19393 v3 pith:HKMYWDMG submitted 2024-11-28 cs.RO cs.AIcs.LGcs.SYeess.SY

An T. Le , Kay Hansel , João Carvalho , Joe Watson , Julen Urain , Armin Biess , Georgia Chalvatzaki , Jan Peters This is my paper · ORCID
classification cs.ROcs.AIcs.LGcs.SYeess.SY
keywords motionplanningbatchprobabilisticcompletenesstensoroperationsrandommultipartitegraphvalueiterationsplineGPUacceleration
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

GTMP is a sampling-based motion planner that replaces the usual incremental tree or roadmap with a fixed-shape random multipartite graph: a start layer, $M$ layers of $N$ uniformly sampled waypoints, and a goal layer, with all pairwise edges between consecutive layers. Because every layer has the same cardinality, the graph, its collision costs, and its value-iteration search are plain tensor operations, so an entire batch of planning instances can be vectorized on GPU/TPU hardware. The paper proves a probabilistic-completeness bound: for a feasible planning problem with $M$ at least the minimum number of segments, the probability that GTMP finds a finite-cost path is at least $1 - M\exp(-a (R - L/(M+1))^d N)$, so success approaches certainty exponentially in the number of samples per layer. The practical payoff is batch planning that the authors report as roughly 50 times faster than a strong vectorized baseline and orders of magnitude faster than classical CPU planners, with a spline extension that returns smooth paths without gradient optimization. The authors position GTMP as a fast, parallel, provably complete way to generate diverse training trajectories for robot learning.

What carries the argument

The central object is the random multipartite graph: a directed graph whose node set is organized into fixed layers (start, $M$ sampled waypoint layers, goals), with all pairwise forward edges between consecutive layers. Because every layer holds exactly $N$ nodes, the graph is stored as tensors, and all operations—uniform sampling, probing collision costs along edges, and the dynamic-programming update as a matrix-reduced min—are tensor reductions that can be broadcast over a batch dimension. The search is finite value iteration: with $M+1$ iterations the value function converges exactly on this acyclic layered graph, and path tracing returns a path of exactly $M+1$ segments. The spline variant builds the same layered graph but replaces straight-line edges with local piecewise-cubic splines, so the returned path is already $C^1$ smooth without a separate optimization step.

What would settle it

Take a 2D occupancy map with a wall so thin that the straight line from start to goal crosses it only between two consecutive probe points of an $H$-point discretization, and run GTMP with the paper's default $H$; if the planner returns the crossing segment as collision-free, that shows the implemented collision check is not the integral assumed in Theorem 1.

Watch

Extended reading notes

Core claim

The central claim is that a planning problem can be discretized as a complete multipartite graph with a fixed number of layers, and that this fixed shape is exactly what makes planning batchable. Let layer $m$ contain $N$ waypoints sampled uniformly in configuration space; connect every waypoint in layer $m$ to every waypoint in layer $m+1$, with the start connected to layer 1 and the last layer to the goal set. GTMP computes the straight-line collision-and-length cost of every edge, stores all costs in tensors, and runs $M+1$ dynamic-programming value iterations to extract the least-cost path. Theorem 1 states that when $M$ is at least a problem-dependent minimum $M_m$, the probability that this procedure terminates with a finite path cost is at least $1 - M\exp(-a (R - L/(M+1))^d N)$, where $R$ is the clearance of the true feasible path, $L$ its arc length, and $a$ a constant from the uniform measure; hence the planner is probabilistically complete and the per-batch work scales as tensor operations. The same tensor graph, with edges replaced by local piecewise-cubic splines, produces $C^1$ smooth paths without any gradient-based refinement, at the cost of not carrying the same completeness guarantee.

Load-bearing premise

The load-bearing assumption is that the edge collision cost is the exact continuous integral of the occupancy function along the edge, but the implementation approximates it with $H$ discrete probe points; a thin obstacle lying between two probe points can therefore be missed, and the completeness guarantee as proven does not apply to the algorithm as actually run.

Editorial extensions

If this is right

  • For any feasible problem with $M \ge M_m$, the failure probability decays exponentially in $N$, so a modest number of samples per layer already gives high success probability and the bound quantifies the trade-off between more layers and more samples.
  • Since every path has exactly $M+1$ segments, planning time and path length are predictable, and no simplification routines are needed after search.
  • The entire algorithm is vectorized over a batch dimension, so the authors report amortized batch planning roughly 50 times faster than a strong vectorized baseline and orders of magnitude faster than standard CPU sampling planners on the tested tasks.
  • With the spline construction, GTMP returns $C^1$ smooth paths directly, matching the smoothness of optimization-based planners without requiring gradient information.
  • Because the value iteration is a composition of differentiable tensor operations, GTMP can act as a differentiable global planner or as a warm-starter for local trajectory optimizers.

Reading between the lines

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

  • Going beyond the paper: the exponential bound suggests an anytime outer loop that grows $M$ and $N$ until at least one path in the batch is feasible; the paper mentions this direction but does not prove its behavior.
  • Going beyond the paper: the completeness theorem is explicitly not extended to spline edges, so a user relying on the smooth variant for execution should treat collision-freeness of those edges as an empirical matter, not a guaranteed one.
  • Going beyond the paper: the finite-probe collision check means the practical guarantee depends on obstacle geometry; environments with thin walls can evade the theorem, and adaptive or continuous collision checking would close that gap.
  • Going beyond the paper: because the graph is fixed-shape and acyclic, the same tensor construction could serve as a differentiable cost-to-go oracle for policy learning, not only as a batch planner; this is a natural extension of the paper's stated direction rather than an evaluated result.
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 / 4 minor

Summary. The paper proposes GTMP, a sampling-based motion planner in which the configuration space is discretized as a random multipartite graph with M layers of N uniformly sampled waypoints. All operations, including sampling, collision checking, and the Bellman updates used to find a shortest path from the start to a set of goals, are expressed as fixed-shape tensor operations and can be batch-vectorized over planning instances. The paper also introduces an Akima-spline variant that plans cubic-spline paths without gradient optimization. The central theoretical claim is Theorem 1, which asserts probabilistic completeness with a quantitative failure bound; the experimental section reports large wall-clock speedups for batch planning on planar occupancy maps and on MotionBenchMarker Panda tasks, together with an ablation over M and N.

Significance. The contribution is algorithmically appealing: the multipartite structured graph is a genuine departure from incremental tree/roadmap construction, the complexity analysis and implementation are clear, and the reported batch speedups (about 50x over VAMP/RRTC and orders of magnitude over OMPL baselines in the authors' setup) would be practically useful for generating training data. The derivation does not fit parameters to data, and the ablation heatmaps give useful evidence about the role of M and N. However, the paper's probabilistic-completeness guarantee is the main theoretical contribution, and as it stands the proof has a false lemma and an incorrect inequality; the theorem therefore does not yet support the claim. The empirical evaluation is not enough to substitute for the proof, because the reported collision-free percentages are produced by the same approximate collision checker whose gap with the theorem is unaddressed.

major comments (2)
  1. [Section VII, Lemma 2 and Theorem 1 proof] Lemma 2 is false as stated: for f(t)=t on [0,1] and g=f (n=1), TV(f)=1 while ||f-g||_∞=0, contradicting the claimed lower bound ||f-g||_∞ > L/n. More importantly, the proof of Theorem 1 needs an upper bound on the interpolation error, not a lower bound, because the clearance of the piecewise-linear approximant g satisfies r ≥ R - ||g-f||_∞ by the triangle inequality. The proof instead asserts r ≤ R - sup||g-f|| < R - L/(M+1), which reverses the triangle inequality. Consequently the event ||h-g||_∞ < r_h with r_h = R - L/(M+1) is not sufficient to guarantee the sampled path h is feasible, and the probability bound in Eq. (16) is not established. This is the load-bearing step of the probabilistic-completeness claim. A repair would replace Lemma 2 with a uniform-continuity or Lipschitz bound that makes ||g-f||_∞ < R/2 and then derive a lower bound on r; the constants in Theorem 1 would need to be re-derived accordingly.
  2. [Section III-C and Algorithm 1 vs. Eq. (3)] The implementation computes the collision term of Eq. (3) by evaluating the cost at H equidistant probe points per edge and averaging, rather than computing the exact continuous integral. Theorem 1 assumes the exact integral, so a thin obstacle lying strictly between two probe points is invisible to the algorithm; the returned 'feasible' path may collide, and the probability bound does not describe the algorithm as actually run. This is not a cosmetic mismatch: the experimental CF% metric is computed by the same approximate checker. The authors should either extend the analysis to a discretized/probed collision check, for example under an explicit clearance assumption relating obstacle thickness to the probe spacing, or state clearly that the guarantee applies only to an idealized continuous collision-checking oracle and adjust the empirical claims accordingly.
minor comments (4)
  1. [Section III, Eq. (3)] The line-integral notation is inconsistent: for a straight-line edge f(t)=q+t(q'-q), t∈[0,1], the arclength factor is ||f'(t)||=||q'-q||, not f'=1/||q'-q|| as stated. Please correct the definition or the parameterization.
  2. [Algorithm 1, Lines 8--13] The path tracing part sets P={i} and then appends Q[m,i] for m=1,...,M-1 and G[i]; the start q0 and the first-layer waypoint Q[0,i] are not both included. Please clarify the indexing so that the output is a sequence of configurations from q0 to a goal.
  3. [Section VII and Definition 2] The symbol G is used both for the random multipartite graph and for the goal set in the problem statement; Theorem 1's 'G' is therefore ambiguous. Please use separate symbols, for example G_g for the goal set.
  4. [Appendix VI, Eq. (10)] The modified-Akima weights use m_{m,i,j}, m_{m-1,i,j}, etc., before the indices are fully defined, and the sums over i,j are not clear; a precise definition would help reproducibility.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity; the completeness theorem is argued from stated sampling assumptions, and the flagged defects are invalid-proof errors rather than derivation-by-construction.

full rationale

The paper's central derivation is Theorem 1, a probabilistic-completeness bound obtained from Assumptions 1-2 via a PRM-style union bound over layered sampling balls; the event whose probability is bounded (a sampled path h staying within the clearance ball of an interpolant g) is explicitly a subset of the target event, so the bound is conservative rather than equivalent to its conclusion. No constants are fitted: a, R, and L are existential and depend only on C_free and G, and the ablation heatmap in Fig. 3 is presented as an experimental check of Eq. (16), not as data from which the bound was fitted. The self-citations ([4], [7], [32]) appear in related-work context and baseline initialization and do not carry the completeness argument. Proposition 2 is a definitional equivalence honestly labeled as such, and Proposition 1 is stated as 'By construction of graph G' (Section III-B); neither masquerades as a prediction derived from data. The flagged concerns are correctness risks, not circularity: (i) Lemma 2's lower bound ||f-g||_inf > L/n is false as stated (f(t)=t, n=1 gives zero error but TV=1), and the proof of Theorem 1 would need the opposite, an upper bound on interpolation error; (ii) the chain 'r <= R - sup||g-f||' inverts the triangle inequality, which gives r >= R - sup||g-f||; (iii) Algorithm 1 checks edges with H probe points (Section III-C) while Theorem 1 assumes the exact continuous integral in Eq. (3), so the guarantee does not apply to the algorithm as actually run; and (iv) Remark 1 defers the spline-continuity verification to unstated algebra. These undermine the validity of the completeness proof but do not reduce the theorem to its inputs, so the circularity score remains minimal.

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

No physically invented entities are introduced; the random multipartite graph is a data structure, not a postulated physical quantity. The proof rests on uniform sampling, positive-clearance feasibility, and an exact edge collision model that the implementation approximates with finite probing.

free parameters (3)
  • M (number of layers) = 200 for planar maps; 2 for MBM; 3 minimum for feasibility
    Controls path resolution and the minimum-layer condition in Theorem 1; selected per experiment, not fitted to optimize a stated objective.
  • N (waypoints per layer) = 4 for planar maps; 30 for MBM; swept 10-100 in ablation
    Controls the probabilistic completeness failure exponent and collision-checking cost; chosen by hand per dataset.
  • H (collision probe points per edge) = 10 default; 30 in ablation
    Number of discrete samples used to approximate the edge collision integral; not covered by the theoretical guarantee.
assumptions (5)
  • domain assumption Assumption 1: proposal distributions p_m are uniform on C for all layers
    Required for the probability bound in Theorem 1; stated in Appendix VII.
  • domain assumption Assumption 2: there exists a feasible path with positive clearance r > 0
    Standard favorable-clearance condition; stated before Proposition 2 and used in Lemma 1 and Theorem 1.
  • ad hoc to paper Exact continuous collision checking along each edge
    Theorem 1 assumes edge costs are the exact integral of c_coll along the edge, but Algorithm 1 uses H discrete probe points (Section III-C).
  • standard math Bellman optimality and finite-horizon value iteration converge for the finite state machine
    Invoked in Section III-B via Puterman and Bertsekas references.
  • standard math Uniform continuity and bounded variation properties of feasible paths used in Lemma 1 and Lemma 2
    The proofs invoke Heine-Cantor and modulus-of-continuity bounds.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Global Tensor Motion Planning." pith.science (2026). https://pith.science/paper/HKMYWDMG

@misc{pith2026241119393,
  author       = {Pith},
  title        = {Pith review of: Global Tensor Motion Planning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/HKMYWDMG}},
  note         = {Machine review of arXiv:2411.19393}
}
read the original abstract

Batch planning is increasingly necessary to quickly produce diverse and quality motion plans for downstream learning applications, such as distillation and imitation learning. This paper presents Global Tensor Motion Planning (GTMP) -- a sampling-based motion planning algorithm comprising only tensor operations. We introduce a novel discretization structure represented as a random multipartite graph, enabling efficient vectorized sampling, collision checking, and search. We provide a theoretical investigation showing that GTMP exhibits probabilistic completeness while supporting modern GPU/TPU. Additionally, by incorporating smooth structures into the multipartite graph, GTMP directly plans smooth splines without requiring gradient-based optimization. Experiments on lidar-scanned occupancy maps and the MotionBenchMarker dataset demonstrate GTMP's computation efficiency in batch planning compared to baselines, underscoring GTMP's potential as a robust, scalable planner for diverse applications and large-scale robot learning tasks.

Figures

Figures reproduced from arXiv: 2411.19393 by the authors.

Figure 1
Figure 1. GTMP can plan with multiple goals or vmap over goals. For clarity, we present an example of performing JAX vmap on GTMP (M=2, N=3) over the batch of B = 3 seeds. (1) The objective is to find a batch of feasible paths from the start (red) to the goals (green). (2, 3) In each seed, we sample a multipartite graph and form a tensor (Algorithm 1, Line 1). (4) A batch of collision checks is performed and stored into cost … view at source ↗
Figure 2
Figure 2. Aggregated statistics of comparison experiments on Planar Occupancy (top-row) and Panda MBM dataset (bottom-row). We note the log scale on the [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. For each M (y-axis), N (x-axis), we set the number of probing H = 30 and plan the batch of B = 200 paths. The red star denotes the minimum number of layers Mm, corresponding to the minimum requirement of N to discover some solutions experimentally. GTMP addresses global exploration challenges but comes with memory requirements, especially for GPU acceleration. In contrast, local methods such as CHOMP or GPMP leverag… view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

45 extracted references · 33 canonical work pages

  1. [1]

    Prob- abilistic roadmaps for path planning in high-dimensional configuration spaces,

    L. E. Kavraki, P. Svestka, J.-C. Latombe, and M. H. Overmars, “Prob- abilistic roadmaps for path planning in high-dimensional configuration spaces,”IEEE Transactions on Robotics and Automation, 1996

    work page 1996

  2. [2]

    Rrt-connect: An efficient approach to single-query path planning,

    J. J. Kuffner and S. M. LaValle, “Rrt-connect: An efficient approach to single-query path planning,” inIEEE ICRA, 2000

    work page 2000

  3. [3]

    Latombe,Robot motion planning

    J.-C. Latombe,Robot motion planning. Springer Science & Business Media, 2012, vol. 124

    2012

  4. [4]

    Motion plan- ning diffusion: Learning and planning of robot motions with diffusion models,

    J. Carvalho, A. T. Le, M. Baierl, D. Koert, and J. Peters, “Motion plan- ning diffusion: Learning and planning of robot motions with diffusion models,” inIEEE/RSJ IROS, 2023

    work page 2023

  5. [5]

    A survey of learning-based robot motion planning,

    J. Wang, T. Zhang, N. Ma, Z. Li, H. Ma, F. Meng, and M. Q.-H. Meng, “A survey of learning-based robot motion planning,”IET Cyber-Systems and Robotics, vol. 3, no. 4, pp. 302–314, 2021

    work page 2021

  6. [6]

    Goal conditioned imitation learning using score-based diffusion policies,

    M. Reuss, M. Li, X. Jia, and R. Lioutikov, “Goal conditioned imitation learning using score-based diffusion policies,” inR:SS, 2023

    work page 2023

  7. [7]

    Accelerating motion planning via optimal transport,

    A. T. Le, G. Chalvatzaki, A. Biess, and J. R. Peters, “Accelerating motion planning via optimal transport,”NeurIPS, vol. 36, 2024

    work page 2024

  8. [8]

    Continuous- time gaussian process motion planning via probabilistic inference,

    M. Mukadam, J. Dong, X. Yan, F. Dellaert, and B. Boots, “Continuous- time gaussian process motion planning via probabilistic inference,”IJRR, 2018

    work page 2018

Show all 45 references
  1. [9]

    Multimodal trajectory optimization for motion planning,

    T. Osa, “Multimodal trajectory optimization for motion planning,”IJRR, 2020

    2020

  2. [10]

    Storm: An integrated framework for fast joint-space model-predictive control for reactive manipulation,

    M. Bhardwaj, B. Sundaralingam, A. Mousavian, N. D. Ratliff, D. Fox, F. Ramos, and B. Boots, “Storm: An integrated framework for fast joint-space model-predictive control for reactive manipulation,” inCoRL. PMLR, 2022

    2022

  3. [11]

    Curobo: Parallelized collision-free robot motion generation,

    B. Sundaralingam, S. K. S. Hari, A. Fishman, C. Garrett, K. Van Wyk, V . Blukis, A. Millane, H. Oleynikova, A. Handa, F. Ramos,et al., “Curobo: Parallelized collision-free robot motion generation,” inIEEE ICRA, 2023

    2023

  4. [12]

    Gpu-based parallel collision detection for fast motion planning,

    J. Pan and D. Manocha, “Gpu-based parallel collision detection for fast motion planning,”IJRR, 2012

    2012

  5. [13]

    Massively parallelizing the rrt and the rrt,

    J. Bialkowski, S. Karaman, and E. Frazzoli, “Massively parallelizing the rrt and the rrt,” inIEEE/RSJ IROS, 2011

    2011

  6. [14]

    Towards gpu-accelerated prm for autonomous navigation,

    J. Blankenburg, R. Kelley, D. Feil-Seifer, R. Wu, L. Barford, and F. C. Harris, “Towards gpu-accelerated prm for autonomous navigation,” in ITNG. Springer, 2020

    2020

  7. [15]

    A scalable method for parallelizing sampling-based motion planning algorithms,

    S. A. Jacobs, K. Manavi, J. Burgos, J. Denny, S. Thomas, and N. M. Amato, “A scalable method for parallelizing sampling-based motion planning algorithms,” inIEEE ICRA, 2012

    2012

  8. [16]

    A formal basis for the heuristic determination of minimum cost paths,

    P. E. Hart, N. J. Nilsson, and B. Raphael, “A formal basis for the heuristic determination of minimum cost paths,”IEEE Transactions on Systems Science and Cybernetics, vol. 4, no. 2, pp. 100–107, 1968

    1968

  9. [17]

    S. J. Russell and P. Norvig,Artificial intelligence: a modern approach. Pearson, 2016

    2016

  10. [18]

    JAX: composable transformations of Python+NumPy programs,

    J. Bradburyet al., “JAX: composable transformations of Python+NumPy programs,” 2018. [Online]. Available: http://github.com/jax-ml/jax

    2018

  11. [19]

    The open motion planning library,

    I. A. Sucan, M. Moll, and L. E. Kavraki, “The open motion planning library,”IEEE Robotics & Automation Magazine, 2012

    2012

  12. [20]

    Probabilistic roadmap methods are embarrassingly parallel,

    N. M. Amato and L. K. Dale, “Probabilistic roadmap methods are embarrassingly parallel,” inIEEE ICRA, 1999

    1999

  13. [21]

    Sampling-based roadmap of trees for parallel motion planning,

    E. Plakuet al., “Sampling-based roadmap of trees for parallel motion planning,”IEEE TRO, 2005

    2005

  14. [22]

    Motions in microsec- onds via vectorized sampling-based planning,

    W. Thomason, Z. Kingston, and L. E. Kavraki, “Motions in microsec- onds via vectorized sampling-based planning,” inIEEE ICRA, 2024

    2024

  15. [23]

    Batch informed trees (bit*): Informed asymptotically optimal anytime search,

    J. D. Gammell, T. D. Barfoot, and S. S. Srinivasa, “Batch informed trees (bit*): Informed asymptotically optimal anytime search,”IJRR, 2020

    2020

  16. [24]

    Fast marching tree: A fast marching sampling-based method for optimal motion planning in many dimensions,

    L. Janson, E. Schmerling, A. Clark, and M. Pavone, “Fast marching tree: A fast marching sampling-based method for optimal motion planning in many dimensions,”IJRR, 2015

    2015

  17. [25]

    Adaptively informed trees (ait*): Fast asymptotically optimal path planning through adaptive heuristics,

    M. P. Strub and J. D. Gammell, “Adaptively informed trees (ait*): Fast asymptotically optimal path planning through adaptive heuristics,” in IEEE ICRA, 2020

    2020

  18. [26]

    Neural rrt*: Learning-based optimal path planning,

    J. Wang, W. Chi, C. Li, C. Wang, and M. Q.-H. Meng, “Neural rrt*: Learning-based optimal path planning,”IEEE Transactions on Automation Science and Engineering, 2020

    2020

  19. [27]

    Reducing collision checking for sampling-based motion planning using graph neural networks,

    C. Yu and S. Gao, “Reducing collision checking for sampling-based motion planning using graph neural networks,”Advances in Neural Information Processing Systems, vol. 34, pp. 4274–4289, 2021

    2021

  20. [28]

    Learning sampling distributions for robot motion planning,

    B. Ichter, J. Harrison, and M. Pavone, “Learning sampling distributions for robot motion planning,” inIEEE ICRA, 2018

    2018

  21. [29]

    Sampling-based motion planning: A comparative review,

    A. Orthey, C. Chamzas, and L. E. Kavraki, “Sampling-based motion planning: A comparative review,”Annual Review of Control, Robotics, and Autonomous Systems, vol. 7, 2023

    2023

  22. [30]

    Multi-modal model predictive control through batch non-holonomic trajectory optimization: Application to highway driving,

    V . K. Adajania, A. Sharma, A. Gupta, H. Masnavi, K. M. Krishna, and A. K. Singh, “Multi-modal model predictive control through batch non-holonomic trajectory optimization: Application to highway driving,” IEEE RA-L, 2022

    2022

  23. [31]

    Stein variational model predictive control,

    A. Lambert, A. Fishman, D. Fox, B. Boots, and F. Ramos, “Stein variational model predictive control,”arXiv:2011.07641, 2020

    2011 arXiv

  24. [32]

    Learning implicit priors for motion optimization,

    J. Urain, A. T. Le, A. Lambert, G. Chalvatzaki, B. Boots, and J. Peters, “Learning implicit priors for motion optimization,” inIEEE/RSJ IROS, 2022

    2022

  25. [33]

    S. M. LaValle,Planning algorithms. Cambridge university press, 2006

    2006

  26. [34]

    A method of bivariate interpolation and smooth surface fitting based on local procedures,

    H. Akima, “A method of bivariate interpolation and smooth surface fitting based on local procedures,”Communications of the ACM, vol. 17, no. 1, pp. 18–20, 1974

    1974

  27. [35]

    M. L. Puterman,Markov decision processes: discrete stochastic dynamic programming. John Wiley & Sons, 2014

    2014

  28. [36]

    Bertsekas,Dynamic programming and optimal control: Volume I

    D. Bertsekas,Dynamic programming and optimal control: Volume I. Athena scientific, 2012, vol. 4

    2012

  29. [37]

    Bertsekas and J

    D. Bertsekas and J. Tsitsiklis,Parallel and distributed computation: numerical methods. Athena Scientific, 2015

    2015

  30. [38]

    Pybullet, a python module for physics simulation for games, robotics and machine learning,

    E. Coumans and Y . Bai, “Pybullet, a python module for physics simulation for games, robotics and machine learning,” http://pybullet.org, 2016–2019

    2016

  31. [39]

    Chomp: Covariant hamiltonian optimization for motion planning,

    M. Zuckeret al., “Chomp: Covariant hamiltonian optimization for motion planning,”IJRR, 2013

    2013

  32. [40]

    Sinkhorn distances: Lightspeed computation of optimal transport,

    M. Cuturi, “Sinkhorn distances: Lightspeed computation of optimal transport,”NeurIPS, 2013

    2013

  33. [41]

    Kinodynamic motion planning by interior-exterior cell exploration,

    I. A. S ¸ucan and L. E. Kavraki, “Kinodynamic motion planning by interior-exterior cell exploration,” inWAFR. Springer, 2009

    2009

  34. [42]

    The robotics data set repository (radish),

    A. Howard, N. Roy, C. Stachniss, G. Grisetti, D. Haehnel, H. Andreasson, P. Larsson, T. Duckett, and P. Beeson, “The robotics data set repository (radish),” 2003. [Online]. Available: http://radish.sourceforge.net/

    2003

  35. [43]

    Motionbenchmaker: A tool to generate and benchmark motion planning datasets,

    C. Chamzas, C. Quintero-Pena, Z. Kingston, A. Orthey, D. Rakita, M. Gleicher, M. Toussaint, and L. E. Kavraki, “Motionbenchmaker: A tool to generate and benchmark motion planning datasets,”IEEE RA-L, 2021

    2021

  36. [44]

    Motion policy networks,

    A. Fishman, A. Murali, C. Eppner, B. Peele, B. Boots, and D. Fox, “Motion policy networks,” inCoRL. PMLR, 2023, pp. 967–977

    2023

  37. [45]

    Sampling-based algorithms for optimal motion planning,

    S. Karaman and E. Frazzoli, “Sampling-based algorithms for optimal motion planning,”IJRR, vol. 30, no. 7, pp. 846–894, 2011

    2011

Pith tools

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