156 research outputs found
A standardisation proof for algebraic pattern calculi
This work gives some insights and results on standardisation for call-by-name
pattern calculi. More precisely, we define standard reductions for a pattern
calculus with constructor-based data terms and patterns. This notion is based
on reduction steps that are needed to match an argument with respect to a given
pattern. We prove the Standardisation Theorem by using the technique developed
by Takahashi and Crary for lambda-calculus. The proof is based on the fact that
any development can be specified as a sequence of head steps followed by
internal reductions, i.e. reductions in which no head steps are involved.Comment: In Proceedings HOR 2010, arXiv:1102.346
Combinatorics of explicit substitutions
is an extension of the -calculus which
internalises the calculus of substitutions. In the current paper, we
investigate the combinatorial properties of focusing on the
quantitative aspects of substitution resolution. We exhibit an unexpected
correspondence between the counting sequence for -terms and
famous Catalan numbers. As a by-product, we establish effective sampling
schemes for random -terms. We show that typical
-terms represent, in a strong sense, non-strict computations
in the classic -calculus. Moreover, typically almost all substitutions
are in fact suspended, i.e. unevaluated, under closures. Consequently, we argue
that is an intrinsically non-strict calculus of explicit
substitutions. Finally, we investigate the distribution of various redexes
governing the substitution resolution in and investigate the
quantitative contribution of various substitution primitives
Developments in the rewriting calculus
The theory of developments, originally developed for the Lambda calculus, has been successfully adapted to several other computational paradigms, like first- and higher-order term rewrite system. The main desirable results on developments are the fact that the complete development of a finite set of redexes always terminates (FD) and the fact that, for a given initial term, all complete developments of a fixed set of redexes end with the same term (FD!). Following the ideas in the Lambda calculus, in this paper, we present a notion of development and the proofs of theorems FD and FD! for the rewriting calculus, a framework embedding Lambda calculus and rewriting capabilities, by allowing abstraction not only on variables but also on patterns. As an additional contribution, a new proof of the confluence property for the rewriting calculus, is obtained as a consequence of the results on developments
Normalisation for Dynamic Pattern Calculi
The Pure Pattern Calculus (PPC) extends the lambda-calculus, as well as the family of algebraic pattern calculi, with first-class patterns; that is, patterns can be passed as arguments, evaluated and returned as results. The notion of matching failure of the PPC not only provides a mechanism to define functions by pattern matching on cases but also supplies PPC with parallel-or-like, non-sequential behaviour. Therefore, devising normalising strategies for PPC to obtain well-behaved implementations turns out to be challenging.
This paper focuses on normalising reduction strategies for PPC. We define a (multistep) strategy and show that it is normalising. The strategy generalises the leftmost-outermost strategy for lambda-calculus and is strictly finer than parallel-outermost. The normalisation proof is based on the notion of necessary set of redexes, a generalisation of the notion of needed redex encompassing
non-sequential reduction systems
Towards sharing in lazy computation systems
Work on proving congruence of bisimulation in functional programming languages often refers to [How89,How96], where Howe gave a highly general account on this topic in terms of so-called lazy computation systems . Particularly in implementations of lazy functional languages, sharing plays an eminent role. In this paper we will show how the original work of Howe can be extended to cope with sharing. Moreover, we will demonstrate the application of our approach to the call-by-need lambda-calculus lambda-ND which provides an erratic non-deterministic operator pick and a non-recursive let. A definition of a bisimulation is given, which has to be based on a further calculus named lambda-~, since the na1ve bisimulation definition is useless. The main result is that this bisimulation is a congruence and contained in the contextual equivalence. This might be a step towards defining useful bisimulation relations and proving them to be congruences in calculi that extend the lambda-ND-calculus
Normalisation for higher-order calculi with explicit substitutions
Explicit substitutions (ES) were introduced as a bridge between the theory of rewrite systems with binders and substitution, such as the λ-calculus, and their implementation. In a seminal paper Melliès observed that the dynamical properties of a rewrite system and its ES-based implementation may not coincide: he showed that a strongly normalising term (i.e. one which does not admit infinite derivations) in the λ-calculus may lose this status in its ES-based implementation. This paper studies normalisation for the latter systems in the general setting of higher-order rewriting: Based on recent work extending the theory of needed strategies to non-orthogonal rewrite systems we show that needed strategies normalise in the ES-based implementation of any orthogonal pattern higher-order rewrite system.Facultad de Informátic
Normalisation for higher-order calculi with explicit substitutions
Explicit substitutions (ES) were introduced as a bridge between the theory of rewrite systems with binders and substitution, such as the λ-calculus, and their implementation. In a seminal paper Melliès observed that the dynamical properties of a rewrite system and its ES-based implementation may not coincide: he showed that a strongly normalising term (i.e. one which does not admit infinite derivations) in the λ-calculus may lose this status in its ES-based implementation. This paper studies normalisation for the latter systems in the general setting of higher-order rewriting: Based on recent work extending the theory of needed strategies to non-orthogonal rewrite systems we show that needed strategies normalise in the ES-based implementation of any orthogonal pattern higher-order rewrite system.Facultad de Informátic
On the Implementation of Dynamic Patterns
The evaluation mechanism of pattern matching with dynamic patterns is
modelled in the Pure Pattern Calculus by one single meta-rule. This
contribution presents a refinement which narrows the gap between the abstract
calculus and its implementation. A calculus is designed to allow reasoning on
matching algorithms. The new calculus is proved to be confluent, and to
simulate the original Pure Pattern Calculus. A family of new, matching-driven,
reduction strategies is proposed.Comment: In Proceedings HOR 2010, arXiv:1102.346
- …