Luís Moniz Pereira

Computational Logic — CL 2000

Syntax for Variable Binders: An Overview . . . . . . . . . . . . . . . . . . . . 239 Dale Miller Goal-Directed Proof Search in Multiple-Conclusioned Intuitionistic Logic . . 254 James Harland, Tatjana Lutovac, and Michael Winikoff Efficient EM Learning with Tabulation for Parameterized Logic Programs . 269 Yoshitaka Kameya and Taisuke Sato Model Generation Theorem Proving with Finite Interval Constraints . . . . . 285 Reiner Hähnle, Ryuzo Hasegawa, and Yasuyuki Shirai Combining Mobile Processes and Declarative Programming . . . . . . . . . . . . . 300 Rachid Echahed and Wendelin Serwe

Dynamic updates of non-monotonic knowledge bases

In this paper we investigate updates of knowledge bases represented by logic programs. In order to represent negative information, we use generalized logic programs which allow default negation not only in rule bodies but also in their heads. We start by introducing the notion of an update P U of one logic program P by another logic program U. Subsequently, we provide a precise semantic characterization of P U , and study some basic properties of program updates. In particular, we show that our update programs generalize the notion of interpretation update. We then extend this notion to compositional sequences of logic programs updates P1 P2 ; defining a dynamic program update, and thereby introducing the paradigm of dynamic logic programming. This paradigm significantly facilitates modularization of logic programming, and thus modularization of non-monotonic reasoning as a whole. Specifically, suppose that we are given a set of logic program modules, each describing a diAerent state of our knowledge of the world. DiAerent states may represent diAerent time points or diAerent sets of priorities or perhaps even diAerent viewpoints. Consequently, program modules may contain mutually contradictory as well as overlapping information. The role of the dynamic program update is to employ the mutual relationships existing between diAerent modules to precisely determine, at any given module composition stage, the declarative as well as the procedural semantics of the combined program resulting from the modules. ” 2000 Elsevier Science Inc. All rights reserved.

Evolving Logic Programs

Logic programming has often been considered less than adequate for modelling the dynamics of knowledge changing over time. In this paper we describe a simple though quite powerful approach to modelling the updates of knowledge bases expressed by generalized logic programs, by means of a new language, hereby christened EVOLP (after EVOlving Logic Programs). The approach was first sparked by a critical analysis of previous efforts and results in this direction [1,2,7,11], and aims to provide a simpler, and at once more general, formulation of logic program updating, which runs closer to traditional logic programming (LP) doctrine. From the syntactical point of view, evolving programs are just generalized logic programs (i.e. normal LPs plus default negation also in rule heads), extended with (possibly nested) assertions, whether in heads or bodies of rules. From the semantics viewpoint, a model-theoretic characterization is offered of the possible evolutions of such programs. These evolutions arise both from self (or internal) updating, and from external updating too, originating in the environment. This formulation sets evolving programs on a firm basis in which to express, implement, and reason about dynamic knowledge bases, and opens up a number of interesting research topics that we brush on.

Monotonic and Residuated Logic Programs

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.

Rational debugging in logic programming

A debugger for Prolog has been developed which automates the reasoning ability required to pinpoint errors, resorting to the user only to ask about the intended program semantics, and making cooperative use of the declarative and the operational semantics. The algorithm is expressed in detail, a session protocol exhibited, comparison to other work made, but the implementation is not examined, nor the treatment of Prologs extra-logical features. This is an abridged version of [Pereira 86].

A survey of paraconsistent semantics for logic programs

Our contribution to this volume consists in giving a logic programmer’s view on handling program inconsistency. The semantics we cover will touch several aspects of implementing reasoning in the presence of contradiction. Logic programming has already shown a wide applicability for representings knowledge [Barai and Gel-fond, 1994]. Also, the most important non-monotonic formalisms, for instance Default Logic [Reiter, 1980] and Autoepistemic logics [Moore, 1984; Moore, 1985], have a counterpart semantics on the logic programming side.1 Moreover, logic programming has turned out to be vehicle for implementing and exploring other important aspects of Artificial Intelligence such as updates and belief revision. Therefore, it is not strange that a lot of work in the logic programming community has been carried out to understand the integration of paraconsistent reasoning with logic programming, in preparation for an applicational and implementational role of great potential, now emerging.

Generalizing Updates: From Models to Programs

Recently the eld of theory update has seen some improve- ment, in what concerns model updating, by allowing updates to be spec- ied by so-called revision programs. The updating of theory models is governed by their update rules and also by inertia applied to those literals not directly aected by the update program. Though this is important, it remains necessary to tackle as well the updating of programs specify- ing theories. Some results have been obtained on the issue of updating a logic program which encodes a set of models, to obtain a new program whose models are the desired updates of the initial models. But here the program only plays the r^ole of a means to encode the models. A logic program encodes much more than a set of models: it encodes knowledge in the form of the relationships between the elements of those models. In this paper we advocate that the principle of inertia is advan- tageously applied to the rules of the initial program rather than to the individual literals in a model. Indeed, we show how this concept of pro- gram update generalizes model or interpretation updates. Furthermore, it allows us to conceive what it is to update one program by another, a crucial notion for opening up a whole new range of applications concern- ing the evolution of knowledge bases. We will consider the updating of normal programs as well as these extended with explicit negation, under the stable semantics.

Abduction in well-founded semantics and generalized stable models via tabled dual programs

Abductive logic programming offers a formalism to declaratively express and solve problems in areas such as diagnosis, planning, belief revision and hypothetical reasoning. Tabled logic programming offers a computational mechanism that provides a level of declarativity superior to that of Prolog, and which has supported successful applications in fields such as parsing, program analysis, and model checking. In this paper we show how to use tabled logic programming to evaluate queries to abductive frameworks with integrity constraints when these frameworks contain both default and explicit negation. The result is the ability to compute abduction over well-founded semantics with explicit negation and answer sets. Our approach consists of a transformation and an evaluation method. The transformation adjoins to each objective literal

Antitonic Logic Programs

O

Automated reasoning in geometry theorem proving with Prolog

in a program, an objective literal