28,333 research outputs found
Transforming acyclic programs
An unfold/fold transformation system is a source-to-source rewriting methodology devised to improve the efficiency of a program. Any such transformation should preserve the main properties of the initial program: among them, termination. In the field of logic programming, the class of acyclic programs plays an important role in this respect, since it is closely related to the one of terminating programs. The two classes coincide when negation is not allowed in the bodies of the clauses. We prove that the Unfold/Fold transformation system defined by Tamaki and Sato preserves the acyclicity of the initial program. From this result, it follows that when the transformation is applied to an acyclic program, then the finite failure set for definite programs is preserved; in the case of normal programs, all major declarative and operational semantics are preserved as well. These results cannot be extended to the class of left-terminating programs without modifying the definition of the transformation
Classes of Terminating Logic Programs
Termination of logic programs depends critically on the selection rule, i.e.
the rule that determines which atom is selected in each resolution step. In
this article, we classify programs (and queries) according to the selection
rules for which they terminate. This is a survey and unified view on different
approaches in the literature. For each class, we present a sufficient, for most
classes even necessary, criterion for determining that a program is in that
class. We study six classes: a program strongly terminates if it terminates for
all selection rules; a program input terminates if it terminates for selection
rules which only select atoms that are sufficiently instantiated in their input
positions, so that these arguments do not get instantiated any further by the
unification; a program local delay terminates if it terminates for local
selection rules which only select atoms that are bounded w.r.t. an appropriate
level mapping; a program left-terminates if it terminates for the usual
left-to-right selection rule; a program exists-terminates if there exists a
selection rule for which it terminates; finally, a program has bounded
nondeterminism if it only has finitely many refutations. We propose a
semantics-preserving transformation from programs with bounded nondeterminism
into strongly terminating programs. Moreover, by unifying different formalisms
and making appropriate assumptions, we are able to establish a formal hierarchy
between the different classes.Comment: 50 pages. The following mistake was corrected: In figure 5, the first
clause for insert was insert([],X,[X]
Automated Termination Proofs for Logic Programs by Term Rewriting
There are two kinds of approaches for termination analysis of logic programs:
"transformational" and "direct" ones. Direct approaches prove termination
directly on the basis of the logic program. Transformational approaches
transform a logic program into a term rewrite system (TRS) and then analyze
termination of the resulting TRS instead. Thus, transformational approaches
make all methods previously developed for TRSs available for logic programs as
well. However, the applicability of most existing transformations is quite
restricted, as they can only be used for certain subclasses of logic programs.
(Most of them are restricted to well-moded programs.) In this paper we improve
these transformations such that they become applicable for any definite logic
program. To simulate the behavior of logic programs by TRSs, we slightly modify
the notion of rewriting by permitting infinite terms. We show that our
transformation results in TRSs which are indeed suitable for automated
termination analysis. In contrast to most other methods for termination of
logic programs, our technique is also sound for logic programming without occur
check, which is typically used in practice. We implemented our approach in the
termination prover AProVE and successfully evaluated it on a large collection
of examples.Comment: 49 page
Operational Semantics of Resolution and Productivity in Horn Clause Logic
This paper presents a study of operational and type-theoretic properties of
different resolution strategies in Horn clause logic. We distinguish four
different kinds of resolution: resolution by unification (SLD-resolution),
resolution by term-matching, the recently introduced structural resolution, and
partial (or lazy) resolution. We express them all uniformly as abstract
reduction systems, which allows us to undertake a thorough comparative analysis
of their properties. To match this small-step semantics, we propose to take
Howard's System H as a type-theoretic semantic counterpart. Using System H, we
interpret Horn formulas as types, and a derivation for a given formula as the
proof term inhabiting the type given by the formula. We prove soundness of
these abstract reduction systems relative to System H, and we show completeness
of SLD-resolution and structural resolution relative to System H. We identify
conditions under which structural resolution is operationally equivalent to
SLD-resolution. We show correspondence between term-matching resolution for
Horn clause programs without existential variables and term rewriting.Comment: Journal Formal Aspect of Computing, 201
Transformations of CCP programs
We introduce a transformation system for concurrent constraint programming
(CCP). We define suitable applicability conditions for the transformations
which guarantee that the input/output CCP semantics is preserved also when
distinguishing deadlocked computations from successful ones and when
considering intermediate results of (possibly) non-terminating computations.
The system allows us to optimize CCP programs while preserving their intended
meaning: In addition to the usual benefits that one has for sequential
declarative languages, the transformation of concurrent programs can also lead
to the elimination of communication channels and of synchronization points, to
the transformation of non-deterministic computations into deterministic ones,
and to the crucial saving of computational space. Furthermore, since the
transformation system preserves the deadlock behavior of programs, it can be
used for proving deadlock freeness of a given program wrt a class of queries.
To this aim it is sometimes sufficient to apply our transformations and to
specialize the resulting program wrt the given queries in such a way that the
obtained program is trivially deadlock free.Comment: To appear in ACM TOPLA
Extending Context-Sensitivity in Term Rewriting
We propose a generalized version of context-sensitivity in term rewriting
based on the notion of "forbidden patterns". The basic idea is that a rewrite
step should be forbidden if the redex to be contracted has a certain shape and
appears in a certain context. This shape and context is expressed through
forbidden patterns. In particular we analyze the relationships among this novel
approach and the commonly used notion of context-sensitivity in term rewriting,
as well as the feasibility of rewriting with forbidden patterns from a
computational point of view. The latter feasibility is characterized by
demanding that restricting a rewrite relation yields an improved termination
behaviour while still being powerful enough to compute meaningful results.
Sufficient criteria for both kinds of properties in certain classes of rewrite
systems with forbidden patterns are presented
Strategic Port Graph Rewriting: An Interactive Modelling and Analysis Framework
We present strategic portgraph rewriting as a basis for the implementation of
visual modelling and analysis tools. The goal is to facilitate the
specification, analysis and simulation of complex systems, using port graphs. A
system is represented by an initial graph and a collection of graph rewriting
rules, together with a user-defined strategy to control the application of
rules. The strategy language includes constructs to deal with graph traversal
and management of rewriting positions in the graph. We give a small-step
operational semantics for the language, and describe its implementation in the
graph transformation and visualisation tool PORGY.Comment: In Proceedings GRAPHITE 2014, arXiv:1407.767
- …