(2) (15pts) Using Prolog, implement a type-checker for the following small subset of System F:

Transcription

1 CS 6371 Advanced Programming Languages Sample Spring 2018 Final Exam This sample final exam is LONGER than a real final exam (to give you more practice problems) and has a medium difficulty level. You may take two, two-sided sheets of notes with you into the exam. All other books or notes must remain closed throughout the exam. You will have 2 hours and 45 minutes to complete the exam; all papers must be turned in by 1:45pm. 1 Problem Set (1) (15 pts) A metric is a function m : α α int that computes some notion of distance between two values. The path-length of a list is the sum of the distances between each consecutive pair of elements. For example, if the data has type α = int and the metric is absolute difference, then the path-length of list [7; 10; 6] is = 7. Using only List.fold left for recursion, implement a function (pathlen m l) that computes the path-length of l using metric function m. If l has less than 2 elements, the path-length is 0. Do not use any other List library functions in your implementation. (2) (15pts) Using Prolog, implement a type-checker for the following small subset of System F: e ::= () λv:τ.e Λα.e v τ ::= unit τ 1 τ 2 α.τ α In particular, implement a predicate typ(e, T ) that succeeds if and only if expression E has type T, where expressions and types are represented as the following Prolog structures: V ::= arbitrary Prolog atoms E ::= uval lam(v,t,e) poly(v,e) var(v ) T ::= unit arr(t 1,T 2 ) forall(v,t ) tvar(v ) Your typ/2 predicate should fail (reject) if E has free variables. If you use any helper Prolog predicates that we defined in class, give their exact definitions (since the exact definition you use might affect the correctness of your implementation). (3) Consider the following recursive definition of function f: f(x) = ( x=100 0 x>100 f(x 1) + 1 x<100 f(x + 1) + 1 ) (a) (1 pt) Define a non-recursive functional F whose least fixed point is f. (b) (4 pts) Give a closed-form function definition h such that h = f. (c) (15 pts) Prove by fixed point induction that h = fix(f ). (4) For each of the following System F types, say whether the type is inhabited or not. If the type is inhabited, give an example of a System F term that inhabits it. (Do not prove that your term inhabits the type, just state it.) If the type is not inhabited, just write uninhabited. 1

2 (a) (3 pts) α. β. η. ((α β) η) (α β η) (b) (3 pts) α.(α + unit) (c) (4 pts) α. β.(α + β) (α β) (d) (7 pts) α. β.((α + β) ((α β) + (β α))) (5) (5 pts) Encode an iseven function in the untyped λ-calculus so that (iseven n N ) evaluates to true whenever n is even and to false whenever n is odd. (6) (15 pts) Consider the untyped λ-calculus expression foo defined as follows: foo = Y ( λf.λx.((iszero x)? x : (f (pred N x))) ) Prove by fixed-point induction that P (foo) holds, where P is the property defined by P (g) (x N, y N ) g. y N = 0 N In your proof when you claim that an expression e 1 evaluates to another expression e 2, you may do so without a formal proof of e 1 e 2. That is, it is not necessary to write out all the small-step derivations. (7) (5 pts) Derive the following typing judgment using the typing rules for the simply-typed λ-calculus: {} (λx:int. x) 3 : int (8) (20 pts) Derive the following partial correctness assertion using Hoare Logic: {x = n}while x<= 1 do x:=x + 1{x = max( n, 0)} 2 Solutions (1) let pathlen m = function [] -> 0 h::t -> fst (List.fold_left (fun (s,p) x -> (s+(m p x),x)) (0,h) t);; (2) % the pick/2 predicate defined in class... pick([x _],X). pick([x T],Y) :- X \= Y, pick(t,y). % succeed if type T in context C has No Free Type Variables nftv(_,unit). nftv(c,arr(t1,t2)) :- nftv(c,t1), nftv(c,t2). nftv(c,forall(a,t)) :- nftv([a C],T). nftv(c,tvar(a)) :- pick(c,a). % type-checker typ(_,_,uval,unit). typ(_,g,var(v),t) :- pick(g,(v,t)). typ(c,g,lam(v,vt,e),arr(vt,t)) :- nftv(c,vt), typ(c,[(v,vt) G],E,T). typ(c,g,poly(a,e),forall(a,t)) :- typ([a C],G,E,T). typ(e,t) :- typ([],[],e,t). 2

3 (3) (a) F (g) = λx. ( x=100 0 x>100 g(x 1) + 1 x<100 g(x + 1) + 1 ) (b) h(x) = x 100 (c) Proof. Define proposition P (g) = x g. g(x) = x 100. We wish to prove that P (fix(f )) holds. Base Case: P ( ) holds vacuously. Inductive Case: As the inductive hypothesis, assume that P (g) holds. We must prove that P (F (g)) holds. Let x F (g) be given. Case 1: Suppose x = 100. Then by definition of F, F (g)(x) = 0 = x 100. Case 2: Suppose x > 100. Then by definition of F, F (g)(x) = g(x 1) + 1. By inductive hypothesis, g(x 1) = x Since x > 100, x = x = x 100 = x 100. Case 3: Suppose x < 100. Then by definition of F, F (g)(x) = g(x + 1) + 1. Since x < 100, x = (x ) + 1 = (x 100) = x 100. (4) (a) Λα.Λβ.Λη.λf:((α β) η).λx:α.λy:β.f(x, y) (b) Λα. in α+unit 2 () (c) uninhabited (d) The type is inhabited. The following is a term that inhabits it: Λα.Λβ.λx:α+β. case x of in 1 (y) in (α β)+(β α) 2 (λz :β.y) (5) The iseven function can be encoded this way: (6) Proof. Define functional Γ by iseven = Y (λf.λn.((iszero N n)? true : in 2 (y) in (α β)+(β α) 1 (λz :α.y) ((iszero N (pred N n))? false : (f (pred N (pred N n)))))) Γ(f) = λx.((iszero N x)? x : (f (pred N x))) Since foo = Y Γ = fix(γ), we can prove the theorem by fixed-point induction on Γ. Base Case: P ( ) holds vacuously. Inductive Case: We must prove that P (g) implies P (Γ(g)). Therefore, assume P (g) holds and let (x N, y N ) Γ(g) be given. We wish to prove that y N = 0 N. Case 1: Suppose x N = 0 N. By the definition of Γ, Γ(x N ) = x N = 0 N, so y N = 0 N. Case 2: Suppose x N 0 N. Then by definition of Γ, y N = (g (pred N x N )) = (g (x 1) N ). This is the same as saying ((x 1) N, y N ) g. Since we assumed P (g) holds, it follows that y N = 0 N. 3

4 (7) The following typing derivation proves the typing judgment: (10) {(x, int)} x : int (11) {} (λx:int.x) : int int {} (λx:int.x)3 : int (9) {} 3 : int (12) (8) Choose loop invariant I = ((x 0) (x = n)) (x n) and derive the following: = I b C = A I (4) {C}x:=x + 1{I} = I I (6) {I b}x:=x + 1{I} (5) {I}p{ b I} = b I B (6) {A}p{B} where p = while x<= 1 do x:=x + 1 b (x 1) I ((x 0) (x = n)) (x n) A (x = n) B (x = max( n, 0)) C I[x + 1/x] ((x + 1 0) (x + 1 = n)) (x + 1 n) 3 Reference In addition to the material in this reference section, you will also be provided any relevant material from the reference section of the sample midterm exam. 3.1 Syntax of SIMPL commands c ::= skip c 1 ; c 2 v:=a if b then c 1 else c 2 while b do c boolean expressions b ::= true false a 1 <=a 2 b 1 && b 2 b 1 b 2!b arithmetic expressions a ::= n v a 1 + a 2 a 1 - a 2 a 1 * a 2 variable names v integer constants n 4

5 3.2 Axiomatic Semantics of SIMPL {A}skip{A} (1) {A}c 1 {C} {C}c{B} {A}c 1 ; c 2 {B} (2) {A b}c 1 {B} {A b}c 2 {B} {A}if b then c 1 else c 2 {B} (3) {B[a/v]}v:=a{B} (4) {I b}c{i} {I}while b do c{ b I} (5) = A A {A }c{b } = B B {A}c{B} (6) 3.3 Untyped Lambda Calculus Syntax and Semantics of Untyped λ-calculus e ::= v λv.e e 1 e 2 e 1 1 e 1 e 1 e 2 1 e 1 e 2 (7) (λv.e 1 )e 2 1 e 1 [e 2 /v] (8) Abbreviations in Untyped λ-calculus true = (λx.λy.x) pair = (λx.λy.λb.(b?e 1 :e 2 )) false = (λx.λy.y) π 1 = (λx. x true) e 1?e 2 :e 3 = (e 1 e 2 e 3 ) π 2 = (λx. x false) not = (λb.(b?false:true)) 0 N = (λx.x) and = (λa.λb.(a?b:false)) succ N = (pair false) or = (λa.λb.(a?true:b)) pred N = π 2 Y = (λf.(λx.f(xx))(λx.f(xx))) iszero N = π 1 add N = (Y (λf.λm.λn.((iszero N m)? n : (f(pred N m)(succ N n))))) sub N = (Y (λf.λm.λn.((iszero N n)? m : (f(pred N m)(pred N n)))) mult N = (Y (λf.λm.λn.((iszero N m)? 0 N : (add N (f (pred N m) n) n)))) 5

6 3.4 Simply-typed Lambda Calculus Syntax of λ expressions e ::= n v λv :τ.e e 1 e 2 true false e 1 aop e 2 e 1 bop e 2 types arithmetic ops aop ::= + - * boolean ops e 1 cmp e 2 (e 1, e 2 ) π 1 e π 2 e () in τ 1+τ 2 1 e in τ 1+τ 2 2 e (case e of in 1 (v 1 ) e 1 in 2 (v 2 ) e 2 ) τ ::= int bool τ 1 τ 2 τ 1 τ 2 unit τ 1 + τ 2 void bop ::= comparisons cmp ::= < > = Static Semantics of λ Γ n : int (9) Γ v : Γ(v) (10) Γ[v τ 1 ] e : τ 2 Γ (λv :τ 1. e) : τ 1 τ 2 (11) Γ e 1 : τ τ Γ e 2 : τ Γ e 1 e 2 : τ (12) Γ true : bool (13) Γ false : bool (14) Γ e 1 : int Γ e 2 : int Γ e 1 aop e 2 : int (15) Γ e 1 : bool Γ e 2 : bool Γ e 1 bop e 2 : bool Γ e 1 : int Γ e 2 : int Γ e 1 cmp e 2 : bool (16) (17) Γ e 1 : τ 1 Γ e 2 : τ 2 Γ (e 1, e 2 ) : τ 1 τ 2 (18) Γ e : τ 1 τ 2 i {1, 2} Γ π i e : τ i (19) Γ () : unit (20) Γ e : τ i i {1, 2} Γ in τ 1+τ 2 (21) i e : τ 1 + τ 2 Γ e : τ 1 + τ 2 Γ[v 1 τ 1 ] e 1 : τ Γ[v 2 τ 2 ] e 2 : τ Γ (case e of in 1 (v 1 ) e 1 in 2 (v 2 ) e 2 ) : τ (22) 3.5 System F expressions types e ::= Λα.e e[τ] τ ::= α α.τ (Λα.e)[τ] 1 e[τ/α] Γ e : τ Γ Λα.e : α.τ (23) Γ e : α.τ Γ e[τ] : τ [τ/α] (24) 6