Introduction to AgentSpeak and Jason for Programming Multi-agent Systems (1)

1. Introduction to AgentSpeak and Jason for Programming Multi-agent Systems(1) Dr Fuhua (Oscar) Lin SCIS Athabasca University June 19, 2009

2. 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).

3. 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.

4. 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

5. 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.

6. 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.

7. 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.

8. 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 !

9. 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 terms constant Variables Person Structures staff(john, age(36)) Number 3 12, 14 String “John” Atom john box1 List [] [1, X, john]

10. 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.

11. 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.

12. 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.

13. 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).

14. 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.

15. Types of AgentSpeak formula terms predicate literal belief goal Triggering event

16. 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)

17. 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)

18. 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.

19. 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)

20. 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 <- ……

21. Body • The body is a sequence of actions and (sub) goals to achieve. • Note: this is the original AgentSpeak syntax; Jason allows other things in the context and body of plans. trigger_event : context <- body