We provide here a systematic comparative study of the relative strength and expressive power of a number of methods for program analysis of Prolog. Among others we show that these methods can be arranged in the following hierarchy: mode analysis ⇒ type analysis ⇒ monotonic properties ⇒ non-monotonic run-time properties. We also discuss a method allowing us to prove global run-time properties.

We provide simple conditions which allow us to conclude that in case of several well-known Prolog programs the unification algorithm can be replaced by iterated matching. The main tools used here are types and generic expressions for types. As already noticed by other researchers, such a replacement offers a possibility of improving the efficiency of program's execution.

We present an algorithm for automatic type checking of logic programs with respect to directional types that describe both the structure of terms and the directionality of predicates. The type checking problem is reduced to a decidable problem on systems of inclusion constraints over set expressions. We discuss some properties of the reduction algorithm, complexity, and present a proof of correctness. 1 1 Introduction Most logic programming languages are untyped. In Prolog, for example, it is considered meaningful to apply any n-ary predicate to any n-tuple of terms. However, it is generally accepted that static type checking has great advantages in detecting programming errors early and for generating efficient executable code. Motivated at least in part by the success of type systems for procedural and functional languages, there is currently considerable interest in finding appropriate definitions of type and welltyping for logic languages. This paper explores the type checki...

This paper presents a new notion of typing for logic programs which generalizes the notion of directional types. The generation of type dependencies for a logic program is fully automatic with respect to a given domain of types. The analysis method is based on a novel combination of program abstraction and ACI-unification which is shown to be correct and optimal. Type dependencies are obtained by abstracting programs, replacing concrete terms by their types, and evaluating the meaning of the abstract programs using a standard semantics for logic programs enhanced by ACI-unification. This approach is generic and can be used with any standard semantics. The method is both theoretically clean and easy to implement using general purpose tools. The proposed domain of types is condensing which means that analyses can be carried out in both top-down or bottom-up frameworks with no loss of precision for goal-independent analyses. The proposed method has been fully implemented within a bottom-up approach and the experimental results are promising.

. This paper illustrates the application of abstract compilation using multiple incarnations of the domain Prop in deriving type dependencies for logic programs. We illustrate how dependencies can be derived in the presence of both monomorphic and polymorphic type information. Type dependencies generalize the recently proposed notion of directional types as well as the more common notion of groundness dependencies. Directional types have proven useful in a number of applications such as in proving termination. These applications, however, are based on type declarations. The main contribution of this paper is in the simplicity in which non-trivial type dependencies are inferred using abstract compilation and by associating each type with an incarnation of Prop. We illustrate the use of a semantics for open logic programs in maintaining space efficient analyses. Time efficiency is also maintained due to approximation of the type domain in a boolean lattice calling on results of universal...

. Logic programs augmented with delay declarations form a higly expressive programming language in which dynamic networks of processes that communicate asynchronously by means of multiparty channels can be easily created. In this paper we study correctness these programs. In particular, we propose proof methods allowing us to deal with occur check freedom, absence of deadlock, absence of errors in presence of arithmetic relations, and termination. These methods turn out to be simple modifications of the corresponding methods dealing with Prolog programs. This allows us to derive correct delay declarations by analyzing Prolog programs. Finally, we point out difficulties concerning proofs of termination. Notes. The research of the first author was partly supported by the ESPRIT Basic Research Action 6810 (Compulog 2). This paper will appear as an invited lecture in: Proc. of the Fourth International Conference on Algebraic Methodology and Software Technology, (AMAST'95). 1 Introduction ...

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.

This paper shows that the annotation proof method, proposed by Deransart for proving declarative properties of logic programs, is also applicable for proving correctness of directional types. In particular, the sufficient correctness criterion of well-typedness by Bronsard et al, turns out to be a specialization of the annotation method. The comparison shows a general mechanism for construction of similar specializations, which is applied to derive yet another concept of well-typedness. The usefulness of the new correctness criterion is shown on examples of Prolog programs, where the traditional notion of well-typedness is not applicable. We further show that the new well-typing condition can be applied to different execution models. This is illustrated by an example of an execution model where unification is controlled by directional types, and where our new well-typing condition is applied to show the absence of deadlock. / 1. INTRODUCTION

This paper investigates the role of coroutining in the termination of logic programs. We define a variant of SLD resolution, in which the execution of atoms may be suspended indefinitely, and give some basic results concerning success, finite failure and floundering. Next we discuss how correct procedures can be combined to form new procedures using disjunction, conjunction and recursion. We argue that modes are crucial to reasoning about termination and show that cyclic modes are the basic reason for conjunctions looping. When recursion is used we identify another cause of loops: speculative binding of output variables. That is, binding output variables before it is known that a solution to a subcomputation exists. Keywords: mode, flounder, Prolog, stream and-parallelism -- 1 -- 1 Introduction

We try to assess to what extent declarative programming can be realized in Prolog and which aspects of correctness of Prolog programs can be dealt with by means of declarative interpretation. More specifically, we shall discuss termination of Prolog programs, partial correctness, absence of errors and the safe use of negation. 1991 Mathematics Subject Classification: 68Q40, 68T15. CR Categories: F.3.2., F.4.1, H.3.3, I.2.3. Keywords and Phrases: declarative programming, Prolog programs, verification. Notes. This research was partly supported by the ESPRIT Basic Research Action 6810 (Compulog 2). This paper will appear as invited lecture in: Proc. of International Logic Programming Symposium (ILPS '93), The MIT Press, D. Miller (editor). It also appeared as a Technical Report No CT-93-06 in the ILLC Prepublication Series of the University of Amsterdam. 1