Task Decomposition

Task decomposition creates a hierarchical tree or graph where the root node is the primary objective and leaf nodes are primitive actions executable by the robot. This abstraction separates high-level intent from low-level control, allowing different algorithms to operate at appropriate levels of detail. For example, the goal 'make coffee' decomposes into subtrees for 'navigate to kitchen', 'grasp mug', 'operate machine', etc., each of which may decompose further into specific joint movements.

Effective decomposition requires reasoning about the world state and action preconditions. Each subtask has prerequisites that must be true for it to execute, and its execution changes the state for subsequent tasks. This creates causal chains. For instance, the subtask 'pour water' has preconditions 'cup is grasped' and 'water is in kettle'. Decomposition algorithms like Hierarchical Task Networks (HTNs) use libraries of methods that encode these preconditions to recursively break down tasks into feasible sequences.

Task decomposition outputs a sequence of symbolic actions (e.g., 'pick up', 'place') which must be translated into continuous trajectories by a motion planner. This creates a task-motion planning pipeline. The high-level plan defines the 'what' and logical order, while the motion planner solves the 'how' for each primitive action, considering kinematics, dynamics, and collisions. Frameworks like PDDLStream formally bridge this gap by allowing symbolic planners to call sampling-based motion planners to check feasibility.

Real-world execution is non-deterministic. A core characteristic of robust decomposition is monitoring and replanning. Systems must detect when a subtask fails (e.g., object slips) and either retry it or trigger a partial re-decomposition from the current state. This often involves:

• Execution monitoring comparing expected vs. observed state changes.
• Contingency planning with alternative methods for key subtasks.
• Anytime algorithms that can quickly repair a plan rather than restarting from scratch.

Task decomposition is formally modeled using planning languages. The two most prevalent are:

• Hierarchical Task Network (HTN) Planning: Uses a library of methods that decompose compound tasks into subtasks. It's highly expressive for procedural knowledge.
• Planning Domain Definition Language (PDDL): A standardized language for defining predicates, actions (with preconditions and effects), objects, and an initial/goal state. Planners like FastDownward then search for a sequence of actions. These representations enable automated reasoning, plan validation, and knowledge sharing between systems.

Modern approaches often decompose tasks into sequences of parameterized skills or motion primitives from a skill library. A skill is a reusable, robust controller for a fundamental capability like 'peg insertion' or 'door opening'. Decomposition then becomes the problem of selecting and parameterizing the correct skills and sequencing them. This promotes modularity, reliability, and faster planning, as the feasibility of each skill is pre-verified. Learning-from-demonstration is often used to build such libraries.

A planning formalism that decomposes complex tasks into subtasks using a library of pre-defined methods. It works recursively until primitive actions are reached. Unlike classical planners that search for sequences of actions, HTNs search for sequences of task decompositions.

• Key Components: A domain with compound tasks, primitive tasks (actions), and methods (recipes for decomposing a compound task into subtasks).
• Use Case: Common in game AI for non-player character behavior and in industrial robotics for structured assembly processes.

The algorithmic process of computing a feasible path or trajectory for a robot from a start state to a goal state while avoiding obstacles and respecting kinematic and dynamic constraints. It is the physical realization of a decomposed task.

• Core Challenge: Searching a high-dimensional configuration space (C-Space).
• Algorithm Families: Includes sampling-based planners (RRT, PRM), graph search methods (A* on grids), and optimization-based methods (trajectory optimization).

A directed graph representation of a plan where nodes represent tasks or actions and edges represent dependencies (temporal, causal, or resource-based). It explicitly models which subtasks must precede others.

• Visualization: Makes concurrency and sequential constraints clear.
• Execution: Used by schedulers and execution monitors to manage the order of operations and handle failures by identifying dependent tasks.

A curated repository of parameterized, reusable motion primitives or behavioral modules. Task decomposition often resolves to selecting and sequencing skills from this library.

• Examples: A Pick(object, location) skill or a NavigateTo(pose) skill.
• Benefits: Promotes code reusability, simplifies high-level planning, and encapsulates low-level control complexity. Skills are often validated and tuned for robustness.

A modular, hierarchical control architecture used to structure the decision-making logic of autonomous agents, including robots. It is an alternative to Finite State Machines (FSMs) for executing decomposed tasks.

• Structure: Composed of control flow nodes (Sequence, Fallback, Parallel) and execution nodes (Actions, Conditions).
• Advantage: More scalable and reusable than FSMs for complex tasks, as subtrees can be dynamically inserted or shared.

A class of automated planning that explicitly reasons about time durations, concurrency, and strict timing constraints between actions. Essential for tasks where decomposition must account for when actions occur and how long they take.

• Representation: Extends languages like PDDL to include temporal features.
• Application: Critical in manufacturing where robot arms and conveyors must operate in a synchronized, timed sequence.