Download Seminar Selected Topics on Specifying Intelligent Agents STRIPS

Rheinisch-Westfälische Technische Hochschule Aachen
Knowledge-Based Systems Group
Prof. G. Lakemeyer, Ph.D.
Seminar Selected Topics on Specifying
Intelligent Agents
im Sommersemester 2010
STRIPS and ADL
Enrique López Mañas
Advisor: Stefan Schiffer last build: August 23, 2010
1
CONTENTS
Contents
1 Introduction
2
1.1
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
1.2
Frequently Used Terms . . . . . . . . . . . . . . . . . . . . . . . .
2
1.3
Automated Planning . . . . . . . . . . . . . . . . . . . . . . . . .
3
1.4
The frame problem . . . . . . . . . . . . . . . . . . . . . . . . . .
4
1.5
Search and planning . . . . . . . . . . . . . . . . . . . . . . . . .
4
2 STRIPS
5
2.1
History . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
2.2
Syntax of STRIPS . . . . . . . . . . . . . . . . . . . . . . . . . .
6
2.3
Semantics of STRIPS . . . . . . . . . . . . . . . . . . . . . . . .
8
2.4
Planning in STRIPS . . . . . . . . . . . . . . . . . . . . . . . . .
8
2.5
Complexity of STRIPS planning . . . . . . . . . . . . . . . . . .
9
3 ADL
10
3.1
History . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
3.2
Syntax of ADL . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
3.3
Semantics of ADL . . . . . . . . . . . . . . . . . . . . . . . . . .
11
3.4
Complexity of ADL planning . . . . . . . . . . . . . . . . . . . .
12
4 Comparison between STRIPS and ADL
4.1
Expressiveness . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5 Examples with ADL and STRIPS
12
12
13
5.1
Implementation with STRIPS . . . . . . . . . . . . . . . . . . . .
13
5.2
Implementation with ADL . . . . . . . . . . . . . . . . . . . . . .
16
5.3
How is planning done
19
. . . . . . . . . . . . . . . . . . . . . . . .
6 Practical applications of STRIPS and ADL
22
7 Conclusions
23
7.1
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23
7.2
Future Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
24
8 Bibliography
25
1
INTRODUCTION
1
2
Introduction
1.1
Motivation
Stories of artificial automats and attempts to create them have a long history,
but fully autonomous machines only appeared in the 20th century. As the
human tends to be lazy, there has been always the necessity of providing such
automats a truly autonomy and a behavior free of human supervision. The
automated planning arises as a methodology for intelligent agents, autonomous
robots and unmanned vehicles to plan strategies or action sequences. Within the
automated planning there are some languages formalizing the basics of planning.
This is a seminar paper which describes two of the most relevant languages for
automated planning: STRIPS and ADL. The paper is structured as follows: first
we will have a summary of the most frequently used terms in the paper. After
that an overview about automated planning will be given. STRIPS and ADL are
studied after that, considering the following elements for each of the languages:
history and motivation, syntax, semantic and examples. Both languages and its
more relevant features will be compared, in order to analyze pros and contras
of each language. Just before a conclusion and discussion of the paper there is
an overview of practical applications using STRIPS and ADL, and a section to
state the future line of development on automated planning.
1.2
Frequently Used Terms
Throughout this seminar paper we will frequently use some terms that the
reader may not be familiar with. Therefore, a summary of this terms and a
brief explanation can be found. Some of those terms will be further explained
in future sections.
• State: represents a configuration for a certain problem. A state is typically
modified by an action. There two special states in a planning problem, the
goal and the initial state. The goal indicates the state that the problem
must reach in order to success. The initial state is the initial configuration
that the problem will face.
• Precondition: the precondition is the condition that a action must accomplish to be executed. For example, a box cant be moved if it is not in our
hands
• Effect: the consequence that results from the execution of an action.
• Action: the execution of a routine that invariably affect a state, leading
to their modification.
• Search Problem: a search problem can be stated as a problem with a set
of instances and a set of solutions. The problem is analyzed with a certain
algorithm, and the goal is to find a instance state which belongs as well
to the solutions set.
1
INTRODUCTION
3
• Search Strategy: each of the algorithms used to explore the tree of a search
problem. They can be divided in two main groups: heuristic algorithms
and non-heuristic algorithms.
1.3
Automated Planning
Automated planning and scheduling is a branch in artificial intelligence research
that studies how to automatically generate and perform action sequences. It
is typically used for execution by intelligent agents, such as autonomous robots
and unmanned vehicles. The solutions to the problems that these agents face are
typically complex and the solution have to be optimized in a multidimensional
space [3]. Although in the theoretical models the ”closed world assumption”
can be considered, in a real environment automated planning has to take into
account external influences to the theoretical model that could possibly affect
it.
The motivation for automated planning, as stated in the previous section, is the
study and design of how to make agents solve problems. Such a study is of practical concern, because some complex artifacts require a truly autonomous and
deliberative behavior while they’re operating. For instance, satellites or spacecrafts. Due to particular constraint (communication can take an inadmissible
time to be performed) this artifacts can not been operated from the distance,
and therefore they should operate even when there is no human supervisor.
A typical planner takes three inputs: a description of the initial state of the
world, a description of the desired goal, and a set of possible actions. All those
inputs are typically encoded in a formal language. In this seminar paper we
will study two of them: STRIPS and ADL. The planner produces a sequence of
actions that lead from an initial state to a state meeting the goal. An alternative
language for describing planning problems is that of hierarchical task networks,
in which a set of tasks is given, and each task can be either realized by a primitive
action or decomposed in a set of other tasks.
The automated planning problems are represented internally as a search problem. From each state we can derive new states depending on the action performed. This leads into a full representation (sometimes infinite) that is likely
represented as a tree with branches, so the analysis and optimization of the
problem can be systematized.
The search strategies can be categorized in two big groups: those searches that
are heuristic and those searches that do not use any heuristic: a heuristic is a
technique designed to solve a problem that ignores whether the solution can be
proven to be correct, but which usually produces a good solution or solves a
simpler problem that contains or intersects with the solution of the more complex problem. Most real-time, and even some on-demand, anti-virus scanners
use heuristic signatures to look for specific attributes and characteristics for
detecting viruses and other forms of malware. The strategies that not use a
heuristic do not have an expert knowledge of the domain, so theyre more likely
to be more durable and less optimized. Typically the searches using a heuristic
are called informed. The ones which doesnt are called uninformed.
1
4
INTRODUCTION
The purpose of this seminar paper is not to analyze deeply the different search
strategies. More information can be found under [11] and [12]. The Table 1
shows a summary of the main uninformed search strategies:
Breadth-first
Uniform cost
Depth-first
Depth-limited
Iterative deepening
Bidirectional
Completeness
Yes
Yes
No
No
Yes
Yes
Optimality
Yes
Yes
No
No
Yes
Yes
Time
O(bd+1)
O(b1+[C / ])
O(bm)
O(bl)
O(bd)
O(bd/2)
Space
O(bd+1)
O(b1+[C / ])
O(bm)
O(bl)
O(bd)
O(bd/2)
Table 1: Comparative of uninformed search strategies
1.4
The frame problem
Briefly, the frame problem is technically defined in [34]. The main question that
this problem arises is how is it possible to write formulae that specify consequences of actions without having to write all of the accompanying formulae
describing the obvious non-effects of those actions. We will give a small example. Suppose we write two formulae, one describing the effects of painting an
object and the other describing the effects of moving an object.
1. Colour(x, c) holds after Paint(x, c)
2. Position(x, p) holds after Move(x, p)
Let’s going to suppose we have an initial state: Colour(A, Red) and Position(A, House).
According to the FOL, after the action Paint(A, Blue) followed by Move(A, Garden)
we can intuitively expect that Colour(A, Blue) and Position(A, Garden) will
hold. But unfortunately this is not the case. If written out more formally in
classical predicate logic, using a suitable formalism for representing time and
action such as the situation calculus, the two formulae above only license the
conclusion that Position(A, Garden) holds. This is because they don’t rule out
the possibility that the colour of A gets changed by the Move action. Further
information on the frame problem can be found at [35]
1.5
Search and planning
In very simple problems of planning, we can first apply any applicable operator
to the initial model, we might first apply all of the applicable operators to the
world model we have built [8], in order to create a set of successors. Afterwards
we would continue to apply to the successors and their descendants until we
reach a goal state. However, most of the problems are more complex than just
this, and using this strategy will generate a quite large world model and would
thus be impractical.
2
STRIPS
5
Let’s consider, for example, the task of getting milk, bananas and oranges. As
we can see in the Figure 1, standard tree search will fail miserably and expand
a lot of states that might not be necessary to solve the problem. A planning
system will have the following behavior in a problem:
1. Open-up actions and goal representation to allow selection
2. Divide and conquer by creating small subgoals
3. Relax requirement for sequential construction of solutions [36]
Figure 1: Search strategies vs. planning. Search will expand many branches
2
2.1
STRIPS
History
The acronym STRIPS stands for Stanford Research Institute Problem Solver.
Along with the beginning of automated planning and artificial intelligence, it
was one of the firsts automated planners developed (Richard Fikes and Nils
Nilsson, 1971)[4]. Later on, the same name was used to refer to the formal
language described in this planner. This planner act as a base for the other
languages that were described after STRIPS, and it is normally the academic
reference for study.
Although STRIPS is the most well-known planning system, it was not the first
one. Green[5] proposed on May 1979 a problem solving system that exclusively
depends on formal theorem-proving methods to search for an appropriate sequence of operators. However, this approach suffered some serious disadvantages
that prevented it from solving non-trivial problems. STRIPS main contribution
to the planning systems was to separate the process of theorem-proving from
those of searching through a space of world model.
Consider a fixed propositional action signature (f,t, F,A). The following two
definitions characterize the syntax and semantics of STRIPS.
2
STRIPS
6
1. An operator is a pair (F , X), where F is a propositional combination of
fluent names (the precondition), and X is a consistent set of literals (the
effects).
2. An action description is a function from action names to operators.
Recall that a (propositional) interpretation of a set of symbols is a function that
maps this set into f, t:
We next need a way to state the effects of operator application on world models.
These effects are simply described by two lists. On the delete list we specify
those clauses in the original model that might no longer be true in the new
model. On the add list are those clauses that might not have been true in the
original model but are true in the new model.
We will discuss now certain aspects of the language, such the syntax and the
semantic. Later on we will describe the search strategy performed by STRIPS.
Both parts, as we said, are independent, which increases the overall performance
of the system.
2.2
Syntax of STRIPS
In STRIPS, the goals are partially defined states, given by conjunctions of positive ground literals. For instance, a state s satisfies a goal g if g is entailed in
s:
s = rich ∧ famous ∧ miserable satisfies g = rich ∧ famous
s = on(a,b) ∧ on(b,c) ∧ clear(a) clear(table) satisfies g = on(a,b) ∧ on(b,c)
But in order to simplify matters, STRIPS can restrict the states’ description as
follows (without any complex formulae)
• A set of conjunctions of propositions or First-Order Literals can describe
state variables
• Literals must be ground (variable-free)
• The Closed World Assumption is used, i.e. everything which is not given
explicitly is false (his is one of the differences with ADL)
The next text provides an example using the world of blocks:
on(b,table) ∧ on(a,b) ∧ on(c,table) ∧ clear(a) ∧ clear(c) ∧ clear(table) on(b,c)
is implicitly false
2
7
STRIPS
Figure 2: Closed-World assumption in STRIPS
Another fundamental element of STRIPS representation are actions (see description below). Actions are always represented in terms of action schemata:
1. There is always a name for the action
2. Parameters for the action, or variables
3. Pre-conditions: conjunctions of positive literals that states how the world
should look like or which conditions should we satisfy in order to perform
the action
4. Effects: is always a conjunction of literals which describe state changes
(could be referred as post-condition as well). Some planners can distinguish positive (an add list) and negative (delete list) effects. An example
is given here:
Action(move(B1, x, y),
PRECOND: on(B1,x) ∧ clear(B1) ∧ clear(y)
EFFECT: ¬ on(B1,x) ∧ on(B1,y) ∧ clear(x) ∧ ¬clear(y)
We can describe in natural language the previous example as follows: in order
to move B1 from the position x to y, B1 needs to be on x, there should be no
other object on B1, and y should be clear. After moving B1 from x to y, B1
is no longer on x but on y, x is clear and y is no longer clear.
Let’s see, for instance, an example of a performed action in STRIPS:
onTable(A) onTable(C) ∧ on(B,C) ∧ clear(A) ∧ clear(B)
Action(stack(A, B),
PRECOND: clear(A) ∧ clear(B)
EFFECT: on(A,B) ∧ ¬ onTable(A) ∧ ¬ clear(B))
NO CHANGES: clear (A), on (B,C), onTable(C)
delete list: onTable(A), clear(B)
add list: on(A,B)
2
8
STRIPS
Figure 3: Performed action in STRIPS
2.3
Semantics of STRIPS
The semantic can be defined as the study of meaning. Meaning in this case
refers to the relation between signifiers and what they stand for. This applies
not only to natural language, but to computer or artificial languages.
The next equation shows a semantic description of the STRIPS language:
Si+1 = transST RIP S (Si , a) =
(Si \del (a)) ∪ add(a), if pc(a) ⊆ Si and add(a) ∪ del(b) = ø
undef ined otherwise
(1)
The previous definition makes a separation between add and delete list. Lets
see how it holds for an example:
s0 = on(a,c) ∧ on(c,table) ∧ on(b,table) ∧ clear(a) ∧ clear(b) ∧ clear(table)
move(a,c,b)
s1 = on(a,b) ∧ on(c,table) ∧ on(b,table) ∧ clear(a) ∧ clear(c) ∧ clear(table)
2.4
Planning in STRIPS
STRIPS adopted the ”GPS” strategy of extracting differences between the current model and the goal, and the different operators that can be relevant to
attempt to reduce these differences [9]. First a relevant operator is determined,
and then we attempt to solve the sub problem of producing a world model to
which it is applicable. If the model is found, we apply the operator and consider
the original goal into the resulting model.
STRIPS employs a theorem prover to attempt to prove that the goal wff (well
formed formula) G0 follows from the set M0 of wff’s that describes initial world
model. If G0 does follow from M0 , the task is trivially solved in the initial
model. Otherwise, the theorem prover will not find a proof, so we need to go
on with the process. In this case, the uncompleted proof is taken to be the
”difference” between M0 and G0 . Next, operators that might be relevant to
”reducing” this difference are sought. These are the operators whose effects on
world models would enable the proof to be continued. In determining relevance,
the parameters of the operators may be partially or fully instantiated. The
corresponding instantiated precondition wff schemata (of the relevant operators)
are then taken to be new subgoals.
The search strategy can be defined with the following algorithm. Given a goal
stack:
2
9
STRIPS
1. Consider the top goal
2. Find a sequence of actions satisfying the goal from the current state and
apply them.
3. The next goal is considered from the new state.
4. Termination: stack empty
5. Check goals again.
2.5
Complexity of STRIPS planning
Tom Bylander proposes the PLANSAT model to analyze the complexity of
STRIPS. Tom defines PLANSAT as the problem of determining the existence
of a solution for STRIPS planning. The following figure shows the complexity
of PLANSAT under some different restrictions: depending on the scenario the
complexity can be PSPACE-complete, NSPACE complete and polynomial.[38]
Figure 4: Complexity results for PLANSAT
In general, it is PSPACE-complete to determine if a given planning instance has
any solutions. Extremely severe restrictions on the operator and the domain theory must be required in order to guarantee tractability or even NP-completeness
3
10
ADL
for planning problems with STRIPS. For example, to ensure polynomial complexity each operator should only have positive preconditions and a single postcondition and there should be a limited number of goals [39]. However, we have
to make it careful regarding the implications of these results.[28].
3
ADL
3.1
History
ADL stands for Action Description Language. ADL is another automated planning and scheduling system, particularly oriented for robots. It is considered to
be an advancement over STRIPS. Pednault proposed this language in 1987.
Pednault [6] observed that the expressive power of STRIPS was susceptible of
being improved by allowing the effects of an operator to be conditional. This
is the main idea of ADL-A, which is basically the propositional fragment of the
ADL proposed by Pednault [7]. ADL-B is an extension of A. In this extension,
actions can be described with indirect effects by the introduction of a new kind
of propositions, ”static laws. A third variation of ADL is ADL-C. This last one
is similar to B, in the sense that its propositions can be classified into static and
dynamic laws. But there are some more particularities, which will be described
in more detail in the following chapters [7]
3.2
Syntax of ADL
An ADL schema consists of an action name, an optional parameter list and four
optional groups of clauses labeled Precond, Add, Delete and Update.
The Precond group is a list of formulas that define the preconditions for the
execution of an action. If the set is empty, the value TRUE is thus inserted into
the group, and the preconditions are always evaluated as holding conditions.
The Add and Delete conditions are specified by the Add and Delete groups,
respectively. Each group consists of a set of clauses of the forms shown in the
left-hand column of the Table 2.
Clause
R(τ1 ,...,
R(τ1 ,...,
R(τ1 ,...,
R(τ1 ,...,
τn )
τn ) if ψ
τn ) for all z1 ,..., zk
τn ) for all z1 ,..., zk such that ψ
α̃R(x1 ,,xn )/δ(x1 ,,xn )
(x1 = τ1 ∧ ... ∧ xn = τn )
(x1 = τ1 ∧ ... ∧ xn = τn ∧ ψ)
∃z1 ,...,zk (x1 = τ1 ∧ ... ∧ n = τn )
∃z1 ,...,zk (x1 = τ1 ∧ ... ∧ n = τn ∧ ψ)
Table 2: Add and delete clauses, and their meaning
1. The R represents a relation symbol.
2. τ1 , ... , τn represent terms
3
11
ADL
3. ψ represents a formula
4. The sequence z1 ,...,zk are variable symbols that appear in the terms τ1 ,...,
τn , but not in the parameter list of the action schema
5. x1 ,...,xn are variable symbols that are different from the variables z1 ,...,zn
and do not appear in τ1 ,...,τn , ψ , or the parameter list of the action
schema
The Update groups are used to specify the update conditions to change the
values of function symbols. An Update group consists of a set of clauses of the
forms shown in the left column of the Table 3.
Clause
F(τ1 ,...,
F(τ1 ,...,
F(τ1 ,...,
F(τ1 ,...,
C
C
C
C
τn )
τn )
τn )
τn )
←τ
← τ if ψ
← τ for all z1 ,..., zk
← τ for all z1 ,..., zk such that ψ
←τ
← τ if ψ
← τ for all z1 ,..., zk
← τ for all z1 ,..., zk such that ψ
µF (x1 ,...,xn , y)/ µc (y)
(x1 = τ1 ∧ ... ∧ n = τn ∧ y =τ )
(x1 = τ1 ∧ ... ∧ n = τn ∧ y =τ ∧ ψ)
∃z1 ,...,zk (x1 = τ1 ∧ ... ∧ xn = τn ∧ y = τ )
∃z1 ,...,zk (x1 = τ1 ∧ ... ∧ xn = τn ∧ y = τ ∧ ψ)
(y = τ )
(y = τ ) ∧ψ
∃z1 ,...,zk (y = τ )
∃z1 ,...,zk (y = τ ) ∧ψ
Table 3: Update clauses, and their meaning
3.3
Semantics of ADL
The formal semantic of ADL is defined by 4 constraints. The first constraint
is that actions may not change the set of objects that exist in the world; that
means that for every action α and every current-state/next-state pair (s, t) ∈
a, it must be the case that the domain of t should be equal to the domain of s.
The second constraint is that actions in ADL must be deterministic. If (s, t1 )
and (s, t2 ) are current-state/next-state pairs of action ∃, then it must be the
case that t1 = t2 .
The third constraint incorporated into ADL is that the functions introduced
above must be representable as first-order formulas. For every n-ary relation
symbol R, there must exist a formula φaR x1 ,... ,xn ) with free variables x2 ,...,xn
such that faR (s) is given by:
t(R) = faR (s) = (d1 , , dn ) ∈ Dom(s)n | s[d1 /x1 ,...,dn /xn |= φaR (x1 ,xn )]
Consequently, F(n1 ,.. -,xn ) = y will be true after performing action |= if and
only if φaR (x1 ,... ,xn ,y) was true beforehand. Note that this representability
requirement relies on the first constraint ( Domain of f should be equal to domain
of s).
4
COMPARISON BETWEEN STRIPS AND ADL
12
The fourth and final constraint incorporated into ADL is that set of states in
which an action is executable must also be representable as a formula. For every
action α that can be represented in ADL, there must exist a formula π a with
the property that s | = πa if and only if there is some state t for which (s, t )
∈ α (i.e. action α is executable in state s)
3.4
Complexity of ADL planning
In terms of computational efficiency, ADL can be located between STRIPS and
the situation calculus [29]. Any ADL problem can be translated into a STRIPS
instance. However, existing compilation techniques are worst-case exponential
[32]. This wort case cannot be improved if we are willing to preserve the length
of plans polynomially [33], and thus ADL is strictly more brief than STRIPS.
ADL planning, however, is still a PSPACE-complete problem.Most of the algorithms polynomial space even if the preconditions and effects are complex
formulae [30].
Interestingly, most of the top-performing approaches to classical planning internally utilize a STRIPS like representation. In fact, most of the planners (FF,
LPG, Fast-Downward, SGPLAN5 , LAMA) first translate the ADL instance into
one that is essentially a STRIPS one (without conditional or quantified effects
or goals).
4
Comparison between STRIPS and ADL
From the above mentioned features (semantics and syntax) we can further analyze both languages, and show the difference between both of them.
4.1
Expressiveness
1. The first remark is that the STRIPS language only allows positive literals
in the states, while ADL can support both positive and negative literals.
For example, a valid sentence in STRIPS could be Rich ∧ Beautiful. The
same sentence could be expressed in ADL as ¬Poor ∧ ¬Ugly
2. In STRIPS the unmentioned literals are false. This is called the Closed
World Assumption. In ADL the unmentioned literals are unknown. This
is known as the Open World Assumption.
3. In STRIPS we only can find ground literals in goals. For instance, Rich ∧
Beautiful. In ADL we can find quantified variables in goals. For example,
∃x At (P1, x) ∧ At(P2, x) is the goal of having P1 and P2 in the same
place in the example of the blocks
4. In STRIPS the goals are conjunctions (Rich ∧ Beautiful ). In ADL the
goals allow conjunction and disjunction (Rich ∧ Beautiful ∨ Smart).
5. In STRIPS the effects are conjunctions, but in ADL conditional effects
are allowed: when P:E means E is an effect only if P is satisfied
5
EXAMPLES WITH ADL AND STRIPS
13
6. The STRIPS language does not support equality. In ADL , the equality
predicate (x = y ) is built in.
7. STRIPS does not have support for types, while in ADL it is supported
(for example, the variable p : Person).
The expressiveness of the STRIPS language is constrained by the types of transformations on sets of formulas that can be described in the language. Transformations on sets of formulas using STRIPS operators are accomplished by
removing some formulas from the set to be transformed and adding new additional formulas. For a given STRIPS operator, the formulas to be added
and deleted are fixed for all sets of formulas to be transformed. Consequently,
STRIPS operators cannot adequately model actions whose effects depend on
the situations in which they are performed. Consider a rocket which is going to
be fired for a certain amount of time. The trajectory may vary not only because
of the bum’s duration, but also because of the velocity, mass, and orientation
of the rockets. It cannot be modeled by means of a STRIPS operator because
the formulas that would have to be added and deleted would depend on the set
of formulas to be transformed [23].
Although a efficient reasoning is possible when the STRIPS language is being
used, it is generally recognized that the expressiveness of STRIPS is not suitable for modeling actions in many real world applications. This inadequacy
motivated the development of the ADL language [23, 37]. ADL expressiveness
and complexity lies between the STRIPS language and the situation calculus.
Its expressive power is sufficient to allow the rocket example described above to
be represented, yet at the same time it is restrictive enough to allow efficient
reasoning algorithms to be developed
As an example, in a more complex version of the blocks world, it could be than
a block A is twice as big as the block B and C, so the action xMoveOnto(B,A)
might only have the effect of negating Clear(A) if On(A,C) is already true,
or creating the conditional effect depending on the size of the blocks. This kind
of conditional effects would be hard to express in STRIPS notation without the
conditional effects.
5
Examples with ADL and STRIPS
Now that the languages have been explained, we provide an example to enhance the comprehension. The problem is the air cargo problem, which involves
loading and unloading cargo onto and off from planes. The cargos must be
transported from some places to others. There are defined three actions for the
problem: Load, Unload and Fly.
5.1
Implementation with STRIPS
We have three variables in the implementation: a (airport), c (cargo), p (plane),
f (start), t (destination)
5
EXAMPLES WITH ADL AND STRIPS
14
Actions:
Load (c, p, a). Load a cargo into the plane
PRECOND: At (c, a) ∧ At (p, a) ∧ Cargo (c) ∧ Plane (p) ∧ airport (a)
EFFECT: ¬At (c, a) ∧ In (c, p))
The precondition states that there must be a Cargo ”c”, a Plane ”p”, and an
Airport ”a”. The cargo and the plane must be at the airport. The effect states
that the Cargo ”c” will not be at the airport ”a” anymore, but inside the plane
”p”.
Unload (c, p, a). Unload a cargo from the plane.
PRECOND: In (c, p) ∧ At (p, a) ∧ Cargo (c) ∧ Plane (p) ∧ Airport (a)
EFFECT: At (c, a) ∧ ¬ In (c, p))
The precondition states that there must be a Cargo ”c”, a Plane ”p” and an
Airport ”a”, and the Cargo ”c” must be inside the Plane ”p” and the Plane ”p”
should be at the Airport ”a”. The effect states that the Cargo ”c” will be out
of the plane ”p”, and at the airport ”a”.
Fly (p, from, to). Fly from a airport to another
PRECOND: At (p, from) ∧ Plane (p) ∧ Airport (from) ∧ Airport (to)
EFFECT: ¬At (p, from) ∧ At (p, to))
The precondition states that there must be an Airport ”from”, an Airport ”to”
and a Plane ”p”, and the Plane ”p” must be at the Airport ”from”. The effect
states that the Plane ”p” will not be anymore at the Airport ”from”, but at the
Airport ”to”.
Initial State:
Init (At (C1, MAD) ∧ At (C2, BER) ∧ At (P1, MAD) ∧ At (P2, BER) ∧
Cargo (C1) ∧ Cargo (C2) ∧ Plane (P1) ∧ Plane (P2) ∧ Airport (BER) ∧
Airport (MAD))
Goal State: Goal (At (C1, BER) ∧ At (C2, MAD))
Init (At (C1, MAD) ∧ At (C2, BER) ∧ At (P1, MAD) ∧ At (P2, BER) ∧
Cargo (C1) ∧ Cargo (C2) ∧ Plane (P1) ∧ Plane (P2) ∧ Airport (BER) ∧
Airport (MAD))
Now we begin the execution of the planner. We have the initial state, we have
the goal, we have the variables from our problem and the possible actions to be
executed.
First Action: Load (C1, P1, MAD) Loading cargo C1 into plane P1 at the
airport MAD
• Action (Load (C1, P1, MAD),
5
EXAMPLES WITH ADL AND STRIPS
15
• PRECOND: At (C1, MAD) ∧ At (P1, MAD) ∧ Cargo (C1) ∧ Plane (P1)
∧ airport (MAD)
• EFFECT: ¬ At (C1, MAD) ∧ In (C1, P1))
• Next state: S1 (In (C1, P1) ∧ At (C2, BER) ∧ At (P1, MAD) ∧ At (P2,
BER) ∧ Cargo (C1) ∧ Cargo (C2) ∧ Plane (P1) ∧ Plane (P2) ∧ Airport
(BER) ∧ Airport (MAD))
Second Action: Fly (P1, MAD, BER) Plane P1 flies from airport MAD to
airport BER
• Action (Fly (P1, MAD, BER),
• PRECOND: At (P1, MAD) ∧ Plane (P1) ∧ Airport (MAD) ∧ Airport
(BER)
• EFFECT: ¬ At (P1, MAD) ∧ At (P1, BER)
• Next state: S2 (In (C1, P1) ∧ At (C2, BER) ∧ At (P1, BER) ∧ At (P2,
BER) ∧ Cargo (C1) ∧ Cargo (C2) ∧ Plane (P1) ∧ Plane (P2) ∧ Airport
(BER) ∧ Airport (MAD))
Third Action: Load (C2, P2, BER) Load cargo C2 into plane P2 at airport
BER
• Action (Load (C2, P2, BER),
• PRECOND: At (C2, BER) ∧ At (P2, BER) ∧ Cargo (C2) ∧ Plane (P2)
∧ airport (BER)
• EFFECT: ¬ At (C2, BER) ∧ In (C2, P2)
• Next state: S3 (In (C1, P1) ∧ In (C2, P2) ∧ At (P1, BER) ∧ At (P2,
BER) ∧ Cargo (C1) ∧ Cargo (C2) ∧ Plane (P1) ∧ Plane (P2) ∧ Airport
(BER) ∧ Airport (MAD))
Fourth Action: Fly (P2, BER, MAD) Plane P2 flies from airport BER to
airport MAD
• Action Action (Fly (P2, BER, MAD),
• PRECOND: At (P2, BER) ∧ Plane (P2) ∧ Airport (BER) ∧ Airport
(MAD)
• EFFECT: ¬ At (P2, BER) ∧ At (P2, MAD)
• Next state: S4 (In (C1, P1) ∧ In (C2, P2) ∧ At (P1, BER) ∧ At (P2,
MAD) ∧ Cargo (C1) ∧ Cargo (C2) ∧ Plane (P1) ∧ Plane (P2) ∧ Airport
(BER) ∧ Airport (MAD))
Fifth Action: Unload (C1, P1, BER) Unload cargo C1 from plane P1 at
airport BER
5
EXAMPLES WITH ADL AND STRIPS
16
• Action (Unload (C1, P1, BER),
• PRECOND: In (C1, P1) ∧ At (P1, BER) ∧ Cargo (C1) ∧ Plane (P1) ∧
Airport (BER)
• EFFECT: At (C1, BER) ∧ ¬ In (C1, P1)
• Next state: S5 (At (C1, BER) ∧ In (C2, P2) ∧ At (P1, BER) ∧ At (P2,
MAD) ∧ Cargo (C1) ∧ Cargo (C2) ∧ Plane (P1) ∧ Plane (P2) ∧ Airport
(BER) ∧ Airport (MAD))
Sixth Action: Unload (C2, P2, MAD) Unload cargo C2 from plane P2 at
airport MAD
• Action (Unload (C2, P2, MAD),
• PRECOND: In (C2, P2) ∧ At (P2, MAD) ∧ Cargo (C2) ∧ Plane (P2) ∧
Airport (MAD)
• EFFECT: At (C2, MAD) ∧ ¬ In (C2, P2)
• Next state: S6 (At (C1, BER) ∧ At (C2, MAD) ∧ At (P1, BER) ∧ At
(P2, MAD) ∧ Cargo (C1) ∧ Cargo (C2) ∧ Plane (P1) ∧ Plane (P2) ∧
Airport (BER) ∧ Airport (MAD)) Goal (At (C1, BER) ∧ At (C2, MAD))
A state s satisfies a goal g if s contains all the atoms in g (and possibly others)
→ S6 satisfies Goal
5.2
Implementation with ADL
Actions
Load (c: cargo, p: plane, a: airport)
PRECOND: At (c, a) ∧ At (p, a)
EFFECT: ¬ At (c, a) ∧ when ¬ At (c, a) : In (c, p))
Unload (c: cargo, p: plane, a: airport)
PRECOND: In (c, p) ∧ At (p, a)
EFFECT: At (c, a) ∧ when At (c, a): ¬ In (c, p))
Fly (p: plane, from: airport, to: airport)
PRECOND: At (p, from) ∧ (from 6= to)
EFFECT: ¬ At (p, from) ∧ when ¬ At (p, from): At (p, to))
Initial State:
Init (At (C1, MAD) ∧ At (C2, BER) ∧ At (P1, MAD) ∧ At (P2, BER)
∧ (C1:Cargo) ∧ (C2:Cargo) ∧ (P1:Plane) ∧ (P2:Plane) ∧ (BER:Airport) ∧
(MAD:Airport) ∧ (MAD 6= BER))
5
EXAMPLES WITH ADL AND STRIPS
17
Goal State:
Goal: (∃x,y At (C1, x) ∧ At (C2, y) ∧ x=BER ∧ y=MAD)
First Action: Load (C1, P1, MAD) Load cargo C1 into plane P1 at airport
MAD
• Action (Load (C1, P1, MAD),
• PRECOND: At (C1, MAD) ∧ At (P1, MAD)
• EFFECT: ¬ At (C1, MAD) ∧ In (C1, P1))
• Next state: S1 (¬ At (C1, MAD) ∧ In (C1, P1) ∧ At (C2, BER) ∧ At
(P1, MAD) ∧ At (P2, BER) ∧ (C1:Cargo) ∧ (C2:Cargo) ∧ (P1:Plane) ∧
(P2:Plane) ∧ (BER:Airport) ∧ (MAD:Airport) ∧ (MAD 6= BER))
Second Action: Fly (P1,MAD, BER) Plane P1 flies from airport MAD to
airport BER
• Action (Fly (P1, MAD, BER),
• PRECOND: At (P1, MAD) ∧ (MAD 6= BER)
• EFFECT: ¬ At (P1, MAD) ∧ At (P1, BER))
• Next state: S2 (¬ At (P1, MAD) ∧ At (P1, BER) ∧ ¬At (C1, MAD) ∧
In (C1, P1) ∧ At (C2, BER) ∧ At (P2, BER) ∧ (C1:Cargo) ∧ (C2:Cargo)
∧ (P1:Plane) ∧ (P2:Plane) ∧ (BER:Airport) ∧ (MAD:Airport) ∧ (MAD
6= BER))
Third Action: Load (C2, P2, BER) Load cargo C2 into plane P2 at airport
BER
• Action (Load (C2, P2, BER),
• PRECOND: At (C2, BER) ∧ At (P2, BER)
• EFFECT: ¬ At (C2, BER) ∧ In (C2, P2))
• Next state: S3 (¬ At (C2, BER) ∧ In (C2, P2) ∧ ¬ At (P1, MAD) ∧
At (P1, BER) ∧ ¬ At (C1, MAD) ∧ In (C1, P1) ∧ At (P2, BER) ∧
(C1:Cargo) ∧ (C2:Cargo) ∧ (P1:Plane) ∧ (P2:Plane) ∧ (BER:Airport) ∧
(MAD:Airport) ∧ (MAD 6= BER))
Fourth Action: Fly (P2,BER,MAD) Plane P2 flies from airport BER to airport MAD
• Action (Fly (P2, BER, MAD),
• PRECOND: At (P2, BER) ∧ (MAD 6= BER)
• EFFECT: ¬ At (P2, BER) ∧ At(P2, MAD))
5
EXAMPLES WITH ADL AND STRIPS
18
• Next state: S4 (¬ At (P2, BER) ∧ At(P2, MAD) ∧ ¬ At (C2, BER)
∧ In (C2, P2) ∧ ¬At (P1, MAD) ∧ At (P1, BER) ∧ ¬ At (C1, MAD)
∧ In (C1, P1) ∧ (C1:Cargo) ∧ (C2:Cargo) ∧ (P1:Plane) ∧ (P2:Plane) ∧
(BER:Airport) ∧ (MAD:Airport) ∧ (MAD 6= BER))
Fifth Action: Unload (C1, P1, BER) Unload cargo C1 from plane P1 at
airport BER
• Action (Unload (C1, P1, BER),
• PRECOND: In (C1, P1) ∧ At (P1, BER)
• EFFECT: At (C1, BER) ∧ ¬In (C1, P1))
• Next state: S5 (At (C1, BER) ∧ ¬ In (C1, P1) ∧ ¬At (P2, BER) ∧ At(P2,
MAD) ∧ ¬ At (C2, BER) ∧ In (C2, P2) ∧ ¬ At (P1, MAD) ∧ At (P1,
BER) ∧ ¬ At (C1, MAD) ∧ (C1:Cargo) ∧ (C2:Cargo) ∧ (P1:Plane) ∧
(P2:Plane) ∧ (BER:Airport) ∧ (MAD:Airport) ∧ (MAD 6= BER))
Sixth Action: Unload (C2, P2, MAD) Unload cargo C2 from plane P2 at
airport MAD
• Action (Unload (C2, P2, MAD),
• PRECOND: In (C2, P2) ∧ At (P2, MAD)
• EFFECT: At (C2, MAD) ∧ ¬ In (C2, P2))
• Next state: S6 (At (C2, MAD) ∧ ¬ In (C2, P2) ∧ At (C1, BER) ∧ ¬ In
(C1, P1) ∧ ¬ At (P2, BER) ∧ At(P2, MAD) ∧ ¬ At (C2, BER) ∧ ¬ At (P1,
MAD) ∧ At (P1, BER) ∧ ¬ At (C1, MAD) ∧ (C1:Cargo) ∧ (C2:Cargo)
∧ (P1:Plane) ∧ (P2:Plane) ∧ (BER:Airport) ∧ (MAD:Airport) ∧ (MAD
6= BER))
Goal: (∃x,y At (C1, x) ∧ At (C2, y) ∧ x=BER ∧ y=MAD) A state s satisfies
a goal g if s contains all the atoms in g (and possibly others) → S6 satisfies Goal
In definitive, ADL allows to express more concrete facts that are not possible
with STRIPS. Besides the example from the section 4.1, here are some other
expressions not possible in STRIPS but in ADL:
• Parent(God,Jesus) ∨ Parent(Maria,Jesus). This sentences says that either
God or Maria is a parent of Jesus, without specifying which one is.
• ∃x Cousin(Maria,x) ∧ Male(x). Maria has at least one cousin, but we do
not specify who.
• ∀x Friend(Jesus, x) ⊃ ∃y Child(x,y). All the friends of Jesus have children.
5
EXAMPLES WITH ADL AND STRIPS
5.3
19
How is planning done
We have previously spoke about planning and search strategies. In this section
we will analyze how the planning is done in STRIPS and ADL.
There are two types of planning search that can be applied: forward and backward search.
The forward (or progression search) starts in the initial state and uses the problem’s action to search forward for the goal state. It select actions whose preconditions match with the current state description (before-action state) through
unification. It apply actions to the current world state and Generate possible
follow-states (after-action states) according to the add and delete lists of the
action description. It is repeated for every generated new world state, and only
stops when a state is generated which includes the goal formula.
The backward (or regression search) starts at the goal state and uses the inverse
of the action to search backward for the initial state. This type of search checks
for unsatisfied (pre)conditions of the goal description. When one is identified,
it is selected and the actions which have those conditions as effects are applied.
Afterwards, it proceeds in the same way backwards, trying to fulfill preconditions of each new action by recursively choosing actions which achieve those
preconditions. It only stops when the precondition is part of the initital state,
and thus a sequence of actions is found leading from the initial state to the goal
state.
The means-ends analysis is the planning used in the GPS strategy, mentioned
in the chapter 2.4. It reduce the difference between the start state and the goal
state. The action-operators are chosen based on which generate literals of the
goal-state description. Recursively they generate an action sequence by trying
to fulfill preconditions of chosen actions, until they are finally grounded in the
start-state (what means, they match with literals of the start-state).
The Figure 5 shows how it works the backwards and the forward search.
5
EXAMPLES WITH ADL AND STRIPS
20
Figure 5: Forward and Backward search
STRIPS and ADL uses the following algorithm to perform the planning search:
Given a goal stack:
1. Consider the top goal
2. Find a sequence of actions satisfying the goal from the current state and
apply them.
3. The next goal is considered from the new state.
4. Termination: stack empty
5. Check goals again.
We will use the problem of the robot and the box to explain the inner working
of STRIPS [40]. There are three different rooms R1, R2 and R3. R1 is next to
R2, and R2 is next to R3. The door D1 connects R1 and R2, and the door D2
connects R2 and R3. The robot is in R1, and the box in R2. The goal is to have
the robot at R1 at the box at R1. We can apply the operators GOTHRU(the
robots goes from one room to another) and PUSHTHRU (the robots pushes the
box from one room to another). Formally, this is represented as:
GOTHRU (d, r1, r2).
PRECOND: INROOM (robot, r1) ∧ CONNECTS(d,r1,r2)
DELETE LIST: INROOM (robot, $)
ADD LIST: INROOM (robot, r2)
PUSHTHRU (b, d, r1, r2).
PRECOND: INROOM (b, r1) ∧ INROOM (robot, r1) ∧ CONNECTS(d,r1,r2)
DELETE LIST: INROOM (robot, $), INROOM (b, $)
5
EXAMPLES WITH ADL AND STRIPS
21
ADD LIST: INROOM (robot, r2), INROOM (b, r2)
Goal:.
G0: (∃x[BOX(x) ∧ INROOM (x, r1)] |
Initial Model:.
M0: INROOM(robot, r1)
CONNECTS(d1,r1,r2)
CONNECTS(d2,r2,r3)
BOX(BOX1)
INROOM(BOX1,r2)
...
∀x ∀y ∀z CONNECTS(x,y,z) ⇒ CONNECTS(x,y,z)
This initial model, M0, consists of a set of wffs. The planner attempts to prove
the conjunctive goal, G0 (having a box and the robot in Room R1). The first
conjunct is false in the initial model. Therefore, the planner tries to search for
an operator with an expression in the Add List which can make the first of the
conjunctions true.
The operator PUSHTHRU has INROOM(b,r2) in its Add List and when BOX 1
is substituted for b and Room R1 for r1 then the first conjunct is satisfied. Now
we have to determine whether this operator can be applied to the current model,
M0. In order to determine this, an attempt is made to prove the Precondition
wff against M0. This attempt fails and the Precondition wff for this operator
becomes a new subproblem. This new subproblem, G1:
G1: INROOM(BOX, r1) ∧ INROOM (robot, r1)] ∧ CONNECTS(d,r1,r2)
We also have another goal, G2, the instantiated precondition obtained from
GOTHRU:
G2: INROOM (robot, r1)] ∧ CONNECTS(d,r1,r2)
It can be proved true in M0. Consequently, this operator can be applied. The
Delete and Add Lists for GOTHRU are used to create the model that results
from the application. This is the new model M1:
Model M1:.
M1: INROOM(robot, r2)
CONNECTS(d1,r1,r2)
CONNECTS(d2,r2,r3)
BOX(BOX1)
INROOM(BOX1,r2)
...
∀x ∀y ∀z CONNECTS(x,y,z) ⇒ CONNECTS(x,y,z)
G1 is now at the top of the goal stack and an attempt is made to prove this
wff against M1 and this proof succeeds. Consequently PUSHTHRU is applied
resulting in model, M2:
6
PRACTICAL APPLICATIONS OF STRIPS AND ADL
22
Model M2:.
M2: INROOM(robot, r1)
CONNECTS(d1,r1,r2)
CONNECTS(d2,r2,r3)
BOX(BOX1)
INROOM(BOX1,r1)
...
∀x ∀y ∀z CONNECTS(x,y,z) ⇒ CONNECTS(x,y,z)
G0 is now at the top of the stack and it is provable against M2. Consequently,
the problem is solved and the plan in this instantiated and completely order set
of actions shown as follows:
GOTHRU(d1,r1,r2), PUSHTHRU(BOX1,d1,r2,r1).
6
Practical applications of STRIPS and ADL
STRIPS and ADL are actually used for automated planning applications.This
comprises intelligent agents, autonomous robots and unmanned vehicles. The
Hubble Space Telescope uses a short-term system called SPSS and a long-term
planning system called Spike . The Hubble Telescope has been proven to be
one of the most successful telescopes ever built, and the fact that it is carried
in the space makes from the automated planning systems one of the keys for its
success [13].
It has as well well-known applications for spacecraft control and operations.
Interval Logic Corporation, a company bought later on by PRI Automation ,
used Spike scheduling techniques to semiconductor manufacturing.
Typically, ADL and STRIPS can be used to model certain games based on a
tree search. By using it we can analyze the adversarial game in order to try to
determine who can win the game and what moves the player should do in order
to win. Game tree based search is one of the oldest topics in AI. The original
idea was developed by Shannon in 1950 [14] and independently by Turing in
1951, in the context of the game of chess. Their ideas still form the basis for
the techniques used today. It has been used in even more complex games, such
F.E.A.R. [31]. The algorithms used in games, however, have mostly to see with
refined variants of a relatively primitive search in game trees. Unlike board
games such players show in card games such as Bridge only partial information
about the game. This leads to a considerable increase of combinatorial diversity
and brings game-tree search phrases into trouble
Instead of maintaining a list of facts about the known world, F.E.A.R. expresses
it as a fixed vector of variables, which at the compilation time are well known.
This increases efficiency at the cost of flexibility, as Jeff Orkin pointed out.
Parts of STRIPS (the planner) are almost a perfect match for many aspects of
game logic, especially for software engineering purposes. Such a design helps
with modularity of the code. However, as specified in this paper, a full STRIPS
solution is not ideal for games. Few games require the complexity of the theorem prover, and games that are complex enough will suffer from performance
7
CONCLUSIONS
23
issues. NPC behaviors can certainly benefit from the additional automation and
modularity brought by a planner. Some games may not see an obvious increase
in intelligence by using this solution, but the AI will be more robust because of
it (compared to more procedural approaches like scripts).
Konstantina Garou and Alexander Koller report in [16] a system which is able
to generate instructions which deliberately guide the hearer to a location that
is convenient for the generation of simple referring expressions. They presented
the development to the Challenge on Generating Instructions in Virtual Environments, GIVE , nding that it performs well even under the constraints of real
time generation.
In definitive, any activity or context susceptible to be planned can be solved
using automated planning. More examples are airport traffic control [24]
7
7.1
Conclusions
Summary
STRIPS operator language contributes with its solution to the frame problem.
The solution employed in the STRIPS language is to represent the effects of
actions as transformations on sets of formulas and afterwards to provide a simple
means of specifying such transformations in terms of differences between sets.
As the transformations are completely defined by set differences, there is no
need to specify the elements of the sets that are in common [23].
ADL issues an important question in the representation of knowledge and automated planning, which is to find the equilibrium of the expressivity of logic
formalism against the cost of reasoning with the same formalism. The expressive
power of ADL approaches that of the situation calculus, yet its computational
costs compare favorably to those of the STRIPS language. In particular, when
the initial state of a planning situation is known, the initial state can be explicitly represented and we can use query techniques developed for relational
database systems in order to perform reasoning tasks. This increases computational costs; however, the increase is inevitable. [27, 28].
Another of the features of ADL is that it carries a solution to the frame problem:
that is the model-theoretic counterpart to the solution used in the STRIPS operator language: the transformations that take place when an action is performed
are represented as set differences, as with the STRIPS operators. Therefore, we
only need to describe that changes that occur when an action is performed, and
not what remains unaltered. Unlike STRIPS operators, ADL schemas define
transformations based on the model-theoretic structures that underlie the semantics of first-order logic, while STRIPS operators define transformations on
formulas. ADL thus has a true model-theoretic semantics. Moreover, the transformations in ADL can be functions of the situations in which the actions are
performed, allowing actions with context-dependent effects to be represented.
Such actions cannot be represented using STRIPS operators.
7
CONCLUSIONS
7.2
24
Future Work
There is more effort needed to develop automated planning under the point of
view of the engineering. One necessity is to put more effort to integrate various approaches, specially the integration of planning and scheduling and the
integration of planning and acting. The integrations effort should also be extensible under the perspective of the levels of knowledge perspective and domain
modeling, and should involve consistent integration of several problem solving
techniques [15].
Standardization in the field of the languages for automated planning is still
a pending issue. PDDL (”Planning Domain Definition Language”) [17] is a
recent development to standardize planning domain and problem description
languages. It was developed mainly to make the 1998/2000 International Planning Competitions possible. PDDL contains the ADL and STRIPS language,
among another. However, most planners do not fully support PDDL, but a restricted subset: in fact, the majority supports only the STRIPS subset. There
have been further extensions of PDDL, such as PPDDL 1.0 [18] (to add support for probabilistic effects) or PPDL 2.1 [19] (to express temporal planning
domains).
Concerning the languages their selves, they can be further developed to allow
more advance features. Richard E. Fikes, Nils J. Nilsson [8] mentioned that one
possible step is the one concerning the synthesis of more complex procedures
rather than just simple sequence of linear operators. Specifically, procedures
involving iterations, recursion and conditional branching. There are some research concerning the problem of automatic program synthesis [20,21, 22] that
could be eventually
ADL has already three extensions (A, B, C) solving the limitations initially
faced, but there is some work to do on it. The Stolen Car example [25] is too
deep to be represented here, but is an example on how ADL cannot be used
for representing ”causal anomalies or ”miracles [26]. The proposed approach to
solve it in is to view them as evidence of unknown events that occur concurrently
with the given actions and contribute to the properties of the new situation
REFERENCES
8
25
Bibliography
References
[1] Heron of Alexandria. Pneumatica and Automatica
[2] Fowler, Charles B. (October 1967), ”The Museum of Music: A History of Mechanical Instruments”, Music Educators Journal 54 (2): 4549,
doi:10.2307/3391092
[3] Ghallab, Malik; Nau, Dana S.; Traverso, Paolo (2004), Automated Planning: Theory and Practice, Morgan Kaufmann, ISBN 1-55860-856-7
[4] STRIPS: A New Approach to the Application of Theorem Proving to Problem Solving. R. E. Fikes, N.J. Nilsson.
[5] Green, C. Application of theorem proving to problem solving. Proc. Int’l.
Joint Conf. Artificial Intelligence, Washington, D.C. (May 1969)
[6] Pednault. Formulating multi-agent dynamic-world problems in the classical planning framework. In Michael Georgeff and Amy Lansky, editors,
Reasoning about actions and plans pages 47-82. Morgan Kaufmann, San
Mateo, CA, 1987.
[7] Action Languages. Michael Gelfond and Vladimir Lifschitz.
[8] Richard E. Fikes, Nils J. Nilsson. STRIPS, a New Approach to the Application of Theorem Proving to Problem Solving. Stanford Research Institute,
Menlo Park, California
[9] Ernst, G. and Newell, A. GPS: A Case Study in Generality and Problem
Solving. ACM. Monograph Series. Academic Press, New York, New York,
1969.
[10] Knoll, B., Kisyski, J., Carenini, G., Conati, C., Mackworth, A., Poole,
D. 2008. AIspace: Interactive Tools for Learning Artificial Intelligence. In
Proceedings of the AAAI 2008 AI Education Workshop.
[11] Pearl. J,Heuristics: Intelligent search strategies for computer problem solving. Addison-Wesley Publishing Co., Inc., Reading, MA 01867.2008
[12] Russell, J., Norvig, P.: Artificial Intelligence: A Modern Approach. Prentice Hall, ISBN -10: 0-13-04259-7
[13] Spitzer, Lyman S.. ”History of the Space Telescope”. Quarterly Journal of
the Royal Astronomical Society 20: 2936. 1979
[14] Claude E. Shannon. Programming a computer for playing chess. Philosophical Magazine (seventh series), XLI(314):256-275, March 1950. First
presented at the National Institute of Radio Engineers Convention, March
9, 1949, New York.
[15] Malik Ghallab,Dana S. Nau,Paolo Traverso. Automated planning: theory
and practice. ISBN-10: 1558608567. Pag. 540
REFERENCES
26
[16] Konstantina Garou and Alexander Koller. Automated planning for situated
natural language generation
[17] Drew Mcdermott, Malik Ghallab, Adele Howe, Craig Knoblock, Ashwin
Ram, Manuela Veloso, Daniel Weld, David Wilkins. The Planning Domain
Definition Language (1998)
[18] H.L.S. Younes, M.L. Littman, PPDDL1.0: An extension to PDDL for expressing planning domains with probabilistic effects, Tech. Rep. CMU-CS04-167, Carnegie Mellon University, October 2004
[19] M Fox, D Long. PDDL2. 1: An extension to PDDL for expressing temporal planning domains. Journal of Artificial Intelligence Research, 2003 aaai.org
[20] Green, C. Application of theorem proving to problem solving. Proc. Int’l.
Joint Conf.Artificial Intelligence, Washington, D.C. (May 1969).
[21] Waldinger, R. and Lee, R. PROW: A step toward automatic program writing. Proc.lnt’l. Conf. Artificial Intelligence, Washington, D.C. (May 1969).
[22] Manna, Z. and Waldinger, R. Towards automatic program synthes,IS.
Comm. ACM.14, No. 3 (March 1971).
[23] Edwing P.D. Pednault. ADL and the State-Transition Model of Action
[24] Sebastian Trg, Jrg Hoffmann and Bernhard Nebel. Applying Automatic
Planning Systems to Airport Ground-Traffic Control A Feasibility Study.
KI 2004: Advances in Artificial Intelligence
[25] M Gelfond, V Lifschitz. Representing action and change by logic programs.
The Journal of Logic Programming, 1993 Elsevier
[26] Vladimir Lifschitz and Arkady Rabinov. Miracles in formal theories of actions. Artificial Intelligence, 626(3):89-116. 1986
[27] H. J. Levesque and R. J. Brachman. A fundamental tradeoff in knowledge
representation and reasoning. In Readings in Knowledge Representation,
H. J. Levesque and R. J. Brachman, eds, pp. 42-70. Morgan Kaufmann,
San Mateo, CA, 1985.
[28] H. J. Levesque. Making believers out of computers. Artificial Intelligence,
30, 81-108, 1986
[29] Edwin P.D. Pednault. ADL. Exploring the Middle Ground Between
STRIPS and the Situation Calculus. In Proceedings of KR-89, 324-332.
[30] Jorge A. Baier. Effective Search Techniques for Non-Classical Planning via
Reformulation. PhD. Thesis, University of Toronto, 2003.
[31] http://aigamedev.com/open/reviews/fear-ai/. F.E.A.R. review. Last time
visited: 12 August 2010.
[32] Gazen, B. C. and Knoblock, C. A. Combining the Expressivity of UCPOP
with the Efficiency of Graphplan. In ECP97, pp. 221233. Toulouse, France.
1997
REFERENCES
27
[33] Nebel, B. On the Compilability and Expressive Power of Propositional
Planning Formalisms. Journal of Artificial Intelligence Research, 12,
271315. 2000
[34] McCarthy, J. and Hayes, P.J. Some Philosophical Problems from the Standpoint of Artificial Intelligence, in Machine Intelligence 4, ed. D.Michie and
B.Meltzer, Edinburgh University Press, pp. 463502. 1969
[35] E. Sandewall. An approach to the Frame Problem and its Implementation,
Machine Intelligence, 7:195204. 1972
[36] F. C. Langbein. Notes from the lecture Artificial Intelligence lectures,
Knowledge and Reasoning. Chapter 6: Planning. School of Computer Science, Cardiff University.
[37] E. P. D. Pednault. Formulating multiagent, dynamic-world problems in
the classical planning framework. In Reasoning about Actions and Plans:
Proceedings of the 1986 Workshop, M. P. Georgeff and A. L. Lansky, eds,
pp. 47-82. Morgan Kaufmann, San Mateo, CA, 1987. Reprinted in Readings
in Planning, J. Allen, J. Hendler, and A. Tale, eds, pp. 675-710. Morgan
Kaufmann, San Mateo, CA, 1990.
[38] K. Erol, D.S. Nau and V.S. Subrahmanian. Complexity, decidability and
undecidability results for domain-independent planning. Technical report,
Dept. of Computer Science, Univ. of Maryland, College Park, Maryland,
1991.
[39] T. Bylander. The Computational Complexity of Propositional STRIPS
Planning. Division of Mathematics, Computer Science and Statistics. University of Texas, San Antonio.
[40] Richard E. Fikes, Peter E. Hart, and Nils J. Nilsson, Learning and Executing Generalized Robot Plans. Artificial Intelligence, 3 (1972) 251-288.