Symbolic Evaluation Graphs and Term Rewriting — A General Methodology for Analyzing Logic Programs

Abstract

There exist many powerful techniques to analyze termination and complexity of term rewrite systems (TRSs). Our goal is to use these techniques for the analysis of other programming languages as well. For instance, approaches to prove termination of definite logic programs by a transformation to TRSs have been studied for decades. However, a challenge is to handle languages with more complex evaluation strategies (such as Prolog, where predicates like the cut influence the control flow). In this paper, we present a general methodology for the analysis of such programs. Here, the logic program is first transformed into a symbolic evaluation graph which represents all possible evaluations in a finite way. Afterwards, different analyses can be performed on these graphs. In particular, one can generate TRSs from such graphs and apply existing tools for termination or complexity analysis of TRSs to infer information on the termination or complexity of the original logic program.

A Transformational Approach to Parametric Accumulated-Cost Static Profiling

“…A significant additional improvement brought about by [28] is that it is combined with a sized types abstract domain, which allows the inference of non-trivial cost bounds when they depend on the sizes of input terms and their subterms at any position and depth. Recently, many other approaches have been proposed for resource analysis [30,12,9,13,23,8,1,2]. While based on different techniques, all these analyses infer, for all predicates p of a given program P, an approximation of the notion of cost that we call the standard cost or single call cost.…”

Concolic Execution and Test Case Generation in Prolog

“…Moreover, we consider moded logic programs. In particular, for simplicity, we assume that every predicate symbol p/n in the considered program has one associated mode, 4 where in(p/n) = {i 1 , . .…”

“…This extension is the subject of ongoing work. For this purpose, we will consider the linear operational semantics of [16], and its symbolic version [4], as a promising starting point.…”

Analyzing Innermost Runtime Complexity of Term Rewriting by Dependency Pairs

“…Therefore, runtime complexity corresponds to the usual notion of "complexity" for programs [4,5]. Note that most termination techniques which transform programs to TRSs (e.g., [8,13,14,28]) result in rewrite systems where one only regards innermost rewrite sequences. This also holds for techniques to analyze termination of languages like Haskell by term rewriting [13], although Haskell has a lazy (outermost) evaluation strategy.…”

“…Techniques for automated termination analysis of term rewriting are very powerful and have been successfully used to analyze termination of programs in many different languages (e.g., Java [8,28], Haskell [13], and Prolog [14]). Hence, by adapting these termination techniques, the ultimate goal is to obtain approaches which can also analyze the complexity of programs automatically.…”