Multiagent Systems and RoboCup: Specification, Analysis, and Theoretical Results

Transcription

1 Multiagent Systems and RoboCup: Specification, Analysis, and Theoretical Results Kumulative Habilitationsschrift von Prof. Dr. rer. nat. Frieder Stolzenburg November 11, 2005

2

3 3 Table of Contents 0 Introduction and Summary Multiagent Systems and RoboCup Specification, Analysis and Verification Theoretical Results Final Remarks Bibliography I Multiagent Systems and RoboCup 39 1 Intelligente Agenten und KI Die neue KI oder: Was sind Agenten? Architekturen für Multiagenten-Systeme Der RoboCup als Multiagenten-System Anwendungen in der Wissensverarbeitung Schlussbemerkungen Literaturverzeichnis Towards a League-Independent Qualitative Soccer Theory for RoboCup Motivation World Modeling for the Soccer Domain The RoboCup as Case Study Discussion Conclusions Bibliography Qualitative Velocity and Ball Interception Motivation Ball Interception with Numerical Methods Ball Interception with Qualitative Velocity Evaluation Conclusions Bibliography Multiagent Matching Algorithms With And Without Coach Introduction Application Scenarios The Geometric Matching Problem and Prior Work Local and Global Matchings Decentralized Matching Globally Maximal Matching

4 4 4.7 Non-Geometric Matching Conclusion Bibliography II Specification, Analysis, and Verification Spatial Agents Implemented in a Logical Expressible Language Introduction Basic Abilities and Actions (Layer 1) Qualitative Spatial Reasoning (Layer 2) Higher Abilities (Layer 3) Cooperative Behavior (Layer 4) Conclusions Bibliography Towards a Logical Approach for Soccer Agents Engineering Introduction and Overview Execution Model for Flexible Multiagent Scripts The Specification of Multiagent Scripts by Statecharts Implementing Agents with RoboLog Related and Future Work Bibliography From the Specification of Multiagent Systems to their Formal Analysis Introduction Example Applications State Machines Specification of Multiagent Systems System Analysis by Model Checking Related Works and Conclusions Bibliography III Theoretical Results Relating Defeasible and Normal Logic Programming Introduction and motivations Preliminaries Transformations for NLP: classifying well-founded semantics Transformation Properties in DeLP Related Work and Conclusion Bibliography

5 5 9 Computing Generalized Specificity Introduction Defeasible Logic Programming An Inherent Criterion for Comparing Arguments Related Work Conclusions Bibliography Loop-Detection in Hyper-Tableaux by Powerful Model Generation Introduction and Outline of the Paper Hyper-Tableaux Revisited Loop-Detection by Examples Inference Rules for the Enhanced Calculus Other Approaches Conclusions and Future Works Bibliography Appendix 243 A C++ Code 245 A.1 Newton Method for Interception Point Computation A.2 Self Localization B Prolog Code 251 B.1 State Machine in Prolog B.2 Statechart for RoboLog Koblenz C Bibliography 259

6 6

7 0. Introduction and Summary Abstract: Nowadays, we are faced with a world where computing and knowledge processing usually is distributed over a network of computing devices. If these entities are autonomous, we speak of agents. The design and implementation of such multiagent systems differs from that of ordinary software in several respects. First and foremost, it must be feasible to specify the whole system, where all agents may act concurrently and in parallel. All agents have to perform together as a team. In addition, correctness and robustness of the system should be demonstrable. This asks for sophisticated techniques in order to verify certain properties of the whole system with formal methods. Finally, since agents are expected to make decisions on their own, they must be able to reason logically. This should even be possible in the context of contradicting information. Therefore, this thesis comprises works on multiagent systems, their specification and foundations thereof, addressing the above-mentioned topics. After this introductory chapter, which summarizes the author s works, a collection of papers written by the author during the last years is reprinted here. Part I deals with multiagent systems in general and introduces the RoboCup robotic soccer scenario. The topic of specification and analysis of multiagent systems is addressed in Part II. We take semi-formal methods like UML statecharts and put them into the formal context of logic programming with temporal reasoning. Finally, Part III discusses further theoretical results, especially an argumentation framework with defeasible reasoning, needed for autonomous agents. The appendix contains code fragments in the programming languages C++ and Prolog, also written by the author. This code was used in the implementation of the RoboLog Koblenz soccer simulation team. Finally, an annotated bibliography of the author s recent publications concludes this thesis. The research compiled in this thesis has been undertaken by the author at the Universität Koblenz-Landau and the Hochschule Harz in the context of several joint projects, especially one on specification and analysis of multiagent systems, funded by the German research council DFG, led by U. Furbach and the author ( , grants Fu 263/8 and Sto 421/2). Robotic soccer and its formal specification as multiagent system serves as main motivation and testbed for the methods proposed in this thesis, that are applicable in diverse contexts, e.g. autonomous robots and vehicles, service and household robotics, intelligent software agents in a networked world, and other industrial applications. 7

8 8 0. Introduction and Summary 0.1. Multiagent Systems and RoboCup Computer science has been and is still a rapidly changing field. Since the development of the first operational programmable computers at about 1940, hardly more than sixty years ago, many generations of computer hardware brought a dramatic increase in speed and capacity for computing in the meantime. While formerly main-frame computers with a single processor were used from many terminals, nowadays we are faced with a world where computing and knowledge processing usually is distributed over a network of computing devices. The development of new hardware and computer architectures demands for new methodologies of software engineering. One of the current trends is ubiquitous computing. This means, we are confronted with computers in nearly all aspects of our everyday live. In order to make all these computers function together, robustness and flexibility of the single machine, as well as of the whole system is required. This takes for granted that the single computing entities are autonomous to a certain extent, because a central control instance that gives directives may not be available, let alone be desired. The overall system should work, even if any of the other components fail. This led to the fields of intelligent agents and multiagent systems. But what are intelligent agents? According to [RN95, p. 31], an agent is anything that can be viewed as perceiving its environment through sensors and acting upon that environment through actuators and effectors. An agent should behave rationally, i.e. goal-oriented (at least partly) with respect to some performance measure, and autonomously to the extent that its behavior is determined by its own experience. A system of agents, acting in the same environment (preferably as a team), is called multiagent system. Currently, multiagent systems are a field of active research in various disciplines, such as computer science, social sciences and economics. In particular, there is a close link from multiagent systems to artificial intelligence research in computer science Intelligent Agents for Artificial Intelligence The term artificial intelligence (AI) was coined by several scientists, meeting for a two-month workshop in Dartmouth (USA) in 1956, addressing topics like automata theory, neural networks, and the study of intelligence. Although this workshop did not lead to any clear breakthroughs, it introduced the major persons who influenced the whole field for many years, bringing up themes such as automated problem solving, e.g. for proving theorems. Generally speaking, AI attempts to understand intelligence not only by investigating intelligent entities but also by building intelligent artifacts. Clearly, this rather informal definition immediately raises a lot of questions, among them: what does intelligence actually involve, and can artifacts be intelligent at all? We will not answer these more or less philosophical questions here, but start with a more pragmatic definition of AI, namely based on the notion of intelligent, rational agents. Following again the lines of [RN95, p. 7], AI can be viewed as the study and construction of rational agents. Usually, we may think of agents as robots, acting in physical environments. Nevertheless, in the early days of AI, there were not any real robots. At that time, AI research concentrated on abstract problem solving, e.g. playing games like checkers or chess, or moving boxes in artificial blocks worlds, where the environment could be simulated completely

9 0.1 Multiagent Systems and RoboCup 9 within one computer, i.e. with only one single agent. In order to address more realistic problems, certainly multiagent systems (i.e. with more than one agent) have to be considered. But the basic principles for agent architectures are independent of the fact whether a single agent or multiple agents are considered. Therefore, [FOS00] (see Chapter 1) briefly discusses some of the basic architectures for agent systems Chapter 1 (see also [Woo99]). Since agents shall act rationally and autonomously, they must be able to reason logically, which leads to the logic-based approach, involving three main components in essence: the knowledge base of the agent, containing information on how the agent believes the world is like, effectors performing the possible actions of the agent, and an inference mechanism that allows the agent to reason which action should or at least could be done next. The clear advantage of this architecture is its explicit control of the agent behavior by a rulebased logic program. However, this requires explicit symbolic representation of knowledge. Critics of this classical AI approach argued that agents normally do not reason symbolically. A formal, i.e. logic-based representation of knowledge is not necessary, it may even hinder real-time behavior of agents which is required for real robots. In consequence, the subsumption architecture was proposed by R. Brooks at about 1986 [Bro86]. Here, it is assumed that intelligence emerges by the cooperation of many small modules that interact with each other. Nevertheless, also this approach employs formal methods from computer science. Each module can be implemented by a finite state automaton, whose function can be comprised by condition-action pairs stating what action should be done under what condition. These pairs are partially ordered, forming a hierarchy of modules which may suppress or inhibit other modules. In this context, the keyword embodiment also has to be mentioned, because it is closely connected to the subsumption architecture. It states that intelligence without a physical body is impossible. Agents should not only contemplate, but interact with a real environment. Hence, intelligent agents should also be mobile. Here, mobility can be characterized in at least three different ways: (i) the agent itself is able to move, e.g. autonomous lawn-mowers or soccer playing robots in the RoboCup (see [FOS00] and Section 0.1.2), (ii) the agent is a portable device, e.g. a portable web information agent, searching relevant information for a user with a specific profile, implemented by a handheld computer or a mobile phone (which is also discussed in [FOS00], i.e. Chapter 1), or (iii) the agent is a computer program, e.g. written in Java, which is executed on different platforms or machines. In the latter case, we may speak of agents moving through a virtual world like a computer game, a so-called web spider in the internet, or a simulated RoboCup agent. Although currently there is broad agreement in modern AI, that agents should be mobile and interacting with real, physical environments, other architectures for agents have been proposed. In the subsumption architecture, agents are merely reactive. This causes difficulties when agents shall follow longer lasting goals. Therefore, in the belief-desire-intention architecture (BDI), agents do not simply react to external stimuli, but follow their own intentions (constraining future deliberation) which nonetheless may change over time, if e.g. the actual efforts of the agent do not lead to the desired goals. For further details the reader is referred to [FOS00, Woo99] and the literature cited therein. It turns out, that no architecture discussed so far is clearly superior in comparison with the others. Thus, it seems to be a good idea to combine different aspects, e.g. symbolic and

10 10 0. Introduction and Summary subsymbolic knowledge representation, in so-called layered architectures [Woo99]. There, the separate subsystems may be layered horizontally, where each software layer is directly connected to the sensory input and action output, i.e., a layer can be understood as an agent in this case. They may also be layered vertically, where the sensory input is passed from one to the next layer, until an appropriate action can be selected. Usually, the specification of mobile intelligent agents is done by means of a layered architecture, in order to treat different aspects of robot behavior adequately The RoboCup Initiative Mobile intelligent agents playing soccer are suitable to demonstrate many aspects of multiagent systems. Originally, soccer playing robots were proposed from the AI community by A. Mackworth [Mac93]. Later on, this idea was taken up by a Japanese research program in the Robot J-League. This became known to a greater audience, when the first RoboCup competition took place in conjunction with the International Joint Conference on AI (IJCAI) in Interestingly, in the same year, an IBM computer named Deep Blue, capable of processing 200 million chess positions per second, won in an official rematch against the world chess champion G. Kasparov. Thus, a classical AI problem seemed to be solved finally at that time. (In addition, the author finished his PhD thesis [Sto98a] in that year.) Since then, the RoboCup has become a world-wide initiative of fostering research in AI, robotics, and related disciplines, by providing a standard problem where a wide range of technologies can be integrated and examined, e.g. from computer vision, multiagent systems, realtime processing, electrical engineering, and mechanics. The ultimate goal of the RoboCup project (see is to develop a team of fully autonomous humanoid robots that can win against the human world champion team in soccer by the year RoboCup chose the soccer game as a central topic of research, because results from that can be applied to socially more significant problems and industries. Techniques developed in this context are already applied in practice for vacuum cleaners (e.g. Dyson, USA, and Electrolux, Ettlingen), lawn-mowers (e.g. Husqvarna, Sweden, and again Electrolux, Ettlingen), search for victims after a major disaster like an earthquake (in several Japanese projects, see also [Mur03]), and robots cleaning sewers (Fraunhofer, Bonn). After some test games in 1996 in Osaka, RoboCup world championships took place annually at different places of the world since 1997: Nagoya, Paris, Stockholm, Melbourne, Seattle, Fukuoka, Padua, Lisbon, Osaka, and Bremen (in preparation). Since 1999, each competition has been accompanied by an international scientific symposium on subjects related to the RoboCup scenario. In addition, there are national events, also open for international participants, e.g. the RoboCup German Open, taking place in Paderborn every year since RoboCup gained a lot of interest and attracted many spectators, e.g., there were more than 180,000 visitors in Osaka (2005). The RoboCup is divided into different leagues for different types of robot hardware, and not all of them deal with the simulation of soccer. In the following, we will describe some of the robotic soccer leagues briefly. In the mid-size league, competing teams play on fields of size about 5m 10m with four fully autonomous robots per team. The additional usage of one external computer for coordination purposes is allowed. The design of robots in the mid-size league underlies only few

11 0.1 Multiagent Systems and RoboCup 11 restrictions like the maximum size of robots. As the robots are fully autonomous, one central problem is the perception of the environment and dealing with actuators like ball kicking devices. Therefore, many problems in this league rather deal with low-level skills of the agents, e.g. vision or ball handling, than with high-level aspects (team-play). In the simulation league, two teams of eleven autonomous agents compete in a completely simulated soccer match. The two-dimensional (2D), discrete-time simulation is carried out in a client/server style by the so-called Soccer Server [CDF + 03]. It maintains a model of the world containing the positions of all objects on the field, as well as additional information about them, e.g. the velocities of moving objects or the remaining stamina of all players. In each simulation step clients may send one command for moving or manipulating the ball, e.g. dash, kick, or turn, and several minor commands. Recently, also a 3D simulation league has been started [OR04], that will probably replace the 2D competition in the future. In the four-legged robot league, teams consisting of four Aibo robots from Sony each play on a field of about 6 m 4 m. The robots operate fully autonomously, i.e., there is no external control, neither by humans nor by computers, and they can communicate with each other via a wireless network. Since all teams use the same robot hardware in this league, programmers mainly have to solve a software engineering task. In the previous years, teams that only dribble the ball were quite successful, so with the current ratio between robot speed, ball speed, and field size, there seems to be no real need for passing the ball. Therefore, as in the other leagues, the rules changed almost annually, in order to keep the challenge of AI research. For instance, the number of landmarks was reduced, the field size was increased, and the type of hardware was developed further by Sony. The AI research group at the Universität Koblenz-Landau entered the RoboCup with the simulation team RoboLog Koblenz, and participated in the world championships in 1999 (report in [OS99]) and all subsequent years. Agents were designed in Prolog and C++, employing logic and deduction techniques (as stated in [OMSB98] for the first time, see also [BDD + 98]). This procedure was refined during the years, making use of logical and procedural specification and analysis techniques (see also Section 0.2). The author was the leader of the RoboCup activities in Koblenz until 2002, when he got a new position at the Hochschule Harz. There, he currently is building up a new four-legged robot team Harzer Rollers (see Figure 0.1) that made some friendly games with other teams in that league so far Qualitative World Modeling for the RoboCup The involvement in different leagues among others leads to the question, whether it is possible to find league-independent principles of agent behavior design, laying foundations for the design of multiagent systems in general. This was the starting point of the joint work on qualitative world models and the behavior-based agent specification [DFL + 04, DFL + 05] (see Chapter 2) in the context of the special priority program of the German research council on co- Chapter 2 operative teams of mobile robots in dynamic environments (DFG-SPP 1125). The key idea here is to start thinking about the human way of playing soccer, adopting basic primitives and principles from human soccer experts and textbooks, e.g. [Luc02]. Textbooks on soccer theory describe the respective domain in an informal manner, usually with the help of many examples, e.g., there are diagrams showing several situations in a soccer

12 12 0. Introduction and Summary Figure 0.1.: The Aibo team Harzer Rollers at the Hochschule Harz. game on nearly every page in [Luc02]. This is not really surprising, because humans are used to learn by doing examples. However, in order to build and program intelligent agents, a more formal and declarative specification is desirable. Although an abstraction of a concrete situation is present both in textbooks and also in formal specification languages, agent specification requires a sufficiently detailed description. Otherwise, the specification will not be executable by the agent. The diagrams in [Luc02] e.g. do not show the opponents in most cases, and preconditions of the presented soccer tactics are not formulated explicitly, but this is needed for a complete specification. Nevertheless, [Luc02] is quite useful for robotic soccer, because it lists possible team moves (e.g. building up the play or double passing), as it is required in multiagent systems, and not simple training lessons (e.g. for dribbling or headers). So, what can be learned for the specification of multiagent systems in general by this case study? Clearly, every specification of such a system depends on the given domain. But there seem to be some principles independent of the chosen domain, because in every case the environment and the possible agent behavior must be specified somehow. Therefore, (i) static aspects of the environment and (ii) dynamic aspects of the agent behavior must be expressed (iii) on some abstract level, in order to make the whole multiagent system work. Static aspects of soccer certainly are the architecture of the soccer field, the rules of the game, and the different objects involved. The soccer field e.g. can be divided into tactical regions corresponding to player roles in two dimensions: back, midfield, forward; left, center, right. The notions player role and position can be seen as specialization of the abstract notion of an address. This is summarized in [DFL + 05] by a class hierarchy. Hence, standard software engineering means (here: class diagrams) can be exploited for the description of static aspects. They can also be employed for stating the top-level ontology of the offensive tactics in [Luc02]

13 0.1 Multiagent Systems and RoboCup 13 (see [DFL + 04]). In addition, (first-order) logic can be used for the statement of preconditions or describing situations in general. Dynamic aspects are essential in multiagent systems. Hence, basic primitives of agent behavior must be given. Following the lines of [Luc02] where player moves are indicated by different arrow types, [DFL + 05] distinguishes simple player movements, passing and dribbling. Using these primitive actions, more complex behavior can be expressed. For this, a formalism for describing agent behavior is mandatory. This can be done by statecharts or logic programs (see Section 0.2), but also with dedicated action calculi such as Golog as done in [DFL + 05]. Golog [LRL + 97] is a language for reasoning about actions and change and is based on the situation calculus. Properties of the world are described by so-called fluents, i.e. functions and relations with situation terms as their last argument. Formulation of the world model of the agents on an abstract level helps us to become independent from the league and finally from the overall chosen domain. [DFL + 04] discusses this for the reachability relation defined as follows: an object can reach an address iff it can move there and after that the ball is still in possession of the own team. Reachability is a prerequisite e.g. of a passing action. In certain domains, it can be expressed by Voronoi diagrams, whereas in other contexts other procedures may be required. A Voronoi diagram partitions the plane with points into convex polygons such that each polygon contains exactly one point and every point in the given polygon is closer to its central point than to any other. Two positions are then called reachable iff they are in neighboring Voronoi regions. This completely abstracts from special player capabilities and leads to a qualitative representation; we will come back to this in the next section. The approach proposed in [DFL + 05] (i.e. Chapter 2) has been applied in several small case studies to three different RoboCup leagues, including the four-legged league (see [GHR05]) where agents can be described by means of XABSL [LBBJ04], an extensible agent behavior specification language, closely related to statecharts. The biggest lesson learned during these case studies is that we are able to formalize soccer theory on an abstract level. This might not be surprising, however, some of the concepts real soccer experts use are quite fuzzy and hence difficult to define and implement. Remedies for the formalization of static and dynamic system aspects on an abstract level are useful not only for the specification of multiagent systems, but also for their evaluation, because one at first needs to know what should be evaluated, as argued in [DFL + 04] Qualitative Spatial Reasoning For the specification and analysis of multiagent systems, obviously a specific representation of the agents and their environment is necessary. Although this is dependent on the domain as said above, it should be as general as possible. This leads to a so-called qualitative world model that abstracts from the physical reality in order to obtain a robust and easily maintainable model of the reality. A qualitative model may still work, even if the exact (physical) laws are not known. Another motivation for a qualitative approach is that it is likely to be cognitively more adequate, e.g., human soccer players probably do not solve differential equations while chasing the ball. But what does qualitative actually mean in this context? First, a qualitative representation

14 14 0. Introduction and Summary Chapter 3 normally is symbolic, without any continuous numerical values. The physical reality is approximated by a bounded number of states, i.e., the level of precision is decreased. Second, usually a qualitative world model yields only local information relative to the observer, i.e., the frame of reference corresponds to an egocentric point of view. [CDH97] exemplifies this e.g. for positional information. Both aspects are quite useful for multiagent systems: Since agents only have restricted computing resources and should act autonomously, an abstraction of the real world might be helpful. In addition, an agent has only access to local information, e.g. its internal state and a fragment of the external world, hence it has essentially an egocentric view of the world. [SOM02] (see Chapter 3) now investigates the question how an appropriate qualitative world model for intelligent agents in the RoboCup scenario should look like and how far existing qualitative approaches can be employed for this purpose. This research has been done in the context of the project on hybrid spatial deduction in dynamic environments with application to cooperating RoboCup agents, funded by the German research council DFG, (also) led by U. Furbach and the author (grant Fu 263/6), associated with the special priority program on spatial cognition (DFG-SPP 1021). Obviously, robotic soccer agents must be able to orient and navigate in spatial environments. However, in many approaches for spatial reasoning, only navigation in a more or less static environment is considered. But in general, real environments are dynamic, which means that both the agent itself and other objects and agents in the environment move. Thus, in order to perform spatial reasoning, not only (qualitative) distance and orientation information is needed (as e.g. in [CDH97]), but also information about (relative) velocity of objects. Most qualitative approaches in the literature, first and foremost, are dedicated to the cognitively adequate description of physical reality. But in the RoboCup scenario and multiagent systems in general, we want to apply qualitative information to the control of agent behavior in order to program them. In robotics it is therefore necessary to deal with velocity of both the robot and objects in the environment. [SOM02] shows that only qualitative direction and velocity is sufficient for the task of ball interception, by introducing concepts for qualitative and relative object velocity: (quickly) to left, neutral, (quickly) to right. This notion in fact is qualitative in the sense that it corresponds to the concrete object velocity projected to the normal of the line from the agent to the object, relative to the maximal velocity of the agent. One major observation in [SOM02] is that the direction to the interception point need not be given exactly. This is one of the main ingredients for the qualitative approach for ball interception. By applying Mollweide s formula, it can be shown that the distance an agent moves during ball interception increases only by 3.5%, if the angle between the direction of the agent and the goal point does not exceed 30. Because of the high tolerance, an approximating, i.e. a qualitative method seems to be very appropriate in this context. The qualitative method just sketched has been compared in an extensive evaluation, comparing it with other approaches: (i) a numerical approach where the interception point is computed exactly, (ii) a strategy based on reinforcement learning, and (iii) a naïve method where the agent simply goes directly to the actual ball position. The evaluation reveals that the qualitative interception method is slightly better in performance than the naïve approach which discards all information about the movement of the ball. One clear advantage the qualitative interception method has over the numerical and the

15 0.1 Multiagent Systems and RoboCup 15 learned methods, which not surprisingly perform best, is its robustness and portability. For the learned method to work it is necessary that the environment does not change after the learning period, otherwise the whole behavior has to be trained again. The exact numerical method even depends on the complete knowledge of the physical model that describes movements in the environment. The latter is also introduced in [SOM02] (i.e. Chapter 3) and makes use of Newton s method for computing the interception point after only a small number of iterations. This procedure was developed and implemented by the author (F. Stolzenburg) in C++ (see Appendix A) and became part of the RoboLog simulated soccer code base. A prerequisite for every interception method is the ability of self-localization and navigation of the agents. There are several possibilities for doing this. The robot agent may keep track of its own movements (odometry), it may navigate by the means of landmarks, or it may follow walls, if possible. All these methods have advantages and disadvantages, dependent on the specific application. In the RoboCup context, navigation with landmarks seems to be the most appropriate. Different methods are applicable in this context, too, dependent on the fact whether distance sensors are available, and absolute or relative angles between landmarks can be measured. The localization method in [BG97] requires (only) three or more directions to visible landmarks relative to the orientation of the agent. Provided that at least three of them and the position of the agent neither form a circle nor lie on a straight line, the absolute position and orientation of the agent can be computed with a time complexity linear in the number of landmarks. If the corresponding equation system in complex numbers is over-determined, and the data is noisy, the procedure estimates the position applying the least squares method. This method has been adopted for the RoboLog team [MOS00]. The general case for more than three landmarks was implemented by the author (see Appendix A). Appendix A Coordination and Matching A multiagent system consists of many agents in general, negotiating and interacting with each other. Therefore, almost immediately the question comes up, how the behavior of the overall system can be controlled. Another question is how the system behavior (as a function of different utility measures, e.g. Pareto efficiency) changes with respect to distributed rational decision making, if there is a central control instance or not. In applications like the RoboCup scenario, decision making is an important issue, too, because the performance of the team clearly depends on the decisions of the single agents or the whole group of agents, respectively. The question how cooperating teams of robotic soccer agents can be controlled is discussed with the aid of the (geometric) matching problem in [SMS03, SMS05] (see Chapter 4). Chapter 4 It corresponds to the problem of finding the best assignment for man-to-man marking in the RoboCup scenario. Generally speaking, a matching is a (one-to-one) mapping between two sets, satisfying some given constraints. In a multiagent scenario, i.e. in a setting where at least one of the sets corresponds to a group of agents, a number of interesting facets is added to the general matching problem. In this case, the problem can be solved in a decentralized manner with local algorithms or by a global algorithm making use of a central agent, called coach in this context. The matching problem is frequently encountered in computer science and other contexts. Formally, a matching in a graph G is a set of edges such that there are no two edges

16 16 0. Introduction and Summary sharing a vertex. In this context, we are interested in weighted matching, where each edge is associated with a weight w 0. Here, G may be assumed to be a complete bipartite graph, i.e., there is an edge for every pair of vertices from two distinct sets P and Q. In addition, we are interested mainly in complete matchings, i.e. of maximal cardinality. The utility or quality of a matching for a given application is certainly dependent (i) on the chosen optimality criterion and (ii) the use of a coach agent. Concerning the first aspect, many criteria from the field of distributed rational decision making can be adopted in this context, among them: social welfare or general optimality (where the sum of the costs of all agents is minimized), Pareto efficiency (where nobody can be better off unless at least another one is worse off), and stability (i.e., there are no two agents where both agents prefer each other over their current partners). Since stability minimizes the minimal cost for pairs of agents (= distance in the geometric matching problem of the RoboCup and related scenarios), a stable matching is also called (locally) minimal matching in [SMS03, SMS05]. The counterpart of that is a maximal matching (where the maximal distance is minimized), that is also called bottleneck matching in the literature, see e.g. [EIK01]. Unfortunately, as [SMS03] demonstrates, all these criteria are different in general. Yet there are some implication relationships among the matching properties, e.g., Pareto efficiency is implied by (variants of) the other properties. For more details including proofs, the reader is referred to [SMS05] (i.e. Chapter 4). The use of a coach agent or the renunciation of that also leads to completely different multiagent system behavior. The variety of applications for the matching problem reveals that there is a need for both centralized and decentralized matching procedures, i.e. with and without coach. For example, a coach may or may not be used for simulated soccer as discussed in [SMS03]. In another scenario, the use of a central instance may be clearly advantageous, e.g. for a taxi service in a big city, where a headquarters can efficiently assign a free taxi to a waiting customer. However, sometimes a central agent may not be available at all or at least it cannot be relied upon that, e.g. in the unfortunate event of a major disaster extensive rescue actions have to be taken as soon as possible, but communication with a headquarters may very well be broken in this case, and an approach with central control cannot be executed then. In consequence, it may be impossible to compute a globally optimal solution, which demands for new criteria. Therefore, [SMS03] introduces some variants of the matching properties stated earlier (e.g. Pareto efficiency): a matching globally satisfies the corresponding simple property iff it holds for all submatchings, i.e. all subsets of the respective matching; a matching locally satisfies the property iff it holds for all submatchings of cardinality 2. The different criteria and their variants ask for different procedures to compute matchings with the desired properties. [SMS03] provides a decentralized and non-deterministic algorithm for calculating local matchings. Its advantage is that it requires only communication between pairs of agents. However, local matchings may be suboptimal as several examples in [SMS05] indicate. Therefore, it is really worthwhile to consider global matching algorithms. In this context, globally maximal matching, i.e., where the maximal distance in the matching is minimized not only for the whole set but also for each submatching seems to be the most appropriate procedure, because man-to-man marking requires to compute a mapping, such that the agents reach the opponent positions as quickly as possible. It is a generalization of geometric bottleneck matching as considered by [EIK01] which presents an algorithm in O(n 1.5 logn) time. In essence, this algorithm performs a binary search for the smallest possible

17 0.2 Specification, Analysis and Verification 17 length of the maximal distance, using so-called augmenting paths [PS98]. This algorithm is refined in [SMS03] in order to compute globally maximal matchings efficiently, extending the given procedure by one additional outer loop. In the RoboLog soccer simulation team, the coach employs a global ranking-based algorithm for computing a stable matching (called globally minimal matching in [SMS03]). Players are assigned to opponents they have to mark during standard situations [MOS02, Stu03]. This procedure is still useful, if we consider non-geometric matching, e.g. in the cases of heterogenous agent teams. In summary, [SMS03, SMS05] show that the way of controlling multiagent systems (with or without coach) has an immense effect on specification of such systems in general. This aspect of cooperation and coordination of teams of agents is as important as world modeling for single agents as we have seen in the previous sections Specification, Analysis and Verification Programming multiagent systems raises many practical questions, ranging from the problem of self-localization to coordinating multiagent teams, which we already addressed in the previous sections. Yet, the task of specification, design, and implementation of multiagent systems is highly complex, because not only one but several systems consisting of software and hardware, i.e. intelligent mobile agents in general, have to be programmed. The problem is, that on the one hand each agent must be able to proceed autonomously on its own, on the other hand all agents should work together as a team. This asks for structured and systematic methods for the development of multiagent systems. For this, techniques from the fields of artificial intelligence and software engineering may be used. The idea in this thesis is to bring together approaches from both fields that only recently try to combine their specific methods and begin to converge. One of the classical methods for the formal specification of domains in AI are logic-based approaches (see also Chapter 1), while in software engineering, currently semi-formal and object-oriented methods dominate the field. The Unified Modeling Language (UML) comprises several methods in order to express static and dynamic system aspects, e.g. by class hierarchies or state machine diagrams. Formal methods seems to offer an umbrella term in order to harmonize both fields. The semi-formal methods are well-suited and can be used not only by computer scientists and programmers. Therefore, if they are equipped with a formal semantics (see e.g. [Sch03]), not only system specification is possible, but also (after possibly applying several transformation steps) an executable agent program can be obtained automatically. This lays the basis for formal system analysis and verification. Over the time, the development of the RoboLog soccer simulation team employed all the methods just mentioned (logic-based, semi-formal, and their combination), which is stated in more detail in the next sections A Logic-Based Approach A logic-based agent chooses an action that logically follows from its knowledge base by some inference mechanism. At least it should not be concluded that the action should not be done. A

18 18 0. Introduction and Summary Cooperative Behavior Higher, Complex Abilities Qualitative Spatial Reasoning Prolog Basic Skills and Perception RoboLog SoccerServer Figure 0.2.: Original system architecture of the RoboLog team. Chapter 5 declarative programming language which has built-in inference mechanisms for logical reasoning (namely SLD-resolution for first-order definite clause logic programs) is Prolog. In fact, it is possible to design agents by means of logic programming and deduction techniques. This has been done during the development of the RoboLog team. In the first implementation of the team [OMSB98, SOMB00], there was an interface to the ECLiPSe Prolog system [ECL98], while later on SWI Prolog [Wie00] was used (because of the improved efficiency for this specific application and the robust C++ interface) [MOS01a, MOS01b]. Figure 0.2 shows the original architecture for agents of the RoboLog team in the 2D RoboCup soccer simulation league with four layers as introduced in [SOMB00] (see Chapter 5), which is inspired a bit by the InterRap architecture [Mül97, Woo99]. A layered architecture seems to be advantageous, if one wants to combine a logic-based approach that requires a more or less discrete, propositional, and hence qualitative presentation with (simulated) robot agents that have to react in real-time utilizing continuous, numerical, and hence quantitative data. Concerning the higher, more qualitative levels of the RoboLog system, Prolog is employed, whereas the kernel, i.e. the basic layer of the system architecture in [SOMB00], is implemented in C++. The basic layer hosts reactive behavior. Time critical tasks are handled within this module, as well as the exchange of data. It provides the Soccer Server commands dash, kick, say, turn, and some more complex actions, e.g. position determination. Spatial cognition and hence predicates expressing information about the current situation of the agents is the contents of the second layer. For example, players have to recognize when passing the ball is possible or a player is offside. The last two layers host behaviors for complex situations, possibly requiring teamwork, i.e. single- or multiagent plans. The third and partly also the neighboring layers host higher abilities such as passing. We investigated, how far it is possible to employ purely logical, i.e. axiomatic approaches. From an axiomatic point of view, passing the ball e.g. is possible in a situation where one player has the ball, another player can be reached and there is no player (of the opposite team) in between. We modeled these situations on top of the logical relations left, right and between. The properties

19 0.2 Specification, Analysis and Verification 19 of the qualities can be axiomatized by means of general geometric axioms [BS60] with (an ordered version of) between as base relation. However, for axiomatic approaches in general, there is one problem: how can negative information be deduced, e.g., if we want to know that there is no opponent in between. With Prolog alone this is not possible, because the built-in negation as (finite) failure [Llo87] is incomplete in general, and, since real-time behavior is required, the use of a more general theorem proving system is not indicated. The RoboLog kernel also provided the possibility of communicating messages in the Knowledge Query and Manipulation Language (KQML) format, where we considered the performatives ask, tell and sorry. Experiments showed that e.g. the passing success rate can be improved by employing communication, if there is enough time for it (see [MOS01a]). Many tasks require deeper reasoning, which can be expressed within a BDI agent architecture [Rao96] (see also Chapter 1). In the context of the RoboLog system, a belief b is a qualitative predicate q, its negation or a conjunction of beliefs. A goal g is either an achievement goal!q or a test goal?q, where q is a qualitative predicate. A desire d is a goal or an action. Now we can build rules for a certain situation in form of scripts, written d : b i, where d is a desire, b is a belief (identifying the precondition of the situation), and i is the intention or, strictly speaking, the intended plan, given by a tree of desires. Edges outgoing from test goals are labeled with yes or no and possibly a time-out delay. An achievement goal has to be performed actively by the actor. The advantage of this procedure is that it allows a rigorously formal specification of agent behavior with a direct translation into executable Prolog code (which is described in [SOMB00]), while it seems that logic is not actually used as implementation language in [Rao96]. But the script language just sketched is only suitable for modeling single-agent plans. Therefore, we have to extend it in order to describe cooperative behavior, which is located in the fourth layer of the architecture stated in [SOMB00]. Then, a desire d is a goal or an action, indexed by a list of agents (the actors), which must satisfy the desire by performing some actions. Now the intended plan i becomes an acyclic graph of desires with a designated start node. Its edges are labeled with actors which must be a subset of the actors in d. We consider now all possible subgraphs wrt. edges for a certain actor. These subgraphs represent the role for the respective actor. Achievement goals are performed by the indexed actors, while the other actors wait for the achievement until a certain time limit. As example of a collective action, double passing is considered in [SOMB00] (i.e. Chapter 5) and (after that) also by many others in the RoboCup community (see e.g. [DFL03, MV02]), perhaps because it is one of the simplest, but sufficiently complex cooperative behaviors in robotic soccer with only two actors. It was successfully integrated in the RoboLog system, demonstrating that a purely logic-based approach is suitable for the implementation of multiagent systems Specification with UML Statecharts One of the advantages of the logic-based approach in [SOMB00] (just stated) is that it enabled programmers to specify multiagent behavior in an explicit manner by means of simple (first-order) logic programming with Prolog. But the rigidity of this model proved to be one of its major disadvantages. Once a plan had been selected for execution, it was difficult to interrupt or stop it, when external events or other agents required this. Only time-limits were