A Novel Architecture Description Language for Multi-agent Systems Base on π-net
Zhenhua Yu1 ∗ , Yuanli Cai1 , Haiping Xu2 1 School
of Electronic and Information Engineering, Xi’an Jiaotong University, Xi’an,710049, China
2 Computer
and Information Science Department, University of Massachusetts Dartmouth, North Dartmouth, MA 02747, USA
Abstract To narrow the gap between multi-agent formal modeling and multi-agent practical systems, multi-agent systems (MAS) are studied from the point of view of software architecture. As the existing architecture description languages (ADLs) are not suitable for describing the characteristics of architecture and behaviors of MAS, a novel architecture description language for MAS (π-net ADL) rooted in the Belief-Desire-Intention (BDI) model is proposed, which adopts two complementary formalisms—Agent-Oriented Petri nets (AOPN) and π-calculus as a formal theory basis. AOPN are used to visualize the static architecture and model the behaviors of MAS while π-calculus is used to represent the dynamic or evolving architecture of MAS. These two formal methods are effectively integrated in π-net ADL. Furthermore, π-net ADL can visually and intuitively depict a formal framework for MAS from the agent level and society level, and stress the description of dynamic MAS architecture. Most importantly, π-net ADL supports formal analysis of MAS model properties in a variety of well-established techniques—simulation, detection, etc. To illustrate the favorable modeling capability of π-net ADL, an example of multi-agent systems in electronic commerce is provided. Finally, by the use of the existing Petri nets and π-calculus tools, the MAS model and some of its key behaviors properties are analyzed and verified. ACM Classification: D.2.11 (Software Architectures), D.2.2 (Design Tools and Techniques), I.2.11 (Distributed Artificial Intelligence)
∗ Corresponding author. Tel.: 086-029-86382043 Email address: zhenhua
[email protected] (Zhenhua Yu1 ).
1
Introduction
Multi-agent systems (MAS) have been recognized as a main aspect of the distributed artificial intelligence and predicted to be the future mainstream computing paradigm. MAS are the most promising technology for developing complex software systems, and many attentions have been paid to MAS in developing complicated, large-scale and distributed industrial and commercial applications (Wooldridge and Jennings, 1994; Wooldridge and Jennings, 1995; Zambonelli and Omicini, 2004; Luck et al , 2004). MAS are adaptive and dynamic systems in order to adapt to changes in their environment, where agents may be added or deleted at run-time, and the agent behaviors and interactions among agents may vary dynamically (Jiao et al , 2003), so MAS architecture can evolve during the execution of the system. For MAS applications, support for dynamism is necessary and indeed vital in the case of certain safety- and mission-critical systems, such as air traffic control and command and control systems. Shutting down and restarting such systems for upgrades may incur unacceptable delays, increased cost, and risk (Medvidovic and Taylor, 2000). Consequently, there is a pressing need for a formal specification to cope with evolution and dynamism, and ensure the developed systems to be robust, reliable, verifiable, and efficient (Xu and Shatz, 2003). It has been recognized that the lack of rigor is one of the major factors that hamper the wide-scale adoption of multi-agent technology (Luck et al , 2004; Brazier et al , 1997). A rigorous approach toward MAS architecture level design can help to detect and eliminate design errors early in the development cycle, and thus to reduce overall development cost. In the past several years, some work has tended to investigate the formal modeling techniques of MAS. However, the effort in multi-agent systems modeling suffers from lack of systematic approach that is grounded in software development methodologies (Park and Sugumaran, 2005), moreover, the existing formal specifications cannot describe the dynamic architecture of MAS from the structure and behavior, which is a large challenge for formal specifications. In this paper, to provide effective support for the development of correct, robust and dynamic MAS in a systematic way, a novel formal specification, called π-net ADL (π-net Architecture Description Language for Multi-agent Systems), is proposed which provides a specification of how the architecture of MAS can evolve at runtime while ensuring integrity across changes. It is important that the formalism for dealing with dynamic MAS be explicitly represented inside the model so that, at each stage of systems development, designers can experiment with the effects of structural changes (Llorens and Oliver, 2004). The π-net ADL is studied from the point of view of software engineering and 2
artificial intelligence. From software engineering, the mainstream software engineering tools, techniques and formal languages (such as software architecture, Architecture Description Language (Medvidovic and Taylor, 2000)) are adopted to go systematically from system requirements to MAS implementation. Despite the flourishing research results on ADLs, research on ADL for MAS was sparse and lagging. The existing ADLs are difficult to describing the architecture, complex dynamic characteristics and reasoning of MAS. π-net ADL based on dual formal methods combining π-calculus (Milner et al , 1992) and Agent-Oriented Petri nets (AOPN) is suitable for describing MAS. The reason π-net ADL adopts π-calculus and AOPN as its formal basis is that AOPN is graphical and mathematical modeling tool which is simplicity and strong expressive power in depicting dynamic system behaviors, and π-calculus is a process algebra specially suited for the description and analysis of concurrent systems with dynamic or evolving topology. Most importantly, π-net ADL supports formal analysis of MAS architecture in a variety of well-established techniques, such as simulation, reachability analysis, model checking and interactive proving. π-net ADL based on dual complimentary formalisms in a unified framework for MAS modeling is distinct and unique. From artificial intelligence, the Belief-Desire-Intention (BDI) model is well suited for describing an agent’s mental state, and reflect the autonomous behaviors of agents, therefore π-net ADL roots in the BDI formalism. π-net ADL is oriented for software engineering and places emphasis on practical software design methods instead of reasoning theories. π-net ADL is brought directly into the MAS design phase, and the formal MAS model is served as the high-level design for MAS implementation. The ultimate goal of π-net ADL is to provide a tool that generates executable implementation skeletons from a formal model and enables software engineers to develop reliable and trustworthy MAS. The rest of this paper is organized as follows: Section 2 surveys the related work, compares π-net ADL with them. Section 3 reviews π-calculus and presents Agent-Oriented Petri nets, and then proposes π-net. Section 4 proposes a novel architecture description language based on π-net for multi-agent systems (πnet ADL). Section 5 discusses MAS modeling process based on π-net ADL. Section 6 provides an agent society in electronic commerce to illustrate π-net ADL. Finally, Section 7 summarizes the results of this paper and discusses further research directions.
2
Related Work
So far, there have existed several typical formal specifications and agentoriented methodologies for MAS, which can be classified into four main groups. 3
In the following, we only briefly describe the main features of these formalisms. The first group of the formalisms uses formal languages, such as Z, to provide a formal theory basis for representing MAS. dMARS (Luck and d’Inverno, 1995) is an agent specification using the Z language as its formal theory basis. In dMARS, agent’s beliefs, goals, intentions, plans, and actions are all described using Z. RIO framework (Gruera et al , 2002) represents MAS based on ObjectZ and state-charts, which uses Object-Z to specify the transformational aspects and state-charts to specify the reactive aspects. Although Z is precise and unambiguous, and facilitates the system description at different levels of abstraction, a key criticism using Z is that it cannot effectively model the interactions among agents and support the effective definition of concurrent and distributed MAS, and it is less expressive with regard to mental states of agents. The second group of the formalisms uses temporal logics and multimodal logics to describe dynamic aspects of the agents that form a basis for specifying, implementing and verifying MAS. In the Concurrent METATEM (Fisher and Wooldridge, 1997) and its extension work (Fisher, 2005), the temporal logic is applied to describe individual agent behaviors. However MAS based on concurrent METATEM have no explicit architecture and interactions among agents are vague. DESIRE (Brazier et al , 1997) based on temporal logic focuses on hierarchical task-based decomposition and provides a much clear and more readily comprehensible description of the application. Although these formal specifications are claimed to represent MAS, it is impractical for developers to use a logic notation directly in the specification and reasoning about largescale MAS, because such the specification will be a complicated logic formula that consists of mathematical notations and symbols. Such formalism has led to a sizable gap between these formal models and implemented MAS. The third group of the formalisms consists of some new formal languages that support the modeling and development of MAS, such as SLABS (Zhu, 2001), agent-based G-net (Xu and Shatz, 2003), etc. SLABS includes a modular structure suitable for the formal specification of multi-agent systems, a scenario description mechanism for defining agents behavior in the context of environment situations, and a notion of caste as a collection of agents that have same behavior and structural characteristics. Agent-based G-net, which is a type of Petri nets, is explicitly oriented for specifying and defining the design architecture of multi-agent software systems and illustrates a useful role for inheritance in the agent-oriented models. However, the methods in agents based on agent-based G-net are fixed and may be not reconfigured, adapted or exchanged by changing their knowledge-base, goals and plans. The fourth group is agent-oriented development methodologies, such as MaSE (DeLoach et al , 2001), Gaia (Wooldridge et al , 2000), Tropos (Bresciani et al , 2004), AUML (Odell et al , 2001), DECAF (Graham et al , 2003), and frame4
work for MAS development(Park and Sugumaran, 2005), etc. MaSE consists of seven phases to develop MAS. The goal of MaSE is to lead the designer from the initial system specification to the implemented agent system. MaSE provides guidance for system design and supports detailed design. It requires that agent interactions are one-to-one rather than multicast. Tropos covers the very early phases of requirement analysis and the conceptual modeling is formalized in a metamodel described with a set of UML class diagrams. However, one criticism of this approach is that it does not provide strong support for protocols and modeling the dynamic aspects of the system (Dam and Winikoff, 2003).
Despite the important contribution of these four groups of formalisms and agent-oriented methodologies to a solid underlying foundation for MAS, most importantly, they cannot describe the dynamic architecture of MAS. Our proposed π-net ADL can effectively support architecture evolution at runtime. Although there exist some ADLs (such as Darwin, Rapide, Wright, Unicon) for describing static and dynamic software systems (Medvidovic and Taylor, 2000), they do not sufficiently comprehend formally specifying and constraining runtime reconfiguration of MAS and are not suitable for representing some essential and important characteristics of MAS, e.g. mental states and complicated interactions among agents. In the existing ADLs, components and connectors are modeling elements and the main functionalities of connectors are to transport data and synchronize the interacting components, whereas agents are modeling elements in MAS and connecting agents possess more communication and coordination functionalities. There exists much difference between components and agents in semantics and function, which may bring on the concept mismatch. ADLs should support the evolution of architectures at runtime (including configuration dynamism). The majority of existing ADLs view architecture statically. Darwin and Rapide support only a priori-defined architectural reconfigurations, and furthermore Darwin has little impact on the internal structure and behaviors of components. These facts mentioned above are the reasons that π-net ADL is proposed and used to model MAS.
π-net ADL stands out in its support for MAS architecture evolution at runtime (as well as at design time). It is a unique ADL in that combines π-calculus and Petri nets in a unified framework. π-net ADL implements the BDI model and effectively describes the mental state of agents, and has both a graphical and textual representation. Furthermore, the focus of π-net ADL taking its root in the use of π-net is on the formal modeling of dynamic and reasoning MAS, and it supports formal analysis and verification by the corresponding tools. π-net ADL is oriented for software engineering, therefore can effectively narrow the gap between MAS formal models and MAS implementation. 5
3
3.1
π-calculus and Agent-Oriented Petri nets
π-Calculus
The π-calculus is an extension of the process algebra CCS, and specially suited for the description and analysis of concurrent systems with dynamic or evolving topology. The modeling entities are names and processes. The π-calculus gains simplicity by removing all distinction among variables, constants, and channels, which are called names. Systems are specified in the π-calculus as collections of processes which interact by means of names. These names can be considered as shared bidirectional channels. When a process receives a name, it can use this name as a subject for future transmissions, which allows an easy and effective reconfiguration of the system. We assume an infinite set of names N , ranged over by a, b, . . . , z, which will function as all of channels, variables and data values; a set of process identifiers K is ranged over by A, B, . . ., each with an arity (an integer ≥ 0); the processes are ranged over by P, Q, R, . . . , which are of seven kinds as follows: P
(1) A Sum i∈I Pi representing the process that can enact one or other of the Pi . (2) A prefix form yx.P , y(x).P , or τ.P . yx. is called negative prefix. y may be thought of as an output port of a process; yx.P outputs the name x at port y and then like P. y(x). is called positive prefix. y may be thought of as an input port of a process; y(x).P inputs an arbitrary name z at port y and then behaves like P{z/x}. τ. is called silent prefix, which represents an agent that can evolve to P without interaction with environment. τ.P performs the silent action τ and then behaves like P. (3) A Parallel Composition P |Q, which represents the combined behaviors of P and Q executing in parallel. The processes P and Q can act independently, and may also communicate if one performs an output and the other an input along the same port. (4) A restriction (νx)P . This process behaves as P but the name x is local, meaning it cannot immediately be used as a port for communication between P and its environment. (5) A match [x = y]P . This process behaves like P if the names x and y are identical, otherwise like 0 (0 represents empty or inactive behavior). (6) A defined agent A(y1 , . . . , yn ). For any process identifier A (with arity n) def used thus, there must be a unique defining equation A(x1 , . . . , xn ) = P , where the names x1 , . . . , xn are distinct and are the only names which 6
Process
Channel
x
x
P
Q
Fig. 1. The π-calculus flow graph
may occur free in P. def (7) A Replication !P . !P is given by the definition !P = P |!P , which represents an unbounded number of copies of P. Computation in π-calculus is represented by applying the reduction rule (Milner, 1993), and a simple example is shown as follows. P = xy.0, Q = x(z).z(s).0 τ P |Q = xy.0|x(z).z(s).0 −→ y(s).0 The above message passing process can be represented as the π-calculus flow graph shown in Fig. 1. The process P sends y along the channel x to Q, the process Q receives the message via the same channel x, and all free occurrences of z in Q are replaced by y. For reasons of conciseness, in this paper we will omit the stop process .0 and write z(s) in place of z(s).0. The π-calculus can be varied in many ways. There are many useful subcalculi, e.g. the polyadic π-calculus (Milner, 1993). The polyadic π-calculus allow multiple objects in communications: outputs of type ahy1 , . . . , yn i.P and inputs of type a(x1 , . . . , xn ).Q. In this paper, the polyadic π-calculus is adopted as the modeling tool, and the names start with a lowercase letter, and the processes start with a uppercase letter. A detailed description of the calculus, including its transition system, one can refer to (Milner et al , 1992).
3.2
Agent-Oriented Petri nets
Petri nets are a graphical and mathematical modeling tool applicable to many systems that exhibit concurrency and synchronization (Murata, 1989). The ordinary Petri nets easily lead to the so-called state-explosion. In order to solve the complexity and state-explosion, Petri nets are combined with ObjectOriented methods to set up the Object-Oriented Petri nets (Saldhana and Shatz, 2001). The proposed Agent-Oriented Petri nets (AOPN) is developed by inheriting the properties of the Object-Oriented Petri nets, and designed based on the characteristics of the agent. 7
Definition 1 AOPN is a 3-tuple, AOPN=(DM, IM, PU),where DM is a Decision Making module, IM is a Interface module, and PU is a Private Utility module. Definition 2 Decision Making Module. A Decision Making module is a 7tuple, DM={Pr , Pk , Pg , Pp , T, F, E}, where Pr is a reasoning place; Pk is a knowledge-base place; Pg is a goal place; Pp is a plan place; T is a finite set of transitions in the module; F is the input and output relationships between transitions and places; E is expression functions in the arcs. In the Decision Making Module, Pr represents reasoning module that supports reasoning for the information which the agent apperceives. The reasoning result will be saved in Pk . Pk is an abstract place, which represents the Beliefs in BDI model. In practical terms, Pk describes the knowledge of the environment and other agents. In this paper, Pk also consists of the rule which Pr produces. We follow the definition of the BDI model proposed by Kavi and his colleagues (Kavi et al , 2002). For agent implementation, the Beliefs of an agent can be regarded as simple variables and data structures or, complex systems (such as knowledge bases) based on the practical scene. Pg is an abstract place, which represents the Desires in BDI model and describes some desired final states and consists of a goal set. The Desires of an agent represent its motivation and are the main source for the agent’s actions. The Desires may be represented as a value of a variable, a record structure, or a symbolic expression in some logic. Pp is an abstract place, which represents the agent’s Intentions. Pp is a list of plans and describes the actions achieving the Goal values of an agent. An agent tries to achieve its goal and executes the plan module to complete its goal. Definition 3 Interface Module. An Interface module is a 6-tuple, IM= {PO , PI , T, AI , AO , E}, where PO is a finite set of Output Message Place; PI is a finite set of Input Message Place; T is a finite set of transitions in the module; AI is a finite set of Input Interface Arc; AO is a finite set of Output Interface Arc; E is expression functions in the Interface arcs. AI and AO represent agent’s interfaces which allow an agent to interact with other agents and the environment, and is used to send and receive messages between agents. The interfaces specify the services (messages, operations, and variables) which an agent requires and provides, and are especially the channels for messages passing. Definition 4 Private Utility Module. A Private Utility module is a 3-tuple, PU= {P, T, F }, where P is a finite set of places; T is a finite set of transitions; F is the input and output relationships between transitions and places. Private Utilities represent private method and utilities, such as register and destroy information. 8
Reasoning
Update Knowledge Private utilities
PO
AO
Use Knowledge
AI
Knowledge Base
PI Update Goal
Execute Plan
Update Plan
Goal
Plan
Fig. 2. The AOPN abstract model of an agent.
An AOPN of agent model is shown in Fig. 2. The Knowledge-base, Goal and Plan are denoted by ellipses. As Fig. 2 only represents a template of an agent, interfaces and internal implementation are added according to the specific system requirements. For simplicity and clarity of the diagrams, only names of places, transitions and arcs of all agents models are presented in this paper, and inscriptions, colors, guards and marking are left unspecified. In the AOPN model, some concepts of CPN are employed and some behavioral semantics does not violate the semantics of CPN formalism. Abstraction and refinement design are crucial for the effective design of large scale and complex MAS. AOPN provides these mechanism that are well integrated into the basic model.
3.3
π-net
Petri nets are graphical representation and a promising tool to describe the static characteristics of the system, represent the dynamic behaviors, and express causality and concurrency in system behavior. Furthermore, Petri nets provide a variety of well-established mathematical methods to analyze, simulate and validate the systems. These properties make Petri nets an excellent tool for the validation of models by non-technical end users. AOPN are an extension of Petri nets, which are suitable for describing the large-scale, complicated and distributed software system. However the structure of AOPN is static, it is hardly possible to model dynamic MAS architecture. π-calculus is suitable for describing software system where components can be dynamically created and removed, and interactions between components are also dynamically established and modified, leading to an evolving communication topology. π-calculus can specify and reason about the design of complex concurrent computing systems by means of algebraic operators corresponding to common programming constructs (Best et al , 2001). 9
The treatment of the structure and semantics of concurrent systems provided by AOPN and π-calculus is different, so it is virtually impossible to take full advantage of their overall strengths when they are used separately. Therefore the idea of combining AOPN and π-calculus is proposed, which is called πnet. π-net integrates the advantages of Petri nets and π-calculus, and provides a rigorous framework for the specification and verification of dynamic MAS, where AOPN describes the initial model of MAS, and π-calculus represents the dynamic model of MAS. The use of dual complimentary formal methods has many advantages over a single formalism, including modeling and analyzing different aspects of MAS using different formalism to improve understandability. The integration of π-calculus and Petri nets provides a bridge between graphical specification techniques and dynamic modeling techniques. π-calculus and Petri nets can complement each other very well.
4
Novel Architecture Description Language for Multi-agent Systems (π-net ADL)
Adopting π-net as a formal theory basis, π-net ADL can accurately describe dynamic MAS architecture at high level. π-net ADL provides with the essential characteristics of ADL, and studies MAS from the agent level and society level: The agent level to the structure of each agent, and the society level to a formal framework for MAS and interactions among agents. The main design objective of π-net ADL is to provide a dynamic architecture modeling mechanism aiming at the complex dynamic characteristics of MAS, and lets the MAS architecture serve as the high-level design for MAS implementation. Definition 5 π-net ADL is a 3-tuple, π-net ADL=(Computing agents, Connecting agents, Configurations). The items in the definition are described in detail as follows.
4.1 Modeling computing agents Computing agents are a finite set of the computing agent in MAS. Computing agents are responsible for interacting with users and environment to provide specific applications. Each computing agent may provide and require services to and from other computing agent, respectively. 10
A computing agent is a 3-tuple, Computing Agent=(ID, AOPN, EA), where ID is the identifier of a computing agent; AOPN defines the interfaces and internal implementation of a computing agent; EA describes the evolvement of a computing agent by π-calculus. The tuples, ID and AOPN, represent a computing agent static model which is shown in Fig. 2. Agents communicate with other ones by message passing, which follows speech act theory and uses complex protocols to negotiate (Xu and Shatz, 2003), e.g., the FIPA agent communication language(ACL) and KQML. Communication is the basis for interaction and organization without which agents would be unable to cooperate, coordinate, or sense changes in their environment. The agents proposed in this paper speak and understand FIPA ACL. In agent model, a message is described as a message Token which is abbreviated to msgTkn. msgTkn is a 2-tuple msgTkn=(mID, body), where mID represents a message holds an unambiguous identification and body is a complicated data structure. When a computing agent first receives a message, a conversation is set up which is responsible for messages passing among agents; meanwhile, the message Token is dispatched into the Pr and further set up reasoning model, and then the reasoning results are saved in the Knowledge-base (Pk ). According to the new acquiring knowledge, Goal and Plan are updated. The messages belonging to the conversation hold an unambiguous identification (mID). If an agent next receives a message carrying such a reference to an existing Token, the message will be directly dealt with by means of the existing rule in the Knowledge-base (Pk ). During a computing agent’s lifecycle, it can evolve in order to adapt to the change very well. The computing agent learns continuously and acquires new knowledge to update Knowledge-base. That is: AcquireKnowledge(nk) = x(nk).U pdateKb(nk) It means that the computing agent receives new knowledge nk along the channel x, and then update knowledge-base. When a computing agent requests a service from another agent, it will first inspect whether it has enough knowledge to provide this service by itself. If the computing agent’s Knowledge-base is rich enough to achieve autonomously some goal which cannot be achieved before, it can provide some new and effective services to adapt to the external environment. Consequently computing agents can adapt to the unanticipated changes of the environment very well. The computing agent updates its services via the following process. U pdSev = k(req).QueryKb(req).U pdateService(req) 11
Computing Agent i
...
... Computing Agent 1
Communication Facilitator
Computing Agent n
(a) Group 1
Group i
...
...
Communication Facilitator
...
Group n (b)
Fig. 3. The communication model of MAS. (a) the communication model of a group, (b) the communication models of multi-group.
It means that the computing agent queries its knowledge-base QueryKb according to a request req, and judge whether its knowledge is rich enough to provide this service. If so, it will update its services and not send this request again. The way of interactions among agents and the MAS architecture may be changed after the services of the computing agent are updated.
4.2
Modeling connecting agents
Connecting agents are a finite set of the connecting agent which is communication facilitator dealing with the interaction information among agents, defining the rules that govern those interactions, and dynamically establishing links among computing agents. Connecting agents also provide a series of services, e.g. lifecycle, naming, register, and reputation, and saves the architectural image of the application and offers an interface for manipulating computing agents. Fig. 3(a) describes a MAS consisting of a communication facilitator and some computing agents, and such MAS is called a group where agents are to achieve a certain goal. Fig. 3(b) represents several groups constitute a large-scale MAS, and these groups is connected by a communication facilitator. A connecting agent is defined as Connecting Agent= (ILP, KBP, Gate, T, F, Role, EC), where ILP is the Intelligent Linking Place denoted by double ellipse; KBP represents Knowledge-base Place which is defined to apperceive the external environment, acquire requisite knowledge, and describe services which computing agents provide via interfaces. Gate is a finite set of special transitions, which is responsible for message-passing and is the channel 12
between the request agent and service agent. Role is a set of interfaces in computing agents, which is defined as Role = {CID1 , . . . , CIDn }, where CIDi is the identifier of an interface in a computing agent. The services provided by the role are stored in the KBP. The roles identify the logical participants in the interaction. There are two types of roles, static and dynamic role respectively. Dynamic role will change with the computing agent deleted or added. EC addresses the evolvement of connecting agent, and represents changes in the architecture by π-calculus. In Section 6, we will describe in more details about how to model dynamic architecture of MAS using a case study. In MAS, computing agents first register their information (such as name, address, interface and capability) in connecting agents when they join MAS. Therefore connecting agents describe the services information which computing agents provide, and computing agents acquire the addresses of other computing agents via connecting agents. Connecting agents are not only responsible for message passing, but also manage the common knowledge of the MAS and monitor the global architecture, and capture and manage changes in the architecture. From the point of view of communication, connecting agents control and manage the communication and collaboration among agents; from the point of view of the system connection and conglutination, connecting agents play the role of glue conglutinating the MAS. If a computing agent achieves its goal, it must delete its information, so the information in connecting agents will not fall into confusion. In π-net ADL, computing agents and connecting agents describe the agent structure from the agent level, as well as the behaviors and interfaces of the individual agent.
4.3
Modeling Configurations
MAS configurations are connected graphs of computing agents and connecting agents that describe architectural topology. Explicit architectural configurations facilitate communication among a system’s many stakeholders, who are likely to have various levels of technical expertise and familiarity with the problem at hand (Medvidovic and Taylor, 2000). The multi-agent systems architecture can not only describe individual agent, but also depict the whole system and interaction among agents. The multiagent systems architectural configuration based on π-net ADL is shown in Fig. 4 , and the MAS are studied from the society level, where MAS are conceived as a multitude of interacting agents. In the society level, the key point is the overall behaviors of the MAS, rather than the mere behaviors of individuals. For simplicity and clarity of the diagrams, this model is predigested. The computing agents are represented by the interface arcs and abstract transitions 13
Connecting agent
Input interface Computing agent 2
Computing agent 1
PO 11
P I21 G1
P O12
P I/O 1
G2
KB
G4
Computing agent 4
G3
Computing agent 3 G8 PO 31
ILP G5
P I31
P O21
P I/O4 P O41
G7 G6
P I41
Output interface
Fig. 4. MAS architectural configurations.
denoted by shaded rectangles. The abstract transitions can be further refined. This architecture consists of four computing agents and one connecting agent, where the computing agent 1, 4 are request agents, and the computing agent 2, 3 are service agents. The computing agents register their information by the Gates G2, G4, G5, G7, and the computing agent 1, 4 request/acquire the information of the corresponding service agents by the Gates G3, G8. The computing agent connects with the connecting agent by the interface; therefore an arborescent topology is formed. The static semantics of the multiagent systems architecture is described in Fig. 4, and the dynamic semantics of the multi-agent systems architecture is controlled by the firing rule. The firing of the transition makes the Token dispatch, which expresses the message passing and well depicts interactions among agents. The dynamic architecture of MAS can be described by π-calculus, such as adding or removing an agent, replacing an existing agent by an update, and reconfiguring or extending the architecture of an application.
5
MAS Modeling Process Based on π-net ADL
The purpose of the proposed π-net ADL is to ease the developer’s effort to implement complicated applications of MAS. In order to design a MAS using π-net ADL, the requirement specification should be decomposed and described by formal methods, and then the computing agents and connecting agents are identified. In the early process of MAS modeling, the exact detailed information of the system is not known. Thus the detailed information and constraints can be 14
temporarily ignored to simplify the modeling complexity of MAS, and a basic MAS model can be constructed to represent the static characteristics and dynamic behaviors. In this way, each agent model is reusable for future modeling. In the next step, these models are refined with the constraints and interrelations among agents, and analyzed (e.g. deadlock and boundness). Then, a complete MAS model based on π-net ADL may be constructed. The procedure for constructing a complete MAS model based on π-net ADL is summarized as follows. (1) According to the system specification, the computing agents and connecting agents are identified, and the functions of each agent are defined. (2) Define and initialize a set of goals Φ based on functional requirements in the computing agent, where each goal is defined as a goal tree Γ, which means a goal may have a number of subgoals. The goal set is dynamic, which means the goals accomplished may be deleted from Φ and newly goals could be added into Φ at run time. Finally according to the template of the computing agent, the Goal model should be set up. (3) Define a set of plans Ω in the computing agent. Each plan has a priority and a set of conditions, and is associated with a particular goal or subgoal. Finally according to the template of the computing agent, the Plan model should be set up. (4) Define and initialize the knowledge base in the computing agent and connecting agent, and an interaction protocol among agents. The knowledge base is dynamic. According to the template of the computing agent, the Knowledge model should be set up. As a result of the execution of a plan, the knowledge base may be updated at run time. Finally the connecting agent model should be set up. (5) Set up the MAS architecture, and simulate and analyze it with the supporting tools and analysis methods of Petri nets. If the model is not correct, we should return step 2 to redefine the MAS model until it is correct, and then we implement the MAS model. The MAS architecture model obtained by the above modeling process is the initial model. Since MAS are dynamic systems, agents may join or leave agent societies at runtime. Thus, the interactions between agents and MAS architecture may be evolved and are different from those at design time. The changing structure and behaviors of MAS (including creation, deletion, reconfiguration, etc) can be described by π-calculus in π-net ADL which can describe the essentials of MAS dynamic evolvement. Finally the dynamic MAS model is analyzed and verified by the supporting tools of π-calculus to judge whether it satisfies the new system specification. There exists some feedback of design information between steps. These steps can be performed in an iterative and incremental way. From the modeling process, this modeling approach based on π-net ADL follows the natural style of 15
human thinking: Desire-Intention-Belief, rather than Intention-Desire-Belief. The goal of π-net ADL is to lead the designer from the initial system specification to the implemented MAS, and further support for automatic code generation. π-net ADL has been successfully applied to Kunming Police Geographical Information System (KPGIS), which is a large-scale, multilevel, and distributed multi-agent system. The application of π-net ADL demonstrated that π-net ADL can help architecture designers to effectively analyze and design the complex MAS. At present, a visual integrated development tool prototype based on π-net ADL has been developed; the MAS architecture can be modeled by this tool. In our future work, we will add the analysis function to this tool.
6
An Example of Multi-agent Systems in Electronic Commerce
In this section, a multi-agent system in an electronic commerce is considered. The buyer agents and seller agents negotiate price, and finally the buyer agents determine whether to buy or not. The MAS architecture based on π-net ADL is set up, and then the model is analyzed by the supporting tool of Petri nets and π-calculus to ensure a correct design.
6.1
MAS initial modeling and analysis in electronic commerce
According to the initial system specification, the architecture of the price negotiation MAS in electronic marketplace based on π-net ADL is shown in Fig. 5, which represents a pair wise negotiation process. The MAS is composed of three functional agents (a buyer agent, a connecting agent and a seller agent) bargaining for goods. For simplicity, the seller agent only reserves the knowledge-base place, interface arcs, input places, and output places, and some constraints are omitted in this figure. This is feasible because agent models can only interact with each other through interfaces. The legend provided in Table 1 and Table 2 describes the meaning of each place and transition in Fig. 5. The interaction protocol among agents is contract net protocol. Fig. 6 depicts an example of price-negotiation contract net protocol expressed as an agent UML (AUML) sequence diagram between a buyer agent and a seller agent (Xu and Shatz, 2003). When a negotiation based on the contract net protocol begins, each agent must register its basic information to the connecting agent. The connecting agent can accept or reject the registration based on the enrolled agent’s reputation or function (Xu and Shatz, 2003). Firstly, the buyer agent sends the request 16
Buyer Agent
P8 PI
T13
T 12
T1 4
P7
P9 Rean T15
T16 P1
T1
PO PI
T3 T4
Plan
Goal P2
T2
P3
T 10 G4
A I1
AO1
P6
T9
KB
T11 G5
T6
P4
T5 G1
PO
T7 G2
P13
PO P12
PO KB
P15
P11 T17
T18 G6
P10
AO2 AO3
T2 1
T19
PI
T8 G3
PO
P5
Seller Agent P14 T20
ILP
Connecting Agent
Fig. 5. The initial MAS model in electronic commerce (initial design). Buyer Agent
Seller Agent Call for price proposal Propose Reject proposal Propose Accept proposal .Confirm
Fig. 6. An example of price-negotiation contract net protocol. Table 1. Legend of Fig. 5 (description of places). Place
Description
P1
The abstract place for the knowledge-base module of the buyer agent.
P2
The abstract place for the goal module of the buyer agent.
P3
The abstract place for the plan module of the buyer agent.
P4/P5/P7/P14/P15
The places for dispatching outgoing messages.
P6/P8/P12
The places for dispatching incoming messages.
P9
The abstract place for the reasoning module of the buyer agent.
P10
The ILP place of the connecting agent.
P11
The abstract place for the knowledge-base module of the connecting agent.
P13
The abstract place related to the internal structure of the connecting agent.
17
Table 2. Legend of Fig. 5 (description of transitions). Place
Description
T1
The transition update goal that updates the goal set.
T2
The transition update plan that updates the plan set.
T3
The transition use kb that uses the knowledge-base. The plan set can make use of the knowledge base.
T4
The transition register or destroy that registers the buyer agent, or deletes its information if it achieves its goal.
T5(G1)
The registration information sent from buyer agent to connecting agent.
T6
The buyer agent requests the information of the corresponding service seller agent.
T7(G2)
The request information sent from buyer agent to connecting agent.
T8(G3)
The corresponding service information sent from the connecting agent to buyer agent
T9
The transition call for new price proposal that sends a new price proposal for seller agents.
T10(G4)
The call for new price proposal sent from the buyer agent to the seller agent.
T11(G5)
The price proposal sent from the seller agent to the buyer agent.
T12
The transition deal with a new price proposal.
T13
The transition deal with similar messages.
T14
The transition throw exception that throws exception if the exceptions occure.
T15
The transition update kb that updates the knowledge-base based on the reasoning results.
T16
The transition use kb that uses the knowledge-base to reason.
T17
The transition query or update knowledge-base.
T18(G6)
The registration information sent from the seller agent to the connecting agent.
T19/T20/T21
The transition related to the abstract place P13.
for the information of the seller agent providing the corresponding service to the connecting agent by the transition T 6. The connecting agent receives the request, and then queries its knowledge-base to judge whether there exists an seller agent satisfying the request and sends the information to the buyer agent by the transition T 8. The buyer agent starts the conversation by sending a 18
call for price proposal to the corresponding seller agent through the transition T 9, and the Token (msgTkn) in the conversation will be provided with an unambiguous identification. The seller agent send the price proposals to the buyer agent by the transition T 11. Upon the arrival of the price proposals, the buyer agent firstly reasons to think whether the price proposals are acceptable or not with the help of its knowledge-base (P1). The reasoning result (the production rules) will be saved in knowledge-base (P1). If the proposals are rejected, the buyer agent will negotiate again. If the proposals are accepted, the buy plan will be generated and executed. To ensure the system is robust, the exception mechanism is adopted (the transition T14 throw exception) to stop the buyer agent, and continue to send call for price proposal. By then, the conversation of price negotiation is finished. When the buyer agent receives a message carrying identification the same as the existing message identification, the transition deal with similar messages (T13) will be enabled. The message is directly dispatched into the place knowledge-base (P1), dealt with based on the previous experience and rules, and finally the corresponding plan will be executed. The dynamic semantics is represented by the firing rule. A significant advantage provided by π-net ADL is that the verification and validation of the model can be accomplished before implementation, and help ensure a correct design (such as liveness, deadlock freeness, boundness and concurrency) with respect to the original specification to enable software engineers to develop reliable and trustworthy MAS. To verify the correctness of MAS model, we use a Petri nets tool, called INA (Integrated Net Analyzer) (Roch, 2003), to analyze the deadlock of the MAS model. All the possible deadlock situations must be detected to avoid their occurrence before implementing the MAS. It is important that how to handle deadlock situations for development of electronic commerce systems and operating systems, where the communication plays a key role. According to (Wang, 1996), we first construct the agent communication net (ACNet) for each generic computing agent Agenti which consists of Agenti and its related agent. Since MAS is fully described by each computing agent and the relationships among all the related agent, we only need to study each ACNet for deadlock analysis of MAS. If deadlock of ACNet of Agenti is detected, both the Agenti and its related agent must be modified; if each ACNet does not deadlock, the MAS will not deadlock. In this paper, we simultaneously use INA and the theory of invariants (Murata, 1989) to detect the deadlock. Theorem 6 Let N is a Petri net model, an n-vector I is a P-invariant (place invariant) of N if and only if I T · [N ] = 0T . kIk = {p ∈ P |I(p) 6= 0} is called the support of an invariant. If all P-invariants are marked in the initial marking and there are no empty siphons, the N is live(Murata, 1989). 19
For the initial MAS model of electronic commerce, the buyer, seller and connecting agent are associated and construct an ACNet. Therefore, with the Petri nets model in Fig. 5 as input, the INA tool produces the following results: processed candidates: 64 There are 2 minimal deadlocks: 1: 11, 2: 1, 2, 3, 7, 8, 9, 12, 13, 14, Corresponding maximal traps: 1: 11, 2: empty clean The deadlock-trap-property is not valid. According to the theory of invariants, there are two P-invariants in the MAS model, and their supports are kI1 k = {P 11}, kI2 k = {P 1, P 2, P 3, P 7, P 8, P 9, P 12, P 13, P 14}respectively. The second P -invariants is cleaned in the initial marking, so the model is deadlock. By analyzing the structure of the initial MAS model, the transition T8 sends the address of the seller agent to the buyer agent, and then the transition T9 fires; however, the address of the seller agent should be dispatched into the knowledge-base P1. To correct this error, we need to modify the design of the initial MAS model. The model modification is to add a new transition T 22 between place P6 and place P1, and delete the arc from place P6 to transition T9. After this correction, we can again evaluate the revised MAS model by using the INA tool. Now, we obtain the following results: processed candidates: 382 There are 2 minimal deadlocks: 1: 11, 2: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, Corresponding maximal traps: 1: 11, 2: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, The The The The The
deadlock-trap-property is valid. net has no dead reachable states. net is live. net has no dead transitions at the initial marking. net is live, if dead transitions are ignored. 20
This automated analysis shows that our modified net model is live. Deadlock analysis can help eliminate human errors in the design process, and verify some key behaviors for the MAS model to perform as expected, and increase confidence in the MAS design process.
6.2 MAS dynamic modeling and analysis in electronic commerce During the execution of the electronic commerce, its architecture may be dynamically changed, e.g. other buyer agents may want to join the system; there are some faults in the seller agent, so the backup seller agent is startup. The dynamic architecture can be modeled by π-net ADL at run-time. In order to improve the robustness of the MAS, a backup seller agent is added and backups data via the channel bak. The creation process of the agents is: BakSellerAgent(sid2, seller) = τ.Create(sid2, seller)
It means that the agents possessing the identifier sid2 and service seller are created. In Fig. 5, the transitions T10, T11 connecting the buyer agent to the seller agent can be abstracted as a channel u in π-calculus, the transition T18 between the connecting agent and the seller agent can be treated as a channel v, and the channel between the buyer agent and connecting agent is w. Before the primary seller agent goes down, it passes u, bak along its link bak, v to the backup seller and connecting agent, respectively, and then the backup seller agent run as the primary seller agent. Finally, the buyer agent requests are redirected towards the backup seller agent. The dynamic configuration process is shown as follows. bakhui.P sSellerAgent|BuyerAgent|bak(x).BakSellerAgent τ −→ P sSellerAgent|BuyerAgent|BakSellerAgent{u/x} vhbaki.P sSellerAgent|BakSellerAgent|v(y).ConAgent τ −→ P sSellerAgent|BakSellerAgent|ConAgent{bak/y} During the system running, a buyer agent joins the MAS according to the system requirements. The creation process of the agents is represented by π-calculus: 21
BuyerAgent(bid2, buyer) = τ.Create(bid2, buyer) It means that the agent possessing the identifier bid2 and service buyer is created. The buyer agent first register its information (such as name, address, interface and capability) in connecting agents, and the register process is BuyerReg(bid2, buyer) = (νbid2, buyer)(registerhbid2, buyeri) The buyer agent transmits the service buyer and its identifier bid2 via the channel register to the connecting agent. The corresponding register process in the connecting agent is RegisterService(x, y) = (νx, y)(register(x, y)) The connecting agent obtain the service information via the channel register from the new agents and update its Knowledge-base, and the x, y is private names. After the buyer agent registers its information, it will inquire of the connecting agent about the seller agent. The connecting agent queries its Knowledge-base to search a seller agent, and then sends the address of the seller agent to the buyer agent. Finally, the channel between the seller agent and buyer agent is set up. This inquiring process in the buyer computing agent is InquireService(i, r, l) = ihai.r(z).zhli The buyer agent sends the request a through the channel i to the connecting agent to query the seller agent, and then wait a response from the connecting agent through the channel r. After the request computing agent receives the identifier of the service agent z, it sends the location l where the service is required by the channel z. The corresponding service query process in the connecting agent is QueryService(i, r, p) = i(y).([y = a]rhpi + [y 6= a]Subscribe(y)) The connecting agent receives a request y from the buyer agent through the channel i, then it judges whether there is a specific service a satisfying the request. If so, the connecting agent will send the identifier of the seller agent p; otherwise it will subscribe the service. 22
BuyerAgent1
ConnectingAgent
BuyerAgent2 i
w
r
bak u
p l
BakSellerAgent
Fig. 7. The π-calculus flow graph of reconfiguration MAS architecture.
The providing service process in the seller agent is P rovdService(p, s) = p(x).xhsi The seller agent receives the location x where the service is required and sends the service s to that location. According to the computation process in the π-calculus, the entire dynamic process for the service requiring and providing is modeled. InquireService(i, r, l)|QueryService(i, r, p)|P rovdService(p, s) = ihai.r(z).zhli|i(y).([y = a]rhpi + [y 6= a]Subscribe(y))|p(x).xhsi τ −→ r(z).zhli|rhpi|p(x).xhsi τ −→ phli|p(x).xhsi τ −→ lhsi Finally, according to the above process, the whole MAS consists of BakSellerAgent, Connecting agent, and two buyer agents. The BuyerAgent2 uses the channels i, r, p, l to interact with the ConnectingAgent and BakSellerAgent. These agents can be treated as processes in π-calculus, and they communicate each other via the channels w, u, bak, i, r, p, l. The π-calculus flow graph of reconfiguration MAS architecture is shown in Fig. 7. The whole MAS dedicated to the electronic commerce may be written as follows. It is worth noticing that all the different agents (Buyer Agent bid1, bid2, and Seller Agent sid2, and Connecting Agent) involved in the MAS have been defined as concurrent processes: M AS = BuyerAgentbid1 |BuyerAgentbid2 |SellerAgentsid2 |ConnectingAgent 23
When a new agent joins the MAS, it interacts with other agents in the MAS, and also changes the existing MAS architecture. Since the MAS itself is a concurrent software system, the architecture change may introduce configuration errors, such as a deadlock. In order to verify the correctness of the new MAS model with respect to the new specification, the ultimate MAS model is also analyzed by the supporting tool, namely Mobility Workbench (MWB, 2005). The MWB is a tool for manipulating and analyzing mobile concurrent systems described in the π-calculus. In the current version, MWB can analyze key properties of the model, such as deadlock-freeness. Here, we verify the deadlock properties of MAS by means of the MWB. Firstly, we construct the ACNet for the BuyerAgent1 and BuyerAgent2. After the BuyerAgent2 joins the MAS, it queries the service agent and finally interacts with the BakSellerAgent. Consequently the final ACNet of the BuyerAgent2 consists of the BuyerAgent2 and the BakSellerAgent. The channel between the BuyerAgent2 and BakSellerAgent is p, l. The ACNet can be represented by π-calculus and using the command deadlocks in MWB we can check if an ACNet contains deadlock or not. —————————————————————————————MWB>input "ACNet.txt" MWB>env agent ACNet = (BuyerAgent2 | BakSellerAgent) agent BakSellerAgent = (\p,l,priceInfo)p(msg).’l. p(msg1).BakSellerAgent agent BuyerAgent2 = (\p,l,cfp,refuse,buy)’p.l(msg). (’p.BuyerAgent2 + ’p. BuyerAgent2) MWB>deadlocks BuyerAgent2 No deadlocks found. MWB>deadlocks BakSellerAgent No deadlocks found. MWB>deadlocks ACNet No deadlocks found. —————————————————————————————According to the above analysis, the ACNet of the BuyerAgent2 is not deadlock. In like manner, we can construct the ACNet for the BuyerAgent1 and analyze it. Finally, according to the analysis result, the final MAS model is live after the MAS evolves. 24
7
Conclusions
Multi-agent systems are regarded as the most promising technology to develop complex software systems. Formal framework for MAS provides a base to design, verify and implement MAS, and ensures that robust, reliable, and efficient software is developed. In this paper, from the software architecture point of view, a novel architecture description language for MAS (π-net ADL) rooted in Agent-Oriented Petri nets and π-calculus is proposed to support the modeling and analysis of multi-agent systems. π-net ADL supports the formal description of dynamic MAS and of their evolution. π-net ADL based on the BDI agent model stresses practical software design methods instead of reasoning theories, and analyze the static and dynamic semantics, and depict the dynamic architecture of MAS. π-net ADL can be applied to investigate MAS from the agent level and society level. From the agent level, the researchers can pay more attention to the implementation details of each agent; and from the society level, they can pay more attention to the overall design and interactions among agents. An example of an agent society in electronic marketplace is used to illustrate the modeling capability of π-net ADL; and moreover, how to detect the deadlock in the MAS model by the theory of invariants is discussed. π-net ADL, as a visual ADL, can promote the intercourse and understand among clients, architecture designers and developers, and provide an effective modeling method for MAS modeling and verifying.
8
Acknowledgements
This work is supported by the National High Technology Research and Development Program of China (863 Program), No. 2003AA721070.
References BEST, E., DEVILLERS, R. and KOUTNY, M. (2001): Petri Net Algebra. SpringVerlag. BRAZIER, F.M.T., DUNIN-KEPLICZ, B. M., JENNINGS, N.R., et al. (1997) DESIRE: modelling multi-agent systems in a compositional formal framework. International Journal of Cooperative Information Systems 6(1): 67-94. BRESCIANI, P., PERINI, A., etc. (2004): Tropos: an agent-oriented software development methodology. Autonomous Agents and Multi-Agent Sytems 8(3): 203-236.
25
DAM, K.H. and WINIKOFF, M. (2003): Comparing agent-oriented methodologies. Proceedings of the 5th International Bi-conference Workshop on Agent-Oriented Information Systems. Melbourne, Australia, 78-93, Springer-Verlag. DELOACH, S.A., WOOD, M.F. and SPARKMAN, C.H. (2001): Multiagent systems engineering. International Journal of Software Engineering and Knowledge Engineering 11(3): 231-258. FISHER, M. and WOOLDRIDGE, M. (1997): On the formal specification and verification of multi-agent systems. International Journal of Cooperative Information Systems 1(6): 37-65. FISHER, M. (2005): Temporal development methods for agent-based systems. Autonomous Agents and Multi-Agent Sytems 10(1): 41-66. GRUERA, P., HILAIREA, V., KOUKAMA, A., et al. (2002): A formal framework for multi-agent systems analysis and design. Expert Systems with Applications 23(4): 349-355. JIAO, W., ZHOU, M. and WANG, Q. (2003): Formal framework for adaptive multiagent systems. Proceedings of the IEEE/WIC International Conference on Intelligent Agent Technology, Beijing, China, 442-446, IEEE Computer Society. LlORENS, M. and OLIVER, J. (2004): Structural and dynamic changes in concurrent systems: reconfigurable Petri nets. IEEE Transactions on Computers 53(9): 1147-1158. GRAHAM, J., DECKER, K. and MERSIC, M. (2003): DECAF-A flexible multi agent system architecture. Autonomous Agents and Multi-Agent Systems 7(1): 7–27. KAVI, K.M., ABORIZKA, M. and KUNG, D. (2002): A framework for designing, modeling and analyzing agent based software systems. Proceedings of the fifth International Conference on Algorithms and Architectures for Parallel Processing,Beijing, China, 196-200, IEEE Computer Society. LUCK, M. and D’INVERNO, M. (1995): A formal framework for agency and autonomy. Proceedings of the First International Conference on Multi-Agent Systems, San Francisco, USA, 254-260, AAAI Press. LUCK, M., MCBURNEY, P. and PREIST, C. (2004): A manifesto for agent technology: towards next generation computing. Autonomous Agents and MultiAgent Sytems 9(3): 203-252. MEDVIDOVIC, N. and TAYLOR, R.N. (2000): A classification and comparison framework for software architecture description languages. IEEE Transactions on Software Engineering 26(1): 70-93. MILNER, R., PARROW, J. and WALKER, D. (1992): A calculus of mobile processes. Journal of Information and Computation 100(1): 1-77. MILNER, R. (1993) The polyadic π-calculus: a tutorial. Springer-verlag
26
MURATA, T. (1989): Petri nets: properties, analysis, and application. Proceedings of the IEEE 77(4): 541-580. MWB. (2005): The Mobility Workbench. http://www.it.uu.se/research/group /mobility/mwb. Accessed 15-Jul-2005. ODELL, J., PARUNAK, H.V.D. and BAUER, B. (2001): Representing agent interaction protocols in UML. Proceedings of the first International Workshop on Agent Oriented Software Engineering 121-140, Springer-Verlag. PARK, S. and SUGUMARAN, V. (2005): Designing multi-agent systems a framework and application. Expert Systems with Applications 28(2): 259-271 Roch S, Starke P H. (2003): INA: integrated net analyzer, Version 2.2.HumboldtUniversit¨at zu Berlin, Institut f¨ ur Informatik, 2003. SALDHANA, J.A., SHATZ, S.M. (2001): Formalization of object behavior and interactions from UML models. International Journal of Software Engineering and Knowledge Engineering 11(6): 643-673. WANG, L. (1996): Object-Oriented Petri nets for modelling and analysis of automated manufacturing systems. Computer Integrated Manufacturing Systems 26(2): 111-125. WOOLDRIDGE, M.J. and JENNINGS, N.R. (1994): Agent theories, architectures, and languages: a survey. Lecture Notes in Artificial Intelligence 890: 1-32. WOOLDRIDGE, M.J. and JENNINGS, N.R. (1995): Intelligent agents: theory and practice. Knowledge Engineering Review 10(2): 115-152. WOOLDRIDGE, M., JENNINGS, N.R. and KINNY, D. (2000): The Gaia methodology for agent-oriented analysis and design. Autonomous Agents and Multi-Agent Systems 3(3): 285-312. XU, H. and SHATZ, S.M. (2003): A framework for model-based design of agentoriented software. IEEE Transactions on Software Engineering 29(1): 15-30. ZAMBONELLI, F. and OMICINI, A. (2004): Challenges and research directions in agent-oriented software engineering. Autonomous Agents and Multi-Agent Sytems 9(3): 253-283. ZHU, H.(2001): SLABS: a formal specification language for agent-based systems. International Journal Software Engineering and Knowledge Engineering 11(5): 529-558.
27
