Introduction

We have been talking about first-order logic as a means to extend our logic-based agents to factored domains.
One important use of such agents is in the field of Planning.
This is the search problem of coming up with a sequence of actions which reach a desired goal state and at each time step satisfy the constraints on the problem at hand.
The particular planning language we use is a first-order logic called PDDL - Planning Domain Definition Language.
This is an extension of an earlier language called STRIPS (one of the first famous planning languages from 1971).

PDDL, PDDL States

As planning is a kind of search problem, we need to define the initial state, the set of actions available in a state, the results of applying an action, and a goal test
Each state is represented as a conjunction of fluents (facts that might change from situation to situation) that are ground, functionless atoms. For example, `P\o\o\r ^^ Unknown` might represent the state of a hapless agent. An example state from a package delivery problem might be `At(Truck_1, Melbou\r\n\e) ^^ At(Truck_2, Syd\n\ey)`.
In our system we make use of the Closed World Assumption (CWA). If a fluent is not in our KB then it is false.
We also make use of the unique names assumption: So if we mention `Truck_1` and `Truck_2` we assume `Truck_1 ne Truck_2`.
The following fluents would not be in a state description: `At(x,y)`, as it is not ground as `x` and `y` are variable); `neg P\o\o\r` as it is a negation of an atom, and `At(Father(Fred), Syd\n\e\y)`, as it uses functions.
Since it is a conjunction, the order of writing the fluents does not matter and we can also use sets of fluents to represent states.

To define Actions, we make use of a schemas that implicitly define the ACTIONS(s) and RESULT(s,a) functions needed for a problem-solving search.
One thing that we require of our schemas is that they clearly define what changes and what stays the same as a result of an action.
Otherwise, it is often quite hard to calculate what stays the same. This is known as the frame problem.
As classical planning concerns itself with problems whose actions leave most things in the state unchanged, PDDL specifies the result of an action by only mentioning what changes, everything that stays the same is unmentioned.
An example action in PDDL might be:
`Action(Fly(p, f\r\o\m, t\o),`
`\quad P\r\e\cond: At(p, f\r\o\m) ^^ Pla\n\e(p) ^^ Airp\o\rt(f\r\o\m) ^^ Airp\o\r\t(t\o),`
`\quad E\f\f\e\c\t: neg At(p, f\r\o\m) ^^ At(p, t\o)\quad )`
A schema consists of the action name, a list of all the variables used in the schema, a precondition, and an effect.
We are free to choose whatever values we want to instantiate the variables.

Which of the following is true?

Truth of a first-order formula with only bound variables still depends on the particular variable assignment one is considering in addition to the model.
Unification is the process of introducing new function symbols to get rid of quantifiers in a first-order formula so that resolution theorem proving might be used.
A definite clause is a clause in which there is exactly one positive literal.

A particular instance, of the last action might be:
`Action(Fly(P_1, SFO, JFK), `
`\quad Precond: At(P_1, SFO) ^^ Pl\a\n\e(P_1) ^^ Airp\o\rt(SFO) ^^ Airp\o\rt(JFK)`,
`\quad Effect: neg At(P_1, SFO) ^^ At(P_1, JFK) \quad)`
Entailment can be expressed with the set semantics `s |== q` iff every positive literal in `q` is in `s` and every negated literal in `q` is not. In formal notation we say:
`(a \in Action(s)) iff s |== Precond(a)`
Here any variables in `a` are universally quantified.
We say that an action `a` is applicable in state `s` if the preconditions are satisfied by `s`.
Different instantiations of the same action can be applicable in a given state. For example, in the initial state, `Fly(P_1, SFO, JFK)` and `Fly(P_2, JFK, SFO)` might both be applicable.
If an action has `v` variables, then in a domain with `k` unique names of objects, it takes `O(k^v)` time in the worst case (try each setting of each variable) to find the applicable ground actions.

The result of executing action `a` in state `s` consists in removing the fluents that appear as negative literals in the action's effects (the delete list, `Del(a)`), and adding the fluents that are positive literals in the action's effects (the add list or `Add(a)`):
`Re\s\u\l\t(s, a) = (s - Del(a)) cup Add(a)`.
For example, with the action `Fly(P_1, SFO, JFK)`, we would remove `At(P_1, SFO)` and add `At(P_1, JFK)`.
We require that any variable in the effect of an action schema be also in the precondition.
This ensures that when we bind the precondition to ground atoms, the result will also contain only ground atoms and no variables.
Notice that fluents do not explicitly refer to time: Preconditions always refer to time `t` and Effects always refer to time `t+1`.

A set of action schemas serves as a definition of a planning domain.
A specific problem is defined with the addition of an initial state and a goal.
As we said before, the initial state is a conjunction of ground atoms.
A goal is a conjunction of literals.
Variables in this goal are treated as existentially quantified.
So to satisfy a goal like `At(p,SFO) ^^ Pla\n\e(p)` it suffices to have any plane at SFO.
A planning problem is solved when we can find a sequence of actions that end in a state `s` that entails the goal.
So for example, `Rich ^^ Famous ^^ Miserab\l\e` entails `Rich ^^ Famous`; the state `Pla\n\e(P_1) ^^ At(P_1, SFO)` entails `At(p,SFO) ^^ Pla\n\e(p)`.
So now we have completely defined a search problem, we have an initial state, an Actions function, a Result function, and a goal test... Let's look at an example.