Non-leftmost Unfolding in Partial Evaluation of Logic Programs with Impure Predicates

Abstract

Partial evaluation of logic programs which contain impure predicates poses non-trivial challenges. Impure predicates include those which produce side-effects, raise errors (or exceptions), and those whose truth value varies according to the degree of instantiation of arguments 4. In particular, non-leftmost unfolding steps can produce incorrect results since the independence of the computation rule no longer holds in the presence of impure predicates. Existing proposals allow non-leftmost unfolding steps, but at the cost of accuracy: bindings and failure are not propagated backwards to predicates which are potentially impure. In this work we propose a partial evaluation scheme which substantially reduces the situations in which such backpropagation has to be avoided. With this aim, our partial evaluator takes into account the information about purity of predicates expressed in terms of assertions. This allows achieving some optimizations which are not feasible using existing partial evaluation techniques. We argue that our proposal goes beyond existing ones in that it is a) accurate, since the classification of pure vs impure is done at the level of atoms instead of predicates, b) extensible, as the information about purity can be added to programs using assertions without having to modify the partial evaluator itself, and c) automatic, since (backwards) analysis can be used to automatically infer the required assertions. Our approach has been implemented in the context of CiaoPP, the abstract interpretation-based preprocessor of the Ciao logic programming system.

Poly-controlled partial evaluation in practice

“…Also, hom emb aggr and hom emb cons are unfolding rules which are both based on homeomorphic embedding for flagging possible non-termination (see [17] for more details). In both cases, non-leftmost unfolding is performed only when it is guaranteed to be safe (see [1]). However, the first one is more aggressive, whereas the second one is more conservative.…”

Decompilation of Java bytecode to Prolog by partial evaluation

“…Type-based homeomorphic embedding ( T ) [4] has been used both at the local and global control to decide when to stop derivations and when to generalize calls so that effectiveness of the decompilation can be obtained in the presence of integers without compromising termination. The unfolding operator must also be able to accurately handle built-in predicates and to safely perform nonleftmost unfolding steps as in [6]. The operator abstract must incorporate a polyvariance control mechanism [18] which avoids performing useless specializations that can introduce superfluous decompiled code and thus degrade the decompilation effectiveness.…”

Quasi-terminating logic programs for ensuring the termination of partial evaluation

“…As mentioned in the introduction, analyzing the strong quasi-termination of programs is essential because liberal selection policies are often mandatory to achieve a good specialization during partial evaluation (see, e.g., [1,25]). …”

“…all possible computation rules. This is essential because liberal selection policies are often mandatory to achieve a good specialization (see, e.g., [1,25]). Therefore, we consider strong termination [2]: a program P and query Q strongly terminate if they universally terminate (i.e., the computation of all solutions terminate) w.r.t.…”