369 research outputs found
Deciding Confluence and Normal Form Properties of Ground Term Rewrite Systems Efficiently
It is known that the first-order theory of rewriting is decidable for ground
term rewrite systems, but the general technique uses tree automata and often
takes exponential time. For many properties, including confluence (CR),
uniqueness of normal forms with respect to reductions (UNR) and with respect to
conversions (UNC), polynomial time decision procedures are known for ground
term rewrite systems. However, this is not the case for the normal form
property (NFP). In this work, we present a cubic time algorithm for NFP, an
almost cubic time algorithm for UNR, and an almost linear time algorithm for
UNC, improving previous bounds. We also present a cubic time algorithm for CR
The exact hardness of deciding derivational and runtime complexity
For any class C of computable total functions satisfying some mild conditions, we prove that the following decision problems are complete for the existential part of the second level of the arithmetical hierarchy: (A) Deciding whether a term rewriting system (TRS for short) has runtime complexity bounded by a function in C. (B) Deciding whether a TRS has derivational complexity bounded by a function in C.
In particular, the problems of deciding whether a TRS has polynomially (exponentially) bounded runtime complexity (respectively derivational complexity) are complete for this level of the arithmetical ierarchy. This places deciding polynomial derivational or runtime complexity of TRSs at the same level as deciding nontermination or nonconfluence of TRSs. We proceed to show that the related problem of deciding for a single computable function f whether a TRS has runtime complexity bounded from above by f is complete for the universal part of the first level of the arithmetical hierarchy. We further prove that analysing the implicit complexity of TRSs is even more difficult: The problem of deciding whether a TRS accepts a language of terms accepted by some TRS with runtime complexity bounded by a function in C is complete for the existential part of the third level of the arithmetical hierarchy.
All of our results are easily extended to the notion of minimal complexity (where the length of shortest reductions to normal form is considered) and remain valid under any computable reduction strategy. Finally, all results hold both for unrestricted TRSs and for the class of orthogonal TRSs
A general framework for Noetherian well ordered polynomial reductions
Polynomial reduction is one of the main tools in computational algebra with
innumerable applications in many areas, both pure and applied. Since many years
both the theory and an efficient design of the related algorithm have been
solidly established.
This paper presents a general definition of polynomial reduction structure,
studies its features and highlights the aspects needed in order to grant and to
efficiently test the main properties (noetherianity, confluence, ideal
membership).
The most significant aspect of this analysis is a negative reappraisal of the
role of the notion of term order which is usually considered a central and
crucial tool in the theory. In fact, as it was already established in the
computer science context in relation with termination of algorithms, most of
the properties can be obtained simply considering a well-founded ordering,
while the classical requirement that it be preserved by multiplication is
irrelevant.
The last part of the paper shows how the polynomial basis concepts present in
literature are interpreted in our language and their properties are
consequences of the general results established in the first part of the paper.Comment: 36 pages. New title and substantial improvements to the presentation
according to the comments of the reviewer
Complexity Hierarchies and Higher-Order Cons-Free Rewriting
Constructor rewriting systems are said to be cons-free if, roughly,
constructor terms in the right-hand sides of rules are subterms of constructor
terms in the left-hand side; the computational intuition is that rules cannot
build new data structures. It is well-known that cons-free programming
languages can be used to characterize computational complexity classes, and
that cons-free first-order term rewriting can be used to characterize the set
of polynomial-time decidable sets.
We investigate cons-free higher-order term rewriting systems, the complexity
classes they characterize, and how these depend on the order of the types used
in the systems. We prove that, for every k 1, left-linear cons-free
systems with type order k characterize ETIME if arbitrary evaluation is
used (i.e., the system does not have a fixed reduction strategy).
The main difference with prior work in implicit complexity is that (i) our
results hold for non-orthogonal term rewriting systems with possible rule
overlaps with no assumptions about reduction strategy, (ii) results for such
term rewriting systems have previously only been obtained for k = 1, and with
additional syntactic restrictions on top of cons-freeness and left-linearity.
Our results are apparently among the first implicit characterizations of the
hierarchy E = ETIME ETIME .... Our work
confirms prior results that having full non-determinism (via overlaps of rules)
does not directly allow characterization of non-deterministic complexity
classes like NE. We also show that non-determinism makes the classes
characterized highly sensitive to minor syntactic changes such as admitting
product types or non-left-linear rules.Comment: Extended version (with appendices) of a paper published in FSCD 201
Layer Systems for Proving Confluence
We introduce layer systems for proving generalizations of the modularity of confluence for first-order rewrite systems. Layer systems specify how terms can be divided into layers. We establish structural conditions on those systems that imply confluence. Our abstract framework covers known results like many-sorted persistence, layer-preservation and currying. We present a counterexample to an extension of the former to order-sorted rewriting and derive new sufficient conditions for the extension to hold
Deciding the Word Problem for Ground Identities with Commutative and Extensional Symbols
The word problem for a finite set of ground identities is known to be decidable in polynomial time using congruence closure, and this is also the case if some of the function symbols are assumed to be commutative. We show that decidability in P is preserved if we add the assumption that certain function symbols f are extensional in the sense that f(s1,…,sn) ≈ f(t1,…,tn) implies s1 ≈ t1,…,sn ≈ tn. In addition, we investigate a variant of extensionality that is more appropriate for commutative function symbols, but which raises the complexity of the word problem to coNP
The First-Order Theory of Ground Tree Rewrite Graphs
We prove that the complexity of the uniform first-order theory of ground tree
rewrite graphs is in ATIME(2^{2^{poly(n)}},O(n)). Providing a matching lower
bound, we show that there is some fixed ground tree rewrite graph whose
first-order theory is hard for ATIME(2^{2^{poly(n)}},poly(n)) with respect to
logspace reductions. Finally, we prove that there exists a fixed ground tree
rewrite graph together with a single unary predicate in form of a regular tree
language such that the resulting structure has a non-elementary first-order
theory.Comment: accepted for Logical Methods in Computer Scienc
- …