Jan Murray

Qualitative Velocity and Ball Interception

In many approaches for qualitative spatial reasoning, navigation of an agent in a more or less static environment is considered (e.g. in the double-cross calculus [12]). However, in general, real environment are dynamic, which means that both the agent itself and also other objects and agents in the environment may move. Thus, in order to perform spatial reasoning, not only (qualitative) distance and orientation information is needed (as e.g. in [1]), but also information about (relative) velocity of objects (see e.g. [2]). Therefore, we will introduce concepts for qualitative and relative velocity: (quick) to left, neutral, (quick) to right. We investigate the usefulness of this approach in a case study, namely ball interception of simulated soccer agents in the RoboCup [10]. We compare a numerical approach where the interception point is computed exactly, a strategy based on reinforcement learning, a method with qualitative velocities developed in this paper, and the naive method where the agent simply goes directly to the actual ball position.

Towards a Logical Approach for Soccer Agents Engineering

Building agents for a scenario such as the RoboCup simulation league requires not only methodologies for implementing high-level complex behavior, but also the careful and efficient programming of low-level facilities like ball interception. With this hypothesis in mind, the development of RoboLog Koblenz has been continued. As before, the focus is laid on the declarativity of the approach. This means, agents are implemented in a logic- and rule-based manner in the high-level and flexible logic programming language Prolog. Logic is used as a control language for deciding how an agent should behave in a situation where there possibly is more than one choice. In order to describe the more procedural aspects of the agent,s behavior, we employ state machines, which are represented by statecharts. Because of this, the script language for modeling multi-agent behavior in [8] has been revised, such that we are now able to specify plans with iterative parts and also reactive behavior, which is triggered by external events. In summary, multi-agent behavior can be described in a script language, where procedural aspects are specified by statecharts and declarative aspects by logical rules (in decision trees). Multi-agent scripts are implemented in Prolog. The RoboLog kernel is written in C++ and makes now use of the low-level skills of the CMUnited-99 simulator team.

Spatial Agents Implemented in a Logical Expressible Language

In this paper, we present a multi-layered architecture for spatial and temporal agents. The focus is laid on the declarativity of the approach, which makes agent scripts expressive and well understandable. They can be realized as (constraint) logic programs. The logical description language is able to express actions or plans for one and more autonomous and cooperating agents for the RoboCup (Simulator League). The system architecture hosts constraint technology for qualitative spatial reasoning, but quantitative data is taken into account, too. The basic (hardware) layer processes the agent’s sensor information. An interface transfers this low-level data into a logical representation. It provides facilities to access the preprocessed data and supplies several basic skills. The second layer performs (qualitative) spatial reasoning. On top of this, the third layer enables more complex skills such as passing, offside-detection etc. At last, the fourth layer establishes acting as a team both by emergent and explicit cooperation. Logic and deduction provide a clean means to specify and also to implement teamwork behavior.

Towards a league-independent qualitative soccer theory for robocup

The paper discusses a top-down approach to model soccer knowledge, as it can be found in soccer theory books. The goal is to model soccer strategies and tactics in a way that they are usable for multiple RoboCup soccer leagues, i.e. for different hardware platforms. We investigate if and how soccer theory can be formalized such that specification and execution is possible. The advantage is clear: theory abstracts from hardware and from specific situations in leagues. We introduce basic primitives compliant with the terminology known in soccer theory, discuss an example on an abstract level and formalize it. We then consider aspects of different RoboCup leagues in a case study and examine how examples can be instantiated in three different leagues.

Approaching A Formal Soccer Theory FromBehaviour Specifi Cations In Robotic Soccer

This chapter discusses a top-down approach to modelling soccer knowledge, as it can be found in soccer theory books. The goal is to model soccer strategies and tactics in a way that they are usable for multiple robotic soccer leagues in the RoboCup. We investigate if and how soccer theory can be formalized such that specifi cation and execution are possible. The advantage is clear: theory abstracts from hardware and from specifi c situations in different leagues. We introduce basic primitives compliant with the terminology known in soccer theory, discuss an example on an abstract level and formalize it. The formalization of soccer presented here is appealing. It goes beyond the behaviour specifi cation of soccer playing robots. For sports science a unifi ed formal soccer theory might help to better understand and to formulate basic concepts in soccer. The possibility of the formalization to develop computer programs, which allow to simulate and to reason about soccer moves, might also take sports science a step further.

Hybrid multiagent systems with timed synchronization: specification and model checking

This paper shows how multiagent systems can be modeled by a combination of UML statecharts and hybrid automata. This allows formal system specification on different levels of abstraction on the one hand and expressing real-time system behavior with continuous variables on the other hand. It is shown, how multi-robot systems can be modeled by hybrid and hierarchical state machines and how model checking techniques for hybrid automata can be applied. An enhanced synchronization concept is introduced that allows synchronization taking time and avoids state explosion to a certain extent.

Specifying agents with UML in robotic soccer

The use of agents and multiagent systems is widespread in computer science nowadays. Thus the need for methods to specify agents in a clear and simple manner arises.In this paper we propose an approach to specifying agent behaviors with the help of UML statecharts. Agents are specified on different levels of abstraction. In addition a method for specifying multiagent plans with explicit cooperation is shown. As an example domain we chose robotic soccer, which lays the basis of the annual RoboCup competitions.

Hybrid State Machines with Timed Synchronization for Multi-Robot System Specification

In multi-robot systems, the need for precise modeling or specification of agent behaviors arises due to the high complexity of the robot agent interactions and the dynamics of the environment. Since the behavior of agents usually can be understood as driven by external events and internal states, it is obvious to model multiagent systems by state transition diagrams. The corresponding formalisms come equipped with a formal semantics which is advantageous. In this paper, a combination of UML statecharts and hybrid automata is proposed, allowing formal system specification on different levels on abstraction on the one hand, and expressing real-time system behavior with continuous variables on the other hand. One important aspect of multi-robot systems is the need of coordination and hence synchronization of behavior. For both, statecharts and hybrid automata, it is assumed that synchronization takes zero time. This is sometimes unrealistic. Therefore, a new notation and implementation of synchronization is proposed here, which overcomes this problem. The proposed method is illustrated with a case study from the robotic soccer domain

Specifying agent behaviors with UML statecharts and StatEdit

The use of agents and multiagent systems is widespread in computer science nowadays. Thus the need for methods to specify agents in a clear and simple manner arises. One way of achieving this is by means of a graphical formalism. For using such a formalism the availability of tools, that support a developer, is of great importance. In this paper we present an approach to specifying agent behaviors on different levels of abstraction with the help of UML statecharts. Cooperation between different agents can explicitly be modeled. To help a developer with applying this formalism to the specification of agent behaviors the statechart editor StatEdit is presented. This development tool supports not only the modelling of an agent but a simple form of code generation as well.

RoboLog Koblenz 2000

RoboCup-2000 was the second world championship, RoboLog Koblenz participated in. To the best of our knowledge, RoboLog Koblenz is the only team in the simulation league, whose agents are programmed in Prolog. The main goal of our research is to make declarative agent programming possible, by writing the agents’ control programs in SWI–Prolog [6]. Procedural aspects of the agents’ behavior can be specified by statecharts, that have become part of the Unified Modeling Language (UML) [4]. See also the paper Towards a logical approach for soccer agents engineering in this volume.