8,252 research outputs found
Termination proofs by multiset path orderings imply primitive recursive derivation lengths
AbstractIt is shown that a termination proof for a term-rewriting system using multiset path orderings (i.e. recursive path orderings with multiset status only) yields a primitive recursive bound on the length of derivations, measured in the size of the starting term, confirming a conjecture of Plaisted (1978). This result holds for a great variety of path orderings, including path of subterms ordering, recursive decomposition ordering, and the path ordering of Kapur (1985) if lexicographic status is not incorporated. The result is essentially optimal as such derivation lengths can be found in each level of the Grzegorczyk hierarchy, even for string-rewriting systems
Decreasing Diagrams for Confluence and Commutation
Like termination, confluence is a central property of rewrite systems. Unlike
for termination, however, there exists no known complexity hierarchy for
confluence. In this paper we investigate whether the decreasing diagrams
technique can be used to obtain such a hierarchy. The decreasing diagrams
technique is one of the strongest and most versatile methods for proving
confluence of abstract rewrite systems. It is complete for countable systems,
and it has many well-known confluence criteria as corollaries.
So what makes decreasing diagrams so powerful? In contrast to other
confluence techniques, decreasing diagrams employ a labelling of the steps with
labels from a well-founded order in order to conclude confluence of the
underlying unlabelled relation. Hence it is natural to ask how the size of the
label set influences the strength of the technique. In particular, what class
of abstract rewrite systems can be proven confluent using decreasing diagrams
restricted to 1 label, 2 labels, 3 labels, and so on? Surprisingly, we find
that two labels suffice for proving confluence for every abstract rewrite
system having the cofinality property, thus in particular for every confluent,
countable system.
Secondly, we show that this result stands in sharp contrast to the situation
for commutation of rewrite relations, where the hierarchy does not collapse.
Thirdly, investigating the possibility of a confluence hierarchy, we
determine the first-order (non-)definability of the notion of confluence and
related properties, using techniques from finite model theory. We find that in
particular Hanf's theorem is fruitful for elegant proofs of undefinability of
properties of abstract rewrite systems
Behavioral Rewrite Systems and Behavioral Productivity
Abstract. This paper introduces behavioral rewrite systems, where rewriting is used to evaluate experiments, and behavioral productivity, which says that each experiment can be fully evaluated, and investigates some of their properties. First, it is shown that, in the case of (infinite) streams, behavioral productivity generalizes and may bring to a more basic rewriting setting the existing notion of stream productivity defined in the context of infinite rewriting and lazy strategies; some arguments are given that in some cases one may prefer the behavioral approach. Second, a behavioral productivity criterion is given, which reduces the problem to conventional term rewrite system termination, so that one can use off-the-shelf termination tools and techniques for checking behavioral productivity in general, not only for streams. Finally, behavioral productivity is shown to be equivalent to a proof-theoretic (rather than model-theoretic) notion of behavioral well-specifiedness, and its difficulty in the arithmetic hierarchy is shown to be Î 0 2 -complete. All new concepts are exemplified over streams, infinite binary trees, and processes
An Abstract Tableau Calculus for the Description Logic SHOI Using UnrestrictedBlocking and Rewriting
Abstract This paper presents an abstract tableau calculus for the description logic SHOI. SHOI is the extension of ALC with singleton concepts, role inverse, transitive roles and role inclusion axioms. The presented tableau calculus is inspired by a recently introduced tableau synthesis framework. Termination is achieved by a variation of the unrestricted blocking mechanism that immediately rewrites terms with respect to the conjectured equalities. This approach leads to reduced search space for decision procedures based on the calculus. We also discuss restrictions of the application of the blocking rule by means of additional side conditions and/or additional premises.
A Formalization of the Theorem of Existence of First-Order Most General Unifiers
This work presents a formalization of the theorem of existence of most
general unifiers in first-order signatures in the higher-order proof assistant
PVS. The distinguishing feature of this formalization is that it remains close
to the textbook proofs that are based on proving the correctness of the
well-known Robinson's first-order unification algorithm. The formalization was
applied inside a PVS development for term rewriting systems that provides a
complete formalization of the Knuth-Bendix Critical Pair theorem, among other
relevant theorems of the theory of rewriting. In addition, the formalization
methodology has been proved of practical use in order to verify the correctness
of unification algorithms in the style of the original Robinson's unification
algorithm.Comment: In Proceedings LSFA 2011, arXiv:1203.542
Synthesis of sup-interpretations: a survey
In this paper, we survey the complexity of distinct methods that allow the
programmer to synthesize a sup-interpretation, a function providing an upper-
bound on the size of the output values computed by a program. It consists in a
static space analysis tool without consideration of the time consumption.
Although clearly related, sup-interpretation is independent from termination
since it only provides an upper bound on the terminating computations. First,
we study some undecidable properties of sup-interpretations from a theoretical
point of view. Next, we fix term rewriting systems as our computational model
and we show that a sup-interpretation can be obtained through the use of a
well-known termination technique, the polynomial interpretations. The drawback
is that such a method only applies to total functions (strongly normalizing
programs). To overcome this problem we also study sup-interpretations through
the notion of quasi-interpretation. Quasi-interpretations also suffer from a
drawback that lies in the subterm property. This property drastically restricts
the shape of the considered functions. Again we overcome this problem by
introducing a new notion of interpretations mainly based on the dependency
pairs method. We study the decidability and complexity of the
sup-interpretation synthesis problem for all these three tools over sets of
polynomials. Finally, we take benefit of some previous works on termination and
runtime complexity to infer sup-interpretations.Comment: (2012
A Purely Functional Computer Algebra System Embedded in Haskell
We demonstrate how methods in Functional Programming can be used to implement
a computer algebra system. As a proof-of-concept, we present the
computational-algebra package. It is a computer algebra system implemented as
an embedded domain-specific language in Haskell, a purely functional
programming language. Utilising methods in functional programming and prominent
features of Haskell, this library achieves safety, composability, and
correctness at the same time. To demonstrate the advantages of our approach, we
have implemented advanced Gr\"{o}bner basis algorithms, such as Faug\`{e}re's
and , in a composable way.Comment: 16 pages, Accepted to CASC 201
Type classes for efficient exact real arithmetic in Coq
Floating point operations are fast, but require continuous effort on the part
of the user in order to ensure that the results are correct. This burden can be
shifted away from the user by providing a library of exact analysis in which
the computer handles the error estimates. Previously, we [Krebbers/Spitters
2011] provided a fast implementation of the exact real numbers in the Coq proof
assistant. Our implementation improved on an earlier implementation by O'Connor
by using type classes to describe an abstract specification of the underlying
dense set from which the real numbers are built. In particular, we used dyadic
rationals built from Coq's machine integers to obtain a 100 times speed up of
the basic operations already. This article is a substantially expanded version
of [Krebbers/Spitters 2011] in which the implementation is extended in the
various ways. First, we implement and verify the sine and cosine function.
Secondly, we create an additional implementation of the dense set based on
Coq's fast rational numbers. Thirdly, we extend the hierarchy to capture order
on undecidable structures, while it was limited to decidable structures before.
This hierarchy, based on type classes, allows us to share theory on the
naturals, integers, rationals, dyadics, and reals in a convenient way. Finally,
we obtain another dramatic speed-up by avoiding evaluation of termination
proofs at runtime.Comment: arXiv admin note: text overlap with arXiv:1105.275
- …