Roland N. Bol

Logic Programming and Negation: A Survey.

Abstract We survey here various approaches which were proposed to incorporate negation in logic programs. We concentrate on the proof-theoretic and model-theoretic issues and the relationships between them.

The meaning of negative premises in transition system specifications

We present a general theory for the use of negative premises in the rules of Transition System Specifications (TSSs). We formulate a criterion that should be satisfied by a TSS in order to be meaningful, that is, to unequivocally define a transition relation. We also provide powerful techniques for proving that a TSS satisfies this criterion, meanwhile constructing this transition relation. Both the criterion and the techniques originate from logic programming [van Gelder et al. 1988; Gelfond and Lifschitz 1988] to which TSSs are close. In an appendix we provide an extensive comparison between them. As in Groote [1993], we show that the bisimulation relation induced by a TSS is a congruence, provided that it is in ntyft/ntyxt-format and can be proved meaningful using our techniques. We also considerably extend the conservativity theorems of Groote[1993] and Groote and Vaandrager [1992]. As a running example, we study the combined addition of priorities and abstraction to Basic Process Algebra (BPA). Under some reasonable conditions we show that this TSS is indeed meaningful, which could not be shown by other methods [Bloom et al. 1995; Groote 1993]. Finally, we provide a sound and complete axiomatization for this example.

An Analysis of Loop Checking Mechanisms for Logic Programs

We systemically study loop checking mechanisms for logic programs by considering their soundness, completeness, relative strength and related concepts. We introduce a natural concept of a simple loop check and prove that no sound and complete simple loop check exists, even for programs without function symbols. Then we introduce a number of sound simple loop checks and identify natural classes of PROLOG programs without function symbols for which they are complete. In these classes a limited form of recursion is allowed. As a by-product we obtain an implementation of the closed world assumption of Reiter and a query evaluation algorithm for these classes of logic programs.

Loop checking in partial deduction

In the framework of Lloyd and Shepherdson [16], partial deduction involves the creation of SLDNF-trees for a given program and some goals up to certain halting points. This paper identifies the relation between halting criteria for partial deduction and loop checking (as formalized in [1]). For simplicity, we consider only positive programs and SLD-resolution here. It appears that loop checks for partial deduction must be complete, whereas traditionally, the soundness of a loop check is more important. However, it is also shown that sound loop checks can contribute to improve partial deduction. Finally, a class of complete loop checks suitable for partial deduction is identified.

Tabulated resolution for the well-founded semantics

This work is motivated by the need for efficient question-answering methods for Horn clause logic and its non-classical extensions - formalisms which are of great importance for the purpose of know ...

Formalizing process algebraic verifications in the calculus of constructions

This paper reports on the first steps towards the formal verification of correctness proofs of real-life protocols in process algebra. We show that such proofs can be verified, and partly constructed, by a general purpose proof checker. The process algebra we use isμCRL, ACPτ augmented with data, which is expressive enough for the specification of real-life protocols. The proof checker we use is Coq, which is based on the Calculus of Constructions, an extension of simply typed lambda calculus. The focus is on the translation of the proof theory ofμCRL andμCRL-specifications to Coq. As a case study, we verified the Alternating Bit Protocol.

Loop checking and negation

In this paper we extend the concept of loop checking from positive programs (as described in [1]) to locally stratified programs. Such an extension is not straightforward: the introduction of negation requires a (re)consideration of the choice of semantics, the description of a related search space, and new soundness and completeness results handling floundering in a satisfactory way. Nevertheless, an extension is achieved that allows us to generalize the loop checking mechanisms from positive programs to locally stratified programs, while preserving most soundness and completeness results. The conclusion is that negative literals cannot give rise to loops, and must be simply ignored. Note: the material presented in this paper is contained in [5, ch. 5], in which also [1, 4] can be found.

Generalizing completeness results for loop checks in logic programming

Abstract Loop checking is a mechanism for pruning infinite SLD-derivations. In (Bol, Apt and Klop, 1991) simple loop checks were introduced and their soundness, completeness and relative strength was studied. Since no sound and complete simple loop check exists even in the absence of function symbols, subclasses of programs were determined for which the (sound) loop checks introduced by Bol are complete. In this paper, the Generalization Theorem is proved. This theorem presents a method to extend (under certain conditions) a class of programs for which a given loop check is complete to a larger class, for which the loop check is still complete. Then this theorem is applied to the results of Bol, giving rise to stronger completeness theorems. It appears that unnecessary complications in the proof of the theorem can be avoided by introducing a normal form for SLD-derivations, allowing only certain most general unifiers. This normal form might have other applications than those in the area of loop checking.

The Meaning of Negative Premises in Transition System Specifications

We present a general theory for the use of negative premises in the rules of Transition System Specifications (TSSs). We formulate a criterion that should be satisfied by a TSS in order to be meaningful, i.e. to unequivocally define a transition relation. We also provide powerful techniques for proving that a TSS satisfies this criterion, meanwhile constructing this transition relation. Both the criterion and the techniques originate from logic programming [8, 7] to which TSSs are close.

On the Power of Subsumption and Context Checks

Loop checking is a mechanism used to prune infinite SLD-derivations. Here we study two classes of loop checking mechanisms — subsumption checks and context checks. We analyze their soundness, completeness relative strength and related concepts. We prove their soundness (no computed answer substitution to a goal is missed) and demonstrate their completeness (all resulting derivations are finite) for some classes of logic programs. The completeness theorems for the subsumption checks make use of a simple version of Kruskals Tree Theorem [K], called Higmans Lemma [H].