3,613 research outputs found
On Constructor Rewrite Systems and the Lambda Calculus
We prove that orthogonal constructor term rewrite systems and lambda-calculus
with weak (i.e., no reduction is allowed under the scope of a
lambda-abstraction) call-by-value reduction can simulate each other with a
linear overhead. In particular, weak call-by- value beta-reduction can be
simulated by an orthogonal constructor term rewrite system in the same number
of reduction steps. Conversely, each reduction in a term rewrite system can be
simulated by a constant number of beta-reduction steps. This is relevant to
implicit computational complexity, because the number of beta steps to normal
form is polynomially related to the actual cost (that is, as performed on a
Turing machine) of normalization, under weak call-by-value reduction.
Orthogonal constructor term rewrite systems and lambda-calculus are thus both
polynomially related to Turing machines, taking as notion of cost their natural
parameters.Comment: 27 pages. arXiv admin note: substantial text overlap with
arXiv:0904.412
Strategic polymorphism requires just two combinators!
In previous work, we introduced the notion of functional strategies:
first-class generic functions that can traverse terms of any type while mixing
uniform and type-specific behaviour. Functional strategies transpose the notion
of term rewriting strategies (with coverage of traversal) to the functional
programming paradigm. Meanwhile, a number of Haskell-based models and
combinator suites were proposed to support generic programming with functional
strategies.
In the present paper, we provide a compact and matured reconstruction of
functional strategies. We capture strategic polymorphism by just two primitive
combinators. This is done without commitment to a specific functional language.
We analyse the design space for implementational models of functional
strategies. For completeness, we also provide an operational reference model
for implementing functional strategies (in Haskell). We demonstrate the
generality of our approach by reconstructing representative fragments of the
Strafunski library for functional strategies.Comment: A preliminary version of this paper was presented at IFL 2002, and
included in the informal preproceedings of the worksho
Needed Computations Shortcutting Needed Steps
We define a compilation scheme for a constructor-based, strongly-sequential,
graph rewriting system which shortcuts some needed steps. The object code is
another constructor-based graph rewriting system. This system is normalizing
for the original system when using an innermost strategy. Consequently, the
object code can be easily implemented by eager functions in a variety of
programming languages. We modify this object code in a way that avoids total or
partial construction of the contracta of some needed steps of a computation.
When computing normal forms in this way, both memory consumption and execution
time are reduced compared to ordinary rewriting computations in the original
system.Comment: In Proceedings TERMGRAPH 2014, arXiv:1505.0681
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
Polynomial Path Orders
This paper is concerned with the complexity analysis of constructor term
rewrite systems and its ramification in implicit computational complexity. We
introduce a path order with multiset status, the polynomial path order POP*,
that is applicable in two related, but distinct contexts. On the one hand POP*
induces polynomial innermost runtime complexity and hence may serve as a
syntactic, and fully automatable, method to analyse the innermost runtime
complexity of term rewrite systems. On the other hand POP* provides an
order-theoretic characterisation of the polytime computable functions: the
polytime computable functions are exactly the functions computable by an
orthogonal constructor TRS compatible with POP*.Comment: LMCS version. This article supersedes arXiv:1209.379
Singular and Plural Functions for Functional Logic Programming
Functional logic programming (FLP) languages use non-terminating and
non-confluent constructor systems (CS's) as programs in order to define
non-strict non-determi-nistic functions. Two semantic alternatives have been
usually considered for parameter passing with this kind of functions: call-time
choice and run-time choice. While the former is the standard choice of modern
FLP languages, the latter lacks some properties---mainly
compositionality---that have prevented its use in practical FLP systems.
Traditionally it has been considered that call-time choice induces a singular
denotational semantics, while run-time choice induces a plural semantics. We
have discovered that this latter identification is wrong when pattern matching
is involved, and thus we propose two novel compositional plural semantics for
CS's that are different from run-time choice.
We study the basic properties of our plural semantics---compositionality,
polarity, monotonicity for substitutions, and a restricted form of the bubbling
property for constructor systems---and the relation between them and to
previous proposals, concluding that these semantics form a hierarchy in the
sense of set inclusion of the set of computed values. We have also identified a
class of programs characterized by a syntactic criterion for which the proposed
plural semantics behave the same, and a program transformation that can be used
to simulate one of them by term rewriting. At the practical level, we study how
to use the expressive capabilities of these semantics for improving the
declarative flavour of programs. We also propose a language which combines
call-time choice and our plural semantics, that we have implemented in Maude.
The resulting interpreter is employed to test several significant examples
showing the capabilities of the combined semantics.
To appear in Theory and Practice of Logic Programming (TPLP)Comment: 53 pages, 5 figure
- …