Integrating Symbolic Logic and Geometric Motion Planning

24 concepts24 papers

When a human decides to clean a kitchen, the high-level strategy is discrete and logical: open the cupboard, pick up the sponge, wipe the counter. We do not consciously calculate the torque required for our shoulder joints or the millimeter-level trajectories needed to avoid bumping into the blender.

In robotics, however, this split creates a profound computational chasm known as the symbolic-geometric representation gap. High-level task planners excel at sequencing abstract actions using symbolic logic, but they are entirely blind to physical realities like reachability, joint limits, and collisions. Conversely, low-level motion planners excel at navigating continuous, high-dimensional physical spaces, but they lack the broader mission context required to sequence multi-step tasks.

To build truly autonomous robots, we must integrate these two paradigms into a unified framework: Task and Motion Planning (TAMP).


The Core Dilemma: Why Decoupling Fails

The simplest way to build a robot planner is to decouple the layers: let a symbolic planner generate a logically sound sequence of actions, and then hand that sequence to a motion planner to find the physical trajectories.

This layered approach frequently fails due to physical impossibilities that the symbolic layer cannot foresee. For example, a task planner might determine that to clear a table, the robot must first move a heavy box. This plan is logically flawless. However, during execution, the motion planner discovers that the box is positioned at an angle that causes the robot's arm to collide with a wall, or that the box is simply out of reach.

As highlighted by Luis et al. and Panov et al., decoupling task allocation from geometric constraints forces systems into expensive, reactive trial-and-error or plan repair during execution. This gap isn't unique to manipulation; even in fields like automated cinematography, Jhala et al. note a severe disconnect between high-level narrative shot sequencing and low-level geometric obstacle resolution in 3D environments.

The fundamental challenge is that the continuous physical world contains an infinite search space. If a robot must repeatedly run expensive geometric simulations, inverse kinematics solvers, and collision checks for every potential action sequence, it faces a combinatorial explosion of queries (Vu et al.; Ait Bouhsain et al.). Early navigation systems like TREK (Gilmore et al.) attempted to bridge this by pairing expert systems with geometric pathfinders, but modern TAMP requires tighter, more scalable integration mechanisms.


Strategy 1: Optimistic Planning and Delayed Evaluation

One powerful way to bridge the gap is to plan optimistically. Instead of calculating every continuous geometric trajectory upfront, the system assumes that a valid physical path exists for a given symbolic action, constructs a candidate task plan, and only evaluates the geometry when strictly necessary.

A foundational framework for this is PDDLStream, developed by Garrett et al.. PDDLStream allows traditional symbolic planners to reason about continuous quantities by integrating "blackbox samplers"—specialized geometric algorithms that stream continuous values (like stable placement coordinates or collision-free trajectories) directly into the logical solver.

[Symbolic Planner] --(Proposes Abstract Plan)--> [Optimistic Evaluation]
       ^                                                   |
       |                                           (Runs Samplers/Checks)
       |                                                   v
[Refined Constraints] <--(Feasibility/Failure Feedback)-- [Geometric Layer]

Taking this a step further, the COAST framework by Vu et al. delays the creation of complex geometric objects until after a high-level task plan is proposed. If the geometric layer finds that a proposed action is physically impossible, it doesn't just say "no"—it communicates the exact physical failure back to the symbolic planner using PDDL constraints. This tight feedback loop prevents the task planner from making the same logical mistake twice, yielding massive computational speedups.


Strategy 2: Unified Optimization and Geometric Abstractions

Rather than treating task and motion planning as two separate systems that talk to each other, why not treat them as a single mathematical problem?

Toussaint introduced Logic-Geometric Programming (LGP), a framework that formulates TAMP as a unified optimization problem. In LGP, discrete logic is used to structure and switch continuous geometric constraints rather than just defining abstract goals. This allows the system to solve complex manipulation tasks where the objective itself is continuous—such as finding the exact physical trajectories required to build the tallest stable tower possible from irregular blocks. This joint formulation ensures that the resulting plans are simultaneously kinematically, spatially, and dynamically executable (Yildirim et al.).

To make unified optimization computationally feasible in real-time, researchers must speed up the most expensive operation in motion planning: collision checking. The Knowledge of Volumes (KVP) framework, detailed by Gaschler et al. and Gaschler et al., addresses this by representing robots, obstacles, and even the space a robot sweeps through as sets of convex polyhedra.

By abstracting complex 3D geometry into bounding polyhedra, their subsequent KABouM planner (Gaschler et al.) allows a robot to rapidly reason about physical constraints and run-time sensing contingencies—such as checking if a container is full before moving it—without getting bogged down in low-level mesh calculations.


Strategy 3: Learning and Language as Feasibility Filters

The latest frontier in TAMP bypasses traditional geometric simulations entirely by using data-driven models to predict whether a symbolic action is physically doable.

Ait Bouhsain et al. introduced Geometric Reasoning Networks (GRN), which use Graph Neural Networks (GNNs) to evaluate action feasibility in milliseconds. Crucially, GRNs don't just output a binary feasibility score; they provide interpretable hints explaining why an action might fail (e.g., "the target object is occluded"). Similarly, the work on Learning Feasibility of Factored Nonlinear Programs uses GNNs to isolate "minimal infeasible subgraphs," allowing the planner to instantly prune geometric dead-ends from the symbolic search tree.

[Natural Language Instruction] 
             |
             v
   [Large Language Model] <-------\
             |                    | (Iterative Refinement
      (Symbolic Plan)             |  via Text Feedback)
             v                    |
[Geometric Feasibility Filter] ---/
             |
      (Executable Plan)
             v
      [Physical Robot]

Simultaneously, Large Language Models (LLMs) are being leveraged to bridge the gap between human language and physical execution. Text2Motion, a framework by Lin et al., pairs the semantic reasoning of LLMs with geometric feasibility checks to turn abstract instructions (like "get two primary colored objects") into kinematically sound robot trajectories.

When the physical execution does fail, frameworks like LLM³ (Wang et al.) translate low-level motion failures (such as joint collisions or kinematic reachability limits) back into natural language feedback. The LLM reads this text-based error report, reasons about the physical constraint, and iteratively refines its symbolic plan and action parameters until a physically executable solution is found.

Key Foundational Work

Terrain Navigation Through Knowledge-based Route Planning (1985) — contributed 1 concept elements to this direction.
Representational Requirements for a Plan Based Approach to Automated Camera Control (2006) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_task_and_motion_planning_integration_87f5cfa6,
  title = {task and motion planning integration},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/task-and-motion-planning-integration/rdr_87f5cfa699304e1e8fbf4e32becd4bee},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-22},
}

This exact version (version 1, frozen text):

@misc{lacuna_task_and_motion_planning_integration_87f5cfa6_v1,
  title = {task and motion planning integration},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/task-and-motion-planning-integration/rdr_87f5cfa699304e1e8fbf4e32becd4bee/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-22},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake