At each level an agent only considers data at an appropriate level of detail, i.e., a commander does not have to generate detailed plans at the unit level. Infantry.
Logic-based Multi-Agent Systems for Conflict Simulations A preliminary report on architecture and implementation
Eduardo Alonso, Daniel Kudenko Artificial Intelligence Group Department of Computer Science University of York, York YO10 5DD telephone: +44-1904 432738, fax: +44-1904 432767 {ea,kudenko}@cs.york.ac.uk
Abstract This paper presents some preliminary results on the architecture and implementation of a logic-based multi-agent system in a conflict simulation domain. On a micro/agent level, we introduce the planning and learning mechanisms of the agents. On the macro/multi-agent system level, a command and control hierarchy is presented. Finally, some details of the implementation are given. This paper extends previous papers [Alonso & Kudenko, 1999; Kudenko & Alonso, 2000], where the project to apply learning techniques to adaptive logicbased multi-agent systems was first introduced.
1.
Introduction
In past papers we introduced a project on applying learning techniques to adaptive logic-based multiagent systems (MAS) [Alonso & Kudenko, 1999]. In this follow-up paper we present a report on the progress in the design and implementation of this system. Our research builds on the hypothesis that agents in complex dynamic MAS need large amounts of background knowledge. We argue that logic-based MAS are therefore a suitable candidate for the design and implementation of such systems. In complex scenarios it is generally infeasible for a MAS designer to foresee all possible situations that agents can find themselves in, and, consequently, agents will have to evolve and adapt to the environment. We propose two logic-based learning mechanisms, Explanation Based Learning and Inductive Logic Programming to tackle this learning problem. Our hypothesis is that logic-based learning techniques improve agents’ performance in complex multi-agent scenarios because they enable an agent to explicitly incorporate domain knowledge in the learning process. We have chosen conflict simulations as a suitable test domain for this hypothesis. In this paper we report on the progress of our project. We discuss both the individual agents and the multi-agent system’s architecture, drawing special attention to organisation, planning and learning issues. The remainder of the paper is structured as follows. In the next section, we introduce and motivate conflict simulations as the application domain of our MAS. The third section describes the agents’ individual architecture. In the fourth section, we consider the organisational structure (the control and communication rules) of the multi-agent system. In Sections 5 and 6, we discuss the planning and learning techniques. In Section 7, we discuss multi-agent planning and multi-agent learning in our system. Some technical details about the implementation of the system are given in Section 8. Finally, in the last two sections we review related work and consider further research. 2.
Conflict Simulations
Conflict simulations (or war games) can be defined as models of military confrontations [Dunnigan, 1992]. These models include a map of a battlefield, military units, and a set of simulation rules that define the abilities of the units, combat resolution, terrain effects, etc. (see Figure 1 for an example). The scale of simulation models can range from tactical skirmishes to grand strategic campaigns.
Figure 1. A conflict simulation battlefield. Conflict simulations are widely used by the military to train personnel and to develop and test battle strategies. As was explained in detail in [Alonso & Kudenko, 1999], conflict simulations are a suitable and challenging application domain to test and evaluate logic based multi-agent systems because of the following properties: • • •
A large amount of useful background knowledge is readily available in the form of the simulation model; The complexity of the simulation model can be easily varied which facilitates tests how well the multi-agent system scales-up; The diversity of conflict simulation models, which poses a challenge to the generality and the adaptivity of the multi-agent system.
Conversely, adaptive logic-based multi-agent techniques are highly promising for creating an intelligent computer opponent for conflict simulations for the following reasons: • • •
3.
Domain knowledge is crucial for intelligent behaviour. Logic based agents are able to use the knowledge available in planning and learning and are thus ideally suited; Since a global search for the optimal strategy is usually not possible, the search process has to be distributed by using a multi-agent approach; Multi-agent systems are suitable for the implementation of command hierarchies that are the basis of military organisations.
Single-Agent Architecture
The agent architecture is depicted in Figure 2. In this section we describe briefly the individual components. More detailed information on planning and learning can be found in later sections. Knowledge Bases: An agent has three different knowledge bases: one containing perfect information about the rules of the simulation, one containing induced knowledge about the opponent’s behaviour, and one where a history of past successes and failures are stored to serve as training examples for learning. Planning: The agents in our system perform pro-active and goal-oriented planning. The knowledge sources serve as the basis for the planning module. After each action (i.e., executed plan step), the agent verifies whether the plan is still valid. If not, plan adjustment or replanning is necessary. We intend to use contingent and conditional planning algorithms in the future which will make plan adjustment more feasible. Learning: After an action has been executed and the result can be observed, it can be potentially used as a training example for the Machine Learning algorithms. The learning result is added to the respective knowledge base: results of explanation-based learning are added to the perfect knowledge base (given that the generalisation process was based on perfect knowledge itself), and the results of inductive logic programming are added to the imperfect knowledge base since there is no guarantee of correctness for inductive reasoning.
Figure 2. An integrated planning and learning architecture.
There are two classes of agents in our system: Units and commanders. A unit is an agent that is physically present on the map and interacts directly with the environment. By contrast, commanders are “virtual” agents that are acting by sending orders to other agents under their command. More details on this hierarchical organisation are given in the next section.
4.
Multi-Agent System Organisation
We have chosen a command and control hierarchy as a natural organisational structure for the conflict simulation domain. In this type of organisational structure, the authority for decision making and control is concentrated in a single problem solver (or specialised group) at each level of the hierarchy. At the top of the hierarchy, agents have to form and execute abstract plans to accomplish high-level goals. To do so, they are provided with abstract general-purpose knowledge. On the other hand, agents at the bottom use more detailed domain specific knowledge to execute precise actions. An example hierarchy is shown in Figure 3. At each level an agent only considers data at an appropriate level of detail, i.e., a commander does not have to generate detailed plans at the unit level.
Battlegroup Lieutenant
Company Captain
Squad Sergeant
Infantry
Tank
Company Captain
Squad Sergeant
Infantry
Tank
Squad Sergeant
Infantry
Tank
Squad Sergeant
Infantry
Figure 3. An example of a command and control hierarchy.
Tank
Different advantages come from using this kind of hierarchies, namely: • • •
• •
It has been shown that distributing problem solving over several levels of abstraction reduces the time complexity of the planning process [Korf, 1987; Montgomery & Durfee, 1993]. In a hierarchical MAS, the learning module can be applied within each abstract problem space. Since the abstract problem spaces define more general and thus simpler problems and theories, agents learn more efficient and appropriate rules [Knoblock et al., 1991]. Plan revision is facilitated. If only the local situation changes, only the plans at the unit level are affected --- there is no need to change the overall plan. This would not be the case if the company commander had initially planned at the lowest level of detail. However, if there is a significant deviation from the expected situation, then the high level plan has to be revised (see also Section 5). Coverage, connectivity, and capability [Corkill & Lesser, 1983] are ensured. Negative interactions are avoided by distributing organisational responsibilities among different commanders in different areas of the map and keeping the units as independent as possible. Coordination and communication costs are reduced as horizontal communication (communication among agents at the same level of the hierarchy) is avoided and vertical communication is restricted to orders and requests (see below).
Different levels in the hierarchy correspond to different abstractions of the problem space. In our simulator, abstraction refers to the different granularity of knowledge that different agents have about both the terrain and other agents. The granularity of the knowledge (i.e. the world view) of an agent depends on the hierarchy level where this agent is situated. Terrain abstraction: At the lowest level of abstraction, specific locations ([X,Y] coordinates) can display one of a set of different terrain features (e.g., plain, forest, mountain, city). Higher up in the hierarchy, the commanders ignore individual locations, but rather summarize them in larger units such as areas and subareas of the map. For example, the locations whose coordinates range between 0 and 30 belong to the north-east area. Those whose coordinates range between 0 and 10 form the north-east subarea in the north-east area. Terrain features of areas and subareas are dependent on the dominant terrain feature in the corresponding set of locations. For example, a subarea is mountainous if more than a predefined percentage of the locations in such an area are mountains. Subareas (and areas) are considered to be ‘’mixed’’ if there is more than one dominant feature. For instance, mixed(nwse, [mountain, swamp]), means that the subarea north-west of the area south-east has more than t per cent of mountains and t per cent of swamps in it, where t is a pre-defined threshold value. Agent abstraction: Agents are organized in groups and commander agents higher up in the hierarchy view a group not as a set of individual agents, but rather as a single “super-agent”. The properties of this super-agent are a summary of the properties of the individual agents (average mobility, average strength, etc.). As mentioned before, communication in our command and control hierarchy is restricted to vertical message-passing. An agent communicates with its direct superiors by sending requests and confirmations, and with his direct subordinates by sending orders. No other types of communication take place. Overall, we believe that the hierarchical agent organization will reduce both coordination and communication costs and thus lead to increased efficiency.
5. Planning We have chosen STRIPS [Fikes & Nilsson, 1971] as the most suitable formalism for the representation of actions. In STRIPS, an action is represented with three lists: • • •
preconditions: a list of atomic formulae that need to be true for the action to occur; delete list: a list of those primitive relations no longer true after the action is performed; add list: a list of the primitive relations made true by the action.
Even though STRIPS is restricted in its expressiveness (only atomic formulae are permitted in the conditions), we do not foresee any need for more expressive formalisms in our application domain. Furthermore, most efficient planning algorithms to date operate on STRIPS representations. We have chosen a variant of the Graphplan algorithm [Blum & Furst, 1997] for the planning module of our agents. Graphplan systems are among the most efficient planners available today [Weld, 1999], while still being sound and complete. A major advantage of choosing Graphplan is its extensibility, e.g. for conditional planning [Anderson et al., 1998], contingent planning [Weld et al., 1998], temporal planning [Smith & Weld, 1999], and probabilistic planning [Blum and Langford, 1999]. Since actions have associated costs in our simulation model, we modified the basic Graphplan algorithm so that it enables agents to compute a minimal cost plan. In our multi-agent system planning can be viewed as a process of goal refinement: The process starts when the commander at the top of the organization hierarchy adopts an abstract goal and forms an abstract plan (CONceptPLAN in military jargon) to achieve it. This plan consists of orders for his immediate subordinate agents. Such orders are then adopted as goals by the subordinates. The process continues down the hierarchy to the unit level, where the agents will form and execute detailed plans (OperationalPLANs) to achieve their goals. The process can be illustrated with the following example where a commander orders a battlegroup to move to the north-east area of the map. Goal(lieutenant, location(battlegroup, NE)). Plan(lieutenant, [ask(captain1, location(company1, NES)), …
]).
Goal(captain1, location(company1, NES)). Plan(captain1, [ask(sergeant1, location(squad1, NESW)),… ]). Goal(sergeant1, location(squad1, NESW). Plan(sergeant1, [order(unit1, location(unit1, [3,1])),… ]). Goal(unit1, location(unit1, [3,1]). Plan(unit1,[move([0,0],[1,0]), move([1,0],[2,1]),move([2,1],[3,1])]).
6. Learning One of the major problems in the implementation of agent systems is the difficulty for a developer to foresee all potential situations an agent could encounter and specify agent behaviour optimally in advance. This is especially true for multi-agent environments. Therefore it is widely recognised in the agent community that one of the more important features of intelligent agents is their capability to adapt and learn (e.g., Russell and Norvig, 1995). A lot of work has been recently produced on this topic, particularly in the field of learning in multi-agent systems (e.g., [Sen, 1998; Weiss, 1997]). It is, however, worth noticing that whereas in some cases logic is used to specify the (multi-)agent architecture in order to incorporate domain knowledge, most learning algorithms that have been applied to agents are not logic-based, and instead other techniques such as reinforcement learning [Kaelbling et al. 1996] are used. Even though these techniques are successful in restricted domains, they strip agents of the ability to adapt in a domain-dependent fashion, based on the background knowledge of the respective situation. This ability is crucial in complex domains where background knowledge has a large impact on the quality of the agents’ decision making. As a solution to this problem, we propose to apply logic-based learning techniques. Learning in our multi-agent system can be divided into two categories: • Speed-up learning, i.e., the optimization of existing knowledge for the planning process and thus improving the system’s problem-solving capabilities; • Acquisition of new knowledge, specifically knowledge about opponent behaviour. Explanation-Based Learning (EBL) and Inductive Logic Programming (ILP) will respectively be used to cope with these learning tasks.
6.1. Explanation-based Learning In our system, agents are provided with perfect knowledge about the rules of the simulation. We know, however, that computing a solution (i.e., a plan) directly from basic principles is a hard problem in terms of complexity. EBL adds potentially useful macro-operators to the knowledge base and thus speeds up the search process for an optimal solution. EBL has been widely used in Artificial Intelligence to speed-up the performance of planners (e.g, in Prodigy [Carbonell et al., 1990]). Generally speaking, the agents are concerned in improving the efficiency of the problem solver rather than acquiring new knowledge. Obviously, problem solvers, when presented with the same problem repeatedly, should not solve it the same way and in the same amount of time. On the contrary, it seems sensible to use general knowledge to analyse, or explain, each problem solving instance in order to optimise future performance. This learning is not merely a way of making a program run faster, but a way of producing qualitative changes in the performance of a problem-solving system. In short, EBL extracts general rules from single examples by generating an explanation why the system succeeded or failed, and generalising it. This provides a deductive (rather than statistical) method to turn first-principles knowledge into useful, efficient, special-purpose expertise. The learned rules enable the planner to make the right choice if a similar situation arises during subsequent problem solving. We sketch how EBL works with a simple example. Let us assume that a commander has sent its units to eliminate an enemy unit and that these units have chosen their locations in such a way that the enemy is surrounded. Let’s assume that they are successful and achieve their goal. In order to explain this success, the commander uses then the following rules that were not used previously (although they have been always in its knowledge database): •
• •
Fact: Each unit has a zone of control, the six hexagons adjacent to its current location Rule 1: A unit entering an enemy zone of control must stop its movement phase Rule 2: A unit withdrawing into an enemy zone of control is eliminated
With these rules is now easy for the commander to explain the success of its section. They succeeded because they surrounded the enemy unit, cutting all its possible paths of withdrawal. This rule is then generalised: •
EBL Rule: If a unit is surrounded, then it is eliminated
This new deduced general rule is then added to the knowledge database and used directly to elaborate more precise plans more quickly. Of course, nothing new was learned. Theoretically, the agents could deduce such a rule from the original database. However, it would have been a more expensive process to do so.
6.2. Inductive Logic Programming It is one thing to deduce from general rules the order and assignment of the subtasks that should, in theory, lead an army to victory; it is another to learn from examples (and some prior knowledge) whether the conditions for such subtasks to be executed successfully do actually hold. In contrast to EBL methods, ILP computes a hypothesis not just based on simulation rules known beforehand but also on external and initially unknown circumstances such as opponent’s strategies. Generally, relying exclusively on EBL-generated rules can turn out to be impractical in real-world domains in which agents work with incomplete knowledge, and thus ILP is an important addition to the system’s effectiveness.
ILP methods compute an inductive hypothesis with the help of training data (positive and negative examples) and background knowledge. As depicted in Figure 4, agents collect training examples based on executed actions and plans and their outcome. This, together with the domain knowledge base and a target predicate (e.g., success or failure) forms the basis of the inductive learning process which computes a hypothesis (i.e., a definition of the target predicate) that can be used in subsequent planning. Target predicates are given by the system designer. Once a certain number of training examples are classified incorrectly (i.e., the agent makes a certain number of mistakes in its predictions of action outcomes) a new hypothesis will be computed based on the extended training set.
Figure 4. Inductive Logic Programming in progress. We illustrate the use of ILP in our system with an example. An agent might deduce the following rule from the current knowledge base (taking into account, for example, the units’ combat strength). •
Rule: If a single tank unit attacks an infantry unit on a bridge, it is successful
The unit uses this rule to compute and execute an appropriate plan (move to the adjacent location, etc). The plan, however, fails repeatedly (e.g., the infantry unit withdraws and blows the bridge up). These new examples contradict the above rule. ILP will be used to find a new hypothesis
•
Hypothesis: If a single tank unit attacks an infantry unit on a bridge, it is not successful
The unit will then rule out a frontal attack and try to find an alternative plan (e.g., moving some friendly units to the other side of the bridge first).
7.
Multi-Agent Planning and Multi-Agent Learning
Generally speaking, planning in our system can be viewed as centralised planning for distributed plans [Fischer, 2000]. On the one hand, agents do not work as a team in the sense described in [Cohen & Levesque, 1991]. In complex societies, such as an army, the amount of communication needed for the agents to agree on a joint plan would overload the system. That’s why the responsibility for making decisions is delegated to ‘’coordinators’’, the commanders. Consequently, agents only act when they receive orders. On the other hand, agents in our system work as independently as possible. Once the agents have received an order, they are free to use their domain-specific knowledge to form and execute their own plans to satisfy the goal described in such an order. The commanders thus give the goals, but not the plans. Planning responsibilities are delegated at the different levels of the hierarchy according to the agents’ knowledge and skills, and some geographical parameters.
As for learning, each agent learns on his own how to improve its skills. Units will learn how to succeed in moving and attacking the enemy. Commanders, whose skills and action repertoire are limited to give orders, will learn how to have their sections effectively coordinated. Coordination is a matter of command. Consequently, units do not learn how to co-operate. Commanders do. Some might argue that this is a type of ‘’isolated’’ learning [Stone & Veloso, 1998], since agents seem to learn separately and individually. On the other hand, what a unit learns will affect the planning and learning processes of other agents. If a unit learns how to achieve its goal effectively, its commander will assign it the same task in a similar operation. If the unit learns that it cannot achieve the goal, it will be replaced or the original commander’s plan will change accordingly.
8.
Implementation
The implementation of our MAS consists of two parts, as illustrated in Figure 5. The user interface (user input, map/agent visualization, plan/move visualization, communication visualization, and agent hierarchy visualization) is being implemented in JAVA. The simulation server and the agents are being implemented in Progol [Muggleton, 1995], a Prolog interpreter augmented with an inductive logic programming algorithm.
Figure 5. Implementation diagram.
The simulation itself is synchronized and turn-based. All agents of one side send their actions to be executed simultaneously to the simulation server, which then computes a world-update accordingly and sends the changes back to all agents. Afterwards the agents of the opposing side take their actions, and so on. Communication is implemented in MAS-Progol, a multi-agent version of Progol that is being developed in the AI research group at the University of York. It enables an agent to send Prolog goals to other agents and receive variable bindings or truth values in return. The communication protocol provided by Progol can be viewed as a subset of the KQML protocol [Finin et al., 1997]. Since our system contains only homogeneous agents communicating in a rather restricted way, full KQML will not be needed.
9.
Related Work
Our work is closely related to other research in various areas: •
•
•
•
Multi-Agent Systems: our work is related to model-based collaborative systems such as GRATE* [Jennings, 1995], COLLAGEN [Rich & Sidner, 1998] and STEAM [Tambe, 1997]. However, the capabilities that the agents need for collaboration in such systems are designed from the start, so learning is not an important part in the agents’ architecture. Machine Learning: Naturally, EBL has been extensively used in the planning literature to improve effectiveness (e.g., in SOAR [Laird et al., 1987] and Prodigy [Carbonell, et al. 1990]), but only in single-agent domains. Our work is also closely related to [Knoblock et al. 1991] research in integrating abstraction and EBL. Our work will benefit from recent work by Tara A. Estlin on how to apply multi-strategy learning to improve planning efficiency and quality [Estlin, 1998]. Multi-Agent Learning: Most implementations of multi-agent learning continue to use reinforcement learning and neural networks techniques (see [Weiss, 1999]). Only [Sugawara & Lesser, 1998] have used EBL techniques in a multi-agent scenario. However, they do not separate out coordination in teamwork and coordination in general. As a result, they fail to exploit the responsibilities and commitments of teamwork in building up coordination relationships. Conflict Simulations: There have been approaches in the past to implement computer forces for military research [Calpin, 1998; Tambe, 1997]. Approaches that were not based on multi-agent techniques suffered strongly from a lack of unit coordination. Recent research systems employ multi-agent techniques (e.g., [Baxter, 1998]), but logic-based approaches for learning and adaptation have not yet been thoroughly studied in this domain.
10. Conclusions and Further Work We have presented some preliminary results on the architecture and implementation of a logic-based multi-agent system and the application to conflict simulation domains. On an agent level, we have introduced the planning and learning mechanisms with which the agents are provided. On the multiagent system level, a command and control hierarchy was presented. Finally, some details of the implementation were given. The implementation and design of the multi-agent system is ongoing work and we plan to evaluate the system using the following three criteria: • Effectiveness of the multi-agent system, by recording win/loss statistics against humans and reactive systems; • Learning/adaptation ability, by testing the system against varying opponent strategies and in varying environments; • Effectiveness gained from background knowledge, by comparing the performance of different versions of the multi-agent system with different amounts of domain knowledge. Future work will also include the extension of the system to more realistic scenarios: weather and time constraints as well as more types of units (fighters, amphibious) and actions (transport, etc.) are to be incorporated. As the model scales up, agents will have to evolve in increasingly uncertain domains. To handle this problem, sensing actions [Weld et al., 1998], conditional planning [Anderson et al., 1998], and probabilistic planning [Blum and Langford, 1999] will be considered.
References Alonso, E. & Kudenko, D. (1999). Machine learning techniques for Adaptive Logic-based Multi-Agent Systems. In Proceedings of The Second Workshop of the UK Special Interest Group on Multi-Agent Systems. Bristol: Hewlett Packard. Anderson, C., Smith, D. & Weld, D. (1998). Conditional effects in Graphplan. In Proceedings of The Fourth Conference on AI Planning Systems. Pittsburgh, PA.
Baxter, J.W. (1998). A model for co-ordination and co-operation between CGF agents. In Proceedings of The Eight Conference on Computer Generated Forces and Behavioral Representation. Orlando, Florida. Blum, A.L. & Furst, M.L. Intelligence 90: 281-300.
(1997). Fast planning through planning graph analysis. Artificial
Blum, A.L. & Langford, J. (1999). Probabilistic Planning in the Graphplan Framework. In The Proceedings of ECP’99. Berlin: Springer-Verlag. Calpin, J.A. (1998). Performance of the DARPA command forces program in the STOW97 ACTD. In Proceedings of The Eight Conference on Computer Generated Forces and Behavioral Representation. Orlando, Florida. Carbonell, J., Knoblock, C. & Minton, S. (1990). PRODIGY: An integrated architecture for planning and learning. In van Lehn, K. (ed.) Architectures for Intelligence. Lawrence Erlbaum Associates: Hillsdale, NJ. Cohen, P. R. & Levesque, H.J. (1991). Teamwork. Nous 25, 487-512. Corkill, D.D. & Lesser, V.R. (1983). The use of meta-level control for coordination in a distributed problem solving network. In Proceedings of IJCAI-93, 748-756. Dunnigan, J.F. (1992). The Complete Wargames Handbook. Morrow: New York. Estlin, T. (1998). Using Multi-Strategy Learning to Improve Planning Efficiency and Quality. PhD thesis, University of Texas at Austin. Fikes, R.E., & Nilsson, N.J. (1971). Strips: A new approach to the application of theorem proving to problem solving. Artificial Intelligence 2(3-4): 189-208. Finin, T., Labrou, Y. & Mayfield, J. (1997). KQML as an agent communication language. In Bradshaw, J. (ed.) Software Agents, 291-316. MIT Press: Cambridge, MA. Fisher, K. (2000). Problem Solving and Planning. In Klusch, M., Fischer, K., & Luck, M. (eds.) Working Notes of The Second European Agent Systems Summer School, EASSS- 2000. Saarbrucken, Germany. Jennings, N.R. (1995). Controlling cooperative problem solving in industrial multi-agent systems using joint intentions. Artificial Intelligence 75: 195-240. Kaelbling, L.P., Littman, M.L. & Moore, A.W. (1996). Reinforcement learning: A survey. Journal of Artificial Intelligence Research 4: 237-285. Knoblock, C.A., Minton, S. & Etzioni, O. (1991). Integrating Abstraction and Explanation-Based Learning in PRODIGY. In Proceedings of The Ninth National Conference on Artificial Intelligence AAAI-91, 93-102. Menlo Park, CA: AAAI Press. Korf, R.E. (1987). Planning as search: A qualitative approach. Artificial Intelligence 33(1): 65-88. Kudenko, D. & Alonso, E. (2000). Machine learning techniques for logic based multi-agent systems. In Proceedings of The First Goddard Workshop on Formal Approaches to Agent-based Systems. Greenbelt, MD. Laird, J.E., Newell, A. & Rosenbloom, P.S. (1987). SOAR: an architecture for general intelligence. Artificial Intelligence 33(1): 1-64. Levesque, H.J., Reiter, R., Lesperance, Y., Lin, F. & Scherl, R.B. (1997). GOLOG: A logic programming language for dynamic domains. Journal of Logic Programming 31, 59-84.
McCarthy, J. & Hayes, P.J. (1969). Some philosophical problems from the standpoint of artificial intelligence. In Meltzer, M. & Michie, D. (eds.) Machine Intelligence 4, 463-502. Edinburgh University Press. Mitchell, T.M., Keller, R. & Kedar-Cabelli, S. (1986). Explanation-based generalisation: A unifying view. Machine Learning 1: 4-80. Montgomery, T. A. & Durfee, E. H. (1993). Search reduction in hierarchical distributed problem solving. Group Decision and Negotiation 2: 301-317. Muggleton, S. & de Raedt, L. (1994). Inductive logic programming: theory and methods. Journal of Logic Programming 19: 629-679. Muggleton, S. (1995). Inverse entailment and progol. New Generation Computing Journal, 13: 245286. Rich, C. & Sidner, C. (1998). COLLAGEN: When agents collaborate with people. In Huhns, M. N. & Singh, M.P. (eds.) Readings in Agents, 117-124. Morgan Kaufmann: San Francisco, CA. Russell, S. & Norvig, P. (1995). Artificial Intelligence: A Modern Approach. Prentice Hall: Upper Saddle River, NJ. Sen, S. (1998). Special issue on evolution and learning in multi-agent systems. International Journal of Human-Computer Studies 48. Smith, D. & Weld, D. (1999). Temporal Planning with Mutual Exclusion. In The Proceedings of the Sixteenth International Joint Conference on Artificial Intelligence, Stockholm, Sweden. Sugawara, T. & Lesser, V. (1998). Learning to improve coordinated actions in cooperative distributed problem solving environments. Machine Learning 33: 129-153. Tambe, M. (1997). Towards flexible teamwork. Journal of Artificial Intelligence Research 7: 83-124. Weiss, G. (1997).Distributed Artificial Intelligence meets Machine Learning. Proceedings of The European Conference on Artificial Intelligence ECAI-96 Workshop. Berlin: Springer. Weiss, G. (1999). Multiagent Systems: A modern approach to Distributed Artificial Intelligence. The MIT Press: Cambridge, MA. Weld, D., Anderson, C. & Smith D. (1998). Extending Graphplan to handle uncertainty and sensing actions. In Proceedings of The Sixteenth National Conference on Artificial Intelligence. Madison, WI. Weld, D. (1999). Recent advances in AI planning. AI Magazine 20(2): 93-123.
