Pith. sign in

REVIEW 3 major objections 3 minor 32 references

ScheduleStream extends task and motion planning from serial plans to asynchronous parallel schedules, roughly halving multi-arm makespan at matched success rates.

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

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

T0 review · deepseek-v4-flash

2026-08-03 23:36 UTC pith:BHIHA4GD

load-bearing objection A genuinely new framework for multi-arm TAMP scheduling with strong empirical results, but the theoretical claims outrun the proofs and one conclusion misreads its own table. the 3 major comments →

arxiv 2511.04758 v2 pith:BHIHA4GD submitted 2025-11-06 cs.RO cs.AIcs.MA

ScheduleStream: Temporal Planning with Samplers for GPU-Accelerated Multi-Arm Task and Motion Planning & Scheduling

Caelan Garrett , Fabio Ramos This is my paper
classification cs.RO cs.AIcs.MA
keywords task and motion planningtemporal planningschedulingdurative actionslazy stream samplingGPU accelerationbimanual manipulationmulti-arm robots
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

Most task and motion planning (TAMP) systems output serial plans in which only one robot arm moves at a time. This paper argues that planning should instead produce schedules: sets of timed actions that let multiple arms move asynchronously in parallel. It introduces ScheduleStream, a general-purpose planning language and algorithms that combine discrete search with continuous samplers to find such schedules. In simulation, the approach roughly halves makespan compared with serial-only planning while keeping success rates near 99 percent, and the authors demonstrate the system on a real bimanual robot. If the claims hold, ScheduleStream would be the first domain-independent TAMP system whose output is an asynchronous multi-arm schedule.

Core claim

ScheduleStream's central claim: task and motion planning can be extended to asynchronous schedules by modeling actions as durative actions with start/end events, ongoing conditions, and parameter-dependent duration. The paper compiles durative actions into paired start/end actions so sequential search yields a timed schedule, with safety certified by conservative swept-volume checks at event times. Continuous parameters come from lazy streams; GPU-batched samplers accelerate collision, IK, and motion checks. On five bimanual benchmarks, the lazy GPU planner matches serial success (~99 percent) while halving makespan (first solution 2.0 vs 3.4 s; best 1.5 vs 3.1 s), and the same planner drive

What carries the argument

The central object is the hybrid durative action: a timed action with start and end events, ongoing conditions, and a duration function. The load-bearing mechanism is the temporal compilation (Algorithm 2) that reduces scheduling to sequential search over start/end events, converting any event-order plan into an asynchronously overlapping schedule. Supporting machinery: lazy stream generators that create placeholder constants and bind them only when needed, and event-time swept-volume predicates (ArmCollision, ObjCollision) that conservatively certify overlapping motions. GPU batching accelerates the samplers that produce configurations, grasps, and trajectories.

Load-bearing premise

The load-bearing premise is that every feasible parallel schedule can be represented as an interleaving of discrete start/end events and that the conservative swept-volume checks evaluated at those event times certify safety; if this event-time certification or its sphere approximation misses a collision, a planned parallel execution could collide.

What would settle it

Run ScheduleStream-certified parallel schedules for a suite of bimanual problems in a high-fidelity simulator that detects exact mesh contact; any certified schedule that produces a collision during overlapping motion falsifies the safety model. Separately, for small problems where optimal makespan can be found by exhaustive search, compare ScheduleStream's makespan against the optimum: if it never approaches the optimum's factor of two improvement over serial, the headline claim fails.

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

Share X Bluesky LinkedIn Reddit HN

If this is right

  • Any TAMP domain expressed with durative actions and streams can in principle be scheduled, not just the benchmark manipulation tasks shown.
  • Problems that are not downward refinable — where a high-level schedule fails at the motion level — remain solvable because scheduling and sampling alternate with backtracking.
  • GPU-batched sampling brings parallel-schedule planning down to about two seconds to a first solution, making it usable on real robots.
  • Serial planning appears as a special case: ScheduleStream on the same problems yields schedules with roughly half the makespan at equal success rates.
  • A single domain-independent planner can replace application-specific multi-arm coordination code for bimanual tasks.

Where Pith is reading between the lines

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

  • Inference: the temporal compilation may transfer to other hybrid planning problems — drone fleets, mobile manipulators, or construction robots — wherever actions have durations and overlapping execution is beneficial.
  • Inference: because the swept-volume checks are conservative, the reported makespans are upper bounds; a planner with tighter, time-indexed collision checking could find shorter schedules, so the halving is a lower bound on the possible gain.
  • Inference: the lazy-stream design could accept learned samplers (neural IK, learned motion generators) as drop-in stream generators, connecting this planning approach to learning-based robotics.
  • Inference: the large gap between eager and GPU-accelerated lazy runtimes suggests search efficiency, not just sampler speed, is the key bottleneck; anytime search or parallel search could extend the tradeoff curve.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 3 minor

Summary. The paper introduces ScheduleStream, a Python-based, domain-independent framework for Task and Motion Planning & Scheduling (TAMPAS) with sampling operations. The language extends PDDL-style planning with durative actions, procedural predicates, and stream generators. The paper proposes two algorithms — EAGER-STREAM and LAZY-STREAM — that alternate between scheduling and stream sampling, and it applies them to multi-arm manipulation with GPU-accelerated samplers. Simulated experiments on Franka and SO100 tasks compare ScheduleStream against sequential-only and strict hierarchical baselines, reporting higher success rates and roughly half the makespan for the lazy/GPU variant. Real-world bimanual demonstrations on a Kinova platform are also presented.

Significance. If the framework and algorithms are correct, ScheduleStream would be a meaningful advance: it is the first domain-independent TAMP system that outputs asynchronous schedules with overlapping durative actions, and it demonstrates practical GPU-accelerated planning for multi-arm manipulation. The empirical core is strong: Ours+GPU matches Sequential success (99% vs. 99%) while approximately halving average makespan, and the strict Hierarchical baseline collapses on non-downward-refinable problems, consistent with known limitations. The paper also contributes a reusable Python implementation and real-world validation. However, several formal claims — particularly the correctness of the temporal compilation, the safety of the approximate collision checking, and the 'provably solve' completeness assertion — are not adequately supported. These issues are load-bearing for the claimed generality and correctness of the approach.

major comments (3)
  1. [IV-B, Algorithm 2] The paper asserts, without proof, that any sequential plan over compiled start/end actions corresponds to a valid durative schedule. Specifically, the compiled start action checks OverCondition at the start instant, and the end action checks OverCondition again, but no argument shows that checking only at these event instants suffices to guarantee that ongoing conditions such as collision_cond hold continuously over the entire overlap interval. A counterexample may exist where trajectories intersect between the start and end events but not at the instants. A formal correctness theorem relating plans in the compiled problem to valid schedules is needed, or a proof that the event-time checks are conservative.
  2. [V] The paper replaces exact swept-volume collision checks with a union of inflated inscribed spheres that are 'greedily sampled for a given computation budget' (Section V). This is an approximation with no stated coverage guarantee. If the sampled spheres do not cover the robot mesh, the sphere-based check can miss collisions, potentially producing a schedule that is unsafe when executed. Since the central claim includes producing correct parallel schedules, the authors need to either use a conservative sphere cover (e.g., with formal bounds) or provide evidence that the approximation is safe for the demonstrated domains. Without this, the safety of the output schedules, especially in real-world deployment, is not established.
  3. [IV-C] The text states that EAGER-STREAM 'will provably solve ScheduleStream problems if a solution exists.' This claim requires assumptions about the stream generators: they must eventually enumerate every constant needed for a solution, and the schedule subroutine must be complete for finite problems. The paper does not state or prove these assumptions for the randomized and GPU-based samplers used in Section V. As written, the 'provably solve' assertion is unsupported and should be replaced with a precise theorem under explicit completeness assumptions, or qualified to probabilistic/demonstrated completeness.
minor comments (3)
  1. [III, running example] In the introductory running example, the goal description says 'arm2 to hold object arm2'; this appears to be a typo for 'obj2'. Please correct.
  2. [Abstract / I] The phrase 'first general-purpose framework' is strong. Related work (e.g., temporal planning literature, DaSH, and Hartmann & Toussaint) addresses related settings. The novelty claim should be more carefully positioned to avoid overclaiming.
  3. [VI-A, Tables I and II] The caption of Table II notes that Hierarchical makespans are averaged only over solved problems (denoted *), but the text in Section VI-A does not clearly explain this until later. Consider moving the explanation to the caption or the first mention. Also, 'Hierarchal' is a typo in the table caption.

Circularity Check

0 steps flagged

No significant circularity: the central claims are supported by novel constructive algorithms and independent empirical evaluation, not by fitting outputs to inputs or by load-bearing self-citations.

full rationale

ScheduleStream's central contributions—the temporal compilation of durative actions into start/end events (Section IV-B, Algorithm 2), the eager and lazy stream scheduling loops (Algorithms 1 and 3), and the GPU-batched sampling/collision pipeline (Section V)—are presented as constructive algorithms and evaluated in simulation and on real hardware. None of the claimed results (schedule existence, makespan reductions, success rates) is obtained by fitting a quantity to the data it claims to predict, and no output is defined in terms of the input in a way that makes the result true by construction. The self-citations to PDDLStream [15], cuTAMP [14], and cuRobo [29] are used as background and implementation tools: PDDLStream is prior work on streams that this paper extends with temporal and functional semantics, and cuRobo is public code with externally verifiable kernels. These citations are not the load-bearing evidence for the paper's main claims. The paper does contain unproven assertions—for example, that the event-time OverCondition checks certify ongoing conditions over entire overlap intervals, that the sphere-sampling collision checks are conservative, and that EAGER-STREAM's 'provably solve' claim relies on streams eventually enumerating needed constants. These are correctness/completeness risks rather than circularity, because they are not definitions of the result, fitted parameters renamed as predictions, or conclusions that reduce to their own premises.

Axiom & Free-Parameter Ledger

4 free parameters · 5 axioms · 0 invented entities

No fitted constants enter the central claim; the free parameters are engineering choices (time budget, sphere-sampling budget, enumeration step, search weight). The load-bearing assumptions are the unproven temporal-reduction properties in Section IV-B and the implicit stream-completeness assumption behind the "provably solve" claim; both are flagged in red_flags. No new physical entities (forces, mediators, dimensions) are postulated — the lazy placeholder constants ("@..." strings) and Ongoing/Remaining bookkeeping are software constructs, not entities with independent falsifiable handles.

free parameters (4)
  • Anytime time budget = 60 s
    Section VI-A: all four algorithms run in anytime mode for 60 s; this hand-chosen cutoff defines success rate and best-makespan (t∞*) metrics.
  • GPU sphere-sampling computation budget = not specified
    Section V: robot meshes are replaced by a union of inflated inscribed spheres "greedily sampled for a given computation budget"; budget and sphere inflation are unspecified, leaving collision-fidelity uncalibrated.
  • Stream enumeration step (one next() per instance) = one output per stream instance per EAGER-STREAM iteration
    Algorithm 1 line 8: next(s.gen(x)); sampling one output rather than fairly enumerating is a hand-made trade-off behind the "provably solve" assertion in Section IV-C.
  • Weighted A* heuristic weight = unspecified (weighted; w=1 only on the reschedule call)
    Section IV-B: SEARCH uses lazy weighted A* with a modified FF heuristic; the weight is not reported, and no suboptimality bound is given for extracted schedules.
axioms (5)
  • domain assumption Closed-world assumption: undeclared functions evaluate to None and undeclared predicates to False
    Section III: underpins action applicability and the augmented-initial-state update (Algorithm 1, lines 11-12) where stream outputs set predicates True.
  • domain assumption Every feasible schedule is representable as a start/end event sequence, and event-time over-condition checks with pairwise swept-volume tests certify safe parallel execution
    Section IV-B (Algorithm 2) and Section III-B collision_cond. Asserted without proof; full-trajectory swept-volume comparisons are conservative and can reject safe temporally-disjoint motions, so optimality/completeness of the reduction is unestablished.
  • domain assumption Stream generators eventually enumerate all constants needed for a solution (fair completeness)
    Section IV-C: "EAGER-STREAM will provably solve ScheduleStream problems if a solution exists" requires this; never stated as an assumption or proven.
  • domain assumption Inflated-sphere approximations of robot meshes preserve collision correctness
    Section V: sphere representation of both arms and asymmetric sphere-mesh checks for objects; no validation against exact mesh collision checks reported.
  • domain assumption Randomly sampled problem sets (100 per task) are representative
    Section VI-A: no seeds or distribution details; all comparisons are single-draw point estimates.

pith-pipeline@v1.3.0-alltime-deepseek · 13334 in / 22836 out tokens · 208969 ms · 2026-08-03T23:36:16.283650+00:00 · methodology

0 comments
Cite this review

Pith. "Pith review of ScheduleStream: Temporal Planning with Samplers for GPU-Accelerated Multi-Arm Task and Motion Planning & Scheduling." pith.science (2026). https://pith.science/paper/BHIHA4GD

@misc{pith2026251104758,
  author       = {Pith},
  title        = {Pith review of: ScheduleStream: Temporal Planning with Samplers for GPU-Accelerated Multi-Arm Task and Motion Planning & Scheduling},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/BHIHA4GD}},
  note         = {Machine review of arXiv:2511.04758}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

Bimanual and humanoid robots are appealing because of their human-like ability to leverage multiple arms to efficiently complete tasks. However, controlling multiple arms at once is computationally challenging due to the growth in the hybrid discrete-continuous action space. Task and Motion Planning (TAMP) algorithms can efficiently plan in hybrid spaces but generally produce plans, where only one arm is moving at a time, rather than schedules that allow for parallel arm motion. In order to extend TAMP to produce schedules, we present ScheduleStream, the first general-purpose framework for planning & scheduling with sampling operations. ScheduleStream models temporal dynamics using hybrid durative actions, which can be started asynchronously and persist for a duration that's a function of their parameters. We propose domain-independent algorithms that solve ScheduleStream problems without any application-specific mechanisms. We apply ScheduleStream to Task and Motion Planning & Scheduling (TAMPAS), where we use GPU acceleration within samplers to expedite planning. We compare ScheduleStream algorithms to several ablations in simulation and find that they produce more efficient solutions. We demonstrate ScheduleStream on several real-world bimanual robot tasks at https://schedulestream.github.io.

Figures

Figures reproduced from arXiv: 2511.04758 by Caelan Garrett, Fabio Ramos.

Figure 1
Figure 1. Figure 1: Real-World Demonstration. Using ScheduleStream, a bimanual robot solves for a schedule to sort the apple into the red bin and the lime in the green bin. ScheduleStream algorithms automatically select which arm to use for which object based on kinematics and execute the actions asynchronously in parallel. Most existing TAMP approaches [2] are only able to produce plans, serial sequences of actions, as oppos… view at source ↗
Figure 2
Figure 2. Figure 2: Illustrative Examples. Three example bimanual TAMPAS problems where the goal is for arm arm1 to hold object obj1 and arm arm2 to hold object obj2. Problem 1 (left): the arms can pick their objects in parallel. Problem 2 (center): the arms can only pick their objects sequentially. Problem 3 (right): one arm must retreat after picking its object in order to make space for the other. or False. In our Python i… view at source ↗
Figure 3
Figure 3. Figure 3: Example Schedules. Left: a solution schedule for Example 1 in [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Simulated Experiments. The “Franka Hold Any 4”, “SO100 Hold Any 4”, “Franka Pack 4”, and “Franka Stack 4” tasks. Algorithm: Sequential Hierarchical Ours Ours+GPU Task % Time % Time % Time % Time Franka Assigned 1 100 0.4 100 0.4 100 0.4 100 0.1 Franka Assigned 2 100 1.7 100 1.7 100 1.7 100 0.4 Franka Assigned 3 100 3.2 100 4.9 100 5.0 100 0.7 Franka Assigned 4 100 8.2 100 14.0 100 14.0 100 1.4 Franka Any 2… view at source ↗

discussion (0)

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

Reference graph

Works this paper leans on

32 extracted references · 5 linked inside Pith

  1. [1]

    What matters in learning from offline human demonstrations for robot manipula- tion,

    A. Mandlekar, D. Xu, J. Wong, S. Nasiriany, C. Wang, R. Kulkarni, L. Fei-Fei, S. Savarese, Y . Zhu, and R. Mart´ın-Mart´ın, “What matters in learning from offline human demonstrations for robot manipula- tion,” in Conference on Robot Learning (CoRL) , 2021

    2021

  2. [2]

    Integrated Task and Motion Planning,

    C. R. Garrett, R. Chitnis, R. Holladay, B. Kim, T. Silver, L. P. Kael- bling, and T. Lozano-P ´erez, “Integrated Task and Motion Planning,” Annual Review of Control, Robotics, and Autonomous Systems , 2021

    2021

  3. [3]

    Imitating task and motion planning with visuomotor transformers,

    M. Dalal, A. Mandlekar, C. R. Garrett, A. Handa, R. Salakhutdinov, and D. Fox, “Imitating task and motion planning with visuomotor transformers,” in 7th Annual Conference on Robot Learning , 2023

    2023

  4. [4]

    Cooperative task and motion planning for multi-arm assembly systems,

    J. Chen, J. Li, Y . Huang, C. Garrett, D. Sun, C. Fan, A. Hofmann, C. Mueller, S. Koenig, and B. C. Williams, “Cooperative task and motion planning for multi-arm assembly systems,” arXiv preprint arXiv:2203.02475, 2022

    Pith/arXiv arXiv 2022

  5. [5]

    Long-horizon multi-robot rearrangement planning for construction assembly,

    V . N. Hartmann, A. Orthey, D. Driess, O. S. Oguz, and M. Toussaint, “Long-horizon multi-robot rearrangement planning for construction assembly,” IEEE Transactions on Robotics , vol. 39, no. 1, pp. 239– 252, 2022

    2022

  6. [6]

    Apex-mr: Multi-robot asyn- chronous planning and execution for cooperative assembly,

    P. Huang, R. Liu, C. Liu, and J. Li, “Apex-mr: Multi-robot asyn- chronous planning and execution for cooperative assembly,” arXiv preprint arXiv:2503.15836, 2025

    Pith/arXiv arXiv 2025

  7. [7]

    Anytime multi-arm task and motion planning for pick-and-place of individual objects via handoffs,

    R. Shome and K. E. Bekris, “Anytime multi-arm task and motion planning for pick-and-place of individual objects via handoffs,” in 2019 International Symposium on Multi-Robot and Multi-Agent Sys- tems (MRS). IEEE, 2019, pp. 37–43

    2019

  8. [8]

    Hierarchical temporal logic task and motion planning for multi-robot systems,

    Z. Wei, X. Luo, and C. Liu, “Hierarchical temporal logic task and motion planning for multi-robot systems,” arXiv preprint arXiv:2504.18899, 2025

    Pith/arXiv arXiv 2025

  9. [9]

    A general task and motion planning framework for multiple manipulators,

    T. Pan, A. M. Wells, R. Shome, and L. E. Kavraki, “A general task and motion planning framework for multiple manipulators,” in 2021 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), 2021, pp. 3168–3174

    2021

  10. [10]

    Multi-robot geometric task-and-motion planning for collaborative manipulation tasks,

    H. Zhang, S.-H. Chan, J. Zhong, J. Li, P. Kolapo, S. Koenig, Z. Agioutantis, S. Schafrik, and S. Nikolaidis, “Multi-robot geometric task-and-motion planning for collaborative manipulation tasks,” Au- tonomous Robots, vol. 47, no. 8, pp. 1537–1558, 2023

    2023

  11. [11]

    Lazy- dash: Lazy approach for hypergraph-based multi-robot task and motion planning,

    S. Lee, J. Motes, I. Ngui, M. Morales, and N. M. Amato, “Lazy- dash: Lazy approach for hypergraph-based multi-robot task and motion planning,” arXiv preprint arXiv:2504.05552 , 2025. Fig. 4: Simulated Experiments. The “Franka Hold Any 4”, “SO100 Hold Any 4”, “Franka Pack 4”, and “Franka Stack 4” tasks. Algorithm: Sequential Hierarchical Ours Ours+GPU Task...

    arXiv 2025

  12. [12]

    Randomized multi-modal motion planning for a humanoid robot manipulation task,

    K. Hauser and V . Ng-Thow-Hing, “Randomized multi-modal motion planning for a humanoid robot manipulation task,” International Journal of Robotics Research (IJRR) , vol. 30, no. 6, pp. 676–698, 2011

    2011

  13. [13]

    Humanoid manipulation planning using backward-forward search,

    M. X. Grey, C. R. Garrett, C. K. Liu, A. D. Ames, and A. L. Thomaz, “Humanoid manipulation planning using backward-forward search,” in 2016 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS). IEEE, 2016, pp. 5467–5473

    2016

  14. [14]

    Differentiable gpu-parallelized task and motion planning,

    W. Shen, C. Garrett, N. Kumar, A. Goyal, T. Hermans, L. P. Kaelbling, T. Lozano-P´erez, and F. Ramos, “Differentiable gpu-parallelized task and motion planning,” in Robotics: Science and Systems , 2025

    2025

  15. [15]

    PDDLStream: Integrating Symbolic Planners and Blackbox Samplers,

    C. R. Garrett, T. Lozano-P ´erez, and L. P. Kaelbling, “PDDLStream: Integrating Symbolic Planners and Blackbox Samplers,” in ICAPS, 2020

    2020

  16. [16]

    The Downward Refinement Property

    F. Bacchus and Q. Yang, “The Downward Refinement Property.” in IJCAI, 1991, pp. 286–293

    1991

  17. [17]

    A mip-based approach for multi-robot geometric task-and-motion planning,

    H. Zhang, S.-H. Chan, J. Zhong, J. Li, S. Koenig, and S. Nikolaidis, “A mip-based approach for multi-robot geometric task-and-motion planning,” in 2022 IEEE 18th international conference on automation science and engineering (CASE) . IEEE, 2022, pp. 2102–2109

    2022

  18. [18]

    Multi-bound tree search for logic- geometric programming in cooperative manipulation domains,

    M. Toussaint and M. Lopes, “Multi-bound tree search for logic- geometric programming in cooperative manipulation domains,” in Proceedings - IEEE International Conference on Robotics and Au- tomation, 2017, pp. 4044–4051

    2017

  19. [19]

    Learning to solve sequential physical reasoning problems from a scene image,

    D. Driess, J.-S. Ha, and M. Toussaint, “Learning to solve sequential physical reasoning problems from a scene image,” The International Journal of Robotics Research , vol. 40, no. 12-14, pp. 1435–1466, 2021

    2021

  20. [20]

    drrt*: Scalable and informed asymptotically-optimal multi-robot mo- tion planning,

    R. Shome, K. Solovey, A. Dobson, D. Halperin, and K. E. Bekris, “drrt*: Scalable and informed asymptotically-optimal multi-robot mo- tion planning,” Autonomous Robots, vol. 44, no. 3, pp. 443–467, 2020

    2020

  21. [21]

    Towards computing low-makespan solutions for multi-arm multi-task planning problems,

    V . N. Hartmann and M. Toussaint, “Towards computing low-makespan solutions for multi-arm multi-task planning problems,” arXiv preprint arXiv:2305.17527, 2023

    Pith/arXiv arXiv 2023

  22. [22]

    Hypergraph-based multi-robot task and motion planning,

    J. Motes, T. Chen, T. Bretl, M. M. Aguirre, and N. M. Amato, Algorithm: Sequential Hierarchical Ours Ours+GPU Task t1 ∗ t∞ ∗ t1 ∗ t∞ ∗ t1 ∗ t∞ ∗ t1 ∗ t∞ ∗ Franka Assigned 1 0.7 0.6 0.7 0.6 0.7 0.6 0.7 0.6 Franka Assigned 2 1.4 1.2 0.8 0.6 0.8 0.6 0.8 0.6 Franka Assigned 3 2.1 1.8 0.8 0.6 0.8 0.6 0.8 0.6 Franka Assigned 4 2.8 2.4 0.8 0.7 0.8 0.8 0.8 0.6 Fr...

    2023

  23. [23]

    PDDL: The Planning Domain Definition Language,

    D. McDermott, M. Ghallab, A. Howe, C. Knoblock, A. Ram, M. Veloso, D. Weld, and D. Wilkins, “PDDL: The Planning Domain Definition Language,” Yale Center for Computational Vision and Control, Tech. Rep., 1998

    1998

  24. [24]

    Functional strips: a more flexible language for planning and problem solving,

    H. Geffner, “Functional strips: a more flexible language for planning and problem solving,” in Logic-based artificial intelligence. Springer, 2000, pp. 187–209

    2000

  25. [25]

    {STRIPS}: A New Approach to the Application of Theorem Proving to Problem Solving,

    R. E. Fikes and N. J. Nilsson, “ {STRIPS}: A New Approach to the Application of Theorem Proving to Problem Solving,” Artificial Intelligence, vol. 2, pp. 189–208, 1971

    1971

  26. [26]

    PDDL2.1: An extension to PDDL for ex- pressing temporal planning domains,

    M. Fox and D. Long, “PDDL2.1: An extension to PDDL for ex- pressing temporal planning domains,” Journal of Artificial Intelligence Research (JAIR), vol. 20, p. 2003, 2003

    2003

  27. [27]

    The ff planning system: Fast plan generation through heuristic search,

    J. Hoffmann and B. Nebel, “The ff planning system: Fast plan generation through heuristic search,” Journal of Artificial Intelligence Research, vol. 14, pp. 253–302, 2001

    2001

  28. [28]

    Using the Context-enhanced Additive Heuristic for Temporal and Numeric Planning,

    P. Eyerich, R. Mattm ¨uller, and G. R¨oger, “Using the Context-enhanced Additive Heuristic for Temporal and Numeric Planning,” in Proceed- ings of the 19th International Conference on Automated Planning and Scheduling (ICAPS). AAAI Press, 2009, pp. 130–137

    2009

  29. [29]

    curobo: Parallelized collision-free minimum-jerk robot motion generation,

    B. Sundaralingam, S. K. S. Hari, A. Fishman, C. Garrett, K. V . Wyk, V . Blukis, A. Millane, H. Oleynikova, A. Handa, F. Ramos, N. Ratliff, and D. Fox, “curobo: Parallelized collision-free minimum-jerk robot motion generation,” 2023

    2023

  30. [30]

    Shrinking sphere: A parallel algorithm for computing the thickness of 3d objects,

    M. Inui, N. Umezu, and R. Shimane, “Shrinking sphere: A parallel algorithm for computing the thickness of 3d objects,” Computer-Aided Design and Applications , vol. 13, no. 2, pp. 199–207, 2016

    2016

  31. [31]

    Long-horizon manipulation of unknown objects via task and motion planning with estimated affordances,

    A. Curtis, X. Fang, L. P. Kaelbling, T. Lozano-P ´erez, and C. R. Garrett, “Long-horizon manipulation of unknown objects via task and motion planning with estimated affordances,” in IEEE International Conference on Robotics and Automation (ICRA) , 2022

    2022

  32. [32]

    Grounding dino: Marrying dino with grounded pre-training for open-set object detection,

    S. Liu, Z. Zeng, T. Ren, F. Li, H. Zhang, J. Yang, C. Li, J. Yang, H. Su, J. Zhu, et al. , “Grounding dino: Marrying dino with grounded pre-training for open-set object detection,” arXiv preprint arXiv:2303.05499, 2023

    Pith/arXiv arXiv 2023