Lecture Notes in Artificial Intelligence Subseries of Lecture Notes in Computer Science Edited by J. G. Carbonell and J. Siekmann
Lecture Notes in Computer Science Edited by G. Goos, J, Hartmanis and J. van Leeuwen
1209
Lawrence Cavedon Anand Rao Wayne Wobcke (Eds.)
Intelligent Agent Systems Theoretical and Practical Issues Based on a Workshop Held at PRICAI '96 Cairns, Australia, August 26-30, 1996
Springer
Series Editors Jaime G. Carbonell, Carnegie Mellon Universit)~ Pittsburgh, PA, USA JOrg Siekmann, University of Saarland, Saarbriicken, Germany
Volume Editors Lawrence Cavedon Royal Melbourne Institute of Technology, Computer Science Department 124 La Trobe Street, Melbourne, Victoria 3000, Australia E-mail: cavedon @cs.rmit.edu.au Anand Rao Australian Artificial Intelligence Institute Level 6, 171 LaTrobe Street, Melbourne, Victoria 3000,Australia E-mail:
[email protected] Wayne Wobcke University of Sydney, Basser Department of Computer Science Sydney, NSW 2006, Australia E-mail:
[email protected] Cataloging-in-Publication Data applied for Die Deutsche Bibliothek- CIP-Einheitsaufnahme
Intelligent agent systems : t h e o r e t i c a l a n d p r a c t i c a l issues ; b a s e d o n a w o r k s h o p h e l d at P R I C A I '96, Cairns, Australia, August 26 - 30, 1996. L a w r e n c e C a v e d o n ... (ed.). - B e r l i n ; Heidelberg ; New York ; Barcelona ; Budapest ; Hong Kong ; L o n d o n ; M i l a n ; Paris ; S a n t a C l a r a ; S i n g a p o r e ; T o k y o : S p r i n g e r , 1997 (Lecture notes in computer science ; Vol. 1209 : Lecture notes in artificial intelligence) ISBN 3-540-62686-7 NE: Cavedon, Lawrence [Hrsg.]; PRICA1 ; GT CR Subject Classification (1991): 1.2, D.2, C.2.4 ISBN 3-540-62686-7 Springer-Verlag Berlin Heidelberg New York This work is subject to copyright. All rights are reserved, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, re-use of illustrations, recitation, broadcasting, reproduction on microfilms or in any other way, and storage in data banks. Duplication of this publication or parts thereof is permitted only under the provisions of the German Copyright Law of September 9, 1965, in its current version, and permission for use must always be obtained from Springer -Verlag. Violations are liable for prosecution under the German Copyright Law. 9 Springer-Verlag Berlin Heidelberg 1997 Printed in Germany Typesetting: Camera ready by author SPIN 10550374 06/3142 - 5 4 3 2 I 0
Printed on acid-free paper
Preface This volume emanated from a workshop on the Theoretical and Practical Foundations of Intelligent Agents, held at the Fourth Pacific Rim Internatione~l Conference on Artificial Intelligence in Cairns, Australia, in August, 1996. The aim of the workshop was to bring together researchers working on formal aspects of rational agency, novel agent architectures, and principles underlying the implementation of agent-based systems. The papers presented at the workshop were revised (in some cases quite substantially) following comments from referees and workshop participants. Further papers were solicited from a number of leading researchers in the area who also served on the programme committee of the workshop: John Bell, Yves Lesperance, JSrg M/Jller, and Munindar Singh. The papers in this volume have been grouped around three main topics: agent architectures, formal theories of rationality, and cooperation and collaboration. The papers themselves represented a broad cross-section of topics within these areas, including software agents, BDI architectures, 1 social commitment, believable agents, and Artificial Life. The workshop also included an invited presentation by Professor Rodney Brooks of Massachusetts Institute of Technology, and a panel discussion on the role of beliefs, desires, and intentions in the design of autonomous agents (not reproduced in this volume).
Agent architectures This section contains an extensive survey of control architectures for autonomous agent systems (M~ller) and papers covering issues related to agent architectures, including software agents (Cranefield and Purvis) and believable agents (Padgham and Taylor). Such issues are gathering increasing importance, particularly with the growing interest in distributed applications and animated interfaces. Also included is a paper on the use of a logic programming language (Golog) to build agent systems (Lesperance et al.). Golog represents a significant link between formal theory (for reasoning about action) and practice. Miiller's article surveys various architectures proposed for reactive agents, deliberative agents, interacting agents, hybrid approaches (i.e., combining the reactive and deliberative approaches), as well as believable agents (i.e., agents with "personality"), software agents, and softbots. This article is in the same style as (but significantly extends) part of Wooldridge and Jennings's earlier survey article. 2 Lesperance, Levesque, and Ruman describe the use of the logic programming language Golog in building a software agent system to support personal banking 1 A number of papers in this volume are based on a BDI framework, in which rational behavior is described in terms of an agent's beliefs, desires, and intentions, drawing particularly on the work of: Bratman, M.E. Intentions, Plans and Practical Reason, Harvard University Press, Cambridge, MA, 1987. Wooldridge, M. and Jennings, N.R. "Intelligent agents: theory and practice," Knowledge Engineering Review, 10, 1995.
Yl over networks. Golog is based on a situation calculus approach to reasoning about actions and their effects. Programming in Golog involves writing out the preconditions and expected effects of actions as axioms. The Golog interpreter constructs proofs from these axioms, which enable the prediction of the effects of various courses of action; these are then used to select the most appropriate action to perform. Cranefield and Purvis present a software agent approach to coordinating different software tools to perform complex tasks in a specified domain. Their architecture combines a planning agent with KQML-communicating agents that control the particular software tools. Goals (tasks requiring multiple subtasks) are sent to the planner, which plans a sequence of actions, each of which is performed by some tool agent, New tool agents are incorporated into the architecture by specifying the preconditions and effects of each action that can be performed in terms of the abstract view of the data on which the actions operate. Padgham and Taylor describe an architecture for believable agents formed by extending a BDI agent architecture with a simple model of emotions and personality. In their model, the way an agent reacts to goal successes and failures affects both the agent's choice of further actions and the depiction of that agent as an animated figure. Personality is a function of the emotions and "motivational concerns" of an agent, as well as how predisposed the agent is in reacting to those emotions.
Formal theories of rationality The papers in this section all concern the formal foundations of agents. Two papers address the formalization of the notion of commitment: in particular, the relationship of commitments to resource-boundedness (Singh) and to goal maintenance and coherence (Bell and Huang). A further two papers address issues related to formalizing "practical" as opposed to "idealized" rational agents: one paper presents a model of a "limited reasoner" (Moreno and Sales) while the other provides a model of a particular implemented system (Morley). The final paper in this section (van der Meyden) shows some interesting connections between logical specifications of knowledge-based protocols and their implementations. 3 These last three papers reflect a current trend towards research bridging the gap between theory and practice. Singh investigates the notion of commitment within a BDI framework. After reviewing the way in which such commitment is of benefit to resource-bounded agents, he discusses and formalizes an approach to precommitments. A precommitment is effectively a long-term commitment to an intention, one that is not normally reconsidered during the agent's deliberative reasoning. Adopting a precommitment has several consequences for an agent, e.g., the cost of satisfying This is related to the work of: Rosenschein, S.J. and Kaelbling, L.P. "The synthesis of digital machines with provable epistemic properties," in Halpern, J.Y. (Ed.) Theoretical Aspects of Reasoning About Knowledge: Proceedings of the 1986 Conference, Morgan Kaufmann, Los Altos, CA, 1986.
VII the corresponding commitment may be increased, or the option of adopting that commitment (in the future) may be ruled out altogether. The potential benefit to the agent is that deliberation may be less resource-intensive after the precommitment has been made. Bell and Huang also consider the concept of strength of commitment. They present a logical framework under which an agent's goals are arranged in a hierarchy depending on the strength of the agent's commitment to them. Within this framework, Bell and Huang address issues such as the mutual coherence of an agent's goals, and the revision of goals when multiple goals are not simultaneously achievable. Moreno and Sales present a model of a "limited reasoner" within an approach to agent design based on a syntactic view of possible worlds. An agent's inference method is implemented using a semantic tableau proof procedure; imperfect reasoning arises from limiting the class of rules used in proof construction. Morley uses a logic of events to provide a detailed formal model of a particular BDI agent architecture (Georgeff and Lansky's pRS4). Morley's logic of actions and events is specifically designed to handle parallel and composite events, making it particularly suited to modeling multi-agent and dynamic environments. Van der Meyden investigates the automatic generation of finite state implementations of knowledge-based programs, i.e., programs whose action-selection is specified in terms of their "knowledge" (represented using modal logic) of their environment. 5 In particular, he defines a sufficient condition under which a finite state implementation of a knowledge-based program exists, under the assumption of perfect recall--the assumption that a program has full knowledge of its previous observations--and defines a procedure (using concepts from the formal analysis of distributed systems) that constructs an efficient finite-state implementation for such programs.
C o o p e r a t i o n and collaboration The papers in this section address the extension of models of single agents to multiple cooperating or competing agents. The first paper addresses the formalization of commitment between agents in a multi-agent setting (Cavedon et al.). The remaining papers adopt an experimental methodology: one paper presents some interesting effects in a multi-agent version of the Tileworld that arise from simplified communication between agents (Clark et al.); the second presents an approach to the prisoner's dilemma in an Artificial Life environment (Ito). Cavedon, Rao and Tidhar investigate the notion of social commitment: i.e., commitment between agents, as opposed to the "internal" commitment of an agent to a goal (e.g. as in Singh's paper). Cavedon et al. describe preliminary 4 Georgeff, M.P. and Lansky, A.L. "Reactive reasoning and planning," Proceedings of the Sixth National Conference on Artificial Intelligence, 1987. 5 An extensive introduction to this approach is given in: Fagin, R., Halpern, J.Y., Moses, Y. and Vardi, M.Y. Reasoning About Knowledge, MIT Press, Cambridge, MA, 1995.
VIII
work towards formalizing Castelfranchi's notion of social commitment6 within a BDI logic. They relate the social commitments of a team to the internal commitments of the agents (though not totally reducing the former to the latter), and formally characterize a variety of social behaviors an agent may display within a team environment. Clark, Irwig, and Wobcke describe a number of experiments using simple BDI agents in the Tileworld, a simple dynamic testbed environment, investigating the "emergence" of benefits to agents arising from simple communication of an agent's intentions to other nearby agents. Their most interesting result is that under certain circumstances, the performance of individual agents actually improves as the number of agents increases, despite a consequent increase in competition for resources due to those agents. Ito adopts an Artificial Life approach to the iterated Prisoner's Dilemma game, and shows that the "dilemma" can be overcome in a setting involving disclosure of information: i.e., in which agents are required to honestly disclose their past social behavior. The experimental results show that a population of cooperative agents eventually dominates a population of more selfish agents under these conditions.
Acknowledgements The editors would like to thank the organizers of the Fourth Pacific Rim International Conference on Artificial Intelligence (PRICAI'96) for their support of the workshop, and all the workshop participants. We would particularly like to thank the programme committee members. Cavedon and Rao were partially supported by the Cooperative Research Centre for Intelligent Decision Systems.
Programme Committee John Bell Queen Mary and Westfield College, UK David Israel SRI International, USA Yves Lesperance York University, Canada JSrg Mfiller Mitsubishi Electric Digital Library Group, UK Ei-Ichi Osawa Computer Science Laboratory, Sony, Japan Munindar Singh North Carolina State University, USA Liz Sonenberg University of Melbourne, Australia
Workshop Organizers Lawrence Cavedon Royal Melbourne Institute of Technology, Australia Anand Rao Australian Artificial Intelligence Institute, Australia Wayne Wobcke University of Sydney, Australia 6 Castelfranchi, C. "Commitments: from individual intentions to groups and organizations," Proceedings of the First International Con]erence on Multi-Agent Systems, 1995.
Contents
C o n t r o l A r c h i t e c t u r e s for A u t o n o m o u s a n d I n t e r a c t i n g A g e n t s : A S u r v e y (Invited paper) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . JSrg Mfitler
1
A n E x p e r i m e n t in Using Golog t o B u i l d a P e r s o n a l B a n k i n g A s s i s t a n t (Invited paper) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Yves Lespdrance, Hector J. Levesque and Shane J. Ruman
27
A n A g e n t - B a s e d A r c h i t e c t u r e for S o f t w a r e Tool C o o r d i n a t i o n . . . . . 44 Stephen Cranefield and Martin Purvis S y s t e m for Modelling Agents Having E m o t i o n and Personality Lin Padgham and Guy Taylor
A
C o m m i t m e n t s in t h e A r c h i t e c t u r e o f a L i m i t e d , R a t i o n a l A g e n t (Invited paper) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Munindar P. Singh D y n a m i c G o a l H i e r a r c h i e s (Invited paper) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . John Bell and Zhisheng Huang
.
59
72
88
L i m i t e d Logical B e l i e f Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Antonio Moreno and Ton Sales
104
Semantics of BDI Agents and Their Environment . . . . . . . . . . . . . . . . . David Morley
119
Constructing Finite State Implementations of Knowledge-Based P r o g r a m s w i t h P e r f e c t Recall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ron van der Meyden Social a n d I n d i v i d u a l C o m m i t m e n t . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Lawrence Cavedon, Anand Rao and Gil Tidhar
135
152
E m e r g e n t P r o p e r t i e s of T e a m s o f A g e n t s in t h e T i l e w o r l d . . . . . . . . 164 Malcolm Clark, Kevin Irwig and Wayne Wobcke H o w do A u t o n o m o u s A g e n t s Solve Social D i l e m m a s ? . . . . . . . . . . . . . Akira Ito
177
A n E x p e r i m e n t in Using Golog to Build a Personal Banking Assistant* Yves Lesp@rance 1, Hector J. Levesque 2, a n d S h a n e J. R u m a n 2 Department of Computer Science, Glendon College, York University, 2275 Bayview Ave., Toronto, ON, Canada M4N 3M6 lesperan@yorku, ca 2 Department of Computer Science, University of Toronto Toronto, ON, Canada M5S 1A4 { h e c t o r , s h a n e ) ~ a i , t oront o. e d u
A b s t r a c t . Golog is a new programming language based on a theory of action in the situation calculus that can be used to develop multi-agent applications. The Golog interpreter automatically maintains an expficit model of the agent's environment on the basis of user supplied axioms about the preconditions and effects of actions and the initial state of the environment. This allows agent programs to query the state of the environment and consider the effects of various possible courses of action before deciding how to act. This paper discusses a substantial multi-agent application developed in Golog: a system to support personal banking over computer networks. We describe the overall system and provide more details on the agent that assists the user in responding to changes in his financial situation. The advantages and limitations of Golog for developing multi-agent applications are discussed and various extensions are suggested.
1
Introduction
G o l o g is a new logic p r o g r a m m i n g l a n g u a g e for d e v e l o p i n g intelligent s y s t e m s t h a t are e m b e d d e d in c o m p l e x e n v i r o n m e n t s a n d use a m o d e l of the e n v i r o n m e n t in d e c i d i n g how to act [7, 4]. It is well suited to p r o g r a m m i n g e x p e r t a s s i s t a n t s , software agents, a n d intelligent robots. T h e l a n g u a g e is based on a f o r m a l t h e o r y of a c t i o n specified in an e x t e n d e d version of the s i t u a t i o n calculus. T h e G o l o g i n t e r p r e t e r a u t o m a t i c a l l y m a i n t a i n s an explicit m o d e l of the s y s t e m ' s environm e n t on t h e basis of user s u p p l i e d a x i o m s a b o u t t h e p r e c o n d i t i o n s a n d effects of a c t i o n s a n d the i n i t i a l s t a t e of the e n v i r o n m e n t . T h i s allows p r o g r a m s to q u e r y the s t a t e of t h e e n v i r o n m e n t a n d consider the effects of various possible courses of a c t i o n before c o m m i t t i n g to a p a r t i c u l a r a l t e r n a t i v e . T h e net effect is t h a t p r o g r a m s m a y be w r i t t e n at a much higher level of a b s t r a c t i o n t h a n is u s u a l l y possible. A p r o t o t y p e i m p l e m e n t a t i o n in P r o l o g has been developed. * This research was made possible by financial support from the Information Technology Research Center, the Natural Science and Engineering Research Council, and the Institute for Robotics and Intelligent Systems.
28 In this paper, we discuss the most substantial experiment done so far in using Golog to develop an application. The application is a system that assists its users in doing their personal banking over computer networks. The system is realized as a collection of Golog agents that interact. Users can perform transactions using the system. They can also have the system monitor their financial situation for particular conditions and take action when they arise, either by notifying them or by performing transactions on their behalf. Currently, the system only works in a simulated financial environment and has limited knowledge of the domain. But with more than 2000 lines of Golog code, it is certainly more than a toy. The personal banking application made an excellent test domain for a number of reasons. A shift from branch-based to PC-based banking would have far reaching and largely positive effects for customers and banks alike. Most banks and other financial institutions are actively investigating PC-based banking and electronic commerce. However, successful implementations of home banking will undoubtedly require more flexibility and power than a simple client-monolithic server environment can provide. Software agents can fill this need. Financial systems need to be extremely flexible given the number of options available, the volatility of markets, and the diversity of the user needs. Software agents excel at this type of flexibility. Furthermore, the distributed nature of information in the financial world (i.e. banks do not share information, users do not trust outside services, etc.) requires that applications have a distributed architecture. As well, Golog's solid logical foundations and suitability for formal analysis of the behavior of agents are attractive characteristics in domains that involve financial resources. Finally, personal bankingapplications raise interesting problems which vary substantially in complexity; this experiment resulted in a system that has some interesting capabilities; it is clear that it could be extended to produce a very powerful application. In the next section, we outline the theory of action on which Golog is based. Then, we show how complex actions can be defined in the framework and explain how the resulting set of complex action expressions can be viewed as a programming language. In section 5, we present the overall structure of the personal banking system and then focus on the agent that assists the user in responding to changes in his financial situation, giving more details about its design. In the last section, we reflect on this experiment in the use of Golog: what were the advantages and limitations of Golog for this kind of multi-agent application? We also mention some extensions of Golog that are under development and address some of the limitations encountered.
2
A Theory
of Action
Golog is based on a theory of action expressed in the situation calculus [11], a predicate calculus dialect for representing dynamically changing worlds. In this framework, the world is taken to be in a certain state (or situation). T h a t state can only change as a result of an action being performed. The term do(a, s) represents the state that results from the performance of action a in state s. For
29 example, the formula ON(B], B2, do(PUTON(B1, B2), s)) could mean that B1 is on B2 in the state that results from the action PuTON(B1, B2) being done in state s. Predicates and function symbols whose value m a y change from state to state (and whose last argument is a state) are called fluents. An action is specified by first stating the conditions under which it can be performed by means of a precondition axiom using a distinguished predicate Poss. For example,
Poss(CaEATEALERT(alertMsg, maxPrio, monlD), s) =_ -~2alertMsg I, m a x P r i d ALEaW(alertM sg~, maxPrid, monID, s)
(1)
means that it is possible in state s to create an alert with respect to the monitored condition m o n l D with the alert message alertMsg and the m a x i m u m priority maxPrio, provided that there is not an alert for the condition monID already; creating an alert leads the agent to send alert messages to the user with a degree of obtrusiveness rising up to maxPrio until it gets an acknowledgement. Secondly, one specifies how the action affects the world's state with effect axioms. For example,
Poss(CaEATEALEaT(alertMsg, maxPrio, monID), s) D ALEaW(alertMsg, max Prio, monID, do(CREATEALERT(alertM sg, max Prio, rnonI D), s) ) says that if the action CREATEALERT(alertMs9, maxPrio, monID) is possible in state s, then in the resulting state an alert is in effect with respect to the monitored condition monID and the user is to be alerted using the message alertMs9 sent at a priority up to maxPrio. The above axioms are not sufficient if one wants to reason about change. It is usually necessary to add frame axioms that specify when fluents remain unchanged by actions. The frame problem [11] arises because the number of these frame axioms is of the order of the product of the number of fluents and the number of actions. Our approach incorporates a treatment of the frame problem due to Reiter [14] (who extends previous proposals by Pednault [12], Schubert [16] and Haas [3]). The basic idea behind this is to collect all effect axioms about a given fluent and assume that they specify all the ways the value of the fluent may change. A syntactic transformation can then be applied to obtain a successor state axiom for the fluent, for example:
Poss(a, s) D [ALEaT(alert M sg, max Prio, monI D, do(a, s) ) = a = CaEATEALEItT(alertMsg, rnaxPrio, monID) V ALERT(alertMsg, maxPrio, monID, s) A a 7s DELETEALERT(monlD)].
(2)
This says that an alert is in effect for monitored condition monID with message alertMsg and m a x i m u m priority maxPrio in the state that results from action a being performed in state s iff either the action a is to create an alert with these attributes, or the alert already existed in state s and the action was not that of
30 canceling the alert on the condition. This treatment avoids the proliferation of axioms, as it only requires a single successor state axiom per fluent and a single precondition axiom per action. 3 It yields an effective way of determining whether a condition holds after a sequence of primitive actions, given a specification of the initial state of the domain.
3
Complex Actions
Actions in the situation calculus are primitive and determinate. They are like primitive computer instructions (e.g., assignments). We need complex actions to be able to describe complex behaviors, for instance that of an agent. Complex actions could be treated as first class entities, but since the tests that appear in forms like i f r t h e n 61 else 62 e n d I f i n v o l v e formulas, this means that we would have to reify fluents and formulas. Moreover, it would be necessary to axiomatize the correspondence between these reified formulas and the actual situation calculus formulas. This would result in a much more complex theory. Instead we treat complex action expressions as abbreviations for expressions in the situation calculus logical language. They may thus be thought of as macros that expand into the genuine logical expressions. This is done by defining a predicate Do as in Do(~, s, s') where ~ is a complex action expression. Do(~, s, s') is intended to mean that the agent's doing action g in state s leads to a (not necessarily unique) state s I. Do is defined inductively on the structure of its first argument as follows:
- Primitive actions: Do(a,s, s ~) d=e f Poss(a, s) A s' -- do(a, s). - Test actions: Do(C?, s, s') ~ f r
A s ----s'
r denotes the situation calculus formula obtained from r by restoring situation variable s as the suppressed situation argument. - Sequences: Do([(~l ; (~2],s, s') d--e--J3s*(Do(61, s, s*) A Do(62, s*, s')).
- Nondeterministic choice of action: 0o((61 I 52), s, s') d=_cfDo(~l, s, s') V 00(62, s, s'). - Nondeterministic choice of argument: Do(~x 6(x), s, s') %f B~ Do(6(x), s, s'). a This discussion ignores the ramification and qualification problems; a treatment compatible with our approach has been proposed by Lin and Reiter [9].
31
-
N o n d e t e r m i n i s t i c iteration: 4 Do(5*, s, s') de----rVP{
v81[p(s1, s,)]
A
Vs,, 8~, s3[P(s,, 82) A Do(5, s2, 83) D P ( s l , 83)] } D P ( s , 80. There is another case to the definition that handles procedure definitions (including recursive ones) and procedure calls. The complete definition appears in
[7]. As in dynamic logic [13], conditionals and while-loops can be defined in terms of the above constructs as follows: i f r t h e n 5, else 52 e n d I f d-ef [r w h i l e r d o 3 e n d W h i l e ~ f [[r
51]1[-~r
52],
5]*;-~r
We also define an iteration construct f o r x : r that performs 5(x) for all x's such that r holds (at the beginning of the loop). 5
4
Golog
The theoretical framework developed above allows us to define a p r o g r a m m i n g language called Golog (alGOl in LOGic). A Golog program includes both a declarative component and a procedural component. The declarative component specifies the primitive actions available to the agent, when these actions are possible and what effects they have on the agent's world, as well as the initial state of the world. The p r o g r a m m e r supplies: precondition axioms, one per primitive action, - successor state axioms, one per fluent, axioms specifying what fiuents holds in the initial state So. -
The procedural part of a Golog program defines the behavior of the agent. This behavior is specified using an expression in the language of complex actions introduced in the previous section (typically involving several procedure definitions 4 We use second order logic here to define Do(b*, s, s ~) as the transitive closure of the relation Do(~, s, s ~) - - transitive closure is not first order definable. A first order version is used in the implementation of Golog, but it is insufficient for proving that an iterative program does not terminate. 5 for x: r is defined as: [proc P(Q) /* where P is a new predicate variable */ if 3y Q(y) t h e n 7r y, R [Q(y) A Vz(R(z) =_ Q(z) A z r y)?; ~f(y); P(R)] e n d I f endProc; rr Q [Vz(O(z) - r P(Q)]]
32 followed by one or more calls to these procedures). Here's a simple example of a Golog program to get an elevator to move to the ground floor of a building:
proc DOWN(n) (n = 0)? I DowNONEFLooR; DOWN(n -- 1) endProc; ~rm [ATFLOOR(m)?; DOWN(m)] In the next section, we will see a much more substantial example. Golog programs are evaluated with a theorem prover. In essence, to execute a program, the Golog interpreter attempts to prove
Axioms ~ 3sDo(program, So, s). that is, that there exists a legal execution of the program. If a (constructive) proof is obtained, a binding for the variable s = do(a,~,.., do(a2, do(a1, So))...) is extracted, and then the sequence of actions al, a2, 9 9 an is sent to the primitive action execution module. The declarative part of the Golog program is used by the interpreter in two ways. The successor state axioms and the axioms specifying the initial state are used to evaluate the conditions that appear in the program (test actions and i f / w h i l e / f o r conditions) as the program is interpreted. The action preconditions axioms are used (with the other axioms) to check whether the next primitive action is possible in the state reached so far. Golog programs are often nondeterministic and a failed precondition or test action causes the interpreter to backtrack and try a different path through the program. For example, given the program (a; P?) I (bic), the Golog interpreter might determine that a is possible in the initial state So, but upon noticing that P is false in do(a, So), backtrack and return the final state do(c, do(b, So)) after confirming that b is possible initially and that c is possible in do(b, So). Another way to look at this is that the Golog interpreter automatically maintains a model of the world state using the axioms and that the program can query this state at run time. If a program is going to use such a model, it seems that having the language maintain it automatically from declarative specifications would be much more convenient and less error prone than the user having to program such model updating from scratch. The Golog programmer can work at a much higher level of abstraction. This use of the declarative part of Golog programs is central to how the language differs from superficially similar "procedural languages". A Golog program together with the definition of Do and some foundational axioms about the situation calculus is a formal theory about the possible behaviors of an agent in a given environment. And this theory is used explicitly by the Golog interpreter. In contrast, an interpreter for an ordinary procedural language does not use its semantics explicitly. Nor do standard semantics of programming languages refer to aspects of the environment in which programs are executed [1]. Note that our approach focuses on high-level programming rather than plan synthesis at run-time. But sketchy plans are allowed; nondeterminism can be
33 used to infer the missing details. For example, the plan w h i l e 3b ONTABLE(b) d o rob aEMOVE(b) e n d W h i l e leaves it to the Golog interpreter to find a legal sequence of actions that clears the table. Before moving on, let us clarify one point about the interpretation of Golog programs. The account given earlier suggests that the interpreter identifies a final state for the program before any action gets executed. In practice, this is unnecessary. Golog programs typically contain fluents that are evaluated by sensing the agent's environment. In the current implementation, whenever the interpreter encounters a test on such a fluent, it commits to the primitive actions generated so far and executes them, and then does the sensing to evaluate the test. One can also acid directives to Golog programs to force the interpreter to commit when it gets to that point in the program. As well, whenever the interpreter commits and executes part of the program, it rolls its database forward to reflect the execution of the actions [8, 10]. We have developed a prototype Golog interpreter that is implemented in Prolog. This implementation requires that the program's precondition axioms, successor state axioms, and axioms about the initial state be expressible as Prolog clauses. Note that this is a limitation of the implementation, not the theory. For a much more complete presentation of Golog, its foundations, and its implementation, we refer the reader to [7]. Prior to the personal banking system documented here, the most substantial application developed in Golog had been a robotics one [4]. The robot's task was mail delivery in an office environment. A high-level controller for the robot was programmed in Golog and interfaced to a software package that supports path planning and local navigation. The system currently works only in simulation mode, but we are in the process of porting it to a real robot. Golog does not in itself support multiple agents or even concurrent processes; all it provides is a sequential language for specifying the behavior of a system. A straightforward way of using it to implement a multi-agent system however, is to have each agent be a Golog process (under Unix with its own copy of the interpreter), and provide these agents with message passing primitive actions that are implemented using T C P / I P or in some other way. This is what was done for the personal banking system described below. 5 5.1
The
Personal
Banking
Application
System Overview
As discussed in the introduction, the multi-agent paradigm is well suited to the decentralized nature of network banking applications. In our experimental system, different agents correspond to the different institutions involved a n d / o r to major subtasks to be handled by the system. The different types of agents in our system and the kind of interactions they have are represented in figure 1. We have:
34
Pers Banking Assistant A g t ~ I ~--__~
transfer request
confirm/reject~'---............~_.~..~..~
balance update/ transfer/ acct recommendation request
~
balance update transfer confirm/reject acct recommendation
I Bank A g e n t ~ d e p o s i t / w i t h d r a w
[Transfer [ [Facilitator Agt[
request
& Fig. 1. System components.
-
-
-
which perform transactions under the direction of their user and monitor his account balances for problem conditions; when the agent detects such a condition, it tries to alert the user or resolve the problem on his behalf; b a n k a g e n t s , which perform operations on users' accounts at the agent's bank in response to requests; they also provide information on the types of accounts available at the bank; t r a n s f e r f a c i l i t a t o r a g e n t s , which take care of funds transfer between different institutions; r o u t e r a g e n t s , which keep track of agents' actual network addresses and dispatch messages; a u t o m a t e d t e l l e r m a c h i n e agents, which provide a simple ATM-like interface to bank agents (not represented on the figure). personal banking assistant agents,
Figure 2 shows the system's graphical user interface, which is implemented by attaching C and Tcl/Tk procedures to Golog's primitive actions for the domain. Currently, the personal banking assistant agents are the most interesting part of the system and are the only agents to have any kind of sophisticated behavior. We describe their design in detail in the next section. A complete description of
35
Bank o f Moabreal
~J
P e ~ o n a l ac~a = nts
uutualCdtvidend)
Canada Trust sav~ngs mutual(e=er~lng)
Im
Im
m
Me$$A90$
-- h c c o ~ t t i at cmu~la t~ust h ~ r ~ f e r z e d 1000 dollaE# fr~l ~ r 1 6 2 ar169
zm
canada t r u s t I t t o c a n a d a ~ t r u s t J2
doll~s fr~acco~t:
I
c=a~h t==t
~,fer[ed 1ooo d o l l a = = f r ~ :~-=d=_t=~,t
m
11000
r i a m ~b~e i ~ 0 3 at r t ~ 0 t to
i a t b ~ k _ o f mont=e~1
o -- acco~tl 1 at = ~ d a t r u s t has ~ i * ~ a b l e 12S0 - - Acco~r.# 1 s t c a n ~ _ E ~ t has r above 1250
Fig. 2. System user interface.
the whole system appears in [15]. A number of assumptions and simplifications were made, chiefly regarding communication: messages exchanged between agents, users, and other system components always reach their destination in a relatively timely manner; communicating processes do not change their addresses without telling the router, and reliable connections can be made quickly and at any time. Furthermore, each agent assumes that the other agents and processes it relies on are available most of the time, and respond to queries and commands within certain time bounds (often very generous). We also ignore all issues associated with security and authentication. Undoubtedly, these assumptions would have to be lifted and overall robustness improved in order to move beyond our experimental prototype.
5.2
The Personal Banking Assistant Agents
Monitoring account balances is the primary duty of the personal banking assistant (PBA) agent. The user specifies "monitors" by giving the account and institution, the limit at which the balance going below or above triggers action, and the action to be taken. The PBA refreshes the balances of monitored accounts by sending messages to the bank agents where the accounts are held.
36 The frequency of account balance queries depends on the user-specified volatility of the account. The PBA agent checks all monitors on an account when an institution replies with the current balance for the account. Two types of actions in response to a monitor trigger are currently supported: alerting its owner of the trigger, and actually resolving the trigger via account transfers. When the PBA is to resolve the trigger by itself, its action depends on whether the trigger involved an account balance going above a m a x i m u m limit or below a minimum limit. In the latter case, i t arranges to bring all account balances up-to-date, and then chooses an account to transfer funds from, considering: rate of return, owner instructions on moving funds out of that account, minimum allowed balance in that account (user or bank restricted), and current account balance. In response to an account being above its maximum limit, the PBA first gathers information about accounts at various financial institutions. This is accomplished by asking the router agent to broadcast a message to all financial institutions containing its owner's investment profile (risk level, liquidity needs, and growth-versus-income needs) and requesting an account recommendation. The PBA then waits for account recommendations (the length of the wait depends on the overall urgency of monitors and can be controlled by the user). When the waiting period has elapsed, the agent examines all of the relevant account recommendations and chooses the best. If the user already has an account of this type at the given institution, the PBA orders a transfer into it; if not it opens an account of this type for the user and then orders the transfer. Some of the fluents that PBA agents use to model the world are:
- UsERAcCOUNT(type, bank, account, balance, lastUpdate, rateOfReturn, moveFunds,minBalance,penalty,refreshRate, s): the agent's owner has an account of type at bank in situation s, - MONITOR(type, bank, account, limit, lowerOrHigher, priority, response, monlD, s): the agent is monitoring account of type at bank in situation 8,
WAITING UPDw(bank, account, s): the agent is expecting an update on account at bank in situation s, ALERT(alertMessage, maxPriority, monID, s): the agent must alert its owner that monitor monID has been triggered, - ALERWSENW(medium,priority, timeStamp, monID, s): an alert has been sent via medium at timeStamp in situation s, ALERTACKNOWLEDGED(monlD,s): the alert on monitor monID has been acknowledged by the agent's owner in situation s, -- MESSAGE(S): the last message read by the agent in situation s.
--
-
-
Note that many of these fiuents, for example WAITINGUPDT, represent properties of the agent's mental state. This is because the agent must be able to react quickly to incoming messages from its owner or other agents. Golog does not support interrupts or any other mechanism that would allow the current process to be suspended when an event that requires immediate attention occurs
37 (although the more recent concurrent version of the language, ConGolog, does [5]). So to get reactive behavior from the agent, one must explicitly program it to monitor its communications ports, take quick action when a message arrives, and return to monitoring its ports. When a new message arrives, whatever associated actions can be performed immediately are done. The agent avoids waiting in the middle of a complex action whenever possible; instead, its mental state is altered using fluents such as WAITINGUPDT. This ensures that subsequent events are interpreted correctly, timely reaction to conditions detected occurs (e.g., sending out a new alert when the old one becomes stale), and the agent is still able to respond to new messages. A m o n g the primitive actions that PBA agents are capable of, we have:
SENDMESSAGE(method, recipient, message): send message to recipient via method, - - SWARWWAITINGUPDW(bank, account): note that the agent is expecting an update on account from bank, - STOPWAITINGUPDT(bank, account): note that the agent is no longer expecting an update on account from bank, CREATEALERT(message, max Priority, monID): note that the user must be alerted with message and keep trying until maxPriority is reached, - SENDALEaT(priority, message, medium, monID): send an alert to the user with priority via medium containing message, DELETEALERT(monID): stop attempting to alert the user that monitor m o n I D was triggered, -- READCOMMUNICATIONSPORT(channel): check the communications channel -
-
( T C P / I P , e-mail, etc.) for messages and set the fluent MESSAGE appropriately, -- UPDATEBALANCE(bank, account, balance, return, time): update the balance on the user's account at bank. PBA agents are programmed in Golog as follows. First, we provide the required axioms: a precondition axiom for each primitive action, for instance, axiom (1) from section 2 for the action CREATEALERT; a successor state axiom for each fluent, for instance, axiom (2) for ALERT; and axioms specifying the initial state of the system - - what accounts the user has, what conditions to monitor, etc. 6 Then, we specify the behavior of the agent in the complex actions language. The main procedure the agent executes is CONTROLPBA:
6 In this case, the axioms were translated into Prolog clauses by hand. We have been developing a preprocessor that does this automatically. It takes specifications in a high level notation similar to Gelfond and Lifschitz's .4 [2]. Successor state axioms are automatically generated from effects axioms.
38 p r o c CONTROLPBA while TaUE do REFRESHMONITOREDACCTS; HANDLECOMMUNICATIONS( T C P / I P ) ; GENERATEALERTS endWhile endProc Thus, the agent repeatedly does the following: first request balance updates for all monitored accounts whose balance has gotten stale, second process all new messages, and third send out new messages alerting the user of monitor triggers whenever a previous alert has not been acknowledged after an appropriate period. The procedure for requesting balance updates for monitored accounts appears below: p r o c REFRESHMONITOREDACCTS f o r type, where, account, lastUpdate, re freshRate : UsERAccOUNT(type, where, account, _, lastUpdate, _, _, _, _, re freshRate) A MONiTOR(type, where, account, _, _, _, _, _) A STALE(last Update, re freshRate) A -~ WAITINGUPDW(where, account) [ /* ask for balance */ COMPOSEREQUESTFORINFORMATION(type, request)?; SENDMESSAGE(TCP/IP, where, request); START WAITING UP DT( where, account) ]endProc Note how the fluent WAITINGUPDT is set when the agent requests an account update; this ensures that the request will only be made once. The following procedure handles the issuance of alert messages: p r o c GENEKATEALERTS for rnsg, maxPriority, monlD: ALERT(rnsg, rnaxPriority, rnonlD)[ if 3rrnediurn, last Priority, time ( ALERTSENT(medium, lastPriority, time, rnonlD) A -~ALERTACKNOWLEDGED(monlD) A STALE(lastPriority, medium, time) A lastPriority < rnaxPriority) then zr p, new M edium, last Priority [ (ALERTSENT(_,lastPriority, _, monID) A p is lastPriority + 1 A APPROPRIATEMEDIUM(p,newMediurn) A WORTHWHILE(newMediurn))?; SENDALERT(p,rnsg, newMedium, rnonlD)] endIf ]endProc It directs the agent to behave as follows: for every monitor trigger of which the user needs to be alerted, if the latest alert message sent has not been acknowledged and is now stale, and the maximum alert priority has not yet been reached, then send a new alert message at the next higher priority via an appropriate medium.
39 p r o e HANDLECOMMUNICATIONS(channel)[ READCOMMUNICATIONSPORT(channel); while -1 EMPTY(MESSAGE) do [ if TYPE(MESSAGE) ---- STARTMONITOR A SENDER(MESSAGE) ---- PERSONALINTERFACE t h e n
7r type, bank, account, limit, lh, prio, resp, m o n I D [ ARGS(MESSAGE) ---- [type, bank, account, limit, lh, prio, resp, m o n I D]? ; START M ONITOR( type, bank, account, limit, lh, prio, resp, mon I D ) ] else i f TYPE(MESSAGE) ---- ACKNOWLEDGEALERT A SENDER(MESSAGE) :
PERSONALINTERFACE t h e n
7r m o n l D [ARGS(MESSAGE) ---- [mon[D]?; ACKNOWLEDGEALERT(monID)] else if TYPE(MESSAGE) ~-~ UPDATECONFIRMATION /k ISBANK (SENDER(MESSAGE)) t h e n rr f r o m , account, amount, rate, time [ ARGS(MESSAGE) ---- [from, account, amount, rate, time]?; HANDLEUPDATECONFIRMATION(from, account , amount, rate, time)] else if TYPE(MESSAGE) ----UPDATEREJECT /k ISBANK(SENDER(MESSAGE)) t h e n LOG(UPDATEREJECT, SENDER(MESSAGE),ARGS(MESSAGE)) /* other cases handling message types SToPMONITOR, */ /* TransferConfirmation, ACCOUNTOPENED, and */ /* RECOMMENDEDACCOUNT are omitted */ endIf READ COMMUNICATIONSP ORT(channel ) ]endWhile ]endProc Fig. 3. Main message handling procedure.
The procedure in figure 3 contains the main message handling loop. It repeatedly reads a message from the port and dispatches to the appropriate action depending on the type of message and sender, for as long as the message queue is not empty. For instance, when a STARTMONITOR message is received from the personal interface, the agent starts monitoring the condition of interest; and when an ACKNOWLEDGEALERT message is received, the agent notes the acknowledgement. Some cases are left out for brevity. The most interesting case involves UPDATECOMFIR.MATION messages from banks. Here, the agent must note the account's updated balance, check whether this triggers a monitor, and take action if it does. HANDLECOMMUNICATIONS sets this in motion by dispatching to the procedure HANDL~.UPDATECONFmMATION which appears in figure 4. When a monitor trigger is detected in the above procedure, the reaction of the agent depends on whether the account balance has gone lower or higher than the limit and whether it is directed to alert the user or solve the problem itself. The SOLvELowBALANCE procedure in figure 5 is invoked when the PBA must solve an account balance going below its limit. The
40 p r o e HANDLEUPDATECONFIRMATION(bank,.account,amount, rate, time)[ UPDATEBALANCE(bank,account, amount, rate, time);
STOPWAITINGUPDT(bank,account); /* check monitors on the account */ for type, limit, lh, prio, resp, monI D: MONITOR(_,bank, account, limit, lh, prio, resp, monI D )[ if (lh = LOWER A amount < limit A ~ALERT(_, _, monlD)) t h e n if resp ----SOLVEt h e n
SOLVELowBALANCE(bank, account, amount, limit, lh, prio, monI D ) else
ALERTLowBALANCE(bank,account, amount, limit, lh, prio, monI D ) endIf else if (lh = HIGHER A amount > limit A ~ALERT(_, _, monID) t h e n if resp = SOLVE t h e n
SOLVEHIGHBALANCE(bank, account, amount, limit, lh, prio, monI D ) else ALERTHIGHBALANCE(bank,account, amount, limit, lh, prio, monI D ) endIf else if ALERT( . . . . monlD) A ((lh = LOWER A amount >_limit) V (lh = HIGHER A amount g limit)) t h e n HANDLEMONITORUNTRIP( resp, monl D ) e n d I f ]]endProc Fig. 4. Procedure treating update confirmation messages.
agent picks the account with the highest score based on the account's m i n i m u m balance and associated penalties, its rate of return, the user-specified mobility of funds in the account, whether the account's balance is sufficient, and whether a monitor exists on the account and what its limit is. If the score of the chosen account is above a certain limit that depends on the monitor's priority, a transfer request is issued, otherwise the user is alerted. It would be interesting to try to generalize this to handle cases where one must transfer funds from several accounts to solve the problem.
6
Discussion
One conclusion t h a t can be drawn from this experiment in developing the personal banking assistance system (2000 lines of Golog code), is that it is possible to build sizable applications in the language. How well did Golog work for this? Golog's mechanism for building and maintaining a world model proved to be easy to use and effective. It provides much more structure to the p r o g r a m m e r for doing this - - precondition and successor state axioms, etc. - - than ordinary p r o g r a m m i n g or scripting languages, and guarantees soundness and expressiveHess.
41
p r o c SOLVELoW BALANCE(bank, account, amount, limit, prio, m o n l D ) 7r bank F r om, account Frorn, score, amt Req [ CHOOSEBEsTACCOUNT(bankFrom, accountFrom, score, amtReq, bank, account, monID)?; if score > TRANSFERLIMIT(prio) t h e n TRANSFERFUNDS(bankFrom, accountFrom, bank, account, amtReq) else 7r msg [ COMPOSEMsG(FAILEDToSOLVE,bank, account, amt Req, mon I D , msg) ? ; CREATEALERT( msg, prio, mon l D )] endIf ]endProc Fig. 5. Procedure to resolve a low balance condition.
The current implementation of the banking assistance system did not make much use of Golog's lookahead and nondeterminism features. But this m a y be because the problem solving strategies used by its agents are relatively simple. For instance, if we wanted to deal with cases where several transactions are necessary to bring an account balance above its limit, the agent would need to search for an appropriate sequence of transactions. We are experimenting with Golog's nondeterminisin as a mechanism for doing this kind of "planning". We also used Golog's situation calculus semantics to perform correctness proofs for some of the PBA agent's procedures, for instance REFRESHMONITOREDACCTS; the proofs appear in [15]. This was relatively easy, since there was no need to move to a different formal framework and Golog programs already include much of the specifications that are required for formal analysis. From a software engineering point of view, we found Golog helpful in that it encourages a layered design where Golog is used to program the knowledgebased aspects of the solution and C or T c l / T k procedures attached to the Golog primitive actions handle low-level details. On the negative side, we found a lot of a r e a s where Golog still needs work. Some things that programmers are accustomed to be able to do easily are tricky in Golog: performing arithmetic or list processing operations, assigning a value to a variable without making it a fluent, etc. The language does not provide as much support as it should for distinctions such as fluent vs. non-fluent, fluents whose value is updated using the successor state axioms vs. sensed fluents, the effects of actions on fluents vs. their effects on unmodeled components of the state, etc. The current debugging facilities are also very limited. Some standard libraries for things like agent communication and reasoning about time would also be very useful. Perhaps the most serious limitation of Golog for agent p r o g r a m m i n g applications is t h a t it does not provide a natural way of specifying event-driven, reactive behavior. Fortunately, an extended version of the language called ConGolog which supports concurrent processes, priorities, and interrupts is under
42 development. This extended language allows event-driven behavior to be specified very naturally using interrupts. In [5], we describe how ConGolog could be used to develop a simple meeting scheduling application. Finally, there are some significant discrepancies between the Golog implementation and our theories of agency in the way knowledge, sensing, exogenous events, and the relation between planning and execution are treated. We would like to develop an account that bridges this gap. The account of planning in the presence of sensing developed in [6] is a step towards this.
References 1. Michael Dixon. Embedded Computation and the Semantics of Programs. PhD thesis, Department of Computer Science, Stanford University, Stanford, CA, 1991. Also appeared as Xerox PARC Technical Report SSL-91-1. 2. M. Gelfond and Lifschitz. Representing action and change by logic programs. Journal of Logic Programming, 17(301-327), 1993. 3. Andrew R. Haas. The case for domain-specific frame axioms. In F.M. Brown, editor, The Frame Problem in Artificial Intelligence: Proceedings of the 1987 Workshop, pages 343-348, Lawrence, KA, April 1987. Morgan Kaufmann Publishing. 4. Yves Lesp~rance, Hector J. Levesque, F. Lin, Daniel Marcu, Raymond Reiter, and Richard B. Scherl. A logical approach to high-level robot programming - a progress report. In Benjamin Knipers, editor, Control of the Physical World by Intelligent Agents, Papers from the 1994 A A A I Fall Symposium, pages 109-119, New Orleans, LA, November 1994. 5. Yves Lesp~rance, Hector J. Levesque, F. Lin, Daniel Marcu, Raymond Reiter, and Richard B. Scherl. Foundations of a logical approach to agent programming. In M. Wooldridge, J. P. Miiller, and M. Tambe, editors, Intelligent Agents Volume II Proceedings of the 1995 Workshop on Agent Theories, Architectures, and Languages (ATAL-95), Lecture Notes in Artificial Intelligence, pages 331-346. Springer-Verlag, 1996. 6. Hector J. Levesque. What is planning in the presence of sensing? In Proceedings of the Thirteenth National Conference on Artificial Intelligence, pages 1139-1146, Portland, OR, August 1996. 7. Hector J. Levesque, Raymond Reiter, Yves Lesp~rance, Fangzhen Lin, and Richard B. Scherl. GOLOG: A logic programming language for dynamic domains. To appear in the Journal of Logic Programming, special issue on Reasoning about Action and Change, 1996. 8. Fangzhen Lin and Raymond Reiter. How to progress a database (and why) I. logical foundations. In Jon Doyle, Erik Sandewall, and Pietro Torasso, editors, Principles of Knowledge Representation and Reasoning: Proceedings of the Fourth International Conference, pages 425-436, Bonn, Germany, 1994. Morgan Kaufmann Publishing. 9. Fangzhen Lin and Raymond Reiter. State constraints revisited. Journal of Logic and Computation, 4(5):655-678, 1994. 10. Fangzhen Lin and Raymond Reiter. How to progress a database Ih The STRIPS connection. In Chris S. MeUish, editor, Proceedings of the Fourteenth International Joint Conference on Artificial Intelligence, pages 2001-2007, Montreal, August 1995. Morgan Kaufmarm Publishing. -
-
43 11. John McCarthy and Patrick Hayes. Some philosophical problems from the standpoint of artificial intelfigence. In B. Meltzer and D. Michie, editors, Machine Intelligence , volume 4, pages 463-502. Edinburgh University Press, Edinburgh, UK, 1979. 12. E. P. D. Pednault. ADL: Exploring the middle ground between STRIPS and the situation calculus. In R.J. Brachman, H.J. Levesque, and R. Reiter, editors, Proceedin9s of the First International Conference on Principles of Knowledge Representation and Reasoning, pages 324-332, Toronto, ON, May 1989. Morgan Kaufmann Publishing. 13. V.R. Pratt. Semantical considerations on Floyd-Hoare logic. In Proc. of the 17th IEEE Symp. on Foundations of Computer Science, pages 109-121, 1976. 14. Raymond Reiter. The frame problem in the situation calculus: A simple solution (sometimes) and a completeness result for goal regression. In Vladimir Lifschitz, editor, Artificial Intelligence and Mathematical Theory of Computation: Papers in Honor of John McCarthy, pages 359-380. Academic Press, San Diego, CA, 1991. 15. Shane J. Ruman. GOLOG as an agent-programming language: Experiments in developing banking applications. Master's thesis, Department of Computer Science, University of Toronto, Toronto, ON, 1996. 16. L.K. Schubert. Monotonic solution to the frame problem in the situation calculus: An efficient method for worlds with fully specified actions. In H.E. Kyberg, R.P. Loui, and G.N. Carlson, editors, Knowledge Representation and Defeasible Reasoning, pages 23-67. Kluwer Academic Press, Boston, MA, 1990.
A System for Modelling Agents Having Emotion and Personality
Lin Padgham, Guy Taylor Department of Computer Science RMIT University, Melbourne, Australia email:
[email protected],
[email protected] 1 Introduction There is currently a widespread interest in agent-oriented systems, partly because of the ability of such systems to model and successfully capture complex functionality in a robust and flexible way, suitable for difficult applications. There has also been significant interest in going beyond the rational model of agents, such as that evidenced in the literature modelling agents as systems of beliefs, desires and intentions (BDI models, e.g. [IGR92, GI89]), to include aspects such as emotions and personality (e.g. [Bat94, BLR92b, Bat93, BLR92a, Slo81]). Motivations for modelling "broader" agents than simply the rational logical agents of BDI architectures are several. Some consider it necessary to incorporate human aspects such as personality and emotion, in order to make agents more engaging and believable, so that they can better play a role in various interactive systems involving simulation. Entertainment is one obvious application area for such simulation systems, but another is education and training. A simulator that was able to realistically model emotional reactions of people could, for instance, be used in training programs for staff who need to be trained to deal with the public. Some people also believe that emotions play a functional role in the behaviour of humans and animals, particularly behaviour as part of complex social systems (e.g. [Tod82]). Certainly the introduction of emotions, and their interaction with goals, at various levels, increases the complexity of the agents and social systems that can be modelled. Our belief is that a successful modelling of emotion will enable us to come closer to the goal of building software agents which approach humans in their flexibility and ability to be adaptable and survive in complex, changing and unpredictable environments. However significant work is needed before we can expect to understand the functional role of emotion sufficiently to successfully model it in our software agents. In this paper we explore some of the ways that we believe emotions and personality interact with goal oriented behaviour, and we describe some of the simplifications we have made in order to build an initial interactive environment
60 for experimentation with animated agents simulating personality and emotions as well as incorporating rational goal directed behaviour.
2
Interactions
of emotions,
behaviour,
goals
In considering the behaviour of human agents, it is evident that emotions affect behaviour in a number of ways. One of the most straightforward ways, and one modelled in systems such as the woggles of oz-world [Bat94] and the agents of the virtual theatre project [HR95], is that emotion modifies the physical behaviour of agents. A happy agent moves faster, and more bouncily, while a sad agent is slower and flatter in its movements. In addition, emotions can clearly affect an agent's goals, hence affecting their actions. An agent that is very scared is likely to drop a goal to explore its surroundings in favour of a goal to move to a secure position. Emotional effects on goals can be via reordering, or re-prioritising, existing goals, or by introducing completely new goals. Some goals may be introduced simply to manage extreme emotional states. An agent which is feeling intense anger may instantiate a goal to harm the subject of its anger, in order to alleviate the emotional pressure. In addition to emotions affecting existence and prioritisation of goals, goals, and their success or failure, can affect emotional states. An agent which experiences a goal failure may feel unhappy, while one experiencing goal success may feel glad. Dyer [Dye87] develops a comprehensive lexicon of emotional states, based on goal success and failure. For example an agent which expects its goal to succeed will feel hopeful, an agent whose goal is achieved by the action of another agent will feel grateful, and an agent who expects its goal to be thwarted will feel apprehensive. Figure 1 shows examples of some emotions, indexed by contributing cause. Frijda and Swagerman [FS87] postulate emotions as processes which safeguard long-term persistent goals or concerns of the agents, such as survival, a desire for stimulation, or a wish to avoid cold and damp. These long term concerns differ from the usual goals of rational agent systems in that they are not things which the agent acts to achieve. Rather they are states which are continually important, and if threatened, cause sub-goals to be instantiated. According to Frijda the process which instantiates appropriate sub-goals is emotion. The earlier work of Toda [Tod82] also postulates emotions as processes which affect the rational system of the agent, and which are based on basic urges. He groups these urges into emergency urges, biological urges, cognitive urges and social urges. These are similar in principle to the long-term concerns of Frijda and Swagerman. When activated, they focus rational activity and determine the extent to which various competing issues are addressed. Emotions are seen as varying in intensity where the intensity level is an important factor in determining the effect on the rational processing of the agent.
61
emotion(x)
status to goal-situation by mode
happy
pos
G(x) achieved
sad
neg
G(x) thwarted
grateful
pos
y G(x) achieved y
hopeful
pos
G(x) achieved
expect
disappointed
neg
G(x) thwarted
expect achieved
guilty
neg
y G(y)thwarted x
Fig. 1. Some emotions and their causes
Emotions can also be seen as processes by which agents manipulate each other in social situations, to enable achievement of their goals. By making my child feel grateful (by acting to help them achieve their goal) I increase the chance that the child will act to achieve my goals. In the emotional model which we are developing it is necessary to capture in some way both the causes of emotion and the effects of emotion. At the most abstract level, we see emotions as being caused by a combination of the state of the world (includiug self and other agents) and the values of the agent. The emotional reaction caused in an agent by goal success or failure (an event in the world), will depend to some extent on the importance of that goal to the agent. An agent m a y have a number of motivational concerns, which reflect what is i m p o r t a n t to that agent. Threats and opportunities associated with these concerns will then generate emotions, as will successs and failure of goals associated with these concerns. Emotions can affect behaviour directly, or indirectly, via the rational system. Direct effects on behaviour include such things as affecting facial expressions, stance and movement, or causing a relatively instantaneous action, as in the case of flight caused by extreme fear. Effects via the rational system include such things as re-prioritising goals, adding goals and deleting goals. An agent experiencing gratitude might delete (or prioritise lower) those goals which conflict with the goals of the agent to whom it is grateful. Or it may instantiate new goals in order to achieve directly the goals of the agent to whom gratitude is felt. Clearly there are complex interactions between goals and emotions, which involve both effect of goals on emotions, and emotions on goals. In order to explore
62 and increase our understanding of the dynamics of emotion, personality and goal directed behaviour we have implemented an interactive system for experimentation with various agent groupings.
3
Simplified
emotional
model
Our goal is to eventually develop an implemented version of a complex model of emotion and personality, incorporating all of the aspects discussed above. However in order to make a start, and to study via an implemented system, the interaction between the emotional subsystem, the cognitive subsystem, and the behavioural subsystem, we have initially developed a rather simple model of emotion. In this model emotions are seen as existing in pairs of opposites 1 such as pride and shame, happiness and sadness, love and hate. They are represented as a guage, with a neutral point about which the emotion fluctuates in a positive or negative direction. Each agent has a specified threshold for the positive and the negative emotion. When this threshold is crossed, the agent is considered to have that emotion. The fluctuation of the emotional guage is caused either by events which happen, or by the passage of time. The latter is relevant only when no events are actively influencing the emotion under consideration. This allows an activated emotional state to decay over time, returning eventually to the neutral state, if no events maintain the active state of the emotion. The events having an influence on emotional state can be of several different types. T h e first are events which universally and directly affect the emotional state. In this case the event results directly in a modification of the emotional guage of the agent experiencing the event. Probably in a richer model there would be no need for such events, but at the current stage we have included t h e m to allow the emotional effect of events which are not included in the other mechanisms. The second type of events are goal success and goal failure. Currently these events affect only the emotions of happiness, sadness and pride. Goal success (failure) of an agent affects the happiness (sadness) emotion of t h a t agent. Success of the goal of another agent that the agent cares about, results in increase of the pride emotion. The third, and perhaps most important source of events which affect an agent's emotions are events which recognise threats or opportunities with respect to the motivational concerns of a n agent. Motivational concerns are associated with states which are recognised as threats (or opportunities) with respect to those concerns. The motivational concerns are also associated with emotional reactions to be triggered in an agent when the event indicating the relevant state occurs. 1 Some emotions may not have an opposite, in which case it is left undefined.
63 A motivational concern of stimulation may have a threat associated with the agent being idle. When this state occurs it triggers an event which activates the stimulation concerns and results in an increase in the boredom emotion, which, if the idle state continues will eventually cause boredom to cross the threshold. This will then in its turn cause a bored event, which can trigger a goal to reduce the boredom. We can represent the set of emotional guages as E , and a particular emotional guage as e, where vo(n) represents the neutral value on the guage, e + represents the name of the positive emotion associated with this guage, and e - the name of the corresponding negative emotion. The value of the emotional guage e for a particular agent at any time point is then determined by the previous value of that guage, incremented (or decremented) according to what events the agent is aware of which affect the emotion, or the decay rate 2 of the emotion for that agent. We let the decay rate be a function over the emotions for each agent, written DA(e). Thus we can say that, with respect to a particular agent, A:
VA,+~(e) = VA, (e) + F({events}tt +~, DA(e, (~)) The effect of an emotion on the behavioural and cognitive subsystems of the agent comes into play when an emotion crosses the threshold for that agent. This then results in the belief that the agent experiences the emotion being asserted (or retracted) in the cognitive subsystem. The behavioural subsystem may also be notified. This in its turn can lead to goals being asserted, deleted, or reprioritised, in the cognitive subsystem, and to behaviour being modified directly in the behavioural susbsystem. For example, if the belief that the emotion sadness is being experienced is asserted, it results in modifying the agent's stance and movement in the behavioural system, to reflect sadness. An assertion of boredom 3 results in instantiating a goal to relieve the boredom. Emotional thresholds are represented individually for each agent and emotion. We let P and N be functions giving the positive and negative thresholds for all emotions for a given agent. Thus PA(e) represents the threshold at which emotion e + is asserted, and NA(e) represents the threshold at which e - is asserted, for agent A. Thus we can say that for a given agent, A: (VAt (e) ~__PA(e)) A -,believeA (e +) ~ assert believeA (e +) which results in behavioural and cognitive effects. and VA, (e) 0) ~ B(Uti(p) = c)]
Constraints Putting together the above, we require constraint D1, D5, D6, and D7. The above constraints handle cases of irrational over-commitment. However, additional primitives, e.g., those of [Norman & Long, 1996], are needed to cause agents to deliberate when the reasons for an intention are invalidated. We lack the space to formalize these here. Means and Ends Rational agents must relate their means to their ends. Intentions correspond to ends, and plans to means. The plans can lead to additional intentions, which apply within the scope of the original intention. We discuss this issue briefly to outline some of the considerations a formalization of commitments would need to accommodate.
83
Example 12. Continuing with Example 7 of section 2.4, let us assume that Joe has an end of being famous, and his means for that end is to go to Mars. ] We propose the following maxim: a rational agent ought to be more committed to his (ultimate) ends than to any specific means. This m a x i m is reasonable, because there are usually more than one means to an end, after all. We define Best(p) as the best plan for achieving p. (We have not formalized plans, but one can take them below as partial orders of actions.) For a plan ~, condition p, and scalar c, we define Yield(~,p, s) to mean that the plan ~ yields a subsidiary c o m m i t m e n t of entrenchment s toward p. Then the above m a x i m translates into the following formal constraint.
D8. A[(DeliB(x) A C(p, c) A c > 0) --* (Yield(Best(p), q, 8)
_< c )
The above constraint states that the tota] of tile c o m m i t m e n t s to the subsidiary intentions are bounded by the c o m m i t m e n t to the original intention. Greater sophistication is required before the subtleties of the interplay between rationality and intentions can be fully captured. 5.2
Deliberative Entrenchment
Now we turn to a formalization of the notion of p r e c o m m i t m e n t in the above framework. We now redefine the c o m m i t m e n t s assigned by an agent to an intention to take into account the p r e c o m m i t m e n t s he might have. The following constraints shows how precommitments can override current deliberations. P r e c o m m i t m e n t b y D e l i b e r a t i v e I n e r t i a By deliberative inertia, we mean that the agent, on adopting a precommitment, simply does not reconsider the corresponding c o m m i t m e n t as often as he might have otherwise.
Example 13. An agent m a y continue to have ice-cream out of habit, even though he would not do so were he to examine his diet carefully. | By conative entrenchment, an agent's c o m m i t m e n t to an intention would peter out in due course. Deliberative inertia makes it last longer. Thus when an agent is precommitted to achieving a certain condition, he would possibly allocate more resources to it than he would have otherwise.
Lower Bound Hysteresis. An agent might precommit by setting the m i n i m u m resources that would be assigned to the given commitment.
D9. A[(Delib(x) A B(Uti(p) -- e) A PreC(p, d)) --* C(p, max(c, d))] Upper Bound Hysteresis. An agent might precommit by setting the m a x i m u m resources that would be assigned to the given c o m m i t m e n t .
D10. A[(Delib(x) A B(Uti(p) -- c) A PreC(p, d)) -~ C(p, rain(e, d))]
84
Additive Bias. An agent might precommit by adding (positive or negative) resources to a commitment when the conative entrenchment is computed. D l l . A[(Delib(x) A B(Uti(p) = c) A PreC(p, d)) --* C(p, c + d)] P r e c o m m i t m e n t b y E l i m i n a t i o n o f O p t i o n s Instead of relying on deliberative inertia, an agent may precommit by simply eliminating certain options, the availability of which might at a later time "tempt" him to consider giving up a commitment too early. An agent may thus "burn his bridges" so to speak, and lose the option he would otherwise have of crossing them. The idea is to take some drastic step that affects the cost of the actions or the utility of the intended conditions, and then to deliberate.
Cost Adjustment. An action is performed that leads the world along a scenario where the cost of the best plan to satisfy a commitment is higher than before. Interestingly, one cannot reduce the cost of the best plan through this technique, because (by Bellman's Principle) the best plan would automatically include any optimizations that might be available and known to the agent. Example 1~. In the refrigerator example of section 3.2, the agent exhibits his precommitment, not by decreasing the resources allocated to the relevant intention, but by making the actions available for achieving it more expensive: he would now need to pry open the refrigerator door, or first locate the key. | DI2. A[(PreC(p, d) A B(Ecost(Best(p)) = c)) -~ ( V a : (a)true A B((a)Ecost(Best(p)) = c 4- d) A (alDelib(x)) ]
Utility Adjustment. Conversely, an agent may perform actions that would later make certain intentions more attractive, i.e., increase their utility to him then. Example 15. Someone may leave his wallet in his office to make sure he returns later to pick it up. Thus he would have to go to his office for his wallet, even if he would not have gone otherwise. | This is formalized below. An agent with precommitment d for p performs an action after which his utility for p increases by d. D13. A[(PreC(p, d) A B(Uti(p) = c)) --+ (V a : (a>true A B((a>Uti(p) = c-4- d) A Delib(x))] 5.3
Conative Policies and Deliberation
Generalizing our technical development, we can see that a natural extension would be to declaratively express conative policies describing not only how the agent acts and deliberates, but also how he controls his deliberations. These policies could accommodate not only the general rationality requirements studied
85 above, but also be made conditional upon properties of the domain, and the qualities of the agent, e.g., the qualities studied by [Kinny & Georgeff, 1991]. One can impose constraints on the conative policies of agents, e.g., to prevent them from adopting intentions that they believe are mutually inconsistent or inconsistent with their beliefs. The conative policies embodied in an agent would not change due to ordinary deliberations. Deliberations of a deeper nature would needed to create and modify them. These deliberations are a kind of "soul searching" that an agent may go through in deciding upon some value system. Intuitively, conative policies are commitments about commitments. Although, one can formally define arbitrarily nested commitments, we suspect that a small number of nestings would suffice in cases of practice, and in fact, greater nestings would probably prove counter-productive. 6
Conclusions
and
Future
Work
We argued that commitments as well as the allied concepts of precommitments and conative policies are crucial for the design of intelligent, autonomous, but limited, agents. However, commitments must be formalized in a manner that is compatible with rationality, and which emphasizes the fact that real agents are limited. It is with this understanding that commitments are an effective component of a descriptive theory of rationality in limited agents. It is with the same understanding that they can prove useful in prescriptive theories as well. There has been some good work in building experimental systems that capture the intentions, commitments, plans, and coordination strategies of agents, and in developing testbeds that can be declaratively customized to different situations, e.g., [Kinny & Georgeff, 1991; Sen & Durfee, 1994; Pollack et al., 1994; Singh el al., 1993]. However, a lot more good work is need to handle the kinds of examples and constraints we described above. Eventually, this work would need the expressiveness to handle the more general conative policies. Future work includes formally expressing a wide range of conative policies that capture various rationality postulates as well as characterize interactions among agents. Real-time reasoning aspects were ignored above, but are important in several applications. Similarly, considerations on deliberating about and scheduling across multiple intentions are also important. Overall, we believe the study of commitments in the architecture of limited, rational agents will prove highly fruitful. References [Brand, 1984] Brand, Myles; 1984. Intending and Acting. MIT Press, Cambridge, MA. [Bratman, 1987] Bratman, Michael E.; 1987. Intention, Plans, and Practical Reason. Harvard University Press, Cambridge, MA. [Brooks, 1991] Brooks, Rodney; 1991. Intelligence without reason. In Proceedings of the International Joint Conference on Artificial Intelligence (IJCAI). Computers and Thought Award Lecture.
86
[Castelfranchi, 1995] Castelfranchi, Cristiano; 1995. Commitments: From individual intentions to groups and organizations. In Proceedings of the International Conference on Multiagent Systems. [Cohen & Levesque, 1990] Cohen, Philip R. and Levesque, Hector J.; 1990. Intention is choice with commitment. Artificial Intelligence 42:213-261. [Emerson, 1990] Emerson, E. A.; 1990. Temporal and modal logic. In Leeuwen, J.van, editor, Handbook of Theoretical Computer Science, volume B. North-Holland Publishing Company, Amsterdam, The Netherlands. [Harman, 1986] Harman, Gilbert; 1986. Change in View. MIT Press, Cambridge, MA. [Kinny &: Georgeff, 1991] Kinny, David N. and Georgeff, Michael P.; 1991. Commitment and effectiveness of situated agents. In IJCAL [McCarthy, 1979] McCarthy, 3ohn; 1979. Ascribing mental qualities to machines. In Ringle, Martin, editor, Philosophical Perspectives in Artificial Intelligence. Harvester Press. Page nos. from a revised version, issued as a report in 1987. [Newell, 1982] Newell, Allen; 1982. The knowledge level. Artificial Intelligence 18(1):87-127. [Norman & Long, 1996] Norman, Timothy J. and Long, Derek; 1996. Alarms: An implementation of motivated agency. In Intelligent Agents Ih Agent Theories, Architectures, and Languages. 219-234. [Pollack et al., 1994] Pollack, Martha E.; Joslin, David; Nunes, Arthur; Ur, Sigalit; and Ephrati, Eithan; 1994. Experimental investigation of an agent commitment strategy. Technical Report 94-13, Department of Computer Science, University of Pittsburgh, Pittsburgh. [Rao ~z Georgeff, 1991] Rao, Anand S. and Georgeff, Michael P.; 1991. Modeling rational agents within a BDI-architecture. In Proceedings of the International Conference on Principles of Knowledge Representation and Reasoning. 473-484. [Sen &: Durfee, 1994] Sen, Sandip and Durfee, Edmund H.; 1994. The role of commitment in cooperative negotiation. International Journal of Intelligent and Cooperative Information Systems 3(1):67-81. [Simon, 1981] Simon, Herbert; 1981. The Sciences of the Artificial. MIT Press, Cambridge, MA. [Singh & Asher, 1993] Singh, Munindar P. and Asher, Nicholas M.; 1993. A logic of intentions and beliefs. Journal of Philosophical Logic 22:513-544. [Singh et al., 1993] Singh, Munindar P.; Huhns, Michael N.; and Stephens, Larry M.; 1993. Declarative representations for multiagent systems. IEEE Transactions on Knowledge and Data Engineering 5(5):721-739. [Singh, 1992] Singh, Munindar P.; 1992. A critical examination of the Cohen-Levesque theory of intentions. In Proceedings of the lOth European Conference on Artificial Intelligence. [Singh, 1994] Singh, Munindar P.; 1994. Multiagent Systems: A Theoretical Framework for Intentions, Know-How, and Communications. Springer Verlag, Heidelberg, Germany. [Singh, 1996] Singh, Munindar P.; 1996. A conceptual analysis of commitments in multiagent systems. Technical Report TR-96-09, Department of Computer Science, North Carolina State University, Raleigh, NC. Available at http://www4.ncsu, edu/eos/info/dblab/www/mpsingh/papers/mas/ commit, ps.
87
A
Formal Semantics
The semantics of C is given relative to intensional models. The formal model is as described informally in section 4. Let M = (T, 2, and we must have P~-I < 2. Since the actual position differs by no more than 1 from the reading, it follows that Pk-ll < 3. Hence p~ _< 3, because the robot can move at most one position at each step. Since p~ > 2 we must also have p~ > 1. This
143
proves that p~ is in the goal region {1, 2, 3}. By definition of P1 and 7, we have p~ = p~ for all l _> k, so p ~ is in the goal region. This proves M, r ' ~ g. [] In the framework of [FHMV95a] knowledge-based programs, even a t e m p o r a l ones, can have no, exactly one, or m a n y implementations, which m a y be behaviourally different. Our notion of implementation is more liberal, so this is also the case for our definitions. However, the notion of implementation is better behaved when we consider implementations with respect to the synchronous perfect recall view. P r o p o s i t i o n 1. For every environment E and atemporal joint knowledge-based program P g , implementations of P g in E with respect to the view {.}P~ always exist. Moreover, all such implementations are behaviourally equivalent. If "/~ is the unique set of all traces generated by any implementation of P g in E with respect to {.}pr, we refer to M(7~, {-}Pr) as the system generated by P g in E with respect to {.}P~. Although our formulation is slightly different, Proposition 1 can be viewed as a special case of Theorem 7.2.4 of [FHMV95b]. Intuitively, the set of traces of length one generated by any implementation must be the set of initial states of the environment. Because of synchrony, this set of states fixes the interpretation of formulae in L;c , so may be used to uniquely determine the actions enabled at the traces of length one in any implementation. These actions in turn uniquely determine the set of traces of length two in any implementation. By the synchrony assumption we again find that the truth values of formulae i n / : c hence the set of actions enabled at a trace of length two, is uniquely determined. This again uniquely determines the traces of length three, and so on. We formalize this intuition in the next section. 5
A Canonical
Implementation
It is convenient for the purpose of later constructions to describe the implementation promised by Proposition 1 using a new type of semantic structure. Note that the temporal slices of the Kripke structures generated by a knowledge-based program have two aspects: they are themselves Kripke structures, but each world (trace) also represents in its final state information about the possible successor traces. The following notion formalizes this. Define a progression structure for an environment E with states S~ and valuation V~ to be a pair N = (M,c~> consisting of an $5,~ Kripke structure M = (W, IC1,..., IOn, V) together with a state mapping c~ : W --+ S~, satisfying V(w, p) = V~(or(w), p) for all worlds w E W and propositions p. If w is a world of N then we will write N, w ~ ~, just when M, W ~ ~. A class of progression structures that will be central to the development below is obtained from the set of traces 7~ generated by a knowledge-based p r o g r a m P g in environment E with respect to {.}pr. Let T~,~ be the set of traces in 7~ of length n. Define Mn to be the structure M(Tt,, {-}Pr), and define the m a p p i n g c~
144
from n n to the states of E by c~(r) = fin(r). Then the structure N , = (M,~, (r) is a progression structure. In particular, note that the structure N1 is independent of the program Pg: its worlds are precisely the initial states of the environment. Progression structures carry sufficient information to represent the execution of a knowledge-based program with respect to the perfect recall view. First, note that the definition of P g ( M , r) above assumes that M is a system, in which the worlds r are traces. Observe that we may extend this definition to the worlds w of arbitrary progression structures N = (M, or). We define P g ( g , w) to be the set of joint actions P~((r(w)) • P g l ( M , w) x . . . x P g , ( M , w ) . Using this observation, we now define an operator on progression structures that captures the execution of a joint knowledge-based program P g in an environment E. If N -- (M, or) is a progression structure for E, then we define the progression structure N * P g = ( i ~, ~'), where i ' = ( W ' , / E l , . . . ,/C', V~), as follows. First, we let W' be the set of pairs (w, s) where w is a world in W and s E Se is a state of E such that there exists a joint action a E Pg(N, w) such that s = v(a)(cr(w)). We define (w, s)lC~(u,t) if and only if wlCiu and Oi(s) = Oi(t). The valuation V' is given by W((w, s),p) = V~(s,p) for all propositions p. Finally the state mapping (r is defined by or(w, s) = s. It is clear that the relations /C~ are equivalence relations, so this is a progression structure.
Example 4. We describe the structure N1 * P g for Example 1. The progression structure N1 for the environment of Example 1 consists of the Kripke structure M with set of worlds W = {(0, 0), (0, 1)}, accessibility relation/(:1 the smallest reflexive relation on this set, valuation V the same as the valuation on the states of E and state mapping ~ the identity function. For both worlds w of this structure we find that M , w ~ -~Klg, hence P g l ( M , w ) -- {hoop}. Thus, N1 * P g has 10 states, which are grouped into equivalence classes by the accessibility relation/C~ as follows: { ((0, 0), (0, 0)),
((0, 0), (1,0)) }
{ ((0, 1), (0, 0)),
((0, 1), (1, 0)) }
{ ((0, 0), (0, 1)),
((0, 0), (1, 1)) }
{ ((0, 1), (0, 1)),
((0, 1), (1, 1)) }
{ }
{ ((0,1),(1,2)) }
The state mapping is the function projecting pairs (s, t) to the state t. The operator 9 can be used to give a description of the system generated by a knowledge-based program as a union of a sequence of incrementally constructed progression structures. Say two progression structures ( i , cr) and ( i ' , cr~) are isomorphic if there exists an isomorphism g of their respective Kripke structures which preserves the state mapping, i.e. for which cr'(n(W)) = or(w) for all worlds w of M. L e m m a 2. For all n, the progression structure Nn+l is isomorphic to the product Nn * P g by means of the mapping ~ defined by t~(rs) -= (r,s), where rs
145
is a trace with final state s and initial portion r. Thus, the system M generated by P g in E with respect to {.}pr is isomorphic to the I(ripke structure of N1 U (N1 * P g ) U (N1 * P g * Pg) U .... This result enables us to give an explicit description of an implementation of P g . Let P be the joint protocol defined as follows. For agent i, the states Si of the protocol are either the initial state qi or a pair (N, X) consisting of a progression structure N together with an equivalence class X of the relation Ki of this structure. The update operation #i is given by
,,(q, o) =
Io [ O (s) = o))
when q is the initial state q~. If q is the state (N, X) we define #~(q, o) = (N * P g , X/), where X ~ is the set of pairs (w,s) where w E X and s E Se is a state of the environment such that Oi(s) = o and for which there exists a joint action a E P g ( N , w) with s = r(a)(c~(w)). Finally the action function c~i is defined by c~i(q, o) = P g i ( g , w), where #i(q, o) = (N, X ) and w is any world in X. L e m m a 3 . The protocol P is an implementation of P g in E with respect to {.}P~. Moreover, for all traces rs, if pi(Pi(rs),Oi(s)) = ( N , X ) then N is isomorphic to Nlrsl. We will refer to the protocol P as the canonical implementation of P g with respect to {.}pr. Since the number of traces of length n is potentially exponential in n, this implementation could be very inefficient. However, the definition of implementation allows considerable leeway in the choice of protocol states, so this does not preclude the existence of more efficient, or even finite state, implementations. Unfortunately, it is undecidable to determine whether a finite state implementation exists [Mey96a]. Nevertheless, we will will show that it is possible to apply to the protocol P an optimization that sometimes results in its running in constant space. Before doing so, we first recall a condition sufficient for the existence of a finite state implementation, which enables us to characterize the circumstances in which this optimization results in a finite state implementation. 6
A Sufficient
Condition
for Finite
State
Implementations
In this section we recall from [Mey96a] a sufficient condition for the existence of a finite state implementation of a knowledge-based program. Define a simulation from an Shn structure M = (W,/C1,...,1Cn, V) to an $5~ structure M ' = (W',/C~,...,/C~, V') to be a function tr : W --+ W ' such that 1. for all worlds w E W and propositions p, V ( w , p ) = V'(t~(w),p), 2. for all w, w' E W and agents i, if wl~iw' then xo(w)IC~n(w'), 3. for all w E W, w ~ E W ~ and agents i, if x~(w)tS~w~ then there exists v E W with wlCiv and n(v) = w'.
146
This is a straightforward generalization of a standard notion from modal logic (called p-morphisms in [Che80]) to $ 5 . structures. An easy induction on the construction of a formula ~ E tl c shows that if ~ is a simulation from M to M ~ then M, w ~ ~ iff M', n(w) ~ ~,. Example 5. Consider the substructure N of the progression structure N1 * P g of Example 4 consisting just of the following 5 states and accessibility relation ~ with the equivalence classes indicated:
{ ((0,0),(0,0)>,
((0,0),(1,0)> }
{ , ) { ((0,0), (1,2)> } Define the mapping ~ from N1 * P g to N by n((s, t)) = ((0, 0), t>. Then n is a simulation from N1 * P g onto N. T h e o r e m 4. [Mey96a] Let P g be an atemporal knowledge-based program. Let M be the system generated by the joint knowledge-based program P g with respect to the view {.}pr. If there exists a simulation from M to a finite Shn structure M ~ then there exists a finite state implementation of P g in E with respect to {.}pr We applied this result in [Mey96a] to show that finite state implementations are guaranteed to exist for all knowledge-based programs in environments in which communication is by synchronous broadcast to all agents. This class of environments includes all single-agent environments, so the result applies to Example 1. We note that the existence of a simulation to a finite structure is not necessary for the existence of a finite state implementation. Unfortunately, Theorem 4 does not in general provide an effective approach to the identification of finite state implementations. T h e o r e m 5. [Mey96a] Given a finite environment E and a knowledge-based program P g , the following problems are undecidable (i) to determine if there exists a finite state implementation of P g in E with respect to {.}pr. (ii) to determine if there exists a simulation from the system generated by P g in E with respect to {.}Pr to a finite $5,~ structure.
This result is not as negative as it may seem, however. It follows from results in [Mey94] that it is decidable to determine whether a given finite state protocol implements a given knowledge-based program with respect to {.}P~. Thus, it is possible to find a finite state implementation, provided one exists, simply by testing each finite state protocol. But this is hardly a computationally efficient procedure. In the next section we show that a much more tractable approach to the construction of a finite state implementation is possible. This approach does not always work, but can be shown to terminate just in case the condition of Theorem 4 applies.
147
7
An Optimization
As noted, the canonical implementation is inefficient. In general, it does not appear to be possible to improve upon the idea of maintaining the temporal slices of the system generated by a knowledge based program in its implementations. Examples such as that in [Mey96b] indicate that traces widely separated in N,~ from a given trace r may have an impact on the actions enabled at later extensions of r, so that, potentially, a representation of the whole progression structure N,~ needs to be maintained in the agents' protocol states. Nevertheless, as we now show, it may be possible to optimize the canonical implementation, on the fly, in such a way that under the appropriate conditions it requires only constant space. The key observation enabling the optimization is that in general, Kripke structures may encode information in highly redundant ways, duplicating the same information across a number of worlds. We now introduce some modifications of known concepts that help to factor out such redundancies from progression structures. A bisimulation between progression structures N = (M, @ and N ' = ( M ' , c~'}, where M = (W,/(;1,...,/(:~, V) and M = ( W ' , / C ~ , . . . , K:~, V'), is a binary relation R C W x W ' such that 1. domain(R) = W and codomain(R) = W', 2. for all i = 1 . . . n, whenever u R u ~ and uICiv there exists v~ E W ~ such that vRv' and u'lC~v', 3. for all i = 1 . . . n , whenever u R u ~ and u~lC~v~ there exists v E W such that v R v ~ and uK 1 take Nk to be the progression structure whose worlds are the traces of M of length k. We now define an implementation P that is similar to the canonical implementation, but which performs a reduction of the progression structure at each 3 Similar results have been previously established for bisimulation relations on labeled transition systems [BR83, HM85].
149
step. As in the canonical implementation, for agent i, the states Si of the protocol are either the initial state qi or a pair (N, X) consisting of a progression structure N together with an equivalence class X of the relation/Ci of this structure. T h e difference lies in the particular progression structures used. In the canonical implementation, the update operation #i is defined by # i ( ( g , X), o) = ( g * P g , X'}, where X ' is some set of worlds. Instead of N * P g , the optimized implementation will use the reduced structure reduce(N, P g ) . More precisely, in the case q = qi we define pi(q, o) to be
(reduce(N1), t~({s E Ie ] Oi(s) = o})) where ~ is the canonical m a p from N1 to reduce(N1). When q is of the form (N, X), let ~ be the canonical m a p from N 9 P g to r e d u c e ( N , P g ) . We define pi(q, o) = (reduce(N, P g ) , X'), where X ' is the set of ~(w, s) for all pairs (w, s) where w E X and s E S~ is a state of the environment such that Oi(s) = o and for which there exists a joint action a e P g ( N , w) with s = r(a)(~r(w)). Finally the action function (~i is defined by c~i(q, o) = P g i ( N , w), where Pi(q, o) = (N, X ) and w is any world in X. L e m m a 10. The protocol P is an implementation of P g in E with respect to {.}pr. Moreover, for all traces rs, if #i(Pi(rs),Oi(s)) = ( N , X ) then N is iso-
morphic to reduce(Nlr~l ). This result follows quite directly from L e m m a 9, and amounts to establishing the c o m m u t a t i v i t y of the diagram in Figure 1. Whereas the canonical implementation uses the progression structures Nk, the optimized protocol uses the reduced structures Qk. Let us now consider the complexity of the optimized implementation. In general, the structures Qk may grow to arbitrary size. The following result shows that the sufficient condition of Section 6 characterizes the situation in which this is not the case.
Suppose that propositions determine state in E. Then the optimized implementation of P g runs in constant space if and only if there exists a simulation from M to some finite SSn structure.
Theorem ll.
Note that we are not required to know the existence of the simulation a
priori in order to obtain the space bound. Given an environment, the optimized implementation simply starts computing the structures Qk: if the appropriate simulation exists, these will never become larger in size than some constant. In this case there will exist some numbers K < L for which Qtr is isomorphic to QL, and we could use this in order to produce an implementation represented as a finite state automaton. (The optimized implementation itself does not consist of an a priori determined finite set of states. Nor do we have a way to predict the size of the cycle point L: this is a nonrecursive function of the size of the environment.)
150
j,
O,*Pg/
/
/
,Ii
/
Q~
/
Q/Pg
Qz*Pg i
Q2
Q3
Qk
Fig. 1. An optimized implementation
8
Conclusion
We have Mready noted that the system generated by the knowledge based prog r a m and environment of Example 1 admits a simulation to a finite $5~ structure. Thus, the optimized implementation runs in constant space in this case. Of course, the existence of a finite state implementation was already known for this example from the analysis carried out in Example 3. The significance of Theorem 11 is that this result could have been obtained as the output of an aut o m a t e d procedure, which would terminate in all cases admitting a simulation to a finite S5n structure. Potentially, implementation of this procedure could result in the discovery of new examples in which finite state implementations exist. As the undecidability results indicate, strong results enabling the synthesis of finite state implementations of knowledge-based programs whenever these exist are impossible for the class of all finite environments. In the face of this, a number of compromises are possible. We have explored one in the present paper: the identification of optimizations that sometimes generate a finite state implementation. One avenue for further research is to seek stronger methods of optimization - - one possibility would be to a t t e m p t to use the structure of the environment in the reduction process. Another avenue is to focus on restricted classes of environments - - as we have remarked in previous work [Mey94], the structure of the environments used in the lower bound proofs is very unnatural, and there appears to be scope for positive results in certain more natural classes.
151
References J. van Benthem. Correspondence theory. In Handbook of Philosophical Logic II: Extensions of Classical Logic, pages 167-247. D. Reidel, Dordrecht, 1984. [BLMS] R.I. Breffman, J-C. Latombe, Y. Moses, and Y. Shoham. Applications of a logic of knowledge to motion planning under uncertainty. Journal of the A CM. to appear. [BR83] S. Brookes and W. Rounds. Behavioural equivalence relations induced by programming logics. In Proc. ICALP, pages 97-108. Springer LNCS No. 154, 1983. [CheS0] B. Chellas. Modal Logic. Cambridge University Press, Cambridge, 1980. [FHMV95a] R. Fagin, J. Halpern, Y. Moses, and M. Vardi. Knowledge-based programs. In Proc. A CM Symposium on Principles of Distributed Computing, 1995. [FHMV95b] R. Fagin, J. Halpern, Y. Moses, and M . Y . Vardi. Reasoning about Knowledge. MIT Press, Cambridge, MA, 1995. [HM85] M. Hennessy and R. Milner. Algebraic laws for non-determinism and concurrency. Journal of the ACM, 32(1):137-161, 1985. [HM90] d. Halpern and Y. Moses. Knowledge and common knowledge in a distributed environment. Journal of the ACM, 37(3):549-587, 1990. [KSg0] P.C. Kanellakis and S. A. Smolka. CCS expressions, finite state processes and three problems of equivalence. Information and Computation, 86:43 68, 1990. [Mey94] R. van der Meyden. Common knowledge and update in finite environments I. In Proc. of the Conf. on Theoretical Aspects of Reasoning about Knowledge, pages 225-242, 1994. [Mey96a] R. van der Meyden. Finite state implementations of knowledge-based programs. In Proc. Conf. on Foundations of Software Technology and Theoretical Computer Science, December 1996. Hyderabad, lndia. Springer LNCS to appear. [Mey96b] R. van der Meyden. Knowledge-based programs: on the complexity of perfect recall in finite environments. In Proc. of the Conf. on Theoretical Aspects of Rationality and Knowledge, pages 31-50. Morgan Kaufmann, 1996. [Mil90] R. Milner. Operational and algebraic semantics of concurrent processes. In Handbook of Theoretical Computer Science, Volume B: Formal Models and Semantics, pages 1201-1242. Elsevier Science Publishers B.V., Amsterdam, 1990. [PT87] R. Paige and R. Tarjan. Three partition refinement algorithms. SIAM Journal of Computing, 16(6):973-989, 1987. [RG92] A.S. Rao and M. Georgeff. An abstract architecture for intelligent agents. In Proc. Int. Joint. Con]. on Artificial Intelligence, pages 439-449, 1992. [RK86] S.J. Rosenschein and L.P. Kaelbling. The synthesis of digital machines with provable epistemic properties. In J.Y. Halpern, editor, Theoretical Aspects of Reasoning about knowledge: Proc. 1986 Con]., pages 83-98. Morgan Kaufman, Los Altos, CA, 1986. [Sho93] Y. Shoham. Agent oriented programming. Artificial Intelligence, 60(1):51-92, 1993. [Ben84]
Semantics of BDI Agents and Their Environment David Morley Australian Artificial Intelligence Institute, Level 6/171 Latrobe Street, Melbourne, 3000 Australia Email: morley~aaii, oz. au A b s t r a c t . This paper describes an approach for reasoning about the interactions of multiple agents in moderately complex environments. The semantics of Belief Desire Intention (BDI) agents has been investigated by many researchers and the gap between theoretical specification and practical design is starting to be bridged. However, the research has concentrated on single-agent semantics rather than multi-agent semantics and has not emphasised the semantics of the environment and its interaction with the agent. This paper describes a class of simple BDI agents and uses a recently introduced logic of actions to provide semantics for these agents independent of the environment in which they may be embedded. The same logic is used to describe the semantics of the environment itself and the interactions between the agent and the environment. As there is no restriction on the number of agents the environment may interact with, the approach can be used to address the semantics of multiple interacting agents.
1
Introduction
There is a great deal of interest in developing computational agents capable of rational behaviour. One approach has been to base the agents on the mental attitudes of Beliefs, Desires (or goals), and Intentions [Bratman, 1987; Rao and Georgeff, 1995]. Much work has been done on the semantics of these BDI agents and in developing implementations of agent-based systems for solving practical problems. The wide gaps between theoretical specification of agents and the implementations is now starting to be bridged. For example, Rao [1996] provides an operational and proof-theoretic semantics for a language AgentSpeak(L), an abstraction of one particular implementation of BDI agents. One of the main benefits of the BDI agent approach is that it is well suited to situations where an agent is embedded in a complex and dynamic real-world environment. Unfortunately, the progress on the semantics of the agents themselves is not matched by progress towards understanding the semantics of the interaction of the agent with its environment. This importance of the agent-environment interaction is illustrated by the special double volume of Artificial Intelligence, on Computational Research on Interaction and Agency [Agre, 1995]. In his introduction, Agre describes the
120
"emerging style of research" of "using principled characterizations of interactions between agents and their environments to guide explanation and design". Agre maps the scope of the research along two axes, environment complexity and number of agents, and within this space identifies three areas that categorise most current research (with papers in the double volume concentrating almost exclusively on the third): complex interactions among several agents where the environment plays almost no part; - emergent behaviour from simple interactions among a multitude of agents in very simple environments; and - single agents in more complex environments.
-
This paper explores a different area, combining the environmental complexity of the first area with the multi-agent capability of the third. What enables this transition to multiple agents is a recently introduced non-modal temporal logic allowing concurrent actions [Morley and Sonenberg, 1996]. The logic provides a monotonic solution to the frame problem that avoids problems inherent in the popular Explanation Closure approach [Schubert, 1994]. By its treatment of concurrent events and actions, the logic allows the single-agent classical planning approach to representing the world to be extended to include the simultaneous actions of multiple agents, and to include the internal operations of the agents themselves. Rather than treating an agent's environment as a finite automaton that provides sensory feedback to the agent, the agent and its workings are treated as an extension of the workings of the environment. We introduce a simplified model of a BDI agent based on the Procedural Reasoning System [Ingrand et al., 1992] (restricted to the propositional case for simplicity). This model deviates from the traditional approach of having primitive actions which enable the agent to act directly on the world, by instead allowing the agent to interact only with its set of beliefs. The interaction between the beliefs and the environment is then achieved through sensors and effectors. The logic of concurrent actions of Morley and Sonenberg [1996] is then applied to the semantics of the agent model, to the semantics of the sensors and effectors, and to the semantics of the environment. Exploiting the composability of the logic, the separate pieces can be integrated, providing the means to analyse the performance of the agent situated in its environment. We can add other agents and sensor/effector processes to model multiple agents interacting through the same environment. For illustration, we show how a simple two agent system can be represented. The focus of the paper is on providing and explaining this analytical tool, rather than on its application to specific problems. Before embarking on the main theme of the paper, we begin with a brief review of the logic of Morley and Sonenberg [1996]. 2
Brief
Overview
of
Action
Logic
Morley and Sonenberg [1996] present a logic of events and actions which al-
121
lows for concurrent actions. The key difference between that work and other approaches to events and actions is in the semantics of events. Rather than a set of behaviours, an event is interpreted as a set of e v e n t instances. An event instance consists of a behaviour, a history of all changes to the state of the world over the duration of the event including changes due to other events, t o g e t h e r w i t h an i n d i c a t i o n o f w h i c h changes are due to the e v e n t in question.
Consider a behaviour where Fred and Mary are both drinking cups of coffee at the same time. We can distinguish two event instances, "Fred drinking coffee" and "Mary drinking coffee", which share this same behaviour. However, the two event instances are distinct, because the first instance includes as effects the changes in the level of coffee in Fred's cup whilst the second instance has the changes to Mary's cup. One advantage of this approach is that it distinguishes different ways of combining events that are not distinguished by other formalisms: c o n c u r r e n t c o m p o s i t i o n - adding the effects of two different events; i n t e r s e c t i o n - taking two descriptions of the s a m e event and producing a
-
more precise description; and c o - o c c u r r e n c e - which leaves open the question of whether the events referred to are the same.
-
2.1
Syntax
To simplify the presentation, the language is untyped. However, in the use of the event language we are commonly dealing with - propositions, p, q, etc., that denote propositional fluents, and are interpreted as sets of worlds in which the propositions hold; - events, e, e', etc., that denote sets of event instances; and - actions, c~,/3, etc., that denote pairs of events: the event of successful execution of the action and the event of unsuccessful execution of the action. Terms of the language, T, are constructed out of function symbols of various arities from F = F0 U F1 U F2 U ..., variable symbols from V , and a selection of special constants and operators. T is defined to be the least set such that: variables, from V C T the universal event constant, e E T arbitrary constants, from F0 C T - arbitrary functions, f ( x l , ..., x~) E T if f E F~, and xl,..., x . E T 5, e N e I , e + e I , e U e ~,ee ~ E T i f e , e ~ E T - events, [p], N , [P• [ / ] E T if p E - events, S ( a ) , F(c~) E T if a E T actions, Z, 4, a?r while(a,/~), a It fl E T if a, fl, 7 E T
-
-
-
-
e
v
e
n
t
s
,
-
Well formed formulas are constructed from terms using predicate symbols of various arities from P = P0 U P1 U P2 U ..., using the special predicates, fluent(x),
122
event(x), action(x), e C_ e', and x = x', and connectives and quantifiers. Although the language is untyped, for 3p.r will be used for Vp.(fiuent(p) --4 r Quantification over events and actions are Va.r and 3a.r
2.2
using the standard first order logical brevity the abbreviations Vp.r and and 3p.(fiuent(p) A r respectively. similarly abbreviated as Ve.r 3e.r
Informal Semantics
T h e special "type" predicates, fluent, event, and action, are true of propositions, events, and actions respectively. The _C event operator is the "more specific than" event relationship. For example, if em is the event of m y depositing some m o n e y into my account and era5 is the event of my depositing 5 dollars into m y account, then em5 C era. The -- operator is the equality relation. and e N e ~ are standard set complement and intersection operators over events. Set intersection is used to further qualify an event. Thus if e5 is the event of someone depositing 5 dollars into my account then em~ =-- em CI es. e, the "universal" event which includes all event instances, is the identity for intersection. Set union can be defined as el U e2 ~ ~'1 1"7~ . If an event instance ends in a state that another starts with, the concatenation of the two event instances consists of concatenating the behaviours and combining the effects. The event ee ~ consists of all possible concatenations of event instances in e with event instances in e ~. The concurrent composition of two event instances is defined for event instances with the same behaviour and disjoint effects. It takes the union of the effects of the two instances. For example, the concurrent composition of the "Mary drinking coffee" event instance with the "Fred drinking coffee" event instance is "Mary and Fred drinking coffee", which causes both cups to empty. The concurrent composition event e + e' contains all possible concurrent compositions of event instances in e and e'. The event em5 9- e5 necessarily increases m y bank balance by 10 dollars. The semantics suggested by Morley and Sonenberg [1996] requires disjoint effects to span different time periods. This leads to an interleaving-style semantics for concurrent composition. However, different semantics, allowing disjoint effects to occur at the same time, are also possible. The co-occurrence event, e IA e ~, contains event instances that are formed from event instances in e and e' with matching behaviours by taking the union of their effects. For example, era5 IAe5 m a y increase m y bank balance by 5 dollars or by 10 dollars, since the events referred to m a y be either distinct or the same. The event e N e' can be seen as the subset of etA e' where the effects of the two instances are identical. The event e + e' can be seen as the subset of etA e ~ where the effects of the two instances are disjoint. Propositions refer to sets of world states and are related to events via a number of operators. The event [p] (not to be confused with a modal operator) contains all event instances where p remains true. T h e event [~] contains all event
123
instances where p remains false. From these we can define [Pt] (and [p,]) where p becomes true (or false). /p• is the set of all event instances where the truth of p is not affected. T h a t is, the truth of p may change, but not as an effect o f the event. As an example, during the "Fred drinking coffee" event instance above, the level of coffee in Mary's cup happens to change, but not as an effect of Fred drinking the coffee. Thus if p refers to Mary's cup being full, the "Fred drinking coffee" event instance is in [p• Conversely, [p-r] is the set of all event instances where if the truth ofp changes, then that change m u s t be an effect of the event. These are the events which cause all observed changes to p. Combining these with [pt] (and [p,]) we get events such as [p~-] = [pt] N [pT] which are those where p is caused to become true, as opposed to incidentally becoming true. Some events lie neither in [p• nor in [pV]. For example, consider two people fighting over what channel to watch on television. The channel may change multiple times. The event corresponding to one person's actions is only responsible for some of those changes, rather than none or all. A c t i o n s represent an agent's attempt to affect the world and may succeed or fail. Giunchiglia et at. [1994] handle the potential failure of actions explicitly using a variant of process logic. In their logic an action is represented by a modal operator and is associated with two sets of behaviours: those in which the action succeeds and those in which it fails. Applying the same basic approach, Morley and Sonenberg [1996] treat an action, a, as nothing more than a pair of events, the event of successful executions of the action, S(a), and the event of failed executions, F ( a ) . Actions can be arbitrarily complex attempts to affect the world and are described by providing axioms to constrain their success and failure events. For example, we would state that all successful event instances of a "load gun" action result in the gun being loaded. We have primitive actions, S and 0, then with probability p,~ calculated by P m = min (105z~(t)-2"~ a random modification of strategy codes was executed. Here, the min(x,y) means the minimum of x and y, and Pr is the upper probability, which was set to 0.4. The term a / S Q R T ( N ( t ) ) was inserted in order to make allowances for statistical
183
errors in the evaluation of the average S(t)/N(t). In the simulation, a was set to 1.0. Random modification of strategy codes The following random replacements of codes were executed, where l stands for the length of its strategy algorithm codes: 1) Deletion of codes: A code in the algorithm was deleted with probability pm/l. If the deleted code was a branch instruction, one of the code sequences corresponding to the branch became unnecessary. Hence, it was also deleted. 2) Insertion of codes: An instruction code selected randomly from the code set was inserted at any place in the algorithm with probability pm/l. If the inserted code was a branch instruction, the algorithm then needed two code sequences corresponding to the branch. Hence one of the code sequences after the branch was set to NIL (NOP: No operation). 3) Replacement of NIL (NOP): Due to an insertion of a branch instruction, the code NIL often entered into the code sequences. This was unfavorable for the system performance. Hence, with an upper probability Pr, NIL was replaced by a code randomly selected from the code set. 4) Simplification of redundant code: Redundant codes brought a b o u t by the above mutation processing were deleted. It is i m p o r t a n t to note that in the above procedure, agents sought to improve their own profit, and no cooperation or altruism was implied a priori.
5
Simulation
First of all, our world needed some pressure, or incentive for learning. In fact, in a world consisting of only cooperative strategies, each agent just played C, and there was no motivation for learning. Hence, agents with uncooperative strategies (called vaccine agents hereafter) were injected into the society of T F T agents. Then cooperative strategies had to learn to fight/retaliate against vaccine agents, or they would be destroyed by the injected vaccines. Note t h a t there was no differences between injected vaccine agents and other agents, and vaccine agents could also revise their own strategies. If an injected vaccine was too strong, the learning agents were destroyed by the vaccine. On the other hand, if the injected vaccine was too weak, it had little effect on the learning. Hence, the vaccine of DDD (who always played D), or RAN (who played either C or D randomly) was injected with increasing intensity. Detailed information on the training procedure is given in Table 3. For example, in the interval [0 10000], vaccine agents with strategy DDD were added every 500 steps, until the number of vaccine agents was 10~0 of the total population. As the RAN strategy was more difficult to detect than the DDD strategy, the RAN vaccine was injected after the training by the DDD vaccine. To evaluate the effect of the learning, the system before the training ( T F T ) , after the training by DDD (S1), and after the training by RAN ($2) were matched against half the population of DDD agents (Fig. 3), or an equal population of RAN agents (Fig. 4). While the society of T F T agents was destroyed by
184
Table 3. Vaccines Injected for Training Time Vaccine Vaccine ratio(%) (TFT)0-10000 DDD 10 10,000-20,000($1) DDD 20 20,000-30,000 DDD 33 ($1)30,000-40,000 RAN 20 40,000-50,000($2) RAN 33
uncooperative strategies, $1 and $2 were able to destroy uncooperative strategies and recovered the original population, verifying the effect of the strategy learning. Figure 4 also shows that training by the RAN vaccine greatly increased the retaliative ability of the system against RAN.
Fig. 3 Matches of T F T , $1, $2 against DDD
6
Fig. 4 Matches of T F T , $1, $2 against RAN
Information, communication, and commitment
Readers may wonder why autonomous agents cannot negotiate for cooperation. When we are confronted with a dilemma situation, we use words in trying to negotiate for cooperation. Autonomous agents can, of course, also communicate, or, more precisely, can exchange information. If agents can negotiate, most of the dilemma games are changed to "cooperative games" and the problem is solved. Our assumption, however, is that an autonomous agent will do anything for its own profit. Therefore, it can tell a lie without regard for moral or other human considerations. Exchanges of information are not the same as communication. Communication has significance only when the speaker commits to what he says.
185
Our ability to communicate is thus based, not only on our intelligence, but also on our ability to commit to what we say. But what does "to commit" mean? If we say something, we mean it. Even if we fail to do what we promised to do, we are ready to admit our failure. We cannot tell a lie without a guilty conscience, without betraying an emotion through facial expressions, etc. Even if this is not true, at least people believe that it is. This is one of the reason why people want to talk face to face on important matters. Frank [Frank 88] describes an interesting role of emotions in solving social dilemmas. On the other hand, a machine system lacks morals, lacks facial expressions that might betray its emotionQ. We need a mechanism that forces a machine system to "commit" to what it says. This ability, or the inability to act otherwise, must be rooted in low level hardware limitations. In our case of the Prisoner's Dilemma game, for example, the following mechanism might work as "commitment." Suppose an agent wants to make the opponent believe that it is going to play "C" in the next turn. Suppose also that it discloses its own strategy algorithm and demonstrates that its algorithm will really output C in the current situation, and that its algorithm can explain all of the moves it played in the past. Unfortunately, this in itself does not make a "commitment," for the agent can invent, on the spot, an algorithm that satisfies the above two conditions. To find such an algorithm, however, is an inverse problem, and is generally very difficult. If we can prove that this is really difficult (such as NP-complete), then by disclosing an algorithm that can explain all of its past moves, an autonomous agent proves its "commitment" to the algorithm. Then the opponent can assure itself that the algorithm was not invented on the spot and is worth trusting. In summary, the role of communication in the cooperation of autonomous agents is effective only if we can implement a mechanism assuring "commitment" of an agent to what it says.
7
Summary
and
discussions
We have explored the problem of cooperation of autonomous agents, and explained why it is important for autonomous agents to solve social dilemma problems. It must be solved in a way that does not restrict the autonomy of agents. One solution is to introduce a social sanction mechanism by the disclosure of information. The effectiveness of this mechanism is investigated by computer simulations. Agents were made to play the Prisoner's Dilemma game repetitively, each time changing the other party of the match, under the condition that the match history was to be disclosed to the public. The aim of the agents was to increase their own profit, and no cooperation or altruism were implied a priori. W h a t we found are the following: 1 The situation does not change by the development of the techniques for machine generation of emotions and facial expressions. The point is that people physiologically hate telling a lie, and cannot help expressing (betraying) emotions.
186
1) Under the disclosure of information, even a selfish agent comes to cooperate for its own sake. 2) An agent can learn to cooperate through interactions with other agents. Thus autonomous agents solved the dilemma problem by themselves. We then discussed the role of commitment in solving social dilemmas, and considered a possible mechanism for implementing commitment in autonomous agents. In a previous paper[Ito & Yano 95], we showed that cooperation emerges through evolution. In this paper, we bestowed the agents with the ability to learn from experiences, and investigated its effects on the emergence of cooperation. At first thought, there seems to be no problem with this additional ability. This is not, however, true for the emergence of cooperation. In a society of agents with the abilities for learning (i.e., for modifying its own strategies), one has to be more cautious against possible defections of other agents. In fact, the performance (measured by the average points agents can earn) is much better in a society without learning abilities than that in a society with learning abilities. As for the cooperation, being intelligent does not improve the situation. The more rationally each agent behaves, the more uncooperative the society becomes. This is why it is called "social dilemmas." The main finding of this paper is that even in a society of agents with learning abilities, agents can develop strategies for cooperation by themselves. There is a long history of research o n Prisoner's Dilemma Game[Axelrod 81] [Axelrod 84][Axelrod 88][Rosenschein & Genesereth 85][Lindgren 92][Angeline 94]. Most of them, however, are on the Iterated Prisoner's Dilemma (IPD) game, for Axelrod showed decisively that in a Non-iterated game defection is the only rational strategy [Axelrod 84]. One of the exceptions is [Oliphant 94], in which agents were scattered randomly in space and forced to stay at its place, thus inhibiting defectors to exploit cooperators. Our research treats a Non-iterated Prisoner's Dilemma game, i. e., agents are forced to play the Prisoner's Dilemma game, each time changing the opponent of the match. Of course, we needed a mechanism to avoid Axelrod's results, and adopted a mechanism of "information disclosure." Theoretical game theory[Osborne & Rubinstein 94] has long investigated the role of information in solving the social dilemma problems, but its results are restricted to the prediction of fixed points and their stabilities, and no dynamics are known for the emergence of cooperations. There is no research we know of which treated the dynamics of the emergence of cooperation under the disclosure of information, nor is there any research mentioning a recursive algorithm, which is essential for the success of cooperative strategies. Recent research focuses on "noisy situation"[Wu & Axelrod 94] in which the player's moves are changed randomly irrespective of the opponent's intention, "multi-player games" [Banks 94] in which part of the participant can make a coalition, and "selective play" [Batali & Kitcher 94] in which a player can somehow select his opponent. This research really reveals interesting aspects of the social dilemma problems. What effect information disclosure plays in these situation is our future research theme.
187
There are a number of researches[Rosenschein &: Genesereth 85] [Rosenschein &: Zlotkin 94] coping with conflict resolution problems. Their aim is, however, to develop protocols a n d / o r heuristics for negotiating among conflicting agents. As we mentioned in Sec. 6, for the negotiation to be effective, it is essential that agents can be trusted, or in other words, an agent will do what it promised to do. We pointed out that this ability to keep promise is itself a "social dilemma" problem. It must be solved without an assumption for the trustworthiness of the negotiating agents. Of course, we cannot calculate everything from scratch, and protocols and heuristics are very useful for everyday life. What is important for an autonomous agents is, however, the ability to doubt these "protocols and heuristics" whenever it is necessary. W h a t should an autonomous agent do if nothing except himself (or his reason) can be trusted? This is the problem we tackled in this paper. In our model, information plays an essential role in maintaining a cooperative society, which is, we think, true even for our society. The secure maintenance of the public information is a very difficult problem, which is beyond the scope of this paper. We need not, however, assume an existence of complete knowledge for the behaviors of other agents. In our model, we charged a calculation cost (0.002 per machine code) for processing of information. With the parameters adopted, an agent cannot process more than several tens of records of the behaviors of other agents. For the processing of these records demands several hundreds of machine codes, whose calculation cost nearly exceeds the profit mutual cooperation can earn through the game (which, in our case, is 0.5 point). Therefore, an agent is forced to cut off his search halfway. Our eventual goal is to develop a machine system that acts at its own will and takes responsibility for its actions. The problem of cooperation - especially that involving social dilemmas - is very difficult to solve, even for a human society. How can we prepare an environment in which autonomous agent can think and act freely and at the same time can cooperate? The mechanisms proposed in this paper defines one possible approach to this question.
References [Angeline 94] Angeline, P. J., "An Alternate Interpretation of the Iterated Prisoner's Dilemma and the Evolution of Non-Mutual Cooperation", Artificial Life VI, pp.353-358, 1994. [Axelrod 81] Axelrod, R., and Hamilton, W. D.: "The Evolution of Cooperation," Science, Vol. 211, Mar. 1981, pp. 1390-1396. [Axelrod 84] Axelrod, R.: The Evolution of Cooperation, Basic Books Inc., 1984. [Axelrod 88] Axelrod, R., and Dion, D.: "The Further Evolution of Cooperation," Science, Vol. 242, Dec. 1988, pp. 1385-1390. [Banks 94] Banks, S., "Exploring the Foundations of artificial Societies: Experiments in Evolving Solutions to Iterated N-player Prisoner's Dilemma. [Batali ~ Kitcher 94] Batali, J., and Kitcher, P., "Evolutionary Dynamics of Altruistic behavior in Optional and Compulsory Versions of the Iterated Prisoner's Dilemma", Artificial Life VI, pp.343-348, 1994.
188
[Frank 88] Frank, R. H.: Passions within reason, The strategic role of the emotions, W.W. Norton & Company, Inc., 1988. [Ito • Yano 95] Ito, A., and Yano, H.: "The Emergence of Cooperation in a Society of Autonomous Agents," First Intl. Conf. on Multi Agent Systems, (ICMAS'95), pp.201-208, San Fransisco, 1995. [Liebrand & Messick 96] Liebrand, W. B. G. and Messick, D. M. (eds.), Frontiers in Social Dilemmas Research, Springer, 1996. [Lindgren 92] Lindgren, K. : "Evolutionary Phenomena in Simple Dynamics," Artificial Life II, C. G. Langton (eds.), Addison Wesley, 1992, pp. 295-312. [Oliphant 94] Oliphant, M., "Evolving Cooperation in the Non-Iterated Prisoner's Dilemma: The Importance of Spatial Organization", Artificial Life VI, pp.349-352, 1994. [Osborne $c Rubinstein 94] Osborne, M. J. and Rubinstein, A., A Course in Game Theory, The MIT Press, 1994. [Ray 92] Ray, T. S.: "An Approach to the Synthesis of Life," Artificial Life II, C. G. Langton et al. (ed.), Addison-Wesley, 1991. [Rosenschein & Genesereth 85] Rosenschein, J. S., and Genesereth, M. R.: "Deals Among Rational Agents," Proc. 9th Intl. Joint Conf. on Artificial Intelligence (IJCAI'85), Aug. 1985, pp. 91-99. [Rosenschein & Zlotkin 94] Rosenschein, J. S., and Zlotkin, G. : Rules of encounter, Designing Conventionbs for Automated Negotiation among Computers, The MIT Press, 1994. [Werner & Dyer 92] Werner, G. M, and and Dyer, M. G., "Evolution of Communication in Artificial Organisms," C. G. Langton (eds.), Artificial Life II, Addison Wesley, 1992, pp. 659-687. [Wu & Axelrod 94] Wu, J. and Axelrod, R., "How to Cope with Noise in the Iterated Prisoner's Dilemma", Journal of Conflict Resolution, pp.1-5(1994)
