Formal semantics for an abstract agent programming language
This presentation is the property of its rightful owner.
Sponsored Links
1 / 40

Formal Semantics for an Abstract Agent Programming Language PowerPoint PPT Presentation


  • 76 Views
  • Uploaded on
  • Presentation posted in: General

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 ([email protected]). Source.

Download Presentation

Formal Semantics for an Abstract Agent Programming Language

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Formal semantics for an abstract agent programming language

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 ([email protected])


Source

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

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

Agenda

  • Introduction

  • Programming BDI-agents

  • Abstract agent programming language

  • Operational semantics

  • Comparison with existing APLs

  • Conclusions


2 programming bdi agents

2.Programming BDI-agents

  • BDI-agents: agents have

    • 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)

  • Many agent programming languages (APLs) based on this model

    • AGENT-0, AgentSpeak(L), …

  • However, APL is still disconnected from theory


Characteristics of bdi agents

Characteristics of BDI-agents

  • Complex internal mental state changes over time

    • Beliefs, Desires, Plans, Intentions

  • Pro-active and reactive

    • Goal-directed (proactive)

    • Respond to changes in environment in a timely manner (reactive)

  • Reflective

    • Meta-level reasoning capabilities (e.g. goal revision)

  • Agent = goal-directed, belief-transforming entity


Requirement for apl

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

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

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

Example 1: robot Greedy

  • Robot & Diamond

    • Diamond may randomly appear / disappear

    • Rocks are obstacles

  • 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

    • xc( x, y ) = x of nearest diamond from (x, y)

    • yc( x, y )

  • Perfect knowledge


Goals and actions

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

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

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

Practical reasoning rules

  • To achieve its goals, agent has to

    • Find the means for achieving them

    • Revise its goal (in case of failure…)

      ⇒ Practical reasoning

  • Practical reasoning rules Lp

    • φ∈L, π,π’∈Lg ⇒ π ← φ| π’ ∈ Lp

    • π: 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

  • Φrepresents condition to apply the rule

  • Or used to retrieve data from B (by unifying predicates)


Plan rules procedural knowledge

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

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

max_diam

0 1 2 3

  • 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 1 2


Robot r x y

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)

    • robot( r, x0, y0 ) : to retrieve current position

    • robot( r, x, y ) (in body): sub-goal

0 1 2 3

0 1 2


Revision of goals reflective rules

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

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

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

Three levels of agent programming

  • Action

  • Goal execution

  • Goal revision (self-modifying program)


Agent programs

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

  • 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

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

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

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

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

4. Operational semantics

  • Operational semantics

    • Specify how a program can transform the system state

  • A transition system is a deductive system which allows to derive the transition of a program.

    • Transition rules specify the meaning of each programming construct.

    • Transition rules transform configuration

  • In APL, configuration is mental state <Π,σ>


4 1 practical reasoning rule

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

Example 7: goal revision

0 1 2 3

  • 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)


4 2 execution rules

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

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

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

Non-deterministic choice

<π1, σ>V →θ <π’1, σ>

_____________________________

<π1 + π2, σ>V →θ <π’1, σ’>

<π2, σ>V →θ <π’2, σ>

_____________________________

<π1 + π2, σ>V →θ <π’2, σ’>


Parallel composition

Parallel composition

<π1, σ>V →θ <π’1, σ>

____________________________________

<π1 || π2, σ>V →θ <π’1 || π2θ, σ’>

(similar rule for π2)


Goal execution

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

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

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

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)


  • Login