Representing Robot Task Plans as Robust Logical-Dynamical Systems

Chris Paxton, Nathan D. Ratliff, Clemens Eppner, Dieter Fox

TL;DR

The Robust Logical-Dynamical Systems (RLDS) framework bridges the gap between high-level task planning and low-level reactive control. By representing robot plans as chains of operators with explicit entry, run, and effect conditions, RLDS allows robots to automatically recover from failures and human interference with formal guarantees of convergence to the goal.

What Problem Does This Paper Address?

Robots operating in "unstructured" environments—like a home kitchen—face constant uncertainty. A simple task like "put the soup in the drawer" can fail in dozens of ways: the robot might miss a grasp, a sensor might glitch, or a human might walk by and slam the drawer shut mid-action.

Traditional methods for handling these issues are often brittle:

  • Finite State Machines (FSMs): To make an FSM robust, you have to manually draw "recovery" arrows between almost every state, leading to an unmanageable "spaghetti" of logic.
  • Behavior Trees (BTs): While more modular, BTs can have opaque internal logic and lack formal proofs that the robot will actually reach its goal under pressure.
  • Standard Planning: Most planners generate a linear sequence of steps. If step two fails, the robot often just stops or requires a computationally expensive "re-plan" from scratch.

The authors seek a framework that is as easy to program as a simple list of steps but as resilient as a complex reactive program.

Methods

The core of the paper is the Robust Logical-Dynamical Chain (RLDC).

The Operator Tuple

Each task step is defined as an operator $o = (L_P, L_R, L_E, \pi)$:

  • $L_P$ (Precondition/Entry): Can I start this task?
  • $L_R$ (Run Condition): Can I keep doing this task? (Crucially, $L_R$ is often broader than $L_P$ to prevent the robot from "chattering" or oscillating between states due to noise).
  • $L_E$ (Effects): What should be true when I'm done?
  • $\pi$ (Policy): The actual continuous control law (e.g., a Riemannian Motion Policy) that moves the robot.

The Execution Logic

Instead of following a rigid sequence, the RLDS constantly monitors the environment. At every tick (10–30Hz), it checks all operators in the plan and executes the most downstream (closest to the goal) operator whose conditions are met.

  • Shortcutting: If a human opens the drawer for the robot, the robot "sees" the next precondition is met and skips ahead.
  • Fallback: If the robot drops an object, the "holding object" condition becomes false, and the robot automatically falls back to the "grasp" operator.

Automatic Composition

The authors provide an algorithm to take a simple sequential plan and propagate "implicit conditions" backward. This ensures that the robot doesn't just try to do things in any order, but maintains the necessary context (e.g., "don't try to put the can in the drawer unless the drawer is already open").

Datasets

The framework was evaluated in two main settings:

  1. Simulation: A kitchen environment using objects from the YCB Dataset (specifically the spam can, sugar box, and tomato soup can). These objects have different geometries requiring different grasp strategies.
  2. Real-World: A Franka Emika Panda 7-DoF robot arm equipped with a camera. The system used PoseCNN for object detection and DART for tracking the state of the kitchen (e.g., how far the drawer is open).

Key Insights and Ideas

  • Hysteresis via Entry vs. Run Conditions: By separating $L_P$ and $L_R$, the authors solve the "oscillation" problem. A robot might need to be very close to a handle to start a pull ($L_P$), but it can continue the pull ($L_R$) even if it drifts slightly, preventing it from constantly stopping and restarting.
  • Convergence Guarantees: The paper provides a mathematical proof that as long as each operator has a non-zero probability of success, the RLDS will eventually reach the goal. They even provide an upper bound on the expected number of transitions required.
  • Implicit Logic: You don't have to program "if I drop the can, go back to step 1." The logic emerges naturally from the way conditions are checked and prioritized.

Key Results

The authors compared their Reactive Plan against Linear Execution (with and without replanning) under "Adversarial" conditions (where a human interferes).

Method Success Rate (Interference) Completion Time
Linear Execution 0% N/A
Linear w/ Replanning 100% 83.84s
Reactive Plan (RLDS) 100% 78.45s
  • Efficiency: RLDS was faster than replanning because it doesn't "pause" to compute a new path; the reactive nature of the conditions allows for instantaneous transitions.
  • Robustness: In real-world tests, the robot successfully completed its task even when a human pushed its arm away, moved the target object, or slammed the drawer shut mid-operation.

Limitations and Future Work

  • Policy Library: The system assumes you already have a library of low-level policies ($\pi$) for grasping, reaching, etc. It doesn't learn these policies from scratch.
  • Planning Complexity: The current implementation uses a simple greedy planner. For extremely long-horizon tasks (e.g., "make a sandwich"), a more sophisticated Task and Motion Planning (TAMP) solver would be needed to generate the initial RLDS chain.
  • Condition Learning: Currently, the logical conditions ($L_P, L_R, L_E$) are manually defined. The authors suggest that future work could involve learning these conditions directly from video demonstrations or trial-and-error.

Summary updated

Abstract

It is difficult to create robust, reusable, and reactive behaviors for robots that can be easily extended and combined. Frameworks such as Behavior Trees are flexible but difficult to characterize, especially when designing reactions and recovery behaviors to consistently converge to a desired goal condition. We propose a framework which we call Robust Logical-Dynamical Systems (RLDS), which combines the advantages of task representations like behavior trees with theoretical guarantees on performance. RLDS can also be constructed automatically from simple sequential task plans and will still achieve robust, reactive behavior in dynamic real-world environments. In this work, we describe both our proposed framework and a case study on a simple household manipulation task, with examples for how specific pieces can be implemented to achieve robust behavior. Finally, we show how in the context of these manipulation tasks, a combination of an RLDS with planning can achieve better results under adversarial conditions.
BibTeX
@inproceedings{paxton2019representing,
  author = {Chris Paxton and Nathan D. Ratliff and Clemens Eppner and Dieter Fox},
  title = {{Representing Robot Task Plans as Robust Logical-Dynamical Systems}},
  booktitle = {IEEE/RSJ International Conference on Intelligent Robots and Systems},
  year = {2019},
  url = {https://openreview.net/forum?id=bXMFH9emNR2},
}

Loading related content...

Figure