We present a method for proving properties of definite logic programs. This method is called unfold/fold proof method because it is based on the unfold/fold transformation rules...

Program specialization is a collection of program transformation techniques for improving program efficiency by exploiting some information available at compiletime about the input data. We show that current techniques for program specialization based on partial evaluation do not perform well on nondeterministic logic programs. We then consider a set of transformation rules which extend the ones used for partial evaluation, and we propose a strategy to direct the application of these extended rules so to derive very efficient specialized programs. The efficiency improvements which may even be exponential, are achieved because the derived programs are semi-deterministic and the operations which are performed by the initial programs in different branches of the computation trees, are performed in the specialized programs within single branches. We also make use of mode information to guide the unfolding process and to reduce nondeterminism. To exemplify our technique, we show that we can...

Given a program P, an unfold/fold program transformation system derives a sequence of programs P = P0, P1,:::, Pn, such that Pi+1 is derived from Pi by application of either an unfolding or a folding step. Existing unfold/fold transformation systems for definite logic programs differ from one another mainly in the kind of folding transformations they permit at each step. Some allow folding using a single (possibly recursive) clause while others permit folding using multiple non-recursive clauses. However, none allow folding using multiple recursive clauses that are drawn from some previous program in the transformation sequence. In this paper we develop a parameterized framework for unfold/fold transformations by suitably abstracting and extending the proofs of existing transformation systems. Various existing unfold/fold transformation systems can be obtained by instantiating the parameters of the framework. This framework enables us to not only understand the relative strengths and limitations of these systems but also construct new transformation systems. Specifically we present a more general transformation system that permits folding using multiple recursive clauses that can be drawn from any previous program in the transformation sequence. This new transformation system is also obtained by instantiating our parameterized framework.

Unfold/fold transformation systems for logic programs have been extensively investigated. Existing unfold/fold transformation systems for normal logic programs allow only Tamaki-Sato style folding using clauses from a previous program in the transformation sequence: i.e., they fold using a single, non-recursive clause. In this paper we present a transformation system that permits folding in the presence of recursion, disjunction, as well as negation. We show that the transformations are correct with respect to various semantics of negation including the well-founded model and stable model semantics.

We show that sometimes partial deduction produces poor program specializations because of its limited ability in (i) dealing with conjunctions of recursively defined predicates, (ii) combining partial evaluations of alternative computations, and (iii) taking into account unification failures. We propose to extend the standard partial deduction technique by using versions of the definition rule and the folding rule which allow us to specialize predicates defined by disjunctions of conjunctions of goals. We also consider a case split rule to take into account unification failures. Moreover, in order to perform program specialization via partial deduction in an automatic way, we propose a transformation strategy which takes as parameters suitable substrategies for directing the application of every transformation rule. Finally, we show through two examples that our partial deduction technique is superior to standard partial deduction. The first example refers to the automatic derivation...

Abstract. We consider the problem of transformations of logic programs without function symbols (database logic programs) into a special subclass, namely linear logic programs. Linear logic programs are dened to be the programs whose rules have at most one intentional atom in their bodies. a) We investigate linearizability of several syntactically de ned subclasses of programs and present both positive and negative results (i.e. demonstrate programs that cannot be transformed into a linear program by any transformation technique), and b) We develop an algorithm which transforms any program in a speci c subclass namely the piecewise logic programs into a linear logic program.

Abstract not found

We study the relationships between the correctness of logic program transformation and program termination. We consider definite programs and we identify some `invariants' of the program transformation process. The validity of these invariants ensures the preservation of the success set semantics, provided that the existential termination of the initial program implies the existential termination of the final program. We also identify invariants for the preservation of the finite failure set semantics. We consider four very general transformation rules: definition introduction, definition elimination, iff-replacement, and finite failure. Many versions of the transformation rules proposed in the literature, including unfolding, folding, and goal replacement, are instances of the iff-replacement rule. By using our proposed invariants which are based on Clark completion, we prove, for our transformation rules, various results concerning the preservation of both the success set and finite ...

Abstract. The branching-time transformation technique has proven to be an e cient approach for implementing functional programming languages. In this paper we demonstrate that such a technique can also be de ned for logic programming languages. More speci cally, we rstintroduce Branching Datalog, a language that can be considered as the basis for branching-temporal deductive databases. We then present a transformation algorithm from Chain Datalog programs to the class of unary Branching Datalog programs with at most one IDB atom in the body of each clause. In this way, we obtain a novel implementation approach for Chain Datalog, shedding at the same time new light on the power of branching-time logic programming.

Recently, a novel transformation technique for Datalog programs, called the branching transformation, was introduced by the authors. In this paper we propose a signicant extension of the branching transformation which we believe opens-up a promising new direction of research in the area of value-propagating Datalog optimizations. One of the novel characteristics of the proposed approach is that the target language is DatalognS extended with choice predicates, a form of non-deterministic construct that was originally introduced in the area of intensional logic programming. Keywords: Logic Program Transformations, Deductive Databases. 1