Results 1  10
of
16
G.: Abstract Interpretation over NonDeterministic Finite Tree Automata for SetBased Analysis of Logic Programs
 In: Fourth International Symposium on Practical Aspects of Declarative Languages (PADL’02). LNCS (2002
"... Abstract. Setbased program analysis has many potential applications, including compiler optimisations, typechecking, debugging, verification and planning. One method of setbased analysis is to solve a set of set constraints derived directly from the program text. Another approach is based on abs ..."
Abstract

Cited by 31 (11 self)
 Add to MetaCart
(Show Context)
Abstract. Setbased program analysis has many potential applications, including compiler optimisations, typechecking, debugging, verification and planning. One method of setbased analysis is to solve a set of set constraints derived directly from the program text. Another approach is based on abstract interpretation (with widening) over an infiniteheight domain of regular types. Up till now only deterministic types have been used in abstract interpretations, whereas solving set constraints yields nondeterministic types, which are more precise. It was pointed out by Cousot and Cousot that set constraint analysis of a particular program P could be understood as an abstract interpretation over a finite domain of regular tree grammars, constructed from P. In this paper we define such an abstract interpretation for logic programs, formulated over a domain of nondeterministic finite tree automata, and describe its implementation. Both goaldependent and goalindependent analysis are considered. Variations on the abstract domains operations are introduced, and we discuss the associated tradeoffs of precision and complexity. The experimental results indicate that this approach is a practical way of achieving the precision of setconstraints in the abstract interpretation framework. 1
Automata on DAG Representations of Finite Trees
, 1999
"... We introduce a new class of finite automata. They are usual bottomup tree automata that run on DAG representations of finite trees. We prove that the emptiness problem for this class of automata is NPcomplete. Using these automata we prove the decidability of directional type checking for logic ..."
Abstract

Cited by 16 (0 self)
 Add to MetaCart
We introduce a new class of finite automata. They are usual bottomup tree automata that run on DAG representations of finite trees. We prove that the emptiness problem for this class of automata is NPcomplete. Using these automata we prove the decidability of directional type checking for logic programs, and thus we improve earlier results by Aiken and Lakshman. We also show an application of these automata in solving systems of set constraints, which gives a new view on the satisfiability problem for set constraints with negative constraints. Keywords Tree Automata, Directed Acyclic Graphs, Types in Logic Programming, Semantics of Logic Programs, Set Constraints 1 Introduction We introduce a new class of finite automata, which we call automata on tdags. They are usual bottomup tree automata that run on DAG representations of ground terms over given signature. The class of languages recognizable by these automata contains all DAG representations of regular sets of terms...
Detecting Unsolvable Queries for Definite Logic Programs
, 1998
"... In logic programming, almost no work has been done so far on proving that certain queries cannot succeed. Work in this direction could be useful for queries which seem to be nonterminating. Such queries are not exceptional, e.g. in planning problems. The paper develops some methods, based on ab ..."
Abstract

Cited by 11 (3 self)
 Add to MetaCart
(Show Context)
In logic programming, almost no work has been done so far on proving that certain queries cannot succeed. Work in this direction could be useful for queries which seem to be nonterminating. Such queries are not exceptional, e.g. in planning problems. The paper develops some methods, based on abduction, goaldirectedness, tabulation, and constraint techniques, for proving failure of queries for definite logic programs. It also reports some experiments with various tools.
Paths vs. Trees in Setbased Program Analysis
 PROCEEDINGS OF POPL'00: PRINCIPLES OF PROGRAMMING LANGUAGES
, 2000
"... Setbased analysis of logic programs provides an accurate method for descriptive typechecking of logic programs. The key idea of this method is to upper approximate the least model of the program by a regular set of trees. In 1991, Frühwirth, Shapiro, Vardi and Yardeni raised the question whether i ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
Setbased analysis of logic programs provides an accurate method for descriptive typechecking of logic programs. The key idea of this method is to upper approximate the least model of the program by a regular set of trees. In 1991, Frühwirth, Shapiro, Vardi and Yardeni raised the question whether it can be more efficient to use the domain of sets of paths instead, i.e., to approximate the least model by a regular set of words. We answer the question negatively by showing that typechecking for pathbased analysis is as hard as the setbased one, that is DEXPTIMEcomplete. This result has consequences also in the areas of set constraints, automata theory and model checking.
Directional Type Checking for Logic Programs: Beyond Discriminative Types
 In Proc. of ESOP 2000
, 2000
"... Directional types form a type system for logic programs which is based on the view of a predicate as a directional procedure which, when applied to a tuple of input terms, generates a tuple of output terms. It is known that directionaltype checking wrt. arbitrary types is undecidable; several autho ..."
Abstract

Cited by 9 (1 self)
 Add to MetaCart
(Show Context)
Directional types form a type system for logic programs which is based on the view of a predicate as a directional procedure which, when applied to a tuple of input terms, generates a tuple of output terms. It is known that directionaltype checking wrt. arbitrary types is undecidable; several authors proved decidability of the problem wrt. discriminative regular types. In this paper, using techniques based on tree automata, we show that directionaltype checking for logic programs wrt. general regular types is DEXPTIMEcomplete and fixedparameter linear. The letter result shows that despite the exponential lower bound, the type system might be usable in practice.
SetBased Failure Analysis for Logic Programs and Concurrent Constraint Programs
 PROGRAMMING LANGUAGES AND SYSTEMS, 8TH EUROPEAN SYMPOSIUM ON PROGRAMMING, ESOP'99, VOLUME 1576 OF LNCS
, 1999
"... This paper presents the first approximation method of the finitefailure set of a logic program by setbased analysis. In a dual view, the method yields a type analysis for programs with ongoing behaviors (perpetual processes). Our technical contributions are (1) the semantical characterization ..."
Abstract

Cited by 6 (1 self)
 Add to MetaCart
(Show Context)
This paper presents the first approximation method of the finitefailure set of a logic program by setbased analysis. In a dual view, the method yields a type analysis for programs with ongoing behaviors (perpetual processes). Our technical contributions are (1) the semantical characterization of finite failure of logic programs over infinite trees and (2) the design and soundness proof of the first setbased analysis of logic programs with the greatestmodel semantics. Finally, we exhibit the connection between finite failure and the inevitability of the `inconsistentstore ' error in fair executions of concurrent constraint programs where no process suspends forever. This indicates a potential application to error diagnosis for concurrent constraint programs.
Polymorphic Directional Types for Logic Programming
 Proceedings of the 3rd international ACM SIGPLAN conference on
, 2001
"... In this paper we present a new type system for logic programs. Our system combines ideas of the classical polymorphic, but not very precise, system due to Mycroft and O'Keefe [16], and the complementary system of directional types that has been proposed by Aiken and Lakshman [1]. ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
(Show Context)
In this paper we present a new type system for logic programs. Our system combines ideas of the classical polymorphic, but not very precise, system due to Mycroft and O'Keefe [16], and the complementary system of directional types that has been proposed by Aiken and Lakshman [1].
Improving Precision of Type Analysis Using NonDiscriminative Union
 HIGHERORDER AND SYMBOLIC COMPUTATION
, 2003
"... This paper presents a new type analysis for logic programs. The analysis is performed with a priori type definitions; and type expressions are formed from a fixed alphabet of type constructors. Nondiscriminative union is used to join type information from different sources without loss of precision ..."
Abstract

Cited by 4 (4 self)
 Add to MetaCart
(Show Context)
This paper presents a new type analysis for logic programs. The analysis is performed with a priori type definitions; and type expressions are formed from a fixed alphabet of type constructors. Nondiscriminative union is used to join type information from different sources without loss of precision. An operation that is performed repeatedly during an analysis is to detect if a fixpoint has been reached. This is reduced to checking the emptiness of types. Due to the use of nondiscriminative union, the fundamental problem of checking the emptiness of types is more complex in the proposed type analysis than in other type analyses with a priori type definitions. The experimental results, however, show that use of tabling reduces the effect to a small fraction of analysis time on a set of benchmarks.
Automated Termination Proofs for Logic Programs by Term Rewriting
"... There are two kinds of approaches for termination analysis of logic programs: “transformational” and “direct ” ones. Direct approaches prove termination directly on the basis of the logic program. Transformational approaches transform a logic program into a term rewrite system (TRS) and then analyze ..."
Abstract
 Add to MetaCart
(Show Context)
There are two kinds of approaches for termination analysis of logic programs: “transformational” and “direct ” ones. Direct approaches prove termination directly on the basis of the logic program. Transformational approaches transform a logic program into a term rewrite system (TRS) and then analyze termination of the resulting TRS instead. Thus, transformational approaches make all methods previously developed for TRSs available for logic programs as well. However, the applicability of most existing transformations is quite restricted, as they can only be used for certain subclasses of logic programs. (Most of them are restricted to wellmoded programs.) In this paper we improve these transformations such that they become applicable for any definite logic program. To simulate the behavior of logic programs by TRSs, we slightly modify the notion of rewriting by permitting infinite terms. We show that our transformation results in TRSs which are indeed suitable for automated termination analysis. In contrast to most other methods for termination of logic programs, our technique is also sound for logic programming without occur check, which is typically used in practice. We implemented our approach in the termination prover
Directional Type Checker for Prolog
"... Data types are one of the most common techniques of increasing program comprehension. At the same time logic programs are a convenient way of specifying problems and finding their solutions. Unfortunately, the most popular logic programming language – Prolog – does not enforce type correctness. The ..."
Abstract
 Add to MetaCart
(Show Context)
Data types are one of the most common techniques of increasing program comprehension. At the same time logic programs are a convenient way of specifying problems and finding their solutions. Unfortunately, the most popular logic programming language – Prolog – does not enforce type correctness. The present thesis describes a directional type system for logic programs, an algorithm for checking type correctness of a program as well as offering the implementation of an appropriate type checker. In order to combine efficiency with type system expressiveness we have used a state of the art mechanism for the implementation of the underlying data structures.