Results 1 - 10
of
46
Confluence properties of Weak and Strong Calculi of Explicit Substitutions
- JOURNAL OF THE ACM
, 1996
"... Categorical combinators [12, 21, 43] and more recently oe-calculus [1, 23], have been introduced to provide an explicit treatment of substitutions in the -calculus. We reintroduce here the ingredients of these calculi in a self-contained and stepwise way, with a special emphasis on confluence prope ..."
Abstract
-
Cited by 114 (7 self)
- Add to MetaCart
Categorical combinators [12, 21, 43] and more recently oe-calculus [1, 23], have been introduced to provide an explicit treatment of substitutions in the -calculus. We reintroduce here the ingredients of these calculi in a self-contained and stepwise way, with a special emphasis on confluence properties. The main new results of the paper w.r.t. [12, 21, 1, 23] are the following: 1. We present a confluent weak calculus of substitutions, where no variable clashes can be feared. 2. We solve a conjecture raised in [1]: oe-calculus is not confluent (it is confluent on ground terms only). This unfortunate result is "repaired" by presenting a confluent version of oe-calculus, named the Env-calculus in [23], called here the confluent oe-calculus.
Inductive Families
- Formal Aspects of Computing
, 1997
"... A general formulation of inductive and recursive definitions in Martin-Lof's type theory is presented. It extends Backhouse's `Do-It-Yourself Type Theory' to include inductive definitions of families of sets and definitions of functions by recursion on the way elements of such sets are generated. Th ..."
Abstract
-
Cited by 59 (12 self)
- Add to MetaCart
A general formulation of inductive and recursive definitions in Martin-Lof's type theory is presented. It extends Backhouse's `Do-It-Yourself Type Theory' to include inductive definitions of families of sets and definitions of functions by recursion on the way elements of such sets are generated. The formulation is in natural deduction and is intended to be a natural generalization to type theory of Martin-Lof's theory of iterated inductive definitions in predicate logic. Formal criteria are given for correct formation and introduction rules of a new set former capturing definition by strictly positive, iterated, generalized induction. Moreover, there is an inversion principle for deriving elimination and equality rules from the formation and introduction rules. Finally, there is an alternative schematic presentation of definition by recursion. The resulting theory is a flexible and powerful language for programming and constructive mathematics. We hint at the wealth of possible applic...
Deriving a Lazy Abstract Machine
- Journal of Functional Programming
, 1997
"... Machine Peter Sestoft Department of Mathematics and Physics Royal Veterinary and Agricultural University Thorvaldsensvej 40, DK-1871 Frederiksberg C, Denmark E-mail: sestoft@dina.kvl.dk Version 6 of March 13, 1996 Abstract We derive a simple abstract machine for lazy evaluation of the lambda cal ..."
Abstract
-
Cited by 57 (2 self)
- Add to MetaCart
Machine Peter Sestoft Department of Mathematics and Physics Royal Veterinary and Agricultural University Thorvaldsensvej 40, DK-1871 Frederiksberg C, Denmark E-mail: sestoft@dina.kvl.dk Version 6 of March 13, 1996 Abstract We derive a simple abstract machine for lazy evaluation of the lambda calculus, starting from Launchbury's natural semantics. Lazy evaluation here means non-strict evaluation with sharing of argument evaluation, that is, call-by-need. The machine we derive is a lazy version of Krivine's abstract machine, which was originally designed for call-by-name evaluation. We extend it with datatype constructors and base values, so the final machine implements all dynamic aspects of a lazy functional language. 1 Introduction The development of an efficient abstract machine for lazy evaluation usually starts from either a graph reduction machine or an environment machine. Graph reduction machines perform substitution by rewriting the term graph, that is, the program itself...
Preservation of Strong Normalisation in Named Lambda Calculi with Explicit Substitution and Garbage Collection
- IN CSN-95: COMPUTER SCIENCE IN THE NETHERLANDS
, 1995
"... In this paper we introduce and study a new lambda-calculus with explicit substitution, lambda-xgc, which has two distinguishing features: first, it retains the use of traditional variable names, specifying terms modulo renaming; this simplifies the reduction system. Second, it includes reduction rul ..."
Abstract
-
Cited by 54 (7 self)
- Add to MetaCart
In this paper we introduce and study a new lambda-calculus with explicit substitution, lambda-xgc, which has two distinguishing features: first, it retains the use of traditional variable names, specifying terms modulo renaming; this simplifies the reduction system. Second, it includes reduction rules for explicit garbage collection; this simplifies several proofs. We show that lambda-xgc is a conservative extension which preserves strong normalisation (PSN) of the untyped lambda-calculus. The result is obtained in a modular way by first proving it for garbage-free reduction and then extending to `reductions in garbage'. This provides insight into the counterexample to PSN for lambda-sigma of Melliès (1995); we exploit the abstract nature of lambda-xgc to show how PSN is in conflict with any reasonable substitution composition rule (except for trivial composition rules of which we mention one). Key words: lambda calculus, explicit substitution, strong normalisation, garbage collection.
From operational semantics to abstract machines
- Mathematical Structures in Computer Science
, 1992
"... We consider the problem of mechanically constructing abstract machines from operational semantics, producing intermediate-level specifications of evaluators guaranteed to be correct with respect to the operational semantics. We construct these machines by repeatedly applying correctness-preserving t ..."
Abstract
-
Cited by 53 (4 self)
- Add to MetaCart
We consider the problem of mechanically constructing abstract machines from operational semantics, producing intermediate-level specifications of evaluators guaranteed to be correct with respect to the operational semantics. We construct these machines by repeatedly applying correctness-preserving transformations to operational semantics until the resulting specifications have the form of abstract machines. Though not automatable in general, this approach to constructing machine implementations can be mechanized, providing machine-verified correctness proofs. As examples we present the transformation of specifications for both call-by-name and call-by-value evaluation of the untyped λ-calculus into abstract machines that implement such evaluation strategies. We also present extensions to the call-by-value machine for a language containing constructs for recursion, conditionals, concrete data types, and built-in functions. In all cases, the correctness of the derived abstract machines follows from the (generally transparent) correctness of the initial operational semantic specification and the correctness of the transformations applied. 1.
Classical Logic, Continuation Semantics and Abstract Machines
, 1998
"... Machines Th. STREICHER Fachbereich 4 Mathematik, TU Darmstadt, Schlossgartenstr. 7, 64289 Darmstadt, streiche@mathematik.th-darmstadt.de B. REUS Institut fur Informatik, Ludwig-Maximilians-Universitat, Oettingenstr. 67, D-80538 Munchen, reus@informatik.uni-muenchen.de Abstract One of the ..."
Abstract
-
Cited by 42 (3 self)
- Add to MetaCart
Machines Th. STREICHER Fachbereich 4 Mathematik, TU Darmstadt, Schlossgartenstr. 7, 64289 Darmstadt, streiche@mathematik.th-darmstadt.de B. REUS Institut fur Informatik, Ludwig-Maximilians-Universitat, Oettingenstr. 67, D-80538 Munchen, reus@informatik.uni-muenchen.de Abstract One of the goals of this paper is to demonstrate that denotational semantics is useful for operational issues like implementation of functional languages by abstract machines. This is exemplified in a tutorial way by studying the case of extensional untyped call-byname -calculus with Felleisen's control operator C. We derive the transition rules for an abstract machine from a continuation semantics which appears as a generalization of the ::-translation known from logic. The resulting abstract machine appears as an extension of Krivine's Machine implementing head reduction. Though the result, namely Krivine's Machine, is well known our method of deriving it from continuation semantics is new and applicable to other languages (as e.g. call-by-value variants).
An Algorithm for Type-Checking Dependent Types
- Science of Computer Programming
, 1996
"... We present a simple type-checker for a language with dependent types and let expressions, with a simple proof of correctness. Introduction Type Theory provides an interesting approach to the problem of (interactive) proof-checking. Instead of introducing, like in LCF [10], an abstract data type of t ..."
Abstract
-
Cited by 41 (4 self)
- Add to MetaCart
We present a simple type-checker for a language with dependent types and let expressions, with a simple proof of correctness. Introduction Type Theory provides an interesting approach to the problem of (interactive) proof-checking. Instead of introducing, like in LCF [10], an abstract data type of theorems, it uses the proofs-as-programs analogy and reduces the problem of proof checking to the problem of type-checking in a programming language with dependent types [5]. This approach presents several advantages, well described in [11,5], among those being the possibility of independent proof verification and of a uniform treatment for naming constants and theorems. It is crucial however for this approach to proof-checking to have a simple and reliable type-checking algorithm. Since the core part of such languages, like the ones described in [5,7], seems very simple, there may be some hope for such a short and simple type-checker for dependent types. Indeed, de Bruijn sketches such an al...
Structured Type Theory
, 1999
"... Introduction We present our implementation AGDA of type theory. We limit ourselves in this presentation to a rather primitive form of type theory (dependent product with a simple notion of sorts) that we extend to structure facility we find in most programming language: let expressions (local defin ..."
Abstract
-
Cited by 36 (4 self)
- Add to MetaCart
Introduction We present our implementation AGDA of type theory. We limit ourselves in this presentation to a rather primitive form of type theory (dependent product with a simple notion of sorts) that we extend to structure facility we find in most programming language: let expressions (local definition) and a package mechanism. We call this language Structured Type Theory. The first part describes the syntax of the language and an informal description of the type-checking. The second part contains a detailed description of a core language, which is used to implement Strutured Type Theory. We give a realisability semantics, and type-checking rules are proved correct with respect to this semantics. The notion of meta-variables is explained at this level. The third part explains how to interpret Structured Type Theory in this core language. The main contributions are: ffl use of explicit substitution to simplify and make
Improvement in a Lazy Context: An Operational Theory for Call-By-Need
- Proc. POPL'99, ACM
, 1999
"... Machine The semantics presented in this section is essentially Sestoft's \mark 1" abstract machine for laziness [Sestoft 1997]. In that paper, he proves his abstract machine 6 A. K. Moran and D. Sands h fx = Mg; x; S i ! h ; M; #x : S i (Lookup) h ; V; #x : S i ! h fx = V g; V; S i (Update) h ; ..."
Abstract
-
Cited by 31 (7 self)
- Add to MetaCart
Machine The semantics presented in this section is essentially Sestoft's \mark 1" abstract machine for laziness [Sestoft 1997]. In that paper, he proves his abstract machine 6 A. K. Moran and D. Sands h fx = Mg; x; S i ! h ; M; #x : S i (Lookup) h ; V; #x : S i ! h fx = V g; V; S i (Update) h ; M x; S i ! h ; M; x : S i (Unwind) h ; x:M; y : S i ! h ; M [ y = x ]; S i (Subst) h ; case M of alts ; S i ! h ; M; alts : S i (Case) h ; c j ~y; fc i ~x i N i g : S i ! h ; N j [ ~y = ~x j ]; S i (Branch) h ; let f~x = ~ Mg in N; S i ! h f~x = ~ Mg; N; S i ~x dom(;S) (Letrec) Fig. 1. The abstract machine semantics for call-by-need. semantics sound and complete with respect to Launchbury's natural semantics, and we will not repeat those proofs here. Transitions are over congurations consisting of a heap, containing bindings, the expression currently being evaluated, and a stack. The heap is a partial function from variables to terms, and denoted in an identical manner to a coll...
A rational deconstruction of Landin’s SECD machine
- Implementation and Application of Functional Languages, 16th International Workshop, IFL’04, number 3474 in Lecture Notes in Computer Science
, 2004
"... Abstract. Landin’s SECD machine was the first abstract machine for applicative expressions, i.e., functional programs. Landin’s J operator was the first control operator for functional languages, and was specified by an extension of the SECD machine. We present a family of evaluation functions corre ..."
Abstract
-
Cited by 23 (16 self)
- Add to MetaCart
Abstract. Landin’s SECD machine was the first abstract machine for applicative expressions, i.e., functional programs. Landin’s J operator was the first control operator for functional languages, and was specified by an extension of the SECD machine. We present a family of evaluation functions corresponding to this extension of the SECD machine, using a series of elementary transformations (transformation into continuation-passing style (CPS) and defunctionalization, chiefly) and their left inverses (transformation into direct style and refunctionalization). To this end, we modernize the SECD machine into a bisimilar one that operates in lockstep with the original one but that (1) does not use a data stack and (2) uses the caller-save rather than the callee-save convention for environments. We also identify that the dump component of the SECD machine is managed in a callee-save way. The caller-save counterpart of the modernized SECD machine precisely corresponds to Thielecke’s doublebarrelled continuations and to Felleisen’s encoding of J in terms of call/cc. We then variously characterize the J operator in terms of CPS and in terms of delimited-control operators in the CPS hierarchy. As a byproduct, we also present several reduction semantics for applicative expressions

