Results 1 
6 of
6
Some LowLevel Source Transformations for Logic Programs
 in Proceedings of Meta90 Workshop on Meta Programming in Logic
, 1990
"... This paper describes an algorithm performing an analysis and transformation of logic programs. The transformation achieves two goals: redundant functors are removed from the program, and procedures may be split into two or more specialised versions handling different cases. It can be applied to most ..."
Abstract

Cited by 32 (10 self)
 Add to MetaCart
(Show Context)
This paper describes an algorithm performing an analysis and transformation of logic programs. The transformation achieves two goals: redundant functors are removed from the program, and procedures may be split into two or more specialised versions handling different cases. It can be applied to most logic programming languages, including concurrent logic programming languages, because the transformations perform no unfolding of the program; they only remove some redundant operations within the unifications. The main saving is in heap usage, though time performance may also be improved. One of the main purposes of the transformation is to “clean up ” programs generated by other methods of transformation or synthesis. The analysis is an example of an abstract interpretation, and is guaranteed to terminate. A Prolog implementation of the algorithm, illustrating some metaprogramming techniques, is given and some results are reported.
Algebra of logic programming
 International Conference on Logic Programming
, 1999
"... At present, the field of declarative programming is split into two main areas based on different formalisms; namely, functional programming, which is based on lambda calculus, and logic programming, which is based on firstorder logic. There are currently several language proposals for integrating th ..."
Abstract

Cited by 22 (4 self)
 Add to MetaCart
(Show Context)
At present, the field of declarative programming is split into two main areas based on different formalisms; namely, functional programming, which is based on lambda calculus, and logic programming, which is based on firstorder logic. There are currently several language proposals for integrating the expressiveness of these two models of computation. In this thesis we work towards an integration of the methodology from the two research areas. To this end, we propose an algebraic approach to reasoning about logic programs, corresponding to the approach taken in functional programming. In the first half of the thesis we develop and discuss a framework which forms the basis for our algebraic analysis and transformation methods. The framework is based on an embedding of definite logic programs into lazy functional programs in Haskell, such that both the declarative and the operational semantics of the logic programs are preserved. In spite of its conciseness and apparent simplicity, the embedding proves to have many interesting properties and it gives rise to an algebraic semantics of logic programming. It also allows us to reason about logic programs in a simple calculational style, using rewriting and the algebraic laws of combinators. In the embedding, the meaning of a logic program arises compositionally from the meaning of its constituent subprograms and the combinators that connect them. In the second half of the thesis we explore applications of the embedding to the algebraic transformation of logic programs. A series of examples covers simple program derivations, where our techniques simplify some of the current techniques. Another set of examples explores applications of the more advanced program development techniques from the Algebra of Programming by Bird and de Moor [18], where we expand the techniques currently available for logic program derivation and optimisation. To my parents, Sandor and Erzsebet. And the end of all our exploring Will be to arrive where we started And know the place for the first time.
Sharing of Computations
, 1993
"... This report is a revised version of my thesis of the same title, which was accepted for the Ph.D. degree in Computer Science at University of Aarhus, Denmark, in June 1993 ..."
Abstract

Cited by 15 (3 self)
 Add to MetaCart
This report is a revised version of my thesis of the same title, which was accepted for the Ph.D. degree in Computer Science at University of Aarhus, Denmark, in June 1993
Automatic Derivation of Logic Programs by Transformation
 Course notes for ESSLLI
, 2000
"... We present the program transformation methodology for the automatic development of logic programs based on the rules + strategies approach. We consider both definite programs and normal programs and we present the basic transformation rules and strategies which are described in the literature. To il ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
We present the program transformation methodology for the automatic development of logic programs based on the rules + strategies approach. We consider both definite programs and normal programs and we present the basic transformation rules and strategies which are described in the literature. To illustrate the power of the program transformation approach we also give some examples of program development. Finally, we show how to use program transformations for proving properties of predicates and synthesizing programs from logical specifications.
Optimisation Problems in Logic Programming: An Algebraic Approach
, 2000
"... Declarative programming, with its mathematical underpinning, was aimed to simplify rigorous reasoning about programs. For functional programs, an algebraic calculus of relations has previously been applied to optimisation problems to derive ecient greedy or dynamic programs from the corresponding ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Declarative programming, with its mathematical underpinning, was aimed to simplify rigorous reasoning about programs. For functional programs, an algebraic calculus of relations has previously been applied to optimisation problems to derive ecient greedy or dynamic programs from the corresponding inefficient but obviously correct specifications. Here we argue that this approach is natural also in the logic programming setting.