Lambda Calculus: Implementation Techniques and a Proof. COS 441 Slides 15
|
|
|
- Jasmin Francis
- 5 years ago
- Views:
Transcription
1 Lambda Calculus: Implementation Techniques and a Proof COS 441 Slides 15
2 Last Time: The Lambda Calculus A language of pure functions: values e ::= x \x.e e e v ::= \x.e With a call-by-value operational semantics: single step: (\x.e) v --> e [v/x] e1 --> e1 e1 e2 --> e1 e2 e2 --> e2 v e2 --> v e2 (beta) (app2) (app1) multi-step: e -->* e e1 --> e2 e2 -->* e3 e1 -->* e3 (reflexivity) (transitivity)
3 Examples We used the formal rules to build proofs that lambda terms could take steps: (beta) (\x.\y. x y) (\w.w) --> \y.(\w.w) y (app1) ((\x.\y. x y) (\w.w)) (\z.z) --> (\y.(\w.w) y) (\z.z) We showed it was possible to encode several simple kinds of data structures or computations booleans pairs numbers looping and I claimed you could code up anything else since the untyped lambda calculus is Turing-complete
4 IMPLEMENTING THE LAMBDA CALCULUS
5 Two Options First-order Abstract Syntax: build a data structure to represent a program data Lam = Var String Abs String Lam App Lam Lam Higher-order Abstract Syntax: use functions in Haskell to represent lambda calculus functions directly data Lam = Abs (Lam -> Lam) App Lam Lam FreeVar String
6 FIRST-ORDER SYNTAX
7 Data structure: Examples data Lam = Var String Abs String Lam App Lam Lam Examples: i = Abs "x" (Var "x") -- \x.x tru = Abs "t" (Abs "f" (Var "t")) fls = Abs "t" (Abs "f" (Var "f")) -- \t.\f.t -- \t.\f.f i, tru, fls all have type Lam
8 Substitution: Substitution -- subst e x v == e[v/x] -- v must be closed (no free variables)
9 Substitution: Substitution -- subst e x v == e[v/x] -- v must be closed (no free variables) subst (Var y) x v = if x == y then v else Var y
10 Substitution: Substitution -- subst e x v == e[v/x] -- v must be closed (no free variables) subst (Var y) x v subst (Abs y e) x v = if x == y then v else Var y = if x == y then (Abs y e) else (Abs y (subst e x v))
11 Substitution: Substitution -- subst e x v == e[v/x] -- v must be closed (no free variables) subst (Var y) x v = if x == y then v else Var y subst (Abs y e) x v = if x == y then (Abs y e) else (Abs y (subst e x v)) subst (App e1 e2) x v = App (subst e1 x v) (subst e2 x v)
12 Substitution: Substitution -- subst e x v == e[v/x] -- v must be closed (no free variables) subst (Var y) x v = if x == y then v else Var y subst (Abs y e) x v = if x == y then (Abs y e) else (Abs y (subst e x v)) subst (App e1 e2) x v = App (subst e1 x v) (subst e2 x v) Example: y = Var "y" x = Var "x" id = Abs "x" x foo = App (Abs "y" y) y subst foo "y" id == App (Abs "y" y) id
13 Values Code to determine if an expression is a value: -- is a value? -- value (Var s) = False value (Abs x e) = True value (App e1 e2) = False
14 Evaluation (\x.e) v --> e [v/x] (beta) eval :: Lam -> Lam e1 --> e1 e1 e2 --> e1 e2 (app1) -- beta rule eval (App (Abs x e) v) value v = subst e x v e2 --> e2 v e2 --> v e2 (app2)
15 Evaluation (\x.e) v --> e [v/x] (beta) eval :: Lam -> Lam e1 --> e1 e1 e2 --> e1 e2 (app1) -- beta rule eval (App (Abs x e) v) value v = subst e x v e2 --> e2 v e2 --> v e2 (app2) -- app2 rule eval (App v e2) value v = let e2' = eval e2 in App v e2'
16 Evaluation (\x.e) v --> e [v/x] (beta) eval :: Lam -> Lam e1 --> e1 e1 e2 --> e1 e2 (app1) -- beta rule eval (App (Abs x e) v) value v = subst e x v e2 --> e2 v e2 --> v e2 (app2) -- app2 rule eval (App v e2) -- app1 rule eval (App e1 e2) value v = let e2' = eval e2 in App v e2' = let e1' = eval e1 in App e1' e2
17 Evaluation (\x.e) v --> e [v/x] (beta) eval :: Lam -> Lam e1 --> e1 e1 e2 --> e1 e2 (app1) -- beta rule eval (App (Abs x e) v) value v = subst e x v e2 --> e2 v e2 --> v e2 (app2) -- app2 rule eval (App v e2) -- app1 rule eval (App e1 e2) value v = let e2' = eval e2 in App v e2' = let e1' = eval e1 in App e1' e2 -- forms that don't match LHS; no rule exists eval (Abs x e) = error "Value!" eval (Var x) = error "Stuck!"
18 HIGHER-ORDER SYNTAX
19 Higher-Order Abstract Syntax Key idea: use functions in Haskell to represent lambda calculus functions directly data Lam = Abs (Lam -> Lam) App Lam Lam FreeVar String needed for printing, and analysis of expressions not needed for evaluation expressions should not have free variables if you want to execute them
20 Higher-Order Abstract Syntax Key idea: use functions in Haskell to represent lambda calculus functions directly data Lam = Abs (Lam -> Lam) App Lam Lam remember, Abs is a converter: it takes a Lam -> Lam function and puts it in an "object" with 1 field that has type Lam Abs :: (Lam -> Lam) -> Lam App :: Lam -> Lam -> Lam
21 Higher-Order Abstract Syntax Key idea: use functions in Haskell to represent lambda calculus functions directly data Lam = Abs (Lam -> Lam) App Lam Lam f :: Lam -> Lam f = \x -> App x x e :: Lam e = Abs f Abs makes a Haskell function f into a Lam a Haskell variable with type Lam appears in the places a lambda calculus variable would think of the body of f like an expression with holes it: App [ ] [ ] during evaluation, we'll plug the holes with the argument to the function
22 Higher-Order Abstract Syntax Key idea: use functions in Haskell to represent lambda calculus functions directly f :: Lam -> Lam f = \x -> App x x e :: Lam e = Abs f data Lam = Abs (Lam -> Lam) App Lam Lam
23 Higher-Order Abstract Syntax Key idea: use functions in Haskell to represent lambda calculus functions directly f :: Lam -> Lam f = \x -> App x x e :: Lam e = Abs f data Lam = Abs (Lam -> Lam) App Lam Lam id :: Lam -> Lam id = \x -> x ide :: Lam ide = Abs id
24 Higher-Order Abstract Syntax Key idea: use functions in Haskell to represent lambda calculus functions directly f :: Lam -> Lam f = \x -> App x x e :: Lam e = Abs f id :: Lam -> Lam id = \x -> x ide :: Lam ide = Abs id e' :: Lam e' = App e ide data Lam = Abs (Lam -> Lam) App Lam Lam evaluating (App e ide): inside e, we have f = \x -> App x x applying f to ide, we get: App ide ide
25 Higher-Order Abstract Syntax Key idea: use functions in Haskell to represent lambda calculus functions directly id :: Lam -> Lam id = \x -> x ide :: Lam ide = Abs ide fls = = Abs (\t -> Abs (\f -> f)) tru = Abs (\t -> Abs (\f -> t)) An Alternative: id = \f -> f ide = Abs id flsf = \t -> Abs id fls = Abs flsf An Alternative: truf = \t -> Abs (\f -> t) tru = Abs truf
26 Evaluation eval :: Lam -> Lam eval (App (Abs f) v) value v = f v -- beta rule (\x.e) v --> e [v/x] (beta) eval (App v e2) value v = -- app2 rule let e2' = eval e2 in App v e2' eval (App e1 e2) = let e1' = eval e1 in App e1' e2 -- app1 rule e1 --> e1 e1 e2 --> e1 e2 e2 --> e2 v e2 --> v e2 (app2) (app1) eval (Abs f) = error "Value!" -- note: we never had to implement -- substitution ourselves; Haskell did it for us data Lam = Abs (Lam -> Lam) App Lam Lam
27 GETTING STUCK
28 Can Evaluation Ever Get Stuck? Values are lambda expressions that have properly finished being evaluated there is nothing more to do. In the pure lambda calculus, the only values are functions \x.x is a value. It can t be evaluated any further. \x.\y.x y is also a value Are there lambda terms that aren t values but can t be evaluated any further using the rules? If there were, we d call those things stuck expressions
29 Can Evaluation Ever Get Stuck? Values are lambda expressions that have properly finished being evaluated there is nothing more to do. In the pure lambda calculus, the only values are functions \x.x is a value. It can t be evaluated any further. \x.\y.x y is also a value Are there lambda terms that aren t values but can t be evaluated any further using the rules? If there were, we d call those things stuck expressions Expressions with free variables can be stuck! Eg: x x (\y.y) (\y. x y) (\w.w) isn t stuck right away, but will be after an evaluation step
30 Stuckness testing Given a lambda term, is it possible to create an automatic analyzer that decides, yes or no, whether or not a lambda term will ever get stuck?
31 Stuckness testing Given a lambda term, is it possible to create an automatic analyzer that decides, yes or no, whether or not a lambda term will ever get stuck? No! The lambda calculus is Turing-Complete. It can encode any Turing Machine. Suppose TM is a lambda term that simulates a Turing Machine Consider: (\x.y x) TM The above expression gets stuck by running in to free variable y if the TM halts; does not get stuck if the TM does not halt. We can t decide if TMs halt, so we can t decide if the lambda term ever gets stuck.
32 Stuckness testing Given a lambda term, is it possible to create an automatic analyzer that soundly but conservatively decides whether or not a lambda term will ever get stuck? ie: can we design an algorithm that given a lambda term, says no the lambda term is not stuck if it can guarantee the lambda term is not stuck? guarantee == sound says yes, maybe if it isn t sure? of course! the algorithm could always cop out and say yes, maybe But it turns out we can also define a principled, non-trivial analyzer that is sound and conservative, but for all practical purposes does a good enough job such an analyzer is called a scope checker and it is the simplest kind of type system
33 A SIMPLE SCOPE CHECKER
34 A Scope Checker for FOAS Expressions data Lam = Var String -- variables Abs String Lam -- \"x". e App Lam Lam -- e1 e2 closed :: Lam -> Bool closed e = clos [] e where clos env (Abs x e) = clos (x:env) e clos env (App e1 e2) = clos env e1 && clos env e2 clos env (Var x) = lookup env x lookup [] x = False lookup (y:env) x = x == y lookup env x
35 Scope Checking Examples A closed lambda expression: \y.\x.y is closed: closed (Abs "y" (Abs "x" (Var "y"))) == True y (\y.y) is not closed: closed (App (Var "y") (Abs "y" (Var y)) == False Can you come up with a lambda term that is not closed according to our Haskell definition but that evaluates safely without encountering a free variable? there must be one because I told you that it is undecidable whether execution encounters a free variable
36 Scope Checking Examples A closed lambda expression: \y.\x.y is closed: closed (Abs "y" (Abs "x" (Var "y"))) == True y (\y.y) is not closed: closed (App (Var "y") (Abs "y" (Var y)) == False Can you come up with a lambda term that is not closed according to our Haskell definition but that evaluates safely without encountering a free variable? there must be one because I told you that it is undecidable whether execution encounters a free variable (\x.\y.y) (\y.z) (\w.w) --> (\y.y) (\w.w) --> \w.w
37 A Scope Checker for HOAS Expressions module Lambda (Lam (Abs,App), -- only Abs App constructors useable by clients freevar, -- freevar function useable ) where data Lam = Abs (Lam -> Lam) App Lam Lam FreeVar String freevar :: String -> Lam freevar s = FreeVar ("!" ++ s)
38 A Scope Checker for HOAS Expressions module Lambda (Lam (Abs,App), -- only Abs App constructors useable by clients freevar, -- freevar function useable ) where data Lam = Abs (Lam -> Lam) App Lam Lam FreeVar String freevar :: String -> Lam freevar s = FreeVar ("!" ++ s) boundname = "bound" closed :: Lam -> Bool closed (Abs f) =
39 A Scope Checker for HOAS Expressions module Lambda (Lam (Abs,App), -- only Abs App constructors useable by clients freevar, -- freevar function useable ) where data Lam = Abs (Lam -> Lam) App Lam Lam FreeVar String freevar :: String -> Lam freevar s = FreeVar ("!" ++ s) boundname = "bound" closed :: Lam -> Bool closed (Abs f) = let body = f (FreeVar boundname) in closed body
40 A Scope Checker for HOAS Expressions module Lambda (Lam (Abs,App), -- only Abs App constructors useable by clients freevar, -- freevar function useable ) where data Lam = Abs (Lam -> Lam) App Lam Lam FreeVar String freevar :: String -> Lam freevar s = FreeVar ("!" ++ s) boundname = "bound" closed :: Lam -> Bool closed (Abs f) = let body = f (FreeVar boundname) in closed body closed (App e1 e2) = closed e1 && closed e2 closed (FreeVar s) = s == boundname
41 ONE MORE WAY TO DESCRIBE CLOSED EXPRESSIONS
42 Closed Expressions env ::= x1 : x2 :. : [] judgement form: clos env e -- "e has no free variables except those in env"
43 Closed Expressions env ::= x1 : x2 :. : [] judgement form: clos env e -- "e has no free variables except those in env" clos (x:env) e clos env \x.e -- if e is closed in (x:env) then \x.e is closed in env
44 Closed Expressions env ::= x1 : x2 :. : [] judgement form: clos env e -- "e has no free variables except those in env" clos (x:env) e clos env \x.e clos env e1 clos env e2 clos env (e1 e2) -- if e is closed in (x:env) then \x.e is closed in env -- if e1 and e2 are closed in env then e1 e2 is closed in env
45 Closed Expressions env ::= x1 : x2 :. : [] judgement form: clos env e -- "e has no free variables except those in env" clos (x:env) e clos env \x.e clos env e1 clos env e2 clos env (e1 e2) lookup env x == true clos env x -- if e is closed in (x:env) then \x.e is closed in env -- if e1 and e2 are closed in env then e1 e2 is closed in env -- if x is in env then x is closed in env
46 A PROOF
47 Evaluation Preserves Closedness Theorem: If clos [] e and e --> e' then clos [] e'.
48 Evaluation Preserves Closedness Theorem: If clos [] e and e --> e' then clos [] e'. Requires a lemma that substitution preserved Closedness Lemma: If clos [] (\x.e) and clos [] v then clos [] (e[v/x])
49 Evaluation Preserves Closedness Theorem: If clos [] e and e --> e' then clos [] e'. Proof: By induction on the derivation that e --> e' proofs by induction on the derivation of e --> e' have 1 case for each rule use the induction hypothesis on when subprog --> subprog in the premise of the rule. use lemma: If clos [] (\x.e) and clos [] v then clos [] (e[v/x])
50 Evaluation Preserves Closedness Theorem: If clos [] e and e --> e' then clos [] e'. Proof: By induction on the derivation that e --> e' Lemma: If clos [] (\x.e) and clos [] v then clos [] (e[v/x]) case: (\x.e) v --> e [v/x] (beta) (1) clos [] ((\x.e) v) (given) (2) clos [] (\x.e) (by 1, def of clos) (3) clos [] v (by 1, def of clos) (4) clos [] (e[v/x]) (by 2, 3) clos (x:env) e clos env \x.e clos env e1 clos env e2 clos env (e1 e2) lookup env x == true clos env x
51 Evaluation Preserves Closedness Theorem: If clos [] e and e --> e' then clos [] e'. Proof: By induction on the derivation that e --> e' Lemma: If clos [] (\x.e) and clos [] v then clos [] (e[v/x]) case: e1 --> e1 e1 e2 --> e1 e2 (app1) (1) clos [] (e1 e2) (given) (2) clos [] e1 (by 1, def of clos) (3) clos [] e2 (by 1, def of clos) (4) clos [] e1' (by IH, 2) (5) clos [] (e1' e2) (by 4, 3, def of clos) clos (x:env) e clos env \x.e clos env e1 clos env e2 clos env (e1 e2) lookup env x == true clos env x
52 Evaluation Preserves Closedness Theorem: If clos [] e and e --> e' then clos [] e'. Proof: By induction on the derivation that e --> e' Lemma: If clos [] (\x.e) and clos [] v then clos [] (e[v/x]) case: e2 --> e2 v e2 --> v e2 (app2) (1) clos [] (v e2) (given) (2) clos [] v (by 1, def of clos) (3) clos [] e2 (by 1, def of clos) (4) clos [] e2' (by IH, 3) (5) clos [] (v e2') (by 2, 4, def of clos) clos (x:env) e clos env \x.e clos env e1 clos env e2 clos env (e1 e2) lookup env x == true clos env x
53 Why do we care? Why do we care if closure is preserved by execution?
54 Why do we care? Why do we care if closure is preserved by execution? The initial motivation was that programs could get "stuck" when executing by running in to a free variable. We wanted to prevent that. In a real language implementations, getting "stuck" often means all hell breaks loose and random bad stuff ensues: derefencing a dangling pointer in C is another way to "get stuck" If we checked a program was closed, but then after 3 steps of evaluation a free variable appeared, then closure checking wouldn't be helpful -- it wouldn't prevent programs from getting stuck Moral: closure checking is a useful kind of static program analysis because if you check a program once before it executes, you never, ever have to worry about it getting stuck on a free variable, no matter how long it runs
55 SUMMARY
56 Summary There are at least two ways to implement the lambda calculus higher-order abstract syntax uses Haskell functions to implement lambdas and Haskell variables to implement lambda variables first-order abstract syntax uses strings to represent variables and does not use functions Unfortunate Fact: Almost every non-trivial property of how a lambda expression evaluates is undecidable Optimistic Perspective: We can approximate many properties Example: do we encounter a free var during execution: undecideable we can still design a useful scope checker the closure property is robust and highly useful because it is preserved by execution
M. Snyder, George Mason University LAMBDA CALCULUS. (untyped)
1 LAMBDA CALCULUS (untyped) 2 The Untyped Lambda Calculus (λ) Designed by Alonzo Church (1930s) Turing Complete (Turing was his doctoral student!) Models functions, always as 1-input Definition: terms,
Programming Languages Fall 2014
Programming Languages Fall 2014 Lecture 7: Simple Types and Simply-Typed Lambda Calculus Prof. Liang Huang huang@qc.cs.cuny.edu 1 Types stuck terms? how to fix it? 2 Plan First I For today, we ll go back
Fall 2013 Midterm Exam 10/22/13. This is a closed-book, closed-notes exam. Problem Points Score. Various definitions are provided in the exam.
Programming Languages Fall 2013 Midterm Exam 10/22/13 Time Limit: 100 Minutes Name (Print): Graduate Center I.D. This is a closed-book, closed-notes exam. Various definitions are provided in the exam.
CMSC 336: Type Systems for Programming Languages Lecture 5: Simply Typed Lambda Calculus Acar & Ahmed January 24, 2008
CMSC 336: Type Systems for Programming Languages Lecture 5: Simply Typed Lambda Calculus Acar & Ahmed January 24, 2008 Contents 1 Solution to the Exercise 1 1.1 Semantics for lambda calculus.......................
Lesson 4 Typed Arithmetic Typed Lambda Calculus
Lesson 4 Typed Arithmetic Typed Lambda 1/28/03 Chapters 8, 9, 10 Outline Types for Arithmetic types the typing relation safety = progress + preservation The simply typed lambda calculus Function types
Programming Languages
CSE 230: Winter 2008 Principles of Programming Languages Ocaml/HW #3 Q-A Session Push deadline = Mar 10 Session Mon 3pm? Lecture 15: Type Systems Ranjit Jhala UC San Diego Why Typed Languages? Development
More Untyped Lambda Calculus & Simply Typed Lambda Calculus
Concepts in Programming Languages Recitation 6: More Untyped Lambda Calculus & Simply Typed Lambda Calculus Oded Padon & Mooly Sagiv (original slides by Kathleen Fisher, John Mitchell, Shachar Itzhaky,
Lambda Calculus and Type Inference
Lambda Calculus and Type Inference Björn Lisper Dept. of Computer Science and Engineering Mälardalen University bjorn.lisper@mdh.se http://www.idt.mdh.se/ blr/ October 13, 2004 Lambda Calculus and Type
Formal Semantics. Prof. Clarkson Fall Today s music: Down to Earth by Peter Gabriel from the WALL-E soundtrack
Formal Semantics Prof. Clarkson Fall 2015 Today s music: Down to Earth by Peter Gabriel from the WALL-E soundtrack Review Previously in 3110: simple interpreter for expression language: abstract syntax
The Substitution Model
The Substitution Model Prof. Clarkson Fall 2017 Today s music: Substitute by The Who Review Previously in 3110: simple interpreter for expression language abstract syntax tree (AST) evaluation based on
Untyped Lambda Calculus
Concepts in Programming Languages Recitation 5: Untyped Lambda Calculus Oded Padon & Mooly Sagiv (original slides by Kathleen Fisher, John Mitchell, Shachar Itzhaky, S. Tanimoto ) Reference: Types and
Goal. CS152: Programming Languages. Lecture 15 Parametric Polymorphism. What the Library Likes. What The Client Likes. Start simpler.
Goal Understand what this interface means and why it matters: CS152: Programming Languages Lecture 15 Parametric Polymorphism Dan Grossman Spring 2011 type a mylist; val mt_list : a mylist val cons : a
Programming Language Features. CMSC 330: Organization of Programming Languages. Turing Completeness. Turing Machine.
CMSC 330: Organization of Programming Languages Lambda Calculus Programming Language Features Many features exist simply for convenience Multi-argument functions foo ( a, b, c ) Ø Use currying or tuples
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Lambda Calculus CMSC 330 1 Programming Language Features Many features exist simply for convenience Multi-argument functions foo ( a, b, c ) Ø Use currying
Chapter 5: The Untyped Lambda Calculus
Chapter 5: The Untyped Lambda Calculus What is lambda calculus for? Basics: syntax and operational semantics Programming in the Lambda Calculus Formalities (formal definitions) What is Lambda calculus
CSE 505: Concepts of Programming Languages
CSE 505: Concepts of Programming Languages Dan Grossman Fall 2003 Lecture 6 Lambda Calculus Dan Grossman CSE505 Fall 2003, Lecture 6 1 Where we are Done: Modeling mutation and local control-flow Proving
1 Introduction. 3 Syntax
CS 6110 S18 Lecture 19 Typed λ-calculus 1 Introduction Type checking is a lightweight technique for proving simple properties of programs. Unlike theorem-proving techniques based on axiomatic semantics,
Untyped Lambda Calculus
Advanced Topics in Programming Languages Untyped Lambda Calculus Oded Padon & Mooly Sagiv (original slides by Kathleen Fisher, John Mitchell, Shachar Itzhaky, S. Tanimoto ) Reference: Types and Programming
Lambda Calculus. Concepts in Programming Languages Recitation 6:
Concepts in Programming Languages Recitation 6: Lambda Calculus Oded Padon & Mooly Sagiv (original slides by Kathleen Fisher, John Mitchell, Shachar Itzhaky, S. Tanimoto ) Reference: Types and Programming
Lecture 9: Typed Lambda Calculus
Advanced Topics in Programming Languages Spring Semester, 2012 Lecture 9: Typed Lambda Calculus May 8, 2012 Lecturer: Mooly Sagiv Scribe: Guy Golan Gueta and Shachar Itzhaky 1 Defining a Type System for
COMP80 Lambda Calculus Programming Languages Slides Courtesy of Prof. Sam Guyer Tufts University Computer Science History Big ideas Examples:
COMP80 Programming Languages Slides Courtesy of Prof. Sam Guyer Lambda Calculus Formal system with three parts Notation for functions Proof system for equations Calculation rules called reduction Idea:
The Untyped Lambda Calculus
Resources: The slides of this lecture were derived from [Järvi], with permission of the original author, by copy & x = 1 let x = 1 in... paste or by selection, annotation, or rewording. [Järvi] is in turn
Subsumption. Principle of safe substitution
Recap on Subtyping Subsumption Some types are better than others, in the sense that a value of one can always safely be used where a value of the other is expected. Which can be formalized as by introducing:
Type Systems Winter Semester 2006
Type Systems Winter Semester 2006 Week 4 November 8 November 15, 2006 - version 1.1 The Lambda Calculus The lambda-calculus If our previous language of arithmetic expressions was the simplest nontrivial
Formal Systems and their Applications
Formal Systems and their Applications Dave Clarke (Dave.Clarke@cs.kuleuven.be) Acknowledgment: these slides are based in part on slides from Benjamin Pierce and Frank Piessens 1 Course Overview Introduction
More Lambda Calculus and Intro to Type Systems
More Lambda Calculus and Intro to Type Systems Plan Heavy Class Participation Thus, wake up! Lambda Calculus How is it related to real life? Encodings Fixed points Type Systems Overview Static, Dyamic
Costly software bugs that could have been averted with type checking
Type Checking Class Notes from Lectures 6 and 7 Lahav Yeffet and Ori Folger The material in these lectures is based on the textbook Types and Programming Languages by Benjamin Pierce. Here is a list of
Variables. Substitution
Variables Elements of Programming Languages Lecture 4: Variables, binding and substitution James Cheney University of Edinburgh October 6, 2015 A variable is a symbol that can stand for another expression.
Writing code that I'm not smart enough to write. A funny thing happened at Lambda Jam
Writing code that I'm not smart enough to write A funny thing happened at Lambda Jam Background "Let s make a lambda calculator" Rúnar Bjarnason Task: write an interpreter for the lambda calculus Lambda
Tradeoffs. CSE 505: Programming Languages. Lecture 15 Subtyping. Where shall we add useful completeness? Where shall we add completeness?
Tradeoffs CSE 505: Programming Languages Lecture 15 Subtyping Zach Tatlock Autumn 2017 Desirable type system properties (desiderata): soundness - exclude all programs that get stuck completeness - include
The Substitution Model. Nate Foster Spring 2018
The Substitution Model Nate Foster Spring 2018 Review Previously in 3110: simple interpreter for expression language abstract syntax tree (AST) evaluation based on single steps parser and lexer (in lab)
CMSC 330: Organization of Programming Languages. Lambda Calculus
CMSC 330: Organization of Programming Languages Lambda Calculus 1 Turing Completeness Turing machines are the most powerful description of computation possible They define the Turing-computable functions
CIS 500 Software Foundations Fall September 25
CIS 500 Software Foundations Fall 2006 September 25 The Lambda Calculus The lambda-calculus If our previous language of arithmetic expressions was the simplest nontrivial programming language, then the
λ calculus is inconsistent
Content Rough timeline COMP 4161 NICTA Advanced Course Advanced Topics in Software Verification Gerwin Klein, June Andronick, Toby Murray λ Intro & motivation, getting started [1] Foundations & Principles
Mutable References. Chapter 1
Chapter 1 Mutable References In the (typed or untyped) λ-calculus, or in pure functional languages, a variable is immutable in that once bound to a value as the result of a substitution, its contents never
5. Introduction to the Lambda Calculus. Oscar Nierstrasz
5. Introduction to the Lambda Calculus Oscar Nierstrasz Roadmap > What is Computability? Church s Thesis > Lambda Calculus operational semantics > The Church-Rosser Property > Modelling basic programming
More Lambda Calculus and Intro to Type Systems
More Lambda Calculus and Intro to Type Systems #1 One Slide Summary The lambda calculus is a model of computation or a programming language that is as expressive as a Turing machine. The lambda calculus
CS-XXX: Graduate Programming Languages. Lecture 9 Simply Typed Lambda Calculus. Dan Grossman 2012
CS-XXX: Graduate Programming Languages Lecture 9 Simply Typed Lambda Calculus Dan Grossman 2012 Types Major new topic worthy of several lectures: Type systems Continue to use (CBV) Lambda Caluclus as our
COMP 4161 NICTA Advanced Course. Advanced Topics in Software Verification. Toby Murray, June Andronick, Gerwin Klein
COMP 4161 NICTA Advanced Course Advanced Topics in Software Verification Toby Murray, June Andronick, Gerwin Klein λ 1 Last time... λ calculus syntax free variables, substitution β reduction α and η conversion
CS 6110 S11 Lecture 25 Typed λ-calculus 6 April 2011
CS 6110 S11 Lecture 25 Typed λ-calculus 6 April 2011 1 Introduction Type checking is a lightweight technique for proving simple properties of programs. Unlike theorem-proving techniques based on axiomatic
Simon Peyton Jones Microsoft Research. August 2012
Simon Peyton Jones Microsoft Research August 2012 Typecheck Desugar Source language Intermediate language Haskell Massive language Hundreds of pages of user manual Syntax has dozens of data types 100+
dynamically typed dynamically scoped
Reference Dynamically Typed Programming Languages Part 1: The Untyped λ-calculus Jim Royer CIS 352 April 19, 2018 Practical Foundations for Programming Languages, 2/e, Part VI: Dynamic Types, by Robert
The Lambda Calculus. 27 September. Fall Software Foundations CIS 500. The lambda-calculus. Announcements
CIS 500 Software Foundations Fall 2004 27 September IS 500, 27 September 1 The Lambda Calculus IS 500, 27 September 3 Announcements Homework 1 is graded. Pick it up from Cheryl Hickey (Levine 502). We
Comp 411 Principles of Programming Languages Lecture 7 Meta-interpreters. Corky Cartwright January 26, 2018
Comp 411 Principles of Programming Languages Lecture 7 Meta-interpreters Corky Cartwright January 26, 2018 Denotational Semantics The primary alternative to syntactic semantics is denotational semantics.
Concepts of programming languages
Concepts of programming languages Lecture 5 Wouter Swierstra 1 Announcements Submit your project proposal to me by email on Friday; The presentation schedule in now online Exercise session after the lecture.
Type Systems. Pierce Ch. 3, 8, 11, 15 CSE
Type Systems Pierce Ch. 3, 8, 11, 15 CSE 6341 1 A Simple Language ::= true false if then else 0 succ pred iszero Simple untyped expressions Natural numbers encoded as succ succ
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Operational Semantics CMSC 330 Summer 2018 1 Formal Semantics of a Prog. Lang. Mathematical description of the meaning of programs written in that language
CIS 500 Software Foundations Fall October 2
CIS 500 Software Foundations Fall 2006 October 2 Preliminaries Homework Results of my email survey: There was one badly misdesigned (PhD) problem and a couple of others that were less well thought through
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Lambda Calculus CMSC 330 Summer 2017 1 100 years ago Albert Einstein proposed special theory of relativity in 1905 In the paper On the Electrodynamics of
Simply-Typed Lambda Calculus
#1 Simply-Typed Lambda Calculus #2 Back to School What is operational semantics? When would you use contextual (small-step) semantics? What is denotational semantics? What is axiomatic semantics? What
Part III. Chapter 15: Subtyping
Part III Chapter 15: Subtyping Subsumption Subtype relation Properties of subtyping and typing Subtyping and other features Intersection and union types Subtyping Motivation With the usual typing rule
CMSC 330: Organization of Programming Languages. Lambda Calculus
CMSC 330: Organization of Programming Languages Lambda Calculus 1 100 years ago Albert Einstein proposed special theory of relativity in 1905 In the paper On the Electrodynamics of Moving Bodies 2 Prioritätsstreit,
Lambda Calculus. Type Systems, Lectures 3. Jevgeni Kabanov Tartu,
Lambda Calculus Type Systems, Lectures 3 Jevgeni Kabanov Tartu, 13.02.2006 PREVIOUSLY ON TYPE SYSTEMS Arithmetical expressions and Booleans Evaluation semantics Normal forms & Values Getting stuck Safety
CS152: Programming Languages. Lecture 11 STLC Extensions and Related Topics. Dan Grossman Spring 2011
CS152: Programming Languages Lecture 11 STLC Extensions and Related Topics Dan Grossman Spring 2011 Review e ::= λx. e x e e c v ::= λx. e c τ ::= int τ τ Γ ::= Γ, x : τ (λx. e) v e[v/x] e 1 e 1 e 1 e
Introduction to the Lambda Calculus
Introduction to the Lambda Calculus Overview: What is Computability? Church s Thesis The Lambda Calculus Scope and lexical address The Church-Rosser Property Recursion References: Daniel P. Friedman et
Lecture 13 CIS 341: COMPILERS
Lecture 13 CIS 341: COMPILERS Announcements HW4: OAT v. 1.0 Parsing & basic code generation Due: March 28 th START EARLY! Midterm Exam Grades Available on Gradescope Zdancewic CIS 341: Compilers 2 Midterm
Logic and Computation Lecture 20 CSU 290 Spring 2009 (Pucella) Thursday, Mar 12, 2009
Logic and Computation Lecture 20 CSU 290 Spring 2009 (Pucella) Thursday, Mar 12, 2009 Note that I change the name of the functions slightly in these notes from what I used in class, to be consistent with
More Lambda Calculus and Intro to Type Systems
#1 More Lambda Calculus and Intro to Type Systems #2 Plan Heavy Class Participation Thus, wake up! (not actually kidding) Lambda Calculus How is it related to real life? Encodings Fixed points Type Systems
Recap. Recap. If-then-else expressions. If-then-else expressions. If-then-else expressions. If-then-else expressions
Recap Epressions (Synta) Compile-time Static Eec-time Dynamic Types (Semantics) Recap Integers: +,-,* floats: +,-,* Booleans: =,
Lecture 9: More Lambda Calculus / Types
Lecture 9: More Lambda Calculus / Types CSC 131 Spring, 2019 Kim Bruce Pure Lambda Calculus Terms of pure lambda calculus - M ::= v (M M) λv. M - Impure versions add constants, but not necessary! - Turing-complete
- M ::= v (M M) λv. M - Impure versions add constants, but not necessary! - Turing-complete. - true = λ u. λ v. u. - false = λ u. λ v.
Pure Lambda Calculus Lecture 9: More Lambda Calculus / Types CSC 131 Spring, 2019 Kim Bruce Terms of pure lambda calculus - M ::= v (M M) λv. M - Impure versions add constants, but not necessary! - Turing-complete
Review. CS152: Programming Languages. Lecture 11 STLC Extensions and Related Topics. Let bindings (CBV) Adding Stuff. Booleans and Conditionals
Review CS152: Programming Languages Lecture 11 STLC Extensions and Related Topics e ::= λx. e x ee c v ::= λx. e c (λx. e) v e[v/x] e 1 e 2 e 1 e 2 τ ::= int τ τ Γ ::= Γ,x : τ e 2 e 2 ve 2 ve 2 e[e /x]:
Static Contract Checking for Haskell
Static Contract Checking for Haskell Dana N. Xu INRIA France Work done at University of Cambridge Simon Peyton Jones Microsoft Research Cambridge Joint work with Koen Claessen Chalmers University of Technology
Recursively Enumerable Languages, Turing Machines, and Decidability
Recursively Enumerable Languages, Turing Machines, and Decidability 1 Problem Reduction: Basic Concepts and Analogies The concept of problem reduction is simple at a high level. You simply take an algorithm
Type Safety. Java and ML are type safe, or strongly typed, languages. C and C++ are often described as weakly typed languages.
Java and ML are type safe, or strongly typed, languages. CMPSCI 630: Programming Languages Spring 2009 (with thanks to Robert Harper) C and C++ are often described as weakly typed languages. What does
Last class. CS Principles of Programming Languages. Introduction. Outline
Last class CS6848 - Principles of Programming Languages Principles of Programming Languages V. Krishna Nandivada IIT Madras Interpreters A Environment B Cells C Closures D Recursive environments E Interpreting
CIS 500 Software Foundations Midterm I
CIS 500 Software Foundations Midterm I October 11, 2006 Name: Student ID: Email: Status: Section: registered for the course not registered: sitting in to improve a previous grade not registered: just taking
Variables and Bindings
Net: Variables Variables and Bindings Q: How to use variables in ML? Q: How to assign to a variable? # let = 2+2;; val : int = 4 let = e;; Bind the value of epression e to the variable Variables and Bindings
Denotational Semantics. Domain Theory
Denotational Semantics and Domain Theory 1 / 51 Outline Denotational Semantics Basic Domain Theory Introduction and history Primitive and lifted domains Sum and product domains Function domains Meaning
CS 242. Fundamentals. Reading: See last slide
CS 242 Fundamentals Reading: See last slide Syntax and Semantics of Programs Syntax The symbols used to write a program Semantics The actions that occur when a program is executed Programming language
Lambda Calculus and Type Inference
Lambda Calculus and Type Inference Björn Lisper Dept. of Computer Science and Engineering Mälardalen University bjorn.lisper@mdh.se http://www.idt.mdh.se/ blr/ August 17, 2007 Lambda Calculus and Type
Part III Chapter 15: Subtyping
Part III Chapter 15: Subtyping Subsumption Subtype relation Properties of subtyping and typing Subtyping and other features Intersection and union types Subtyping Motivation With the usual typing rule
CSE505, Fall 2012, Midterm Examination October 30, 2012
CSE505, Fall 2012, Midterm Examination October 30, 2012 Rules: The exam is closed-book, closed-notes, except for one side of one 8.5x11in piece of paper. Please stop promptly at Noon. You can rip apart
Static Program Analysis Part 8 control flow analysis
Static Program Analysis Part 8 control flow analysis http://cs.au.dk/~amoeller/spa/ Anders Møller & Michael I. Schwartzbach Computer Science, Aarhus University Agenda Control flow analysis for the -calculus
CS 4110 Programming Languages & Logics. Lecture 17 Programming in the λ-calculus
CS 4110 Programming Languages & Logics Lecture 17 Programming in the λ-calculus 10 October 2014 Announcements 2 Foster Office Hours 11-12 Enjoy fall break! Review: Church Booleans 3 We can encode TRUE,
Typed Lambda Calculus and Exception Handling
Typed Lambda Calculus and Exception Handling Dan Zingaro zingard@mcmaster.ca McMaster University Typed Lambda Calculus and Exception Handling p. 1/2 Untyped Lambda Calculus Goal is to introduce typing
Lecture 5: The Untyped λ-calculus
Lecture 5: The Untyped λ-calculus Syntax and basic examples Polyvios Pratikakis Computer Science Department, University of Crete Type Systems and Static Analysis Pratikakis (CSD) Untyped λ-calculus I CS49040,
COP4020 Programming Languages. Functional Programming Prof. Robert van Engelen
COP4020 Programming Languages Functional Programming Prof. Robert van Engelen Overview What is functional programming? Historical origins of functional programming Functional programming today Concepts
Lecture 13: Subtyping
Lecture 13: Subtyping Polyvios Pratikakis Computer Science Department, University of Crete Type Systems and Programming Languages Pratikakis (CSD) Subtyping CS546, 2018-2019 1 / 15 Subtyping Usually found
Constraint-based Analysis. Harry Xu CS 253/INF 212 Spring 2013
Constraint-based Analysis Harry Xu CS 253/INF 212 Spring 2013 Acknowledgements Many slides in this file were taken from Prof. Crista Lope s slides on functional programming as well as slides provided by
(Refer Slide Time: 4:00)
Principles of Programming Languages Dr. S. Arun Kumar Department of Computer Science & Engineering Indian Institute of Technology, Delhi Lecture - 38 Meanings Let us look at abstracts namely functional
Functional Languages. Hwansoo Han
Functional Languages Hwansoo Han Historical Origins Imperative and functional models Alan Turing, Alonzo Church, Stephen Kleene, Emil Post, etc. ~1930s Different formalizations of the notion of an algorithm
Types for References, Exceptions and Continuations. Review of Subtyping. Γ e:τ τ <:σ Γ e:σ. Annoucements. How s the midterm going?
Types for References, Exceptions and Continuations Annoucements How s the midterm going? Meeting 21, CSCI 5535, Spring 2009 2 One-Slide Summary Review of Subtyping If τ is a subtype of σ then any expression
Printed by Zach Tatlock Dec 08, 15 22:18 Page 1/11. Lemma subst_only_free: forall e1 e2 x e3, Subst e1 e2 x e3 > ~ free e1 x > e1 = e3. Proof.
Dec 08, 15 22:18 Page 1/11 Require Import List. Require Import ZArith. Require Import String. Open Scope string_scope. Ltac inv H := inversion H; subst. Ltac break_match := match goal with _ : context
The Eval/Apply Cycle Eval. Evaluation and universal machines. Examining the role of Eval. Eval from perspective of language designer
Evaluation and universal machines What is the role of evaluation in defining a language? How can we use evaluation to design a language? The Eval/Apply Cycle Eval Exp & env Apply Proc & args Eval and Apply
CSE 505: Programming Languages. Lecture 10 Types. Zach Tatlock Winter 2015
CSE 505: Programming Languages Lecture 10 Types Zach Tatlock Winter 2015 What Are We Doing? Covered a lot of ground! Easy to lose sight of the big picture. Zach Tatlock CSE 505 Winter 2015, Lecture 10
From the λ-calculus to Functional Programming Drew McDermott Posted
From the λ-calculus to Functional Programming Drew McDermott drew.mcdermott@yale.edu 2015-09-28 Posted 2015-10-24 The λ-calculus was intended from its inception as a model of computation. It was used by
The Untyped Lambda Calculus
Resources: The slides of this lecture were derived from x = 1 [Järvi], with permission of the original author, by copy & let x = 1 in... paste or by selection, annotation, or rewording. [Järvi] is in turn
Introduction to Functional Programming in Haskell 1 / 56
Introduction to Functional Programming in Haskell 1 / 56 Outline Why learn functional programming? The essence of functional programming What is a function? Equational reasoning First-order vs. higher-order
A formal derivation of an executable Krivine machine
A formal derivation of an executable Krivine machine Wouter Swierstra Universiteit Utrecht IFIP WG 2.1 Meeting 68; Rome, Italy 1 β reduction (λx. t0) t1 t0 {t1/x} 2 Motivation Implementing β-reduction
Programming with Math and Logic
.. Programming with Math and Logic an invitation to functional programming Ed Morehouse Wesleyan University The Plan why fp? terms types interfaces The What and Why of Functional Programming Computing
HOL DEFINING HIGHER ORDER LOGIC LAST TIME ON HOL CONTENT. Slide 3. Slide 1. Slide 4. Slide 2 WHAT IS HIGHER ORDER LOGIC? 2 LAST TIME ON HOL 1
LAST TIME ON HOL Proof rules for propositional and predicate logic Safe and unsafe rules NICTA Advanced Course Forward Proof Slide 1 Theorem Proving Principles, Techniques, Applications Slide 3 The Epsilon
Induction and Semantics in Dafny
15-414 Lecture 11 1 Instructor: Matt Fredrikson Induction and Semantics in Dafny TA: Ryan Wagner Encoding the syntax of Imp Recall the abstract syntax of Imp: a AExp ::= n Z x Var a 1 + a 2 b BExp ::=
> module Lambda where > import Data.List -- I need some standard list functions
Lecture 9 Lambda Calculus We now look at lambda calculus, the theoretical stuff that underlies functional programming. It was introduced by Alonzo Church to formalise two key concepts when dealing with
The Untyped Lambda Calculus
Resources: The slides of this lecture were derived from [Järvi], with permission of the original author, by copy & x = 1 let x = 1 in... paste or by selection, annotation, or rewording. [Järvi] is in turn
The Environment Model. Nate Foster Spring 2018
The Environment Model Nate Foster Spring 2018 Review Previously in 3110: Interpreters: ASTs, evaluation, parsing Formal syntax: BNF Formal semantics: dynamic: small-step substitution model static semantics
An experiment with variable binding, denotational semantics, and logical relations in Coq. Adam Chlipala University of California, Berkeley
A Certified TypePreserving Compiler from Lambda Calculus to Assembly Language An experiment with variable binding, denotational semantics, and logical relations in Coq Adam Chlipala University of California,
Begin at the beginning
Begin at the beginning Expressions (Syntax) Exec-time Dynamic Values (Semantics) Compile-time Static Types 1. Programmer enters expression 2. ML checks if expression is well-typed Using a precise set of
Intro. Scheme Basics. scm> 5 5. scm>
Intro Let s take some time to talk about LISP. It stands for LISt Processing a way of coding using only lists! It sounds pretty radical, and it is. There are lots of cool things to know about LISP; if
Harvard School of Engineering and Applied Sciences CS 152: Programming Languages
Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Lecture 18 Thursday, April 3, 2014 1 Error-propagating semantics For the last few weeks, we have been studying type systems.