712 research outputs found
Termination of lambda-calculus with the extra Call-By-Value rule known as assoc
In this paper we prove that any lambda-term that is strongly normalising for
beta-reduction is also strongly normalising for beta,assoc-reduction. assoc is
a call-by-value rule that has been used in works by Moggi, Joachimsky, Espirito
Santo and others. The result has often been justified with incomplete or
incorrect proofs. Here we give one in full details
GLC actors, artificial chemical connectomes, topological issues and knots
Based on graphic lambda calculus, we propose a program for a new model of
asynchronous distributed computing, inspired from Hewitt Actor Model, as well
as several investigation paths, concerning how one may graft lambda calculus
and knot diagrammatics
Executable Structural Operational Semantics in Maude
This paper describes in detail how to bridge the gap between theory and practice when implementing
in Maude structural operational semantics described in rewriting logic, where transitions
become rewrites and inference rules become conditional rewrite rules with rewrites in the conditions,
as made possible by the new features in Maude 2.0. We validate this technique using it in
several case studies: a functional language Fpl (evaluation and computation semantics, including
an abstract machine), imperative languages WhileL (evaluation and computation semantics) and
GuardL with nondeterminism (computation semantics), Kahn’s functional language Mini-ML (evaluation
or natural semantics), Milner’s CCS (with strong and weak transitions), and Full LOTOS
(including ACT ONE data type specifications). In addition, on top of CCS we develop an implementation
of the Hennessy-Milner modal logic for describing local capabilities of processes, and
for LOTOS we build an entire tool where Full LOTOS specifications can be entered and executed
(without user knowledge of the underlying implementation of the semantics). We also compare this
method based on transitions as rewrites with another one based on transitions as judgements
Some Lambda Calculus and Type Theory Formalized
"This paper is about our hobby." That is the first sentence of [MP93], the first report on our formal development of lambda calculus and type theory, written in autumn 1992. We have continued to pursue this hobby on and off ever since, and have developed a substantial body of formal knowledge, including Church-Rosser and standardizationtheorems for beta reduction, and the basic theory ofPure Type Systems (PTS) leading to the strengthening theorem and type checking algorithms for PTS. Some of this work is reported in [MP93, vBJMP94, Pol94b, Pol95]. In the present paper we survey this work, including some new proofs, and point out what we feel has been learned about the general issues of formalizing mathematics. On the technical side, we describe an abstract, and simplified, proof of standardization for beta reduction, not previously published, that doesnot mention redex positions or residuals. On the general issues, we emphasize the search for formal definitions that are convenient for formal proof and convincingly represent the intended informal concepts. The LEGO Proof Development System [LP92] was used to check the work in an implementation of the Extended Calculus of Constructions(ECC) with inductive types [Luo94]. LEGO is a refinement styleproof checker, publicly available by ftp and WWW, with a User's Manual [LP92] and a large collection of examples. Section 1.3 contains information on accessing the formal development described in this paper. Other interesting examples formalized in LEGO include program specification and data refinement [Luo91], strong normalization of System F [Alt93], synthetic domain theory [Reu95, Reu96], and operational semantics for imperative programs [Sch97]
The Computer Modelling of Mathematical Reasoning
xv, 403 p.; 23 cm
Deforestation for higher-order functional programs
Functional programming languages are an ideal medium for program optimisations based
on source-to-source transformation techniques. Referential transparency affords opportunities
for a wide range of correctness-preserving transformations leading to potent optimisation
strategies.
This thesis builds on deforestation, a program transformation technique due to Wadler
that removes intermediate data structures from first-order functional programs.
Our contribution is to reformulate deforestation for higher-order functional programming
languages, and to show that the resulting algorithm terminates given certain syntactic and
typing constraints on the input. These constraints are entirely reasonable, indeed it is
possible to translate any typed program into the required syntactic form. We show how
this translation can be performed automatically and optimally.
The higher-order deforestation algorithm is transparent. That is, it is possible to determine
by examination of the source program where the optimisation will be applicable.
We also investigate the relationship of deforestation to cut-elimination, the normalisation
property for the logic of sequent calculus. By combining a cut-elimination algorithm and
first-order deforestation, we derive an improved higher-order deforestation algorithm.
The higher-order deforestation algorithm has been implemented in the Glasgow Haskell
Compiler. We describe how deforestation fits into the framework of Haskell, and design
a model for the implementation that allows automatic list removal, with additional deforestation
being performed on the basis of programmer supplied annotations. Results from
applying the deforestation implementation to several example Haskell programs are given
Objects and subtyping in the λΠ-calculus modulo
We present a shallow embedding of the Object Calculus of Abadi and Cardelli in the λΠ-calculus modulo, an extension of the λΠ-calculus in which conversion is considered modulo a rewrite system. This embedding may be used as an example of translation of subtyping, a feature also present in some proof assistants like Coq and PVS. This embedding is proved correct with respect to the operational semantics and the type system of the Object Calculus. It has been implemented as a translation tool from the Object Calculus to Dedukti, a type-checker for the λΠ-calculus modulo
- …