8,227 research outputs found
Equality of Corecursive Streams Defined by Finitary Equational Systems
In recent work, non-regular streams have been defined corecursively, by representing them with finitary equational systems built on top of various operators, besides the standard constructor. With finitary equational systems based only on the stream constructor, one can use the free theory of regular (a.k.a. rational) trees to get a sound and complete procedure to decide whether two streams are equal. However, this is not the case if one allows other operators in equations, since the underlying equational theory becomes non-trivial, hence equality of regular trees is too strong to guarantee termination of corecursive functions defined even only with the constructor and tail operators. To overcome this problem, we provide a weaker definition of equality between streams denoted by finitary equational systems built on different stream operators, including tail operator and constructor, and prove its soundness
Relating Church-Style and Curry-Style Subtyping
Type theories with higher-order subtyping or singleton types are examples of
systems where computation rules for variables are affected by type information
in the context. A complication for these systems is that bounds declared in the
context do not interact well with the logical relation proof of completeness or
termination. This paper proposes a natural modification to the type syntax for
F-Omega-Sub, adding variable's bound to the variable type constructor, thereby
separating the computational behavior of the variable from the context. The
algorithm for subtyping in F-Omega-Sub can then be given on types without
context or kind information. As a consequence, the metatheory follows the
general approach for type systems without computational information in the
context, including a simple logical relation definition without Kripke-style
indexing by context. This new presentation of the system is shown to be
equivalent to the traditional presentation without bounds on the variable type
constructor.Comment: In Proceedings ITRS 2010, arXiv:1101.410
Complexity Analysis of Precedence Terminating Infinite Graph Rewrite Systems
The general form of safe recursion (or ramified recurrence) can be expressed
by an infinite graph rewrite system including unfolding graph rewrite rules
introduced by Dal Lago, Martini and Zorzi, in which the size of every normal
form by innermost rewriting is polynomially bounded. Every unfolding graph
rewrite rule is precedence terminating in the sense of Middeldorp, Ohsaki and
Zantema. Although precedence terminating infinite rewrite systems cover all the
primitive recursive functions, in this paper we consider graph rewrite systems
precedence terminating with argument separation, which form a subclass of
precedence terminating graph rewrite systems. We show that for any precedence
terminating infinite graph rewrite system G with a specific argument
separation, both the runtime complexity of G and the size of every normal form
in G can be polynomially bounded. As a corollary, we obtain an alternative
proof of the original result by Dal Lago et al.Comment: In Proceedings TERMGRAPH 2014, arXiv:1505.06818. arXiv admin note:
text overlap with arXiv:1404.619
Generic Encodings of Constructor Rewriting Systems
Rewriting is a formalism widely used in computer science and mathematical
logic. The classical formalism has been extended, in the context of functional
languages, with an order over the rules and, in the context of rewrite based
languages, with the negation over patterns. We propose in this paper a concise
and clear algorithm computing the difference over patterns which can be used to
define generic encodings of constructor term rewriting systems with negation
and order into classical term rewriting systems. As a direct consequence,
established methods used for term rewriting systems can be applied to analyze
properties of the extended systems. The approach can also be seen as a generic
compiler which targets any language providing basic pattern matching
primitives. The formalism provides also a new method for deciding if a set of
patterns subsumes a given pattern and thus, for checking the presence of
useless patterns or the completeness of a set of patterns.Comment: Added appendix with proofs and extended example
Observation of implicit complexity by non confluence
We propose to consider non confluence with respect to implicit complexity. We
come back to some well known classes of first-order functional program, for
which we have a characterization of their intentional properties, namely the
class of cons-free programs, the class of programs with an interpretation, and
the class of programs with a quasi-interpretation together with a termination
proof by the product path ordering. They all correspond to PTIME. We prove that
adding non confluence to the rules leads to respectively PTIME, NPTIME and
PSPACE. Our thesis is that the separation of the classes is actually a witness
of the intentional properties of the initial classes of programs
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
- …