Results 1  10
of
15
BindingTime Analysis for Mercury
 16th International Conference on Logic Programming, pages 500 { 514
, 1999
"... . In this paper, we describe a bindingtime analysis (BTA) for a statically typed and strongly moded pure logic programming language, in casu Mercury. Bindingtime analysis is the key concept in achieving oline program specialisation: the analysis starts from a description of the program's ..."
Abstract

Cited by 10 (5 self)
 Add to MetaCart
. In this paper, we describe a bindingtime analysis (BTA) for a statically typed and strongly moded pure logic programming language, in casu Mercury. Bindingtime analysis is the key concept in achieving oline program specialisation: the analysis starts from a description of the program's input available for specialisation, and propagates this information throughout the program, deriving directives for when and how to perform specialisation. 1
ConstraintBased Mode Analysis of Mercury
 International Conference on Principles and Practice of Declaxative Programming', ACM
, 2002
"... Recent logic programming languages, such as Mercury and HAL, require type, mode and determinism declarations for predicates. This information allows the generation of efficient target code and the detection of many errors at compiletime. Unfortunately, mode checking in such languages is difficult. O ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
Recent logic programming languages, such as Mercury and HAL, require type, mode and determinism declarations for predicates. This information allows the generation of efficient target code and the detection of many errors at compiletime. Unfortunately, mode checking in such languages is difficult. One of the main reasons is that, for each predicate mode declaration, the compiler is required to decide which parts of the procedure bind which variables, and how conjuncts in the predicate definition should be reordered to enforce this behaviour. Current mode checking systems limit the possible modes that may be used because they do not keep track of aliasing information, and have only a limited ability to infer modes, since inference does not perform reordering. In this paper we develop a mode inference system for Mercury based on mapping each predicate to a system of Boolean constraints that describe where its variables can be produced. This allows us handle programs that are not supported by the existing system.
Typed static analysis: Application to groundness analysis of Prolog and lambdaProlog
 In Procs. of FLOPS99, LNCS 1722
, 1999
"... ..."
When Size Does Matter  Termination Analysis for Typed Logic Programs
 Logicbased Program Synthesis and Transformation, 11th International Workshop, LOPSTR 2001, Selected Papers, volume 2372 of LNCS
, 2002
"... Proofs of termination typically proceed by mapping program states to a well founded domain and showing that successive states of the computation are mapped to elements decreasing in size. Automated termination analysers for logic programs achieve this by measuring and comparing the sizes of succ ..."
Abstract

Cited by 6 (4 self)
 Add to MetaCart
Proofs of termination typically proceed by mapping program states to a well founded domain and showing that successive states of the computation are mapped to elements decreasing in size. Automated termination analysers for logic programs achieve this by measuring and comparing the sizes of successive calls to recursive predicates. The size of the call is measured by a level mapping that in turn is based on a norm on the arguments of the call. A norm maps a term to a natural number.
Pos(T): Analyzing Dependencies in Typed Logic Programs
"... Dependencies play a major role in the analysis of program properties. The analysis of groundness dependencies for logic programs using the class of positive Boolean functions is a main applications area. Work has been done to improve its precision through the integration of either pattern informati ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
Dependencies play a major role in the analysis of program properties. The analysis of groundness dependencies for logic programs using the class of positive Boolean functions is a main applications area. Work has been done to improve its precision through the integration of either pattern information or type information. This paper develops another approach where type information is exploited. Different from previous work, a separate simple analysis is done for each subtype of the types. Also, a technique is developed that reuses the results of a polymorphic predicate for the type instances under which it is called.
Precise and Expressive Mode Systems for Typed Logic Programming Languages
, 2003
"... In this thesis we look at mode analysis of logic programs. Being based on the mathematical formalism of predicate logic, logic programs have no a priori notion of data flow  a single logic program may run in multiple modes where each mode describes, or prescribes, a pattern of data flow. ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
In this thesis we look at mode analysis of logic programs. Being based on the mathematical formalism of predicate logic, logic programs have no a priori notion of data flow  a single logic program may run in multiple modes where each mode describes, or prescribes, a pattern of data flow.
Analysis of Polymorphically Typed Logic Programs Using ACIUnification
 In Proceedings of the Eighth International Conference on Logic for Programming, Artificial Intelligence, and Reasoning. Lecture Notes in Artificial Intelligence
, 2001
"... . Analysis of (partial) groundness is an important application of abstract interpretation. There are several proposals for improving the precision of such an analysis by exploiting type information, including our own work [15], where we had shown how the information present in the type declarations ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
. Analysis of (partial) groundness is an important application of abstract interpretation. There are several proposals for improving the precision of such an analysis by exploiting type information, including our own work [15], where we had shown how the information present in the type declarations of a program can be used to characterise the degree of instantiation of a term in a precise but finite way. This approach worked for polymorphically typed logic programs. Here, we recast this approach following [5, 11]. To formalise which properties of terms we want to characterise, we use labelling functions, which are functions that extract subterms from a term along certain paths. An abstract term collects the results of all labelling functions of a term. For the analysis, programs are executed on abstract terms instead of the concrete ones, and usual unification is replaced by unification modulo an equality theory which includes the wellknown ACItheory. Thus we generalise [5, 11] w.r.t. the type systems considered and relate those two works. 1
Smart testing of functional programs in Isabelle
"... Abstract. We present a novel counterexample generator for the interactive theorem prover Isabelle based on a compiler that synthesizes test data generators for functional programming languages (e.g. ML, Haskell) from specifications in Isabelle. In contrast to naive typebased test data generators, t ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
Abstract. We present a novel counterexample generator for the interactive theorem prover Isabelle based on a compiler that synthesizes test data generators for functional programming languages (e.g. ML, Haskell) from specifications in Isabelle. In contrast to naive typebased test data generators, the smart generators take the preconditions into account and only generate tests that fulfill the preconditions. The smart generators are constructed by a compiler that reformulates the preconditions as logic programs and analyzes them with an enriched mode inference. From this inference, the compiler can construct the desired generators in the functional programming language. Applying these test data generators reduces the number of tests significantly and enables us to find errors in specifications where naive random and exhaustive testing fail. 1
Smart test data generators via logic programming ∗
"... We present a novel counterexample generator for the interactive theorem prover Isabelle based on a compiler that synthesizes test data generators for functional programming languages (e.g. Standard ML, OCaml) from specifications in Isabelle. In contrast to naive typebased test data generators, the ..."
Abstract
 Add to MetaCart
We present a novel counterexample generator for the interactive theorem prover Isabelle based on a compiler that synthesizes test data generators for functional programming languages (e.g. Standard ML, OCaml) from specifications in Isabelle. In contrast to naive typebased test data generators, the smart generators take the preconditions into account and only generate tests that fulfill the preconditions. The smart generators are constructed by a compiler that reformulates the preconditions as logic programs and analyzes them by an enriched mode inference. From this inference, the compiler can construct the desired generators in the functional programming language. These test data generators are applied to find errors in specifications, as we show in a case study of a hotel key card system.