We present the syntax and proof theory of a logic of argumentation, LA. We also outline the development of a category theoretic semantics for LA. LA is the core of a proof theoretic model for reasoning under uncertainty. In this logic, propositions are labelled with a representation of the arguments which support their validity. Arguments may then be aggregated to collect more information about the potential validity of the propositions of interest. We make the notion of aggregation primitive to the logic, and then define strength mappings from sets of arguments to one of a number of possible dictionaries. This provides a uniform framework which incorporates a number of numerical and symbolic techniques for assigning subjective confidences to propositions on the basis of their supporting arguments. These aggregation techniques are also described, with examples. Key words: Uncertain reasoning, epistemic probability, argumentation, non-classical logics, non-monotonic reasoning 1. Introd...

3.672> X with the complex term 1 + 1, not with 2, which, for people unused to Prolog's little ways, tends to come as a bit of a surprise. If we want to carry out the actual arithmetic involved, we have to explicitly force evaluation by making use of the very special inbuilt `operator' is/2. This calls an inbuilt mechanism which carries out the arithmetic evaluation of its second argument, and then unication plays no role here!). On the other hand, \== checks whether its argument are not identical. Arithmetic Prolog contains some built-in operators for handling integer arithmetic. These include *, / +, - (for multiplication, division, addition, and subtraction, respectively) and >, < for comparing numbers. These symbols, however, are just ordinary Prolog operators. That is, they are just a user friendly notation for writing

An overview of linear logic is given, including an extensive bibliography and a simple example of the close relationship between linear logic and computation.

A formalism for the specification of multiagent systems should be expressive and illustrative enough to model not only the behavior of one single agent, but also the collaboration among several agents and the influences caused by external events from the environment. For this, state machines [25] seem to provide an adequate means. Furthermore, it should be easily possible to obtain an implementation for each agent automatically from this specification. Last but not least, it is desirable to be able to check whether the multiagent system satisfies some interesting properties. Therefore, the formalism should also allow for the verification or formal analysis of multiagent systems, e.g. by model checking [6]. In this paper, a framework is introduced, which allows us to express declarative aspects of multiagent systems by means of (classical) propositional logic and procedural aspects of these systems by means of state machines (statecharts). Nowadays statecharts are a well accepted means to specify dynamic behavior of software systems. They are a part of the Unified Modeling Language (UML). We describe in a rigorously formal manner, how the specification of spatial knowledge and robot interaction and its verification by model checking can be done, integrating different methods from the field of artificial intelligence such as qualitative (spatial) reasoning and the situation calculus. As example application domain, we will consider robotic soccer, see also [24, 31], which present predecessor work towards a formal logic-based approach for agents engineering.

In this paper we define the rather general framework of Monotonic Logic Programs, where the main results of (definite) logic programming are validly extrapolated. Whenever defining new logic programming extensions, we can thus turn our attention to the stipulation and study of its intuitive algebraic properties within the very general setting. Then, the existence of a minimum model and of a monotonic immediate consequences operator is guaranteed, and they are related as in classical logic programming. Afterwards we study the more restricted class of residuated logic programs which is able to capture several quite distinct logic programming semantics. Namely: Generalized Annotated Logic Programs, Fuzzy Logic Programming, Hybrid Probabilistic Logic Programs, and Possibilistic Logic Programming. We provide the embedding of possibilistic logic programming.

Natural semantics is a formalism used for specifying both semantics and implementations of programming languages. Until recently, no practical implementation of the formalism existed. We have defined the Relational Meta-Language, RML, as an executable specification language for natural semantics. After a brief outline of the language, we describe the compilation strategy used by our rml2c compiler: transformations are applied to minimize non-determinism, and a continuation-passing style form is produced and simplified. Finally the CPS is emitted as low-level C code, using an efficient technique for implementing tailcalls. We also present performance measurements that support our choice of compilation strategy.

In a previous work we have de ned Monotonic Logic Programs which extend definite logic programming to arbitrary complete lattices of truth-values with an appropriate notion of implication. We have shown elsewhere that this framework is general enough to capture Generalized Annotated Logic Programs, Probabilistic Deductive Databases, Possibilistic Logic Programming, Hybrid Probabilistic Logic Programs and Fuzzy Logic Programming [3, 4]. However, none of these semantics define a form of non-monotonic negation, which is fundamental for several knowledge representation applications. In the spirit of our previous work, we generalise our framework of Monotonic Logic Programs to allow for rules with arbitrary antitonic bodies over general complete lattices, of which normal programs are a special case. We then show that all the standard logic programming theoretical results carry over to Antitonic Logic Programs, defining Stable Model and Well-founded Model alike semantics.

We consider a class of logical formalisms, in which first-order logic is extended by identifying propositions modulo a given congruence. We particularly focus on the case where this congruence is induced by a confluent and terminating rewrite system over the propositions. This extension enhances the power of first-order logic and various formalisms, including higher-order logic, can be described in this framework. We conjecture that proof normalization and logical consistency always hold over this class of formalisms, provided some minimal conditions over the rewrite system are fulfilled. We prove this conjecture for some subcases, including higher-order logic. At last, we extend these results to classical sequent calculus.

We develop two applications of middle-out reasoning in inductive proofs: Logic program synthesis and the selection of induction schemes. Middle-out reasoning as part of proof planning was first suggested by Bundy et al [Bundy et al 90a]. Middle-out reasoning uses variables to represent unknown terms and formulae. Unification instantiates the variables in the subsequent planning, while proof planning provides the necessary search control. Middle-out reasoning is used for synthesis by planning the verification of an unknown logic program: The program body is represented with a meta-variable. The planning results both in an instantiation of the program body and a plan for the verification of that program. If the plan executes successfully, the synthesized program is partially correct and complete. Middle-out reasoning is also used to select induction schemes. Finding an appropriate induction scheme during synthesis is difficult, because the recursion of the program, which is un...

A closed view of a database schema is one which is totally encapsulated. Insofar as the user is concerned, the view is the database schema. The rest of the database system is not visible through the view, and is is not required for complete use of the view. Similarly, the updates which may be effected through the view have their scope limited entirely to that view. In this paper, we lay the mathematical foundations for the systematic support of such views. The proper context is shown to be that of update translation under constant meet complement, a refinement of the constant complement strategy of Bancilhon and Spyratos. The central complexity result for relational schemata is that checking the legality of updates is “infinitely ” simpler than blindly checking that the new state is legal for the view schema, and in the particular case that the base schema is constrained by functional dependencies, may always be performed in constant time, even if the view schema is not finitely axiomatizable. We further establish that, under very natural assumptions, update strategies for closed views are unique.