Upload
ronald-gallagher
View
219
Download
1
Tags:
Embed Size (px)
Citation preview
Introduction to AgentSpeak and Jason for Programming Multi-agent Systems
(1)Dr Fuhua (Oscar) Lin
SCISAthabasca University
June 19, 2009
AgentSpeak
• Originally Proposed by Rao (1996)• Programming language for BDI agents• Elegant notation, based on logic programming• Inspired By PRS (Georgeff & Lansky), dMARS (Kinny), and BDI
Logics • Abstract programming language aimed at theoretical results • Why BDI? The BDI architecture is the predominant approach
to the implementation of “intelligent” or “rational” agents (Wooldridge, 2000).
AgentSpeak(L) Agent
• An AgentSpeak(L) agent is created by the specification of a set of base beliefs and a set of plans.
• A belief atom is simply a first-order predicate in the usual notation, and belief atoms or their negations are termed belief literals
• An initial set of beliefs is just a collection of ground belief atoms. A formula is called ground when it has no more uninstantiated variables.
Syntax of AgentSpeak
• The main language constructs of AgentSpeak are:– Beliefs– Goals– Plans
• The architecture of an AgentSpeak agent has four main components:– Belief Base– Plan Library– Set of Events– Set of Intentions
Agent
• an agent is simply specified by – a set bs of beliefs (the agent’s initial belief base)
• a set of ground (first-order) atomic formula (i.e., variables are not allowed): bs ::= at1, at2, …, atm.
– a set ps of plans (the agent’s plan library): ps ::= p1, p2, …, pn
• The atomic formula at of the language are predicates – at ::= P(t1, t2, …, tn)– where P is a predicate symbol,– t1 , . . . , tn are standard terms of first order logic.
Plan p• p ::= te : ct <- h – te triggering event, – ct plan’s context, – h sequence of actions, goals, or belief updates;– te : ct head of the plan, conditions under which
the plan can be executed – h its body.
• The formula ct must be a logical consequence of the agent’s beliefs if the plan is to be considered applicable.
The Concrete Syntax of AgentSpeak(L)
• A triggering event te can then be the addition or the deletion of a belief from an agent’s belief base (+at and −at, respectively), or the addition or the deletion of a goal (+g and −g, respectively).
• A sequence h of actions, goals, and belief updates defines the body of a plan.
• We assume the agent has at its disposal a set of actions and we use a as a metavariable ranging over them. They are given as normal predicates except that an action symbol A is used instead of a predicate symbol.
Beliefs • Beliefs or a belief base represent the information available to an agent (e.g.
about the environment or other agents)• A collection of literals, as in traditional logic programming.• A literal is a predicate or its negation.• An example of predicates:
tall(john) ------ the agent believes a particular property (“tall”) of an individual (“John”)
Fact(0, 1) ------ the agent believes the factorial of 0 is 1.Fact(X, Y) ------ the agent believes the factorial of X is Y.So, when the agent starts executing, this belief is added to the agent’s belief base.
• To represent the fact that a certain relationship holds between two or more objects, we can use a predicate such as:
likes(john, music)Which states that John likes music.
To compose predicates, we must use Terms !
Types of AgentSpeak Terms in Jason--- Basics of Logic Programming (1/5)
• Atom – As in Prolog, any symbol starting with a
lower-case is called an atom, which is used to represent particular individuals or object;
– They are the equivalent of “constants” in first-order logic.
– E.g. john is an atom• Variable
– A symbol starting with an uppercase letter is interpreted as a logical variable.
– For example, Person is a variable.• Number and String
– Are Represented as usual in programming languages
– Are classified as constants
termsterms
constantconstant VariablesPerson
VariablesPerson
Structuresstaff(john, age(36))
Structuresstaff(john, age(36))
List[]
[1, X, john]
List[]
[1, X, john]
Number3
12, 14
Number3
12, 14
String“John”String“John”
Atomjohnbox1
Atomjohnbox1
• Variable instantiation– Initially variables are free or uninstantiated and once instantiated or
bound to a particular value, they maintain that value throughout their scope --- in the case of AgentSpeak, we shall see that the scope is the plan in which they appear.
– Variables are bound to values by unification; – A formula is called ground when it has no more uninstantiated
variables.– For example, a variable Person could be bound to the atom john. – More generally, variables can be bound to a constant (i.e. an atom, a
number, or a string), or to a more complex data type called structure. • Term
– Is used to refer to a constant, a variable, or a structure.
Structure
• Structure– Is used to represent complex data, – for example,
staff(“Oscar Lin”, 9892591, professor, married, wife(Yu), daughter(Sally))
– Can be used to represent the information about a member of staff in a university.
– Structures start with an atom (called the functor) and are followed by a number of terms (called arguments) separated by commas and enclosed in parentheses.
Predicate
• facts in Prolog• Have the exactly same format as structures, e.g.
like(john, music)
• Difference is purely semantical– A structure is used as term to represent an individual
or object. – A fact is used to represent a logical proposition --- i.e.
a formula that is to be interpreted as being either true or false.
arity
• The number of arguments of a predicate/structure is important, and is called its arity.
• A particular structure is referred to by its functor and its arity
• For example, ‘staff/6’ , as it must have always exactly six different terms as arguments (otherwise it is considered a different structure altogether).
• List – e.g. [Spring, Winter, Summer, Fall]– A special type of structure– The Prolog syntax for lists is also used in Jason.– There are some special operators for lists in
particular ‘|’ can be used to separate the first item in a list from the list of all remaining items in it.
Types of AgentSpeak
formulatermsterms
predicatepredicate
literalliteral
goalgoalbeliefbelief
Triggering eventTriggering event
Goals
• Goals g can be either achievement goals (!at) or test goals (?at).
• Goals represent states of affairs the agent wants to bring (come to believe, when goals are used declaratively)
g– Achievement goals: !g
!write(book)• Or attempts to retrieve information from the belief base
– Test goals: ?g
?publisher(P)
Events
• Events happen as a consequence to changes in the agent’s beliefs or goals
• Changes:+ addition- deletion
• Events+b (belief addition)-b (belief deletion)+!g (achievement-goal addition)-!g (achievement-goal deletion)+?g (test-goal addition)-?g (test-goal deletion)
Plans
• An agent reacts to events by executing plans• Plans are recipes for action, representing the agent’s know-how• An AgentSpeak plan has the following general structure:
trigger_event : context <- body
Where • The triggering event denotes the events that the plan is meant to
handle;• The context represents the circumstances in which the plan can be
used;• The body is the course of action to be used to handle the event if
the context is believed true at the time a plan is being chosen to handle the event.
Triggering Events trigger_event : context <- body• +b ------- when the agent acquires the belief b;
+started.+fact(X, Y) --- when the agent acquires the belief that the factorial of X is Y.
• -b ------- (belief deletion)• +!g ------ (achievement-goal addition),
whenever you acquire the goal g, or to achieve the goal g.
+!print_fact(N) <- !fact(N,F); .print("Factorial of ", N, " is ", F). +!fact(N, F): N>0 <- !fact(N-1, F1); F = F1*N.
+!fact(N, 1): N == 0. • -!g ------ (achievement-goal deletion)• +?g ------ (test-goal addition)
• -?g ------ (test-goal deletion)
Plan Context
• +at and −at (in the body of a plan) represent operations for updating (u) the belief base by, respectively, adding and removing at.
• The context is logical expression, typically a conjunction of literals to be checked whether they follow from the current state of belief base.
• Types of literals in a plan context
l --- the agent believes l is true ~l --- the agent believes l is false not l --- the agent does not believe l is true not ~l --- the agent does not believe l is false
Example: +!prepare(Something)
: number_of_people(N) & stock(Something, S) & S > N <- ……