Types and Programming Languages (15-814), Fall 2018 Assignment 4: Data Representation (Sample Solutions)

Transcription

1 Types and Programming Languages (15-814), Fall 2018 Assignment 4: Data Representation (Sample Solutions) Contact: Course Staff Due Tuesday, October 16, 2018, 10:30am This assignment is due by 10:30am on the above date and it must be submitted electronically as a PDF file on Canvas. Please use the attached template to typeset your assignment and make sure to include your full name and Andrew ID. As before, problems marked WB are subject to the whiteboard policy; all other problems must be done individually. We have again provided you the syntax, statics, and dynamics for our simple language from class. Please ensure that your terms are syntactically correct and that they have the right type! General hint. Consider whether the results from a given task can be used to solve subsequent tasks! Task 1 (0 points). How long did you spend on this assignment? Please list the questions that you discussed with classmates using the whiteboard policy. 1 Natural Numbers in Binary Form Recall the definition of natural numbers in binary representation in the first line below and the isomorphism satisfied by this type. bin = ρ(α. (b0 : α) + (b1 : α) + (ɛ : 1)) bin = (b0 : bin) + (b1 : bin) + (ɛ : 1) 1

2 We also defined the constants and functions bzero, dbl0, and dbl1 encapsulating the constructors for binary numbers. bzero : bin = fold (ɛ ) dbl0 : bin bin = λx. fold (b0 x) dbl1 : bin bin = λx. fold (b1 x) Also recall the increment function from lecture: inc : bin bin = fix(i. λx. case (unfold x) { b0 y fold (b1 y) b1 y fold (b0 (i y)) ɛ fold (b1 (fold (ɛ ))) }) In order to simplify the typesetting task and make the code easier to write and read, we encourage you to use verbatim code 1 that exploits pattern matching, recursive definitions of functions by name, and constructor functions with implicit fold and unfold operations. For example, the definitions above might be written as bzero = eps () dbl0 x = b0 x dlb1 x = b1 x inc (b0 y) = b1 y inc (b1 y) = b0 (inc y) inc (eps _) = b1 (eps ()) Task 2 (5 points, WB). Define a function plus : bin bin bin that adds two natural numbers in binary form. You may use the functions and constants defined above. Solution 2: plus (b0 x) (b0 y) = b0 (plus x y) plus (b0 x) (b1 y) = b1 (plus x y) plus (b0 x) (eps _) = b0 x plus (b1 x) (b0 y) = b1 (plus x y) plus (b1 x) (b1 y) = b0 (inc (plus x y)) plus (b1 x) (eps _) = b1 x plus eps y = y 1 Use the verbatim environment. 2

3 Task 3 (5 points, WB). Define a function eqbits : bin bin bool that returns true if the two arguments are the exact same sequence of bits and false otherwise. Solution 3: eqbits (b0 x) (b0 y) = eqbits x y eqbits (b0 x) (b1 y) = false eqbits (b0 x) (eps _) = false eqbits (b1 x) (b0 y) = false eqbits (b1 x) (b1 y) = eqbits x y eqbits (b1 x) (eps _) = false eqbits (eps _) (b0 y) = false eqbits (eps _) (b1 y) = false eqbits (eps _) (eps _) = true Task 4 (5 points, WB). Demonstrate that eqbits is not a correct implementation of equality of natural numbers in binary representation. Summarize what you see as the source of the issue. Solution 4: or, in short form eqbits bzero (dbl0 bzero) eqbits (fold (ɛ )) (fold (b0 (fold (ɛ )))) false eqbits bzero (b0 bzero) ->* false The source of the issue is that a number in binary form may have leading 0 bits, so there are multiple different representations of every natural number. The bitwise equality does not account for this. Task 5 (10 points, WB). The problem exhibited in previous task can be addressed in several ways. Explain at least two approaches of how the problem in the previous section may be addressed, and provide the details for two different solutions. Provide definitions and code in each case as appropriate, including a function eq : bin bin bool that correctly implements equality of natural numbers in binary form. Solution 5: We sketch three approaches. 1. Change the definition of equality so that leading zero bits are ignored. 3

4 eq (b0 x) (b0 y) = eq x y eq (b0 x) (b1 y) = false eq (b0 x) (eps _) = eq x (eps ()) eq (b1 x) (b0 y) = false eq (b1 x) (b1 y) = eq x y eq (b1 x) (eps _) = false eq (eps _) (b0 y) = eq (eps ()) y eq (eps _) (b1 y) = false eq (eps _) (eps _) = true Now we have to be careful that any functions we write on type bin work correctly no matter how many leading zeros there might be. 2. Change the definition of the constructor function dbl0 so it avoids constructing terms with leading zero bits. We would then have to agree not to build terms with leading zero bits directly, but go only through the constructor functions. Or, in an appropriately extended language, we could enforce these abstractions. dbl (b0 x) = b0 (b0 x) dbl (b1 x) = b0 (b1 x) dbl (eps _) = eps () eq x = eqbits x 3. Change the type definition of to satisfy the following isomorphisms: bin = (b0 : pos) + (b1 : bin) + (ɛ : 1) pos = (b0 : pos) + (b1 : bin) bin = ρ α. (b0 : ρ β. (b0 : β) + (b1 : α)) + (b1 : α) + (ɛ : 1) pos = ρ β. (b0 : β) + (b1 : ρ α. (b0 : β) + (b1 : α) + (ɛ : 1)) Now dbl0 is ill-typed and will have to distinguish the case of the empty bit string. eq can then be the same as eqbits. 2 Representing Integers We can represent integers a as pairs x, y of natural numbers x and y in binary form where a = x y. We ll use this as an example of a recursive type that is not 4

5 actually recursive. int = ρ α. bin bin int = bin bin In the tasks below, you should look for opportunities to use the functions defined in the previous problem on natural numbers in binary form. Task 6 (5 points, WB). Define a function bintoint : bin int that, when given a representation of a the natural number n, returns an integer representing n. Solution 6: bintoint x = (x, 0) Task 7 (5 points, WB). Define a constant izero : int representing the integer 0 as well as functions iplus and iminus of type int int int representing addition and subtraction on integers. Solution 7: izero = (0, 0) iplus (x1,y1) (x2,y2) = (plus x1 x2, plus y1 y2) iminus (x1,y1) (x2,y2) = (plus x1 y2, plus x2 y1) Task 8 (5 points, WB). Propose an alternative representation of integers using sums instead of products and define how mathematical integers are represented. You do not need to implement any functions on this representation, but please explain in a few sentences which one you would prefer and why. Solution 8: We can define signed integers as sint = (pos : nat) + (neg : nat). Let n be the representation of n in binary form (so that n val and n : bin. Then the integer representation of n is pos n, while the integer representation of n for n > 0 is neg n. The representation as pairs could be less efficient unless we normalize it back to n, 0 for positive numbers n (including 0) and 0, n for negative numbers. On the other hand, operations on signed integers may have to distinguish cases. Personally, I like the elegance of the difference representation. 5

6 3 Reasoning Inductively with Data The values of so-called purely positive types only contain other values but not arbitrary expression. They follow this grammar: Positive types τ + ::= τ + 1 τ i I (i : τ + i ) ρ(α+. τ + ) α + We can now specialize the typing rules to values of purely positive type, giving us both an easy way to reason about canonical forms and inductively prove properties of programs. The rules for the judgment v :: τ + establish simultaneously that v is a value and that it has type τ +. v :: τ + i i v :: i I (i :: τ + i ) (I-+) v 1 :: τ + 1 v 2 :: τ + 2 v 1, v 2 :: τ + 1 τ + 2 (I- ) :: 1 (I-1) v :: [ρ(α +. τ + )/α + ]τ + fold v :: ρ(α +. τ + ) (I-ρ) Observe that there are no elimination rules (since they don t form values), and that there are no variables or contexts. Theorem. For any expression v and purely positive type τ +, we have that v :: τ + iff v : τ + and v val. Proof. In each direction, by rule induction on the given derivation. From right to left we also use inversion on v val to conclude that the given rules are the only applicable ones. Task 9 (5 points, WB). Give a detailed proof showing that there are no closed values of type ρ(α +. α + α + ) by assuming v :: ρ(α +. α + α + ) and deriving a contradiction. Solution 9: Assume v :: ρ α +. α + α +. We prove a contradiction by rule induction on the value typing judgment. v :: ρ α +. α + α + Assumption v = fold v with v :: (ρ α +. α + α + ) (ρ α +. α + α + ) By inversion v = v 1, v 2 with v 1 :: (ρ α+. α + α + ) and v 2 :: (ρ α+. α + α + ) By inversion Contradiction By ind.hyp. on the value typing of v 1. 6

7 Here, we can apply the induction hypothesis to the value typing derivation of v 1 because it is a subderivation of the typing of v. We can further specialize the rules to particular types, such as the type of bin of bit strings from Problem 1: bin fold (ɛ ) :: bin bin = ρ α. (b0 : α) + (b1 : α) + (ɛ : 1) bin = (b0 : bin) + (b1 : bin) + (ɛ : 1) bin v :: bin bin fold (b0 v) :: bin bin v :: bin bin fold (b1 v) :: bin These rules are complete for closed values of type bin (which we do not prove, but is straightforward). They are interesting because they give rise to an induction principle for bit strings which is just a rule induction over this new judgment. Task 10 (5 points, WB). Prove that for all closed values v of type bin, inc v w for some value w Solution 10: The proof is by rule induction of the value typing bin v :: bin. Case: Case: Case: bin fold (ɛ ) :: bin where v = fold (ɛ ). Then with w = fold (b1 (fold (ɛ y))) we have inc v w. bin v :: bin bin fold (b0 v ) :: bin where v = fold (b0 v ). Then with w = fold (b1 v ) we have inc v w. were v = fold (b1 v ). Then bin v :: bin bin fold (b1 v ) :: bin inc v w for some w By ind. hyp. inc v = inc (fold (b1 v )) fold (b0 (inc v )) fold (b0 w ) So for w = fold (b0 w ) we have inc v w. 7

8 We now define a decrement function on numbers in binary representation. dec : bin bin = fix d. λx. case unfold x { b0 y b1 (d y) b1 y b0 y ɛ u ɛ u } In surface syntax, using data constructors, pattern matching and recursive definitions: dec (b0 y) = b1 (dec y) dec (b1 y) = b0 y dec (eps _) = eps () Task 11 (10 points, WB). Attempt to prove that for all closed values v of type bin dec (inc v) v by using rule induction on the value typing bin v :: bin. This proof will fail in one case. Indicate how this failure might be addressed in light of Problem 1. You do not need to write new code or carry out a revised proof. Solution 11: The proof attmempt is by rule induction over the value typing bin v :: bin. Case: Case: where v = fold (b0 v ). Then bin v :: bin bin fold (b0 v ) :: bin dec (inc v) = dec (inc (b0 v )) ->* dec (b1 v ) ->* b0 v = v were v = fold (b1 v ). Then bin v :: bin bin fold (b1 v ) :: bin 8

9 dec (inc v) = dec (inc (b1 v )) ->* dec (b0 (inc v )) ->* dec (b0 w ) (since inc v ->* w for some w by Task 11) ->* b1 (dec w ) dec (inc v ) ->* dec w dec (inc v ) ->* v dec w ->* v (since inc v ->* w ) (by ind.hyp.) (by determinacy of evaluation) dec (inv v) ->* b1 (dec w ) (see above) ->* b1 v (by computation rules) = v Case: where v = fold (ɛ ). Then bin fold (ɛ ) :: bin dec (inc v) = dec (inc (eps ())) ->* dec (b1 (eps ())) ->* b0 (eps ()) The proof attempt fails here, since fold (ɛ ) fold (b0 fold (ɛ )). We can salvage this proof in several ways. One is to change the decrement function so it avoids introducing leading 0 bits. Another is to state the theorem in terms of the fixed equality function from Problem 1: eq (dec (inc v)) v true 9

10 A Syntax Types τ and terms e are given by the following grammars, where I ranges over finite index sets: τ ::= α τ 1 τ 2 τ 1 τ 2 1 i I (i : τ i) &i I (i : τ i) ρ(α. τ) e ::= x λx. e e 1 e 2 i e case e {i x i e i } i I e 1, e 2 case e 0 { x 1, x 2 e } case e 0 { e } i e i i I e i fold(e) unfold(e) fix(x.e) As discussed in class, the 0 is a special case of sums with I =. 10

11 B Statics For any type constructor %, we use the name (I-%) for a rule that introduces (constructs) an expression of type % and (E-%) for a rule that eliminates (destructs) an expression of type %. Variables and fixed points are special, since they are not tied to any particular type. x : τ Γ Γ x : τ (VAR) Γ, x : τ e : τ (I- ) Γ λx.e : τ τ Γ e 1 : τ τ Γ e 1 e 2 : τ Γ e 2 : τ (E- ) Γ e : τ j (j I) Γ j e : i I (i : τ i) (I-+) Γ e : i I (i : τ i) Γ, x i : τ i e i : τ ( i I) Γ case e {i x i e i } i I : τ (E-+) Γ e 1 : τ 1 Γ e 2 : τ 2 Γ e 1, e 2 : τ 1 τ 2 (I- ) Γ e 0 : τ 1 τ 2 Γ, x 1 : τ 1, x 2 : τ 2 e : τ Γ case e 0 { x 1, x 2 e } : τ (E- ) Γ : 1 (I-1) Γ e 0 : 1 Γ e : τ Γ case e 0 { e } : τ (E-1) Γ e i : τ i ( i I) Γ i e i i I : &i I (i : τ i) (I-&) Γ e : &i I (i : τ i) (j I) Γ e j : τ j Γ e : [ρ(α. τ)/α]τ Γ fold(e) : ρ(α. τ) (I-ρ) Γ e : ρ(α. τ) Γ unfold(e) : [ρ(α. τ)/α]τ (E-ρ) Γ, x : τ e : τ Γ fix(x.e) : τ (FIX) (E-&) 11

12 C Dynamics For any type constructor % we write (V-%) for defining a value of type %, (R-%) for a reduction where a destructor meets a constructor, and (CI-%) and (CE-%) for the congruence rules for constructors and destructors for the type %. λx.e val (V- ) v 2 val (λx. e 1 ) v 2 [v 2 /x]e 1 (R- ) e 1 e 1 e 1 e 2 e 1 e 2 (CE- 1 ) v 1 val e 2 e 2 v 1 e 2 e 1 e 2 (CE- 2 ) v val i v val (V-+) e e (CI-+) i e i e e e case e {i x i e i } i I case e {i x i e i } i I (CE-+) v j val case (j v j ) {i x i e i } i I [v j /x j ]e j (R-+) v 1 val v 2 val v 1, v 2 val (V- ) e 1 e 1 e 1, e 2 e 1, e 2 (CI- 1) v 1 val e 2 e 2 v 1, e 2 v 1, e 2 (CI- 2) e 0 e 0 case e 0 { x 1, x 2 e } case e 0 { x 1, x 2 e } (CE- ) v 1 val v 2 val (R- ) case v 1, v 2 { x 1, x 2 e } [v 1 /x 1, v 2 /x 2 ]e val (V-1) e 0 e 0 case e 0 { e } case e 0 { e } (CE-1) case { e } e (R-1) i e i i I val (V-&) e e e j e j (CI-&) i e i i I j e j (R-&) v val fold(v) val (V-ρ) e e fold(e) fold(e ) (CI-ρ) e e unfold(e) unfold(e ) (CE-ρ) v val unfold(fold(v)) v (R-ρ) fix(x.e) [fix(x.e)/x]e (R-FIX) 12