A class of predicates is identified for which termination does not depend on left-to-right execution. The only assumption about the selection rule is that derivations are input-consuming, that is, in each derivation step, the input arguments of the selected atom do not become instantiated. This assumption is a natural abstraction of previous work on programs with delay declarations. The method for showing that a predicate is in that class is based on level mappings, closely following the traditional approach for LD-derivations. Programs are assumed to be well and nicely moded, which are two widely used concepts for verification. Many predicates terminate under such weak assumptions. Knowing these predicates is useful even for programs where not all predicates have this property.

We present a new approach to termination analysis of logic programs. The essence of the approach is that we make use of general orderings (instead of level mappings), like it is done in transformational approaches to logic program termination analysis, but we apply these orderings directly to the logic program and not to the term-rewrite system obtained through some transformation. We define some variants of acceptability, based on general orderings, and show how they are equivalent to LD-termination. We develop a demand driven, constraint-based approach to verify these acceptability-variants. The advantage

This paper describes a method for proving termination of queries to logic programs based on abstract interpretation. The method uses query-mapping pairs to abstract the relation between calls in the LD-tree associated with the program and query. Any well founded partial order for terms can be used to prove the termination. The ideas of the query-mapping pairs approach have been implemented in SICStus Prolog in a system called TermiLog, which is available on the web. Given a program and query pattern the system either answers that the query terminates or that there may be non-termination. The advantages of the method are its conceptual simplicity and the fact that it does not impose any restrictions on the programs.

We consider a general prescriptive type system with parametric polymorphism and subtyping for logic programs. The property of subject reduction expresses the consistency of the type system w.r.t. the execution model: if a program is well-typed, then all derivations starting in a well-typed goal are again well-typed. It is well-established that without subtyping, this property is readily obtained for logic programs w.r.t. their standard (untyped) execution model. Here we give syntactic conditions that ensure subject reduction also in the presence of general subtyping relations between type constructors. The idea is to consider logic programs with a xed dataow, given by modes.

We study the properties of input-consuming derivations of moded logic programs. Input-consuming derivations do not employ a fixed selection rule, and can be used to model the behavior of logic programs using dynamic scheduling and employing constructs such as delay declarations. We consider the class of nicely-moded programs and queries. We show that for these programs one part of the well-known Switching Lemma holds also for input-consuming derivations. Furthermore, we provide conditions which guarantee that all input-consuming derivations starting in a Nicely-Moded query are finite. The method presented here is easy to apply and generalizes other related works.

The procedural interpretation of logic programs and queries is parametric to the selection rule, i.e. the rule that determines which atom is selected in each resolution step. Termination of logic programs and queries depends critically on the selection rule. In this survey, we present a unified view and comparison of seven notions of universal termination considered in the literature, and the corresponding classes of programs. For each class, we focus on a su#cient, and in most cases even necessary, declarative characterisation for determining that a program is in that class. By unifying di#erent formalisms and making appropriate assumptions, we are able to establish a formal hierarchy between the di#erent classes and their respective declarative characterisations.

We introduce the notion of bounded nondeterminism for logic programs and queries. A program and a query have bounded nondeterminism if there are finitely many refutations for them via any selection rule. We o#er a declarative characterization of the class of programs and queries that have bounded nondeterminism by defining bounded programs and queries. The characterization is provided in terms of Herbrand interpretations and level mappings, in the style of existing characterizations of universal termination.

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.

Recent logic programming languages employ dynamic scheduling of calls to improve efficiency of programs. Dynamic scheduling is realized by allowing some calls to be dynamically "delayed" until their arguments are sufficiently instantiated. To this end, logic languages are extended with constructs such as delay declarations. However, many declarative properties that hold for logic and pure Prolog programs do not apply any longer in this extended setting. In particular, the equivalence between the model-theoretic and operational semantics does not hold. In this paper, we study the class of input-consuming programs. Firstly, we argue that input-consuming logic programs are suitable for modeling programs employing delay declarations. Secondly, we show that -- under some syntactic restrictions -- the S-semantics of a program is correct and fully abstract also for input-consuming programs. This allows us to conclude that for a large class of programs employing delay declarations there exists a model-theoretic semantics which is equivalent to the operational one. Thus, input-consuming programs are shown to be the right answer for conjugate eciency and declarativeness.

The term meta-programming... In this paper we aim to specify conditions on the meta-interpreters that imply that termination of the object program with respect to some goal is improved or preserved. We start by identifying popular classes of meta-interpreters, such as extended meta-interpreters [7], and then develop a methodology to prove the desired. Our approach is based on two observations. First, termination of logic programs can be proved via general term-orderings, similar to those used to prove termination of term-rewrite systems [9]. Second, if is an ordering such that termination of a meta-program, obtained from "vanilla" and an object program P , with respect to a goal solve(G) can be proved via it, then termination of P with respect to G can be proved via >, where > is de ned as A > B if solve(A) solve(B). This is not necessary true for more practical applications of meta-interpreters, such as debuggers, since they also are required to produce some additional output or to perform some additional tasks during the execution, such as constructing proof trees. These extensions can and usually will influence termination properties of the meta-interpreter. However, for the specified classes of meta-interpreters we can state conditions that imply a simple relation between an ordering proving termination of a meta-program and an ordering proving termination of an object program. These conditions imply termination improvement or preservation