Domains

Domain structures remain essentially as specified in PDDL1.x. The main alterations are to introduce a slightly modified syntax for numeric fluent expressions and to remove the syntax for hierarchical expansions. The latter is not necessarily abandoned, but it has not, to the best of our knowledge, been used in any publicly available planning systems or even domains. In the original PDDL specification, a distinction was drawn between strict PDDL and non-strict PDDL, where strict PDDL must follow the ordering of the fields specified below, while non-strict PDDL is not restricted in this way. In practice, there are relatively few fields that it is intuitive to accept in arbitrary orders -- it is natural to expect declarations to precede use of symbols and for preconditions to precede effects. However, declarations of constants, predicates and function symbols are not naturally ordered, so in the current definition of PDDL the ordering of all fields must follow the specification below, with the exception of these three fields which are legal in any order with respect to one another, although the group must follow types (if there are any) and precede action specifications.

 <domain>   ::= (define (domain <name>)

[<require-def>]  

[<types-def>]$^{\tt :typing}$ 

[<constants-def>] 

[<predicates-def>] 

[<functions-def>]$^{\tt :fluents}$ 

<structure-def>$^*$) 

<require-def> 		 ::= (:requirements <require-key>$^{\tt +}$) 

<require-key> 		 ::= See Section A.5 

<types-def> 		 ::= (:types <typed list (name)>) 

<constants-def> 		::= (:constants <typed list (name)>) 

<predicates-def> 		 ::= (:predicates <atomic formula skeleton>$^{\tt +}$) 

<atomic formula skeleton> 

::= (<predicate> <typed list (variable)>) 

<predicate> 		 ::= <name> 

<variable> 		 ::= ?<name> 

<atomic function skeleton> 

::= (<function-symbol> <typed list (variable)>) 

<function-symbol> 		 ::= <name> 

<functions-def> 		 ::=$^{\tt :fluents}$ (:functions <function typed list 

(atomic function skeleton)>) 

<structure-def> 		::= <action-def>

<structure-def> 		::=$^{\tt :durative-actions}$ <durative-action-def>

A slight modification has been made to the type syntax - it is no longer possible to nest either expressions (a possibility that was never exploited, but complicates parsing). Numbers are no longer considered to be an implicit type - the extension to numbers is now handled only through functional expressions. This ensures that there are only finitely many ground action instances. A desirable consequence is that action selection choice points need never include choice over arbitrary numeric ranges. The use of finite ranges of integers for specifying actions is useful (see Mystery or FreeCell for example) and an extension of the standard syntax to allow for a more convenient representation of these cases could be useful. The syntax of function declarations allows functions to be declared with types. At present the syntax is restricted to number types, since we do not have a semantics for other functions, but the syntax offers scope for possible extension. Where types are not given for the function results they are assumed to be numbers.

 <typed list ($x$)> ::= $x$$^*$

<typed list ($x$)> 		::=$^{\tt :typing}$ $x$$^{\tt +}$- <type> <typed list($x$)>

<primitive-type>		 ::= <name> 

<type> 		 ::= (either <primitive-type>$^{\tt +}$) 

<type> 		 ::= <primitive-type> 

 <function typed list ($x$)> ::= $x$$^*$

<function typed list ($x$)> 		::=$^{\tt :typing}$ $x$$^{\tt +}$- <function type> 

<function typed list($x$)>

<function type> 		 ::= number