Hierarchical, Symbolic, Language, and Multi-Agent Planning › Symbolic abstractions and task planning

Options let us plan over long horizons, but they do not tell us which option to pick. For that, we need a higher-level representation of what is true in the world and what each option can change. That is exactly what symbolic abstraction provides.

The idea is to project continuous state $s \in \mathbb{R}^n$ onto Boolean or discrete predicates. For a fixed object set and finite grounded vocabulary, a predicate such as $\texttt{on(cup, table)}$ is either present or absent from a symbolic state. An option can then be represented by an operator with preconditions and effects. This supports graph search over grounded states and classical planning formalisms such as STRIPS.

The projection removes continuous detail from symbolic search, but it does not guarantee a small problem: $m$ Boolean ground atoms admit up to $2^m$ valuations, and grounding more objects can create many atoms. What it buys is a task-specific state description whose transitions can be searched discretely. What it gives up is resolution and often geometry, so the abstraction must preserve the distinctions needed for feasibility and reward.

A STRIPS-style operator defines when a symbolic action applies and how it changes the state. Formally, it takes the form

$$\texttt{op} = (\mathrm{pre}, \mathrm{add}, \mathrm{del}),$$

where:

• $\mathrm{pre}$: the precondition set, i.e., the predicates that must all be true in the current symbolic state for the operator to be applicable
• $\mathrm{add}$: the add set, the predicates that become true after the operator is applied
• $\mathrm{del}$: the delete set, the predicates that become false after the operator is applied

The operator applies if all predicates in $\mathrm{pre}$ are true, and produces a new state where the predicates in $\mathrm{add}$ become true and the predicates in $\mathrm{del}$ become false:

$$\mathrm{result}(s) = (s \setminus \mathrm{del}) \cup \mathrm{add}$$

where:

• $s$: the current symbolic state, represented as a set of predicates that are true
• $\mathrm{pre}$: the precondition set, which must be a subset of $s$ for the operator to be applicable
• $\mathrm{add}$: the predicates the operator turns on
• $\mathrm{del}$: the predicates the operator turns off
• $\mathrm{result}(s)$: the symbolic state after the operator is applied, i.e., the original state with the delete set removed and the add set inserted

Classical planners search over sequences of operators that take an initial symbolic state to a goal state. The search operates over symbolic states, i.e., sets of predicates, and each operator application must satisfy $\mathrm{pre} \subseteq s$ in the current state before the update $s \mapsto (s \setminus \mathrm{del}) \cup \mathrm{add}$ is applied.

Two assumptions are easy to conflate. Under a closed-world state representation, unlisted ground facts are treated as false. Under STRIPS persistence semantics, facts not mentioned in an applicable operator's add or delete effects retain their truth values. Exogenous events violate the modeled persistence rule: if a cup falls while no operator records the change, the symbolic state becomes stale.

The interesting question for us is not how STRIPS works in the abstract, which is a well-covered topic in classical planning literature, but how the symbols relate to the world model. Specifically:

1. Predicates are grounded in observations or latent state. Object-centric representations can provide inputs for learning task-specific relations such as on(x, y) or holding(x), but slots do not automatically supply calibrated predicates.
2. Operators summarize option effects. Rolling an option through a model can estimate its predicate-level outcomes. This is one neuro-symbolic planning pattern, alongside hand-authored operators and integrated geometric checks.
3. Goals come from the task specification. In the basic STRIPS setting used here, a goal is a conjunction of ground predicates. Richer planning languages also support numeric, quantified, disjunctive, and temporal goals.

Layering can decouple symbolic search from continuous evaluation. A fully compiled symbolic model may avoid low-level simulation during search. Integrated task-and-motion or model-validated planners instead query geometry or learned dynamics while constructing candidate plans. Either design can extend the useful planning horizon, but physical validity still depends on grounding, operator models, and execution monitoring.

The interface must answer at least two questions: which predicates hold now, and what predicate-level outcomes can an option produce? Reliable answers are necessary but not sufficient. Planner correctness also depends on complete goals, applicable operators, exogenous-event assumptions, resource limits, and monitoring. A symbolic plan can therefore be internally valid yet physically infeasible.

A practical failure mode is that grounded predicates may be wrong or stale. If a detector says on(cup, table) after the cup has fallen, subsequent search starts from a false state. This reliability problem is related to, but narrower than, Harnad's symbol grounding problem, which asks how symbols acquire semantic content from nonsymbolic representations. Several engineering responses help:

• Re-check preconditions before acting. Before executing an option, verify its preconditions still hold. If not, replan.
• Interleave symbolic and continuous reasoning. Instead of planning symbolically once and executing blindly, alternate a symbolic plan step with a short continuous rollout that validates it. This is one interleaved task-and-motion or model-validated planning pattern.
• Train predicates and effects for feasibility. Joint objectives can favor features predictive of feasible actions, but that property must be included and evaluated explicitly.
• Let symbolic planners propose and continuous planners dispose. The symbolic plan is a sketch; the continuous planner fills in the details.

These remedies treat a symbolic plan as a hypothesis rather than a fact. Rechecking high-risk or changeable preconditions is often worth the sensing cost, but monitoring can itself be expensive, delayed, or occluded. Its frequency should reflect uncertainty and consequence. In noisy physical domains, recovery matters because perfectly reliable learned predicates are generally unrealistic.

Symbolic planning also omits continuous parameters. Task-and-motion planning (TAMP) combines discrete operator choices with continuous state, geometry, and motion constraints. A simple decomposition proposes an operator skeleton $o_{1:m}$ and solves for continuous parameters $\theta_{1:m}$ and states $x_{1:m}$:

$$\begin{aligned} \min_{\theta_{1:m},x_{1:m}}\quad &\sum_{k=1}^{m} c_k(x_{k-1},\theta_k) \\ \text{s.t.}\quad &\operatorname{pre}(o_1,x_0),\\ &(x_{k-1},\theta_k)\in\mathcal{F}_{o_k}, && k=1,\ldots,m,\\ &x_k=F_{o_k}(x_{k-1},\theta_k), && k=1,\ldots,m,\\ &\operatorname{pre}(o_{k+1},x_k), && k=1,\ldots,m-1,\\ &G(x_m). \end{aligned}$$

where:

• $x_k$: the continuous state after operator $o_k$
• $\theta_k \in \mathbb{R}^{d_k}$: continuous parameters such as a grasp or target pose
• $\mathcal{F}_{o_k}$: admissible state-parameter pairs whose resulting motion satisfies collision, kinematic, and dynamic constraints
• $F_{o_k}$: the continuous transition or trajectory endpoint induced by $o_k$
• $\operatorname{pre}(o_k,x)$: applicability, including relevant geometric conditions
• $G(x_m)$: the terminal goal constraint
• $c_k$: execution cost over the feasible state-parameter choices

A skeleton-first solver fixes the operator order while solving continuous feasibility. Integrated TAMP methods interleave these searches and revise the skeleton when geometry fails; Garrett et al. (2021) survey these designs. We will not implement a full TAMP solver here.

The transition and precondition constraints couple consecutive operators: the state produced by one parameterized motion must make the next operator applicable. The feasible-set constraint separately rules out motions that violate collision, kinematic, or dynamic limits even when their endpoints satisfy symbolic predicates. Initial applicability and the terminal goal are separate constraints, which avoids the undefined $o_{m+1}$ that a shorthand “next precondition” would create.