Current norm-based automatic... In this paper we present a new termination analysis which integrates the various components and produces a set of constraints that, when solvable, identifies successful termination proofs. The proposed method is both efficient and precise. The use of constraint sets enables the propagation of information over all different phases while the need for multiple analyses is considerably reduced.

The Constraint Logic Programming (CLP) Scheme merges logic programming with constraint solving over predefined domains. In this paper, we study proof methods for universal left termination of constraint logic programs. We provide a sound and complete characterization of left termination for ideal CLP languages which generalizes acceptability of logic programs. The characterization is then refined to the notion of partial acceptability, which is well-suited for automatic modular inference. We describe a theoretical framework for automation of the approach, which is implemented. For non-ideal CLP languages and without any assumption on their incomplete constraint solvers, even the most basic sound termination criterion from logic programming does not lift. We focus on a specific system, namely CLP(R), by proposing some additional conditions that make (partial) acceptability sound

We study the notion of binding-time analysis for logic programs. We formalise the unfolding aspect of an on-line partial deduction system as a Prolog program. Using abstract interpretation, we collect information about the run-time behaviour of the program. We use this information to make the control decisions about the unfolding at analysis time and to turn the on-line system into an off-line system. We report on some initial experiments.

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

Numerical computations form an essential part of almost any real-world program. Clearly, in order for a termination analyser to be of practical use it should contain a mechanism for inferring termination of such computations. However, this topic attracted less attention of the research community. In this work we concentrate on automatic termination inference for logic programs depending on numerical computations. Dershowitz et al. [8] showed that termination of general numerical computations, for instance on floating point numbers, may be counter-intuitive, i.e., the observed behaviour does not necessarily coincide with the theoretically expected one. Thus, we restrict ourselves to integer computations only. While discussing termination of integer computations the following question should be asked: what conditions on the queries should be assumed, such that the queries will terminate. We refer to this question as the termination inference...

Introduction There are many different approaches to termination analysis of logic programs. One particular distinction is between transformational approaches and "direct" ones. A transformational approach first transforms the logic program into an "equivalent" term-rewrite system (or, in some cases, into an equivalent functional program). Here, equivalence means that, at the very least, the termination of the term-rewrite system should imply the termination of the logic program, for some predefined collection of queries 1 . Direct approaches do not include such a transformation, but prove the termination directly on the basis of the logic program. Besides the transformation step itself, there is one other technical difference between these approaches. Direct approaches usually prove termination on the basis of a well-founded ordering over the natural numbers. More specifically, they use a level mapping, which m

this paper we present a termination inference technique for numerical loops based on the well-known constraints based approach [4], further extending [3], and on the adornments technique [6, 7]. We restrict our interest only to integer loops, since termination of real number computations is often implementation dependent (see [5]). Example 1. p(X) / X ? 0; X 5; X1 is X + 1; p(X) p(X) / X ? 5 This example illustrates two possible sources of termination. First, if no rule is applicable for some query (e.g. ?\Gammap(\Gamma1)), and second, if some rules are applicable, but the execution terminates(e.g. ?\Gamma p(3) or ?\Gamma p(7)). We distinguish between these cases and infer terminati

Numerical computations form an essential part of almost any real-world program. Traditional approaches to termination of logic programs are restricted to domains isomorphic to N , more recent works study termination of integer computations. Termination of computations involving real numbers is cumbersome and counter-intuitive due to rounding errors and implementation conventions. We present a novel technique that allows us to prove termination of such computations.

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