DOCSLIB.ORG

Lecture 3: Typed Lambda Calculus and Curry-Howard

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Lecture 3: Typed Lambda Calculus and Curry-Howard Lecture 3: Typed Lambda Calculus and Curry-Howard H. Geuvers Radboud University Nijmegen, NL 21st Estonian Winter School in Computer Science Winter 2016 H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 1 / 65 Outline H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 2 / 65 Typed λ calculus as a basis for logic λ-term : type M:A program : data type proof : formula program : (full) specification Aim: • Type Theory as an integrated system for proving and programming. • Type Theory as a basis for proof assistants and interactive theorem proving. H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 3 / 65 Simple type theory Simplest system: λ! or simple type theory, STT. Just arrow types Typ := TVar j (Typ ! Typ) • Examples: (α ! β) ! α,(α ! β) ! ((β ! γ) ! (α ! γ)) • Brackets associate to the right and outside brackets are omitted: (α ! β) ! (β ! γ) ! α ! γ • Types are denoted by A; B;:::. H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 4 / 65 Simple type theory `ala Church Formulation with contexts to declare the free variables: x1 : A1; x2 : A2;:::; xn : An is a context, usually denoted byΓ. Derivation rules of λ! (`ala Church): x:A 2 Γ Γ ` M : A ! B Γ ` N : A Γ; x:A ` P : B Γ ` x : A Γ ` MN : B Γ ` λx:A:P : A ! B Γ `λ! M : A if there is a derivation using these rules with conclusion Γ ` M : A H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 5 / 65 Examples ` λx : A.λy : B:x : A ! B ! A ` λx : A ! B.λy : B ! C.λz : A:y (x z):(A!B)!(B!C)!A!C ` λx : A.λy :(B ! A) ! A:y(λz : B:x): A ! ((B ! A) ! A) ! A Not for every type there is a closed term of that type: (A ! A) ! A is not inhabited That is: there is no term M such that ` M :(A ! A) ! A: H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 6 / 65 Typed Terms versus Type Assignment • With typed terms also called typing `ala Church, we have terms with type information in the λ-abstraction λx : A:x : A ! A • Terms have unique types, • The type is directly computed from the type info in the variables. • With typed assignment also called typing `ala Curry, we assign types to untyped λ-terms λx:x : A ! A • Terms do not have unique types, • A principal type can be computed using unification. H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 7 / 65 Church vs. Curry typing • The Curry formulation is especially interesting for programming: you want to write as little type information as possible; let the compiler infer the types for you. • The Church formulation is especially interesting for proof checking: terms are created interactively; type structure is so intricate that type inference is undecidable (if you start from an untyped term). [ This lecture] H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 8 / 65 Formulas-as-Types (Curry, Howard) Recall: there are two readings of a judgement M : A 1 term as algorithm/program, type as specification: M is a function of type A 2 type as a proposition, term as its proof: M is a proof of the proposition A • There is a one-to-one correspondence: typable terms in λ!' derivations in minimal proposition logic • x1 : B1; x2 : B2;:::; xn : Bn ` M : A can be read as M is a proof of A from the assumptions B1; B2;:::; Bn. H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 9 / 65 Example [A ! B ! C]3 [A]1 [A ! B]2 [A]1 B ! C B C 1 ' A ! C 2 (A ! B) ! A ! C 3 (A ! B ! C) ! (A ! B) ! A ! C λx:A ! B ! C.λy:A ! B.λz:A:x z (y z) :(A ! B ! C) ! (A ! B) ! A ! C H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 10 / 65 Example [x : A ! B ! C]3 [z : A]1 [y : A ! B]2 [z : A]1 x z : B ! C y z : B x z (y z): C 1 λz:A:x z (y z): A ! C 2 λy:A ! B.λz:A:x z (y z):( A ! B) ! A ! C 3 λx:A ! B ! C.λy:A ! B.λz:A:x z (y z):( A!B!C)!(A!B)!A!C Exercise: Give the derivation that corresponds to λx:C ! E.λy:(C ! E) ! E:y(λz:y x): (C ! E) ! ((C ! E) ! E) ! E H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 11 / 65 Typed Combinatory Logic We have seen Combinatory Logic with the axioms for I, K and S. We now know their typed definition in λ!: I := λx : A:x : A ! A K := λx : A.λy : B:x : A ! B ! A S := λx:A ! B ! C.λy:A ! B.λz:A:x z (y z) :(A ! B ! C) ! (A ! B) ! A ! C • The three axiom schemes A ! A, A ! B ! A and (A ! B ! C) ! (A ! B) ! A ! C together with the derivation rule Modus Ponens is exactly Hilbert style minimal proposition logic. • The typed CL terms are exactly the derivations in this logic. • Modus Ponens corresponds with Application in CL Exercise: Show that the scheme A ! A is derivable. Cast in CL terminology: I can be defined in terms of S and K. To be precise: I = SKK. H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 12 / 65 Computation = Cut-elimination • β-reduction:(λx:A:M)P !β M[x := P] Cut-elimination in minimal logic= β-reduction in λ!. [A]1 D D1 2 A B D2 −! 1 D A ! B A 1 B B [x : A]1 D1 D2 D P : A M : B 2 −! 1 β D λx:A:M : A ! B P : A 1 M[x := P]: B (λx:A:M)P : B H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 13 / 65 Example Proof of A ! A ! B; (A ! B) ! A ` B with a cut. [A]1 A ! A ! B [A]1 A ! A ! B [A]1 A ! B [A]1 A ! B B B (A ! B) ! A A ! B A ! B A B It contains a cut: a !-i directly followed by an !-e. H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 14 / 65 Example proof with term information [x : A]1 p : A ! A ! B [y : A]1 p : A ! A ! B [x : A]1 p x : A ! B [y : A]1 p y : A ! B p x x : B p y y : B q :(A ! B) ! A λx:A:p x x : A ! B λy:A:p y y : A ! B q(λx:A:p x x): A (λy:A:p y y)(q(λx:A:p x x)): B Term contains a β-redex: (λx:A:p x x)(q(λx:A:p x x)) H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 15 / 65 Extension with other connectives Adding product types × to λ!. (Proposition logic with conjunction ^.) Γ ` M : A × B Γ ` M : A × B Γ ` P : A Γ ` Q : B Γ ` π1M : A Γ ` π2M : B Γ ` hP; Qi : A × B With reduction rules π1hP; Qi ! P π2hP; Qi ! Q Similar rules can be given for sum-types A + B, corresponding to disjunction A _ B. H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 16 / 65 Extension to predicate logic • First order language: domain D, with variables x; y; z : D and possibly functions over D, e.g. f : D ! D, g : D ! D ! D. • Rules for 8x:D.φ and 9x:D.φ. • NB There are two \kinds" of variables: the first order variables (ranging over the domain D) and the \proof variables" (used as [local] assumptions of formulas). • Formulas and domain are both types. What is the type of a predicate or relation? • A predicate P is a map from D to the collection of types, ∗ • P : D ! ∗ for P a predicate and R : D ! D ! ∗ for R a binary relation on D. • We will have to make this more precise . H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 17 / 65 Idea of extending to 8 Term rules for the 8-quantifier in predicate logic. Γ ` M : 8x:D:A Γ ` M : A if t : D x not free in Γ Γ ` M t : A[x := t] Γ ` λx:D:M : 8x:D:A With the usual β-reduction rule (λx:D:M)t ! M[x := t] . This conforms with cut-elimination (or \detour elimination") on logical derivations. H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 18 / 65 Example Deriving irreflexivity from anti-symmetry AntiSym R := 8x; y:D:(Rxy) ! (Ryx) !? Irrefl R := 8x:D:(Rxx) !? Derivation in predicate logic: 8x; y:D:R x y ! R y x !? 8y:D:R x y ! R y x !? R x x ! R x x !? [R x x]1 R x x !? [R x x]1 ? 1 R x x !? 8x:D:R x x !? H. Geuvers - Radboud Univ. EWSCS 2016 Typed λ-calculus 19 / 65 Example derivation in type theory, with terms H : 8x; y:D:R x y ! R y x !? H x : 8y:D:R x y ! R y x !? H x x : R x x ! R x x !? [H0 : R x x]1 H x x H0 : R x x !? [H0 : R x x]1 H x x H0 H0 : ? 1 λH0:(R x x):H x x H0 H0 : R x x !? λx:A.λH0:(R x x):H x x H0 H0 : 8x:D:R x x !? H.
Load more

Recommended publications
  • Lecture Notes on the Lambda Calculus 2.4 Introduction to Β-Reduction
    2.2 Free and bound variables, α-equivalence. 8 2.3 Substitution ............................. 10 Lecture Notes on the Lambda Calculus 2.4 Introduction to β-reduction..................... 12 2.5 Formal definitions of β-reduction and β-equivalence . 13 Peter Selinger 3 Programming in the untyped lambda calculus 14 3.1 Booleans .............................. 14 Department of Mathematics and Statistics 3.2 Naturalnumbers........................... 15 Dalhousie University, Halifax, Canada 3.3 Fixedpointsandrecursivefunctions . 17 3.4 Other data types: pairs, tuples, lists, trees, etc. ....... 20 Abstract This is a set of lecture notes that developed out of courses on the lambda 4 The Church-Rosser Theorem 22 calculus that I taught at the University of Ottawa in 2001 and at Dalhousie 4.1 Extensionality, η-equivalence, and η-reduction. 22 University in 2007 and 2013. Topics covered in these notes include the un- typed lambda calculus, the Church-Rosser theorem, combinatory algebras, 4.2 Statement of the Church-Rosser Theorem, and some consequences 23 the simply-typed lambda calculus, the Curry-Howard isomorphism, weak 4.3 Preliminary remarks on the proof of the Church-Rosser Theorem . 25 and strong normalization, polymorphism, type inference, denotational se- mantics, complete partial orders, and the language PCF. 4.4 ProofoftheChurch-RosserTheorem. 27 4.5 Exercises .............................. 32 Contents 5 Combinatory algebras 34 5.1 Applicativestructures. 34 1 Introduction 1 5.2 Combinatorycompleteness . 35 1.1 Extensionalvs. intensionalviewoffunctions . ... 1 5.3 Combinatoryalgebras. 37 1.2 Thelambdacalculus ........................ 2 5.4 The failure of soundnessforcombinatoryalgebras . .... 38 1.3 Untypedvs.typedlambda-calculi . 3 5.5 Lambdaalgebras .......................... 40 1.4 Lambdacalculusandcomputability . 4 5.6 Extensionalcombinatoryalgebras . 44 1.5 Connectionstocomputerscience .
    [Show full text]
  • Lecture Notes on Types for Part II of the Computer Science Tripos
    Q Lecture Notes on Types for Part II of the Computer Science Tripos Prof. Andrew M. Pitts University of Cambridge Computer Laboratory c 2016 A. M. Pitts Contents Learning Guide i 1 Introduction 1 2 ML Polymorphism 6 2.1 Mini-ML type system . 6 2.2 Examples of type inference, by hand . 14 2.3 Principal type schemes . 16 2.4 A type inference algorithm . 18 3 Polymorphic Reference Types 25 3.1 The problem . 25 3.2 Restoring type soundness . 30 4 Polymorphic Lambda Calculus 33 4.1 From type schemes to polymorphic types . 33 4.2 The Polymorphic Lambda Calculus (PLC) type system . 37 4.3 PLC type inference . 42 4.4 Datatypes in PLC . 43 4.5 Existential types . 50 5 Dependent Types 53 5.1 Dependent functions . 53 5.2 Pure Type Systems . 57 5.3 System Fw .............................................. 63 6 Propositions as Types 67 6.1 Intuitionistic logics . 67 6.2 Curry-Howard correspondence . 69 6.3 Calculus of Constructions, lC ................................... 73 6.4 Inductive types . 76 7 Further Topics 81 References 84 Learning Guide These notes and slides are designed to accompany 12 lectures on type systems for Part II of the Cambridge University Computer Science Tripos. The course builds on the techniques intro- duced in the Part IB course on Semantics of Programming Languages for specifying type systems for programming languages and reasoning about their properties. The emphasis here is on type systems for functional languages and their connection to constructive logic. We pay par- ticular attention to the notion of parametric polymorphism (also known as generics), both because it has proven useful in practice and because its theory is quite subtle.
    [Show full text]
  • Category Theory and Lambda Calculus
    Category Theory and Lambda Calculus Mario Román García Trabajo Fin de Grado Doble Grado en Ingeniería Informática y Matemáticas Tutores Pedro A. García-Sánchez Manuel Bullejos Lorenzo Facultad de Ciencias E.T.S. Ingenierías Informática y de Telecomunicación Granada, a 18 de junio de 2018 Contents 1 Lambda calculus 13 1.1 Untyped λ-calculus . 13 1.1.1 Untyped λ-calculus . 14 1.1.2 Free and bound variables, substitution . 14 1.1.3 Alpha equivalence . 16 1.1.4 Beta reduction . 16 1.1.5 Eta reduction . 17 1.1.6 Confluence . 17 1.1.7 The Church-Rosser theorem . 18 1.1.8 Normalization . 20 1.1.9 Standardization and evaluation strategies . 21 1.1.10 SKI combinators . 22 1.1.11 Turing completeness . 24 1.2 Simply typed λ-calculus . 24 1.2.1 Simple types . 25 1.2.2 Typing rules for simply typed λ-calculus . 25 1.2.3 Curry-style types . 26 1.2.4 Unification and type inference . 27 1.2.5 Subject reduction and normalization . 29 1.3 The Curry-Howard correspondence . 31 1.3.1 Extending the simply typed λ-calculus . 31 1.3.2 Natural deduction . 32 1.3.3 Propositions as types . 34 1.4 Other type systems . 35 1.4.1 λ-cube..................................... 35 2 Mikrokosmos 38 2.1 Implementation of λ-expressions . 38 2.1.1 The Haskell programming language . 38 2.1.2 De Bruijn indexes . 40 2.1.3 Substitution . 41 2.1.4 De Bruijn-terms and λ-terms . 42 2.1.5 Evaluation .
    [Show full text]
  • Plurals and Mereology
    Journal of Philosophical Logic (2021) 50:415–445 https://doi.org/10.1007/s10992-020-09570-9 Plurals and Mereology Salvatore Florio1 · David Nicolas2 Received: 2 August 2019 / Accepted: 5 August 2020 / Published online: 26 October 2020 © The Author(s) 2020 Abstract In linguistics, the dominant approach to the semantics of plurals appeals to mere- ology. However, this approach has received strong criticisms from philosophical logicians who subscribe to an alternative framework based on plural logic. In the first part of the article, we offer a precise characterization of the mereological approach and the semantic background in which the debate can be meaningfully reconstructed. In the second part, we deal with the criticisms and assess their logical, linguistic, and philosophical significance. We identify four main objections and show how each can be addressed. Finally, we compare the strengths and shortcomings of the mereologi- cal approach and plural logic. Our conclusion is that the former remains a viable and well-motivated framework for the analysis of plurals. Keywords Mass nouns · Mereology · Model theory · Natural language semantics · Ontological commitment · Plural logic · Plurals · Russell’s paradox · Truth theory 1 Introduction A prominent tradition in linguistic semantics analyzes plurals by appealing to mere- ology (e.g. Link [40, 41], Landman [32, 34], Gillon [20], Moltmann [50], Krifka [30], Bale and Barner [2], Chierchia [12], Sutton and Filip [76], and Champollion [9]).1 1The historical roots of this tradition include Leonard and Goodman [38], Goodman and Quine [22], Massey [46], and Sharvy [74]. Salvatore Florio [email protected] David Nicolas [email protected] 1 Department of Philosophy, University of Birmingham, Birmingham, United Kingdom 2 Institut Jean Nicod, Departement´ d’etudes´ cognitives, ENS, EHESS, CNRS, PSL University, Paris, France 416 S.
    [Show full text]
  • Computational Lambda-Calculus and Monads
    Computational lambda-calculus and monads Eugenio Moggi∗ LFCS Dept. of Comp. Sci. University of Edinburgh EH9 3JZ Edinburgh, UK [email protected] October 1988 Abstract The λ-calculus is considered an useful mathematical tool in the study of programming languages, since programs can be identified with λ-terms. However, if one goes further and uses βη-conversion to prove equivalence of programs, then a gross simplification1 is introduced, that may jeopardise the applicability of theoretical results to real situations. In this paper we introduce a new calculus based on a categorical semantics for computations. This calculus provides a correct basis for proving equivalence of programs, independent from any specific computational model. 1 Introduction This paper is about logics for reasoning about programs, in particular for proving equivalence of programs. Following a consolidated tradition in theoretical computer science we identify programs with the closed λ-terms, possibly containing extra constants, corresponding to some features of the programming language under con- sideration. There are three approaches to proving equivalence of programs: • The operational approach starts from an operational semantics, e.g. a par- tial function mapping every program (i.e. closed term) to its resulting value (if any), which induces a congruence relation on open terms called operational equivalence (see e.g. [Plo75]). Then the problem is to prove that two terms are operationally equivalent. ∗On leave from Universit`a di Pisa. Research partially supported by the Joint Collaboration Contract # ST2J-0374-C(EDB) of the EEC 1programs are identified with total functions from values to values 1 • The denotational approach gives an interpretation of the (programming) lan- guage in a mathematical structure, the intended model.
    [Show full text]
  • Continuation Calculus
    Eindhoven University of Technology MASTER Continuation calculus Geron, B. Award date: 2013 Link to publication Disclaimer This document contains a student thesis (bachelor's or master's), as authored by a student at Eindhoven University of Technology. Student theses are made available in the TU/e repository upon obtaining the required degree. The grade received is not published on the document as presented in the repository. The required complexity or quality of research of student theses may vary by program, and the required minimum study period may vary in duration. General rights Copyright and moral rights for the publications made accessible in the public portal are retained by the authors and/or other copyright owners and it is a condition of accessing publications that users recognise and abide by the legal requirements associated with these rights. • Users may download and print one copy of any publication from the public portal for the purpose of private study or research. • You may not further distribute the material or use it for any profit-making activity or commercial gain Continuation calculus Master’s thesis Bram Geron Supervised by Herman Geuvers Assessment committee: Herman Geuvers, Hans Zantema, Alexander Serebrenik Final version Contents 1 Introduction 3 1.1 Foreword . 3 1.2 The virtues of continuation calculus . 4 1.2.1 Modeling programs . 4 1.2.2 Ease of implementation . 5 1.2.3 Simplicity . 5 1.3 Acknowledgements . 6 2 The calculus 7 2.1 Introduction . 7 2.2 Definition of continuation calculus . 9 2.3 Categorization of terms . 10 2.4 Reasoning with CC terms .
    [Show full text]
  • 1 Simply-Typed Lambda Calculus
    CS 4110 – Programming Languages and Logics Lecture #18: Simply Typed λ-calculus A type is a collection of computational entities that share some common property. For example, the type int represents all expressions that evaluate to an integer, and the type int ! int represents all functions from integers to integers. The Pascal subrange type [1..100] represents all integers between 1 and 100. You can see types as a static approximation of the dynamic behaviors of terms and programs. Type systems are a lightweight formal method for reasoning about behavior of a program. Uses of type systems include: naming and organizing useful concepts; providing information (to the compiler or programmer) about data manipulated by a program; and ensuring that the run-time behavior of programs meet certain criteria. In this lecture, we’ll consider a type system for the lambda calculus that ensures that values are used correctly; for example, that a program never tries to add an integer to a function. The resulting language (lambda calculus plus the type system) is called the simply-typed lambda calculus (STLC). 1 Simply-typed lambda calculus The syntax of the simply-typed lambda calculus is similar to that of untyped lambda calculus, with the exception of abstractions. Since abstractions define functions tht take an argument, in the simply-typed lambda calculus, we explicitly state what the type of the argument is. That is, in an abstraction λx : τ: e, the τ is the expected type of the argument. The syntax of the simply-typed lambda calculus is as follows. It includes integer literals n, addition e1 + e2, and the unit value ¹º.
    [Show full text]
  • Lambda-Calculus Types and Models
    Jean-Louis Krivine LAMBDA-CALCULUS TYPES AND MODELS Translated from french by René Cori To my daughter Contents Introduction5 1 Substitution and beta-conversion7 Simple substitution ..............................8 Alpha-equivalence and substitution ..................... 12 Beta-conversion ................................ 18 Eta-conversion ................................. 24 2 Representation of recursive functions 29 Head normal forms .............................. 29 Representable functions ............................ 31 Fixed point combinators ........................... 34 The second fixed point theorem ....................... 37 3 Intersection type systems 41 System D­ ................................... 41 System D .................................... 50 Typings for normal terms ........................... 54 4 Normalization and standardization 61 Typings for normalizable terms ........................ 61 Strong normalization ............................. 68 ¯I-reduction ................................. 70 The ¸I-calculus ................................ 72 ¯´-reduction ................................. 74 The finite developments theorem ....................... 77 The standardization theorem ......................... 81 5 The Böhm theorem 87 3 4 CONTENTS 6 Combinatory logic 95 Combinatory algebras ............................. 95 Extensionality axioms ............................. 98 Curry’s equations ............................... 101 Translation of ¸-calculus ........................... 105 7 Models of lambda-calculus 111 Functional
    [Show full text]
  • The Lambda Calculus Bharat Jayaraman Department of Computer Science and Engineering University at Buffalo (SUNY) January 2010
    The Lambda Calculus Bharat Jayaraman Department of Computer Science and Engineering University at Buffalo (SUNY) January 2010 The lambda-calculus is of fundamental importance in the study of programming languages. It was founded by Alonzo Church in the 1930s well before programming languages or even electronic computers were invented. Church's thesis is that the computable functions are precisely those that are definable in the lambda-calculus. This is quite amazing, since the entire syntax of the lambda-calculus can be defined in just one line: T ::= V j λV:T j (TT ) The syntactic category T defines the set of well-formed expressions of the lambda-calculus, also referred to as lambda-terms. The syntactic category V stands for a variable; λV:T is called an abstraction, and (TT ) is called an application. We will examine these terms in more detail a little later, but, at the outset, it is remarkable that the lambda-calculus is capable of defining recursive functions even though there is no provision for writing recursive definitions. Indeed, there is no provision for writing named procedures or functions as we know them in conventional languages. Also absent are other familiar programming constructs such as control and data structures. We will therefore examine how the lambda-calculus can encode such constructs, and thereby gain some insight into the power of this little language. In the field of programming languages, John McCarthy was probably the first to rec- ognize the importance of the lambda-calculus, which inspired him in the 1950s to develop the Lisp programming language.
    [Show full text]
  • Semantic Theory Week 4 – Lambda Calculus
    Semantic Theory Week 4 – Lambda Calculus Noortje Venhuizen University of Groningen/Universität des Saarlandes Summer 2015 1 Compositionality The principle of compositionality: “The meaning of a complex expression is a function of the meanings of its parts and of the syntactic rules by which they are combined” (Partee et al.,1993) Compositional semantics construction: • compute meaning representations for sub-expressions • combine them to obtain a meaning representation for a complex expression. Problematic case: “Not smoking⟨e,t⟩ is healthy⟨⟨e,t⟩,t⟩” ! 2 Lambda abstraction λ-abstraction is an operation that takes an expression and “opens” specific argument positions. Syntactic definition: If α is in WEτ, and x is in VARσ then λx(α) is in WE⟨σ, τ⟩ • The scope of the λ-operator is the smallest WE to its right. Wider scope must be indicated by brackets. • We often use the “dot notation” λx.φ indicating that the λ-operator takes widest possible scope (over φ). 3 Interpretation of Lambda-expressions M,g If α ∈ WEτ and v ∈ VARσ, then ⟦λvα⟧ is that function f : Dσ → Dτ M,g[v/a] such that for all a ∈ Dσ, f(a) = ⟦α⟧ If the λ-expression is applied to some argument, we can simplify the interpretation: • ⟦λvα⟧M,g(A) = ⟦α⟧M,g[v/A] Example: “Bill is a non-smoker” ⟦λx(¬S(x))(b’)⟧M,g = 1 iff ⟦λx(¬S(x))⟧M,g(⟦b’⟧M,g) = 1 iff ⟦¬S(x)⟧M,g[x/⟦b’⟧M,g] = 1 iff ⟦S(x)⟧M,g[x/⟦b’⟧M,g] = 0 iff ⟦S⟧M,g[x/⟦b’⟧M,g](⟦x⟧M,g[x/⟦b’⟧M,g]) = 0 iff VM(S)(VM(b’)) = 0 4 β-Reduction ⟦λv(α)(β)⟧M,g = ⟦α⟧M,g[v/⟦β⟧M,g] ⇒ all (free) occurrences of the λ-variable in α get the interpretation of β as value.
    [Show full text]
  • Brief Notes on the Category Theoretic Semantics of Simply Typed Lambda Calculus
    University of Cambridge 2017 MPhil ACS / CST Part III Category Theory and Logic (L108) Brief Notes on the Category Theoretic Semantics of Simply Typed Lambda Calculus Andrew Pitts Notation: comma-separated snoc lists When presenting logical systems and type theories, it is common to write finite lists of things using a comma to indicate the cons-operation and with the head of the list at the right. With this convention there is no common notation for the empty list; we will use the symbol “”. Thus ML-style list notation nil a :: nil b :: a :: nil etc becomes , a , a, b etc For non-empty lists, it is very common to leave the initial part “,” of the above notation implicit, for example just writing a, b instead of , a, b. Write X∗ for the set of such finite lists with elements from the set X. 1 Syntax of the simply typed l-calculus Fix a countably infinite set V whose elements are called variables and are typically written x, y, z,... The simple types (with product types) A over a set Gnd of ground types are given by the following grammar, where G ranges over Gnd: A ::= G j unit j A x A j A -> A Write ST(Gnd) for the set of simple types over Gnd. The syntax trees t of the simply typed l-calculus (STLC) over Gnd with constants drawn from a set Con are given by the following grammar, where c ranges over Con, x over V and A over ST(Gnd): t ::= c j x j () j (t , t) j fst t j snd t j lx : A.
    [Show full text]
  • Labelled Λ-Calculi with Explicit Copy and Erase
    Labelled λ-calculi with Explicit Copy and Erase Maribel Fern´andez, Nikolaos Siafakas King’s College London, Dept. Computer Science, Strand, London WC2R 2LS, UK [maribel.fernandez, nikolaos.siafakas]@kcl.ac.uk We present two rewriting systems that define labelled explicit substitution λ-calculi. Our work is motivated by the close correspondence between L´evy’s labelled λ-calculus and paths in proof-nets, which played an important role in the understanding of the Geometry of Interaction. The structure of the labels in L´evy’s labelled λ-calculus relates to the multiplicative information of paths; the novelty of our work is that we design labelled explicit substitution calculi that also keep track of exponential information present in call-by-value and call-by-name translations of the λ-calculus into linear logic proof-nets. 1 Introduction Labelled λ-calculi have been used for a variety of applications, for instance, as a technology to keep track of residuals of redexes [6], and in the context of optimal reduction, using L´evy’s labels [14]. In L´evy’s work, labels give information about the history of redex creation, which allows the identification and classification of copied β-redexes. A different point of view is proposed in [4], where it is shown that a label is actually encoding a path in the syntax tree of a λ-term. This established a tight correspondence between the labelled λ-calculus and the Geometry of Interaction interpretation of cut elimination in linear logic proof-nets [13]. Inspired by L´evy’s labelled λ-calculus, we define labelled λ-calculi where the labels attached to terms capture reduction traces.
    [Show full text]