Formal Semantics for an Abstract
Agent Programming Language
K.V. Hindriks, Ch. Mayer et al.
Lecture Notes In Computer Science, Vol. 1365, 1997
http://www.nue.ci.i.u-tokyo.ac.jp/~duc/ppt/abstract-apl.ppt
M1. Nguyen Tuan Duc (duc@nue)
Source




Formal Semantics for an Abstract Agent
Programming Language
Authors: K.V.Hindriks, F.S. de Boer, W. van
der Hock, J.Ch. Mayer (Dept. of Computer
Science, Utrecht Univ., the Netherlands)
Lecture Notes In Computer Science; Vol.
1365, 1997, pp 215 – 229
Proceedings of the 4th International
Workshop on Intelligent Agents IV, Agent
Theories, Architectures, and Languages
1.Introduction

There exist many agent programming languages



AGENT-0, AgentSpeak(L)
Lack a clear and formally defined semantics, difficult to
formalize the design, specification and verification
Need for an agent programming model based on
existing programming concepts


Logic programming, imperative programming
Operational semantics
Agenda






Introduction
Programming BDI-agents
Abstract agent programming language
Operational semantics
Comparison with existing APLs
Conclusions
2.Programming BDI-agents

BDI-agents: agents have





Many agent programming languages (APLs) based
on this model


Explicit goals (Desires)
A set of plans to achieve a goal (Intensions)
Information about the environment (Belief)
Based on Human practical reasoning theory (Michael
Bratman)
AGENT-0, AgentSpeak(L), …
However, APL is still disconnected from theory
Characteristics of BDI-agents

Complex internal mental state changes over time


Pro-active and reactive



Goal-directed (proactive)
Respond to changes in environment in a timely manner
(reactive)
Reflective


Beliefs, Desires, Plans, Intentions
Meta-level reasoning capabilities (e.g. goal revision)
Agent = goal-directed, belief-transforming entity
Requirement for APL

Theoretically, APL must have features for




Belief updating (for newly observed,
communicated data, …)
Goal updating (for goal revision)
Practical reasoning (for finding the means to
achieve a goal)
Practically, APL should contain all the familiar
constructs from imperative programming

Sequential composition, tests, parallel execution,
etc.
3. An abstract agent programming language
(3APL)

An APL provides mechanism for



Belief updating
Goal updating (goal revision)
Practical reasoning (rule / plan to achieve a goal)
Belief


Beliefs are represented as First-order logic formulae
from a language L.
P, F, C, A





P: set of predicate symbols
F: set of function symbols
C: set of constant
A: set of action symbols (not used in Belief)
Basic elements of L are given by a signature (Σ)




Σ = <P, C, F, A>
Term T ::= x | f(t, t,..., t) (x∈TVar, variable; f∈F)
Formulae B::= P(t, t,..., t) | not B | B∧B | B∨B |∃x.P(x)
At = the set of atoms ( constants, primitive predicates, …)
Example 1: robot Greedy

Robot & Diamond



Basic predicates




diam( d, x, y ) : diamond d at (x, y)
robot( r, x, y ): robot r at (x, y)
rock( x, y ) : rock at (x, y)
Basic functions



Diamond may randomly appear /
disappear
Rocks are obstacles
xc( x, y ) = x of nearest diamond from
(x, y)
yc( x, y )
Perfect knowledge
Goals and actions


Goal: set of objectives agent tries to achieve
 Goal to do some action
 Goal to achieve some state of affairs
Signature Σ= <P, F, C, A>, Gvar: global variables, set of goal Lg
 A⊆Lg (basic actions)
 At ⊆ Lg
 Φ∈L ⇒ φ? ∈ Lg
 Gvar ⊆ Lg
 π1, π2 ⊆ Lg ⇒ π1; π2, π1 + π2, π1 || π2 ∈Lg



Rule for composition of goal
Basic goals: basic actions, achievement goals (P(t)∈At), test goal
(φ?)
Basic actions are update operators on belief base
 pickup( Greedy, d ) ⇒ delete diam( d, x, y ) from σ (belief base)
Goal variables

The language contains variables range over
Goals


Reflective reasoning
Communication (parameter passing)

Receive request to establish some goal in a goal
variable
Example 2: Actions and goal of Greedy



west, east, north, south: move a step
pickup( r, d ) : robot r pickup diamond d
Goal: max_diam


User defined predicate
Usually given in a procedure definition
Practical reasoning rules



To achieve its goals, agent has to
 Find the means for achieving them
-Φrepresents condition
 Revise its goal (in case of failure…)
to apply the rule
⇒ Practical reasoning
- Or used to retrieve
p
Practical reasoning rules L
data from B (by unifying
g
p
 φ∈L, π,π’∈L ⇒ π ← φ| π’ ∈ L
predicates)
 π: head of the rule
 π’: body of the rule
 φ: guard
 Global variables of the rule = Free variables in π
 Local variables = variables in the rule except global one
Practical reasoning rule (PR) serves two functions
 Mean, recipe to achieve a goal (plan rule)
 Goal revision
Plan rules: procedural knowledge

Plan rules: rules with head is a basic goal P(t)


P(t) may be viewed as procedure calls to plans to
achieve the goal
Plan rules encode procedural knowledge of
an agent
Example 3: plan rules

max_diam ← robot( Greedy, x0, y0 ) ∧ x =
xc( x0, y0 ) ∧ y = yc( x0, y0 ) | robot( Greedy,
x, y ); diam( z, x, y )?; pickup( Greedy, z );
max_diam

Implementing greedy algorithm: repeat the
following action: go to nearest diamond, take it
max_diam










x0 = 0, y0 = 0
x = 1, y = 1
robot(Greedy, 1, 1)
diam(z, 1, 1)?
pickup(Greedy, z)
x0 = 1, y0 = 1
x = 3, y = 2
robot(Greedy, 3, 2)
diam(z, 3, 2)?
pickup(Greedy, z)
0
0
1
2
1
2
3
robot( r, x, y )

robot( r, x, y ) ← robot( r, x0, y0 ) |
(x = x0 ∧ y = y0 )? + [(x < x0)? west + (x0 <
x)? east + (y > y0)? south + (y0 > y)? north];
robot( r, x, y)
0


1
2
robot( r, x0, y0 ) : to retrieve current position
robot( r, x, y ) (in body): sub-goal
0
1
2
3
Revision of goals: reflective rules


Rules with head contains an arbitrary
programs (including goal variables)
Goal revise in case


Found a more optimal strategy
Failure
Example 4: More optimal strategy


Diamond suddenly appeared as nearer
position
X; robot( r, x, y ) ← robot( r, x0, y0 ) ∧not( x =
xc( x0, y0 ) ∧ y = yc(x0, y0) ) | robot( r, xc( x0,
y0 ), yc( x0, y0) )
Example 5: Failure


rock as (x0-1, y0)
west; robot( r, x, y ) ← robot( r, x0, y0 ) ∧
rock( x0 – 1, y0 ) | [(y<=y0)?; north + (y0 <=
y)?; south]; robot( r, x, y )
Three levels of agent programming



Action
Goal execution
Goal revision (self-modifying program)
Agent programs




Agent = goal directed, belief transforming
entity
Beliefs are updated by Actions
Goals are updated by execution and revision
An agent changes its beliefs and goals (PR
and basic actions are fixed)
Mental state

Mental state = <Π, σ>, where





Π∈Lg is a goal base (set of goals)
σ∈ L is a belief base (set of beliefs)
Thus, the changing components in previous slide
Denote: B: set of belief bases, Γ: PR-base
The behavior of an agent is fully specified if


The semantics of basic actions is given
The mechanism for executing goals and applying rules are
defined
Some definitions

Free vs. bounded variables






P(x, d) ∧∃x. Q(y, x) ∧ ∀z. G(a, b, z)
Alpha conversion: P(x, d) ∧∃x1. Q(y, x1)∧∀z. G(a,b,z)
Free(e) = { x | x is free in e }
Substitution: [x/5] f(x) ≡ f(5)
Unifier: if t1, t2, … are terms then unifier of t1, t2,…,
tn is a substitution θsuch that
θ(t1) ≡ θ(t2) ≡…≡θ(tn)
Ex: f(x, x) and f(y, z) ⇒ θ = [x/z, y/z]
Most general unifier (MGU) ξ


∀θ∈unifier、∃ψ: θ = ψξ
In the above example: [x/c, y/c] = [z/c][x/z, y/z]
Basic action transitions

Semantics of basic actions A is given by a transition
function T: B x B → P(A)





P(A) is variant of A
If a ∈ T(σ,σ’) then denoted by <σ,σ’>a
<{…, robot(Greedy, n, m), not(rock(n-1,m)),…}, {…,
robot(Greedy, n-1, m), not(rock(n-1, m))}> west;
<{…, diam(d,n,m), robot(Greedy, n, m), …}, {…,
robot(Greedy, n, m), not(diam(d, n, m), …}>
pickup(Greedy, d)
By observing the environment, agent knows action
has succeeded or failed
Agent program

An agent program is a quadruple <T, Π0, σ0, Γ>





T : a basic transition function (specifying the effect of basic
actions)
Π0 : initial goal base
σ0 : initial belief base
Γ : PR-base
Thus, to program an agent is to



specify its initial mental state
define semantics of basic actions
write a set of PR
Example 6: Agent program for
Greedy

Basic actions:






<{…, robot(Greedy, n, m), not(rock(n-1,m)),…}, {…,
robot(Greedy, n-1, m), not(rock(n-1, m))}> west;
north, south, east
<{…, diam(d,n,m), robot(Greedy, n, m), …}, {…,
robot(Greedy, n, m), not(diam(d, n, m), …}> pickup(Greedy,
d)
Π0 = {max_diam}
σ0 = { robot(Greedy, 0, 0), rock(1,5), rock(3,3),
rock(2,1), diam(d, 2, 2) }
PR-base in example 4, 5
4. Operational semantics

Operational semantics


A transition system is a deductive system
which allows to derive the transition of a
program.



Specify how a program can transform the system
state
Transition rules specify the meaning of each
programming construct.
Transition rules transform configuration
In APL, configuration is mental state <Π,σ>
4.1. Practical reasoning rule


V = set of global variables in goal base
PR-rule application
π’ ← φ| π’’ ∈’ Γ ∧ σ|= ∀(φθγ)
____________________________________
<π, σ> V → θγ <π’’θγ, σ>
 Where,
θ(π’) = θ(π), π∈Π
 A ∈’ Γmeans A is a variant of a PR-rule (alpha conversion)
 γis a substitution such that no variable x: γ(x)∈V (retrieves
parameter values from σ)
⇒ Perform alpha-conversion to avoid interference of local and
global parameters

→ followed by θγ to record the substitution process

Example 7: goal revision
0





Suppose that Π = {east; robot( Greedy, 3,
2 )}, σ = {robot(Greedy, 0, 0), diam(d’, 3, 2),
diam(d,2,2) }
Apply rule: X; robot( r, x, y ) ← robot( r, x0,
y0 ) ∧not( x = xc( x0, y0 ) ∧ y = yc(x0, y0) ) |
robot( r, xc( x0, y0 ), yc( x0, y0) )
θ = { X/east, r/Greedy, x/3, y/2 }
⇒ φθ≡ robot(Greedy, x0, y0)∧not( 3 = xc(x0,
y0) ∧2 = yc(x0, y0) )
γ= {x0/0, y0/0}
π’’θγ ≡ robot(Greedy, xc(0, 0), yc(0, 0)) ≡
robot(Greedy, 2, 2)
1
2
3
4.2. Execution rules

E denotes termination




E;π≡π
E+π≡π
….
Execution rule 1: basic actions
<σ, σ’>a
____________________________
<a, σ>V →Φ <E, σ’>


Φ is an identity substitution
Thus, basic action means changing the state according
to transition function and stop execution
First-order tests


Check if some condition follows from σ
σ |= ∀(φθ)
____________________
<φ?, σ>V →θ <E, σ>
Ex: diam(z, x, y)?; pickup(Greedy, z)


θ = {z/d, x/2, y/2}
After first-order test, goal becomes pickup(Greedy,
d)
Sequential composition

<π1, σ>V →θ <π’1, σ’>
________________________________
<π1;π2, σ>V → θ <π’1; π2θ, σ’>
Ex: in previous slide:




π1 = diam(z, x, y)?, π’1 = E
θ = {z/d, x/2, y/2}
π2 = pickup(Greedy, z)
π1;π2θ ≡ E; pickup(Greedy, d) ≡ pickup(Greedy,
d)
Non-deterministic choice
<π1, σ>V →θ <π’1, σ>
_____________________________
<π1 + π2, σ>V →θ <π’1, σ’>
<π2, σ>V →θ <π’2, σ>
_____________________________
<π1 + π2, σ>V →θ <π’2, σ’>
Parallel composition
<π1, σ>V →θ <π’1, σ>
____________________________________
<π1 || π2, σ>V →θ <π’1 || π2θ, σ’>
(similar rule for π2)
Goal execution



Let Π = {π0, …, πi, πi+1, …} ⊆Lg,
V = Free(Π)
Goal execution
<πi, σ>V →θ <π’i, σ’>
__________________________________________________
< {π0, …, πi, πi+1, …}, σ>V → < {π0, …, π’i, πi+1, …}, σ’>
 There is no θ in the consequence
 This is because the mental state is the top level of execution. At
this level, various goal are executed in a parallel fashion without
communication
Computations of an agent program

A computation of an agent program is a finite
or infinite sequence of configurations <Π0,
σ0>, <Π1, σ1>, <Π2, σ2>, … such that, for
each i: <Πi, σi> → <Πi+1, σi+1>
5. Comparison with existing APLs

AGENT-0:


Only executes basic, primitive actions or skills of
agent
Goal revision is restricted to removing infeasible
commitments and uses built-in mechanism


3APL allows much more general revision rule
AgentSpeak(L):


Quite similar to the proposed language
3APL provides more general and high-level
programming construct then AgentSpeak(L)
6. Conclusions


A transition system is a suitable formalism for
specifying the operational semantics of APL
An abstract APL is proposed


Includes all the regular programming constructs from
imperative programming and logic-programming
Future work




Extensions to multi-agent systems with communication
Mechanism for failure recovery
Apply notions of standard concurrency theory (π-calculus)
…