Frieder Stolzenburg

Computing Generalized Specificity

Most formalisms for representing common-sense knowledge allow incomplete and potentially inconsistent information. When strong negation is also allowed, contradictory conclusions can arise. A criterion for deciding between them is needed. The aim of this paper is to investigate an inherent and autonomous comparison criterion, based on specificity as defined in [POO 85, SIM 92]. In contrast to other approaches, we consider not only defeasible, but also strict knowledge. Our criterion is context-sensitive, i. e., preference among defeasible rules is determined dynamically during the dialectical analysis. We show how specificity can be defined in terms of two different approaches: activation sets and derivation trees. This allows us to get a syntactic criterion that can be implemented in a computationally attractive way. The resulting definitions may be applied in general rulebased formalisms. We present theorems linking both characterizations. Finally we discuss other frameworks for defeasible reasoning in which preference handling is considered explicitly.

Relating defeasible and normal logic programming through transformation properties

This paper relates the Defeasible Logic Programming (DeLP) framework and its semantics SEMDeLP to classical logic programming frameworks. In DeLP, we distinguish between two different sorts of rules: strict and defeasible rules. Negative literals (∼A) in these rules are considered to represent classical negation. In contrast to this, in normal logic programming (NLP), there is only one kind of rules, but the meaning of negative literals (not A) is different: they represent a kind of negation as failure, and thereby introduce defeasibility. Various semantics have been defined for NLP, notably the well-founded semantics (WFS) (van Gelder et al., Proceedings of the Seventh Symposium on Principles of Database Systems, 1988, pp. 221-230; J. ACM 38 (3) (1991) 620) and the stable semantics Stable (Gelfond and Lifschitz, Fifth Conference on Logic Programming, MIT Press, Cambridge, MA, 1988, pp. 1070-1080; Proceedings of the Seventh International Conference on Logical Programming, Jerusalem, MIT Press, Cambridge, MA, 1991, pp. 579-597).In this paper we consider the transformation properties for NLP introduced by Brass and Dix (J. Logic Programming 38(3) (1999) 167) and suitably adjusted for the DeLP framework. We show which transformation properties are satisfied, thereby identifying aspects in which NLP and DeLP differ. We contend that the transformation rules presented in this paper can help to gain a better understanding of the relationship of DeLP semantics with respect to more traditional logic programming approaches. As a byproduct, we obtain the result that DeLP is a proper extension of NLP.

Computing answers with model elimination

Abstract We demonstrate that theorem provers using model elimination (ME) can be used as answer-complete interpreters for disjunctive logic programming. More specifically, we introduce a family of restart variants of model elimination and we introduce a mechanism for computing answers. Building on this, we develop a new calculus called ancestry restart ME. This variant admits a more restrictive regularity restriction than restart ME and, as a side-effect, it is in particular attractive for computing definite answers. The presented calculi can also be used successfully in the context of automated theorem proving. We demonstrate experimentally that it is more difficult to compute nontrivial answers to goals than to prove the existence of answers.

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.

Multiagent systems specification by UML statecharts aiming at intelligent manufacturing

Multiagent systems are a promising new paradigm in computing, which are contributing to various fields. Many theories and technologies have been developed in order to design and specify multiagent systems, however, no standard procedure is used at present. Industrial applications often have a complex structure and need plenty of working resources. They require a standard specification method as well. As the standard method to design and specify software systems, we believe that one of the key words is simplicity for their wide acceptance. In this paper, we propose a method to specify multiagent systems, namely with UML statecharts. We use them for specifying almost all aspects of multiagent systems, because we think that it is an advantage to keep everything in one type of diagram.We apply our method to different domains, namely to robotic soccer and a network application. This approach enables not only standardized design of multiagent systems, but also almost automatic translation of the specification into a running implementation (here: into Prolog). Moreover, the verification or formal analysis is feasible, because of the rigidly formal manner of the system specification. We concentrate on the formal specification of multiagent systems in general and its application to robotic soccer, which is already implemented, and to networking. The application to different domains---with homogeneous or heterogeneous agents---corroborates the generality of the proposed approach.

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.

Membership-Constraints and Complexity in Logic Programming with Sets

General agreement exists about the usefulness of sets as very high- level representations of complex data structures. Therefore it is worthwhile to introduce sets into constraint logic programming or set constraints into programming languages in general.