We present a framework for expressing bottom-up algorithms to compute the well-founded model of non-disjunctive logic programs. Our method is based on the notion of conditional facts and elementary program transformations studied by BRASS and DIX (Brass and Dix, 1994; Brass and Dix, 1999) for disjunctive programs. However, even if we restrict their framework to nondisjunctive programs, their ‘residual program’ can grow to exponential size, whereas for function-free programs our ‘program remainder’ is always polynomial in the size of the extensional database (EDB). We show that particular orderings of our transformations (we call them strategies) correspond to well-known computational methods like the alternating fixpoint approach (Van Gelder, 1989; Van Gelder, 1993), the well-founded magic sets method (Kemp et al., 1995) and the magic alternating fixpoint procedure (Morishita, 1996). However, due to the confluence of our calculi (first noted in Brass and Dix, 1998), we come up with computations of the well-founded model that are provably better than these methods. In contrast to other approaches, our transformation method treats magic set transformed programs correctly, i.e. it always computes a relevant part of the well-founded model of the original program. These results show that our approach is a valuable tool to analyze, compare, and optimize existing evaluation methods or to create new strategies that are automatically proven to be correct if they can be described by a sequence of transformations in our framework. We have also developed a prototypical implementation. Experiments illustrate that the theoretical results carry over to the implemented prototype and may be used to optimize real life systems.

Jack Minker explains, in his accompanying Editor's Introduction, the circumstances which have brought about the founding of this new journal, the Theory and Practice of Logic Programming (TPLP). The birth of any new journal is an occasion for rejoicing, but in the present case the logic programming community has special reasons to be proud and grateful.

We should be proud that TPLP is published by the Cambridge University Press. The Press in Cambridge is the oldest, and many (I am one) believe it is by far the best, university press in the world. In joining its lists the TPLP immediately acquires some of the patina of centuries of glorious academic excellence and devotion to scholarship. It is a splendid thing – an honor, indeed – to be associated with a publishing house which has for so long and so brilliantly served the academic community without in any way needing to compromise academic values in achieving commercial success.

We should be grateful to our colleagues Krzysztof Apt and Maurice Bruynooghe, who have worked so hard and with such selfless dedication to provide the logic programming community with a journal that it can continue to sponsor. Sadly, this is no longer the case with respect to Journal of Logic Programming. In 1984 when I decided as Founding Editor to publish JLP with the Elsevier organization, the arrangement was satisfactory to both parties, and continued to be so for many years. However, more recently, with the increasing pressures being put on library budgets, the worlds of academic and commercial publishers seem to have grown apart to the point where incompatibilities outweigh affinities. The logic programming community has now entered into a far more solid relationship. The logic of the new marriage is based much more on solid assessment of the interests of both parties. We are living through times of important change in the publishing world, and the new order is taking shape along intelligible and stable lines.

All is well. Although it is with sadness that we bid goodbye to the JLP, we must reflect that this is only a transmigration of one and the same living entity, from an old incarnation to a new one. So it is with joy and hope that we at the same time welcome the Theory and Practice of Logic Programming. The JLP had a good life, and its great spirit will live on in TPLP. The continuity of the logic programming community's research record is unbroken and unscathed. Its future is now secure in the care of the best of all possible editorial leadership, and under the banner of the best of all possible publishers.

In the design of algorithms, the greedy paradigm provides a powerful tool for solving efficiently classical computational problems, within the framework of procedural languages. However, expressing these algorithms within the declarative framework of logic-based languages has proven a difficult research challenge. In this paper, we extend the framework of Datalog-like languages to obtain simple declarative formulations for such problems, and propose effective implementation techniques to ensure computational complexities comparable to those of procedural formulations. These advances are achieved through the use of the choice construct, extended with preference annotations to effect the selection of alternative stable-models and nondeterministic fixpoints. We show that, with suitable storage structures, the differential fixpoint computation of our programs matches the complexity of procedural algorithms in classical search and optimization problems.

We introduce [Ascr ]k, an extension of the action description language [Ascr ] (Gelfond and Lifschitz, 1993) to handle actions which affect knowledge. We use sensing actions to increase an agent's knowledge of the world and non-deterministic actions to remove knowledge. We include complex plans involving conditionals and loops in our query language for hypothetical reasoning. We also present a translation of [Ascr ]k domain descriptions into epistemic logic programs.This paper extends the results of the work first presented in Lobo et al. (1997).

As an invited contributor to this Festschrift honoring Alain Colmerauer, I feel compelled to give not only an account of his main research contributions, but also of my perspective on the motivations behind them. I hope that this will provide the reader with a glimpse of how a focused, tenacious, rigorous, and inventive mind like Alain's picks research problems and proceeds to solve them. The history of Prolog, the language that remains one of Alain's major accomplishments, is well documented. His paper on the ‘Birth of Prolog,’ co-authored with Philippe Roussel (Colmerauer & Roussel, 1970), is a highly recommended account of the circumstances that led to the development of Prolog. Bob Kowalski (1988) presents his views of the early history of Prolog from the automatic theorem proving perspective. Finally, my own paper on the topic (Cohen, 1988) contains material complementing Alain's and Bob's narratives. Instead of recasting already-available historical material, I have opted to present here a more personal account of Alain's contributions, acknowledging in advance the individual bias inherent in such an accounting of long-past events.

Computational logic systems can offer an attractive environment for developing Internet applications. They share many of the important characteristics of popular network programming tools, including dynamic memory management, well-behaved structure and pointer manipulation, robustness, and compilation to architecture-independent bytecode. However, in addition, computational logic systems offer some unique features such as very powerful symbolic processing capabilities, constraint solving, dynamic databases, search facilities, grammars, sophisticated meta-programming, and well understood semantics. Such features can often make it very easy to code simple applications.

This special issue concerned with applications is the third of its kind in a journal sponsored by the Association for Logic Programming. The first appeared in 1990, and showed the potential for logic programming to be extended. The second issue highlighted some papers from the Practical Applications of Prolog conference that had been held. This third time, the applications are concerned with the Internet and reflect the profound impact that the Internet has had on the computing landscape.

We discuss from a practical point of view a number of issues involved in writing distributed Internet and WWW applications using LP/CLP systems. We describe PiLLoW, a public-domain Internet and WWW programming library for LP/CLP systems that we have designed to simplify the process of writing such applications. PiLLoW provides facilities for accessing documents and code on the WWW; parsing, manipulating and generating HTML and XML structured documents and data; producing HTML forms; writing form handlers and CGI-scripts; and processing HTML/XML templates. An important contribution of PiLLoW is to model HTML/XML code (and, thus, the content of WWW pages) as terms. The PiLLoW library has been developed in the context of the Ciao Prolog system, but it has been adapted to a number of popular LP/CLP systems, supporting most of its functionality. We also describe the use of concurrency and a high-level model of client-server interaction, Ciao Prolog's active modules, in the context of WWW programming. We propose a solution for client-side downloading and execution of Prolog code, using generic browsers. Finally, we also provide an overview of related work on the topic.

We apply to logic programming some recently emerging ideas from the field of reductionbased communicating systems, with the aim of giving evidence of the hidden interactions and the coordination mechanisms that rule the operational machinery of such a programming paradigm. The semantic framework we have chosen for presenting our results is tile logic, which has the advantage of allowing a uniform treatment of goals and observations and of applying abstract categorical tools for proving the results. As main contributions, we mention the finitary presentation of abstract unification, and a concurrent and coordinated abstract semantics consistent with the most common semantics of logic programming. Moreover, the compositionality of the tile semantics is guaranteed by standard results, as it reduces to check that the tile systems associated to logic programs enjoy the tile decomposition property. An extension of the approach for handling constraint systems is also discussed.

Constraint Logic Programming (CLP) and Hereditary Harrop formulas (HH) are two well known ways to enhance the expressivity of Horn clauses. In this paper, we present a novel combination of these two approaches. We show how to enrich the syntax and proof theory of HH with the help of a given constraint system, in such a way that the key property of HH as a logic programming language (namely, the existence of uniform proofs) is preserved. We also present a procedure for goal solving, showing its soundness and completeness for computing answer constraints. As a consequence of this result, we obtain a new strong completeness theorem for CLP that avoids the need to build disjunctions of computed answers, as well as a more abstract formulation of a known completeness theorem for HH.

We propose a general framework for first-order functional logic programming, supporting lazy functions, non-determinism and polymorphic datatypes whose data constructors obey a set [Cscr ] of equational axioms. On top of a given [Cscr ], we specify a program as a set [Rscr ] of [Cscr ]-based conditional rewriting rules for defined functions. We argue that equational logic does not supply the proper semantics for such programs. Therefore, we present an alternative logic which includes [Cscr ]-based rewriting calculi and a notion of model. We get soundness and completeness for [Cscr ]-based rewriting w.r.t. models, existence of free models for all programs, and type preservation results. As operational semantics, we develop a sound and complete procedure for goal solving, which is based on the combination of lazy narrowing with unification modulo [Cscr ]. Our framework is quite expressive for many purposes, such as solving action and change problems, or realizing the GAMMA computation model.

In Ferrucci, Pacini and Sessa (1995) an extended form of resolution, called Reduced SLD resolution (RSLD), is introduced. In essence, an RSLD derivation is an SLD derivation such that redundancy elimination from resolvents is performed after each rewriting step. It is intuitive that redundancy elimination may have positive effects on derivation process. However, undesiderable effects are also possible. In particular, as shown in this paper, program termination as well as completeness of loop checking mechanisms via a given selection rule may be lost. The study of such effects has led us to an analysis of selection rule basic concepts, so that we have found convenient to move the attention from rules of atom selection to rules of atom scheduling. A priority mechanism for atom scheduling is built, where a priority is assigned to each atom in a resolvent, and primary importance is given to the event of arrival of new atoms from the body of the applied clause at rewriting time. This new computational model proves able to address the study of redundancy elimination effects, giving at the same time interesting insights into general properties of selection rules. As a matter of fact, a class of scheduling rules, namely the specialisation independent ones, is defined in the paper by using not trivial semantic arguments. As a quite surprising result, specialisation independent scheduling rules turn out to coincide with a class of rules which have an immediate structural characterisation (named stack-queue rules). Then we prove that such scheduling rules are tolerant to redundancy elimination, in the sense that neither program termination nor completeness of equality loop check is lost passing from SLD to RSLD.

The publication of this first issue of the Theory and Practice of Logic Programming (TPLP) is an important milestone in the history of logic programming. The field of logic programming started in the early 1970s and is based on the seminal work of J. Alan Robinson who developed the well-known Robinson resolution principle that revolutioned the field of automated reasoning and upon which logic programming is based. The field of logic programming was created by Alain Colmerauer and Robert Kowalski in the early 1970sIn addition to Colmerauer and Kowalski, others had conceived of similar concepts at about the same time: Ted Elcock developed a system ABSET, which was basically a logic programming system and Carl Hewitt developed Planner, which although advertised as a procedural-oriented system, had a declarative component.. Alain Colmerauer and his group developed the first logic programming language, Prolog (PROgrammation en LOGique).

Robert Kowalski modified the resolution principle by limiting it to Horn clauses and by extending it to a formalism amenable for computing. His work with van Emden provided semantic foundations to this approach to programming. The importance of logic programming is that it is a declarative rather than a procedural programming language.

Defeasible logic is a rule-based nonmonotonic logic, with both strict and defeasible rules, and a priority relation on rules. We show that inference in the propositional form of the logic can be performed in linear time. This contrasts markedly with most other propositional nonmonotonic logics, in which inference is intractable.

The well-founded semantics is one of the most widely studied and used semantics of logic programs with negation. In the case of finite propositional programs, it can be computed in polynomial time, more specifically, in O([mid ]At(P)[mid ] × size(P)) steps, where size(P) denotes the total number of occurrences of atoms in a logic program P. This bound is achieved by an algorithm introduced by Van Gelder and known as the alternating-fixpoint algorithm. Improving on the alternating-fixpoint algorithm turned out to be difficult. In this paper we study extensions and modifications of the alternating-fixpoint approach. We then restrict our attention to the class of programs whose rules have no more than one positive occurrence of an atom in their bodies. For programs in that class we propose a new implementation of the alternating-fixpoint method in which false atoms are computed in a top-down fashion. We show that our algorithm is faster than other known algorithms and that for a wide class of programs it is linear and so, asymptotically optimal.

Significant advances have recently been made in the area of updates of logic programs, and, more generally, updates of knowledge bases and their applications. Accordingly, the journal Theory and Practice of Logic Programming has planned a special issue on Change in Knowledge Bases, tentatively scheduled to appear at the beginning of 2003.

High-quality papers are sought containing either original research results or offering an insightful synthesis of past work on various aspects of change in knowledge bases.

Revised and enhanced versions of papers published in conference proceedings that have not appeared in archival journals are eligible for submission. Surveys and comparison of state of the art techniques are also solicited.

We propose a framework for modeling uncertainty where both belief and doubt can be given independent, first-class status. We adopt probability theory as the mathematical formalism for manipulating uncertainty. An agent can express the uncertainty in her knowledge about a piece of information in the form of a confidence level, consisting of a pair of intervals of probability, one for each of her belief and doubt. The space of confidence levels naturally leads to the notion of a trilattice, similar in spirit to Fitting's bilattices. Intuitively, the points in such a trilattice can be ordered according to truth, information, or precision. We develop a framework for probabilistic deductive databases by associating confidence levels with the facts and rules of a classical deductive database. While the trilattice structure offers a variety of choices for defining the semantics of probabilistic deductive databases, our choice of semantics is based on the truth-ordering, which we find to be closest to the classical framework for deductive databases. In addition to proposing a declarative semantics based on valuations and an equivalent semantics based on fixpoint theory, we also propose a proof procedure and prove it sound and complete. We show that while classical Datalog query programs have a polynomial time data complexity, certain query programs in the probabilistic deductive database framework do not even terminate on some input databases. We identify a large natural class of query programs of practical interest in our framework, and show that programs in this class possess polynomial time data complexity, i.e. not only do they terminate on every input database, they are guaranteed to do so in a number of steps polynomial in the input database size.

We present verification methods for logic programs with delay declarations. The verified properties are termination and freedom from errors related to built-ins. Concerning termination, we present two approaches. The first approach tries to eliminate the well-known problem of speculative output bindings. The second approach is based on identifying the predicates for which the textual position of an atom using this predicate is irrelevant with respect to termination. Three features are distinctive of this work: it allows for predicates to be used in several modes; it shows that block declarations, which are a very simple delay construct, are sufficient to ensure the desired properties; it takes the selection rule into account, assuming it to be as in most Prolog implementations. The methods can be used to verify existing programs and assist in writing new programs.

This paper presents the multi-threading and internet message communication capabilities of Qu-Prolog. Message addresses are symbolic and the communications package provides high-level support that completely hides details of IP addresses and port numbers as well as the underlying TCP/IP transport layer. The combination of the multi-threads and the high level inter-thread message communications provide simple, powerful support for implementing internet distributed intelligent applications.

We study here a natural situation when constraint programming can be entirely reduced to rule-based programming. To this end we explain first how one can compute on constraint satisfaction problems using rules represented by simple first-order formulas. Then we consider constraint satisfaction problems that are based on predefined, explicitly given constraints. To solve them we first derive rules from these explicitly given constraints and limit the computation process to a repeated application of these rules, combined with labeling. We consider two types of rule here. The first type, that we call equality rules, leads to a new notion of local consistency, called rule consistency that turns out to be weaker than arc consistency for constraints of arbitrary arity (called hyper-arc consistency in Marriott & Stuckey (1998)). For Boolean constraints rule consistency coincides with the closure under the well-known propagation rules for Boolean constraints. The second type of rules, that we call membership rules, yields a rule-based characterization of arc consistency. To show feasibility of this rule-based approach to constraint programming, we show how both types of rules can be automatically generated, as CHR rules of Frühwirth (1995). This yields an implementation of this approach to programming by means of constraint logic programming. We illustrate the usefulness of this approach to constraint programming by discussing various examples, including Boolean constraints, two typical examples of many valued logics, constraints dealing with Waltz's language for describing polyhedral scenes, and Allen's qualitative approach to temporal logic.

In this paper we analyze declarative deterministic and non-deterministic semantics for active rules. In particular, we consider several (partial) stable model semantics, previously defined for deductive rules, such as well-founded, max deterministic, unique total stable model, total stable model and maximal stable model semantics. The semantics of an active program [Ascr ][Pscr ] is given by first rewriting it into a deductive program [Lscr ][Pscr ], then computing a model M defining the declarative semantics of [Lscr ][Pscr ] and, finally, applying ‘consistent’ updates contained in M to the source database. The framework we propose permits a natural integration of deductive and active rules and can also be applied to queries with function symbols or to queries over infinite databases.