Foundations of Computation

Transcription

1 The Australian National University Semester 2, 2018 Research School of Computer Science Tutorial 5 Dirk Pattinson Foundations of Computation The tutorial contains a number of exercises designed for the students to practice the course content. During the lab, the tutor will work through some of these exercises while the students will be responsible for completing the remaining exercises in their own time. There is no expectation that all the exercises will be covered in lab time. Exercise 1 Consider the following definition of binary trees Reversing a binary tree data Tree a = Nul Node (Tree a) a (Tree a) along with the function that reverses binary trees: revt :: Tree a -> Tree a revt Nul = Nul -- T1 revt (Node t1 x t2) = Node (revt t2) x (revt t1) -- T2 1. Use tree induction to show that the equation revt (revt t) = t is true for all trees t of type Tree a. We prove t.p (t) by induction (on t) where P (t) = revt (revt t) = t. Base Case revt (revt Nul) = Nul revt (revt Nul) = revt Nul -- by T1 = Nul -- by T1 Step Case Assume revt (revt a1) = a1 -- (IH1) revt (revt a2) = a2 -- (IH2) Prove revt (revt (Node a1 x a2)) = Node a1 x a2 revt (revt (Node a1 x a2)) = revt (Node (revt a2) x (revt a1)) -- by T2 = Node (revt (revt a1)) x (revt (revt a2)) -- by T2 = Node a1 x a2 -- by IH1, IH2 Having showed P (a1) P (a2) P (Node a1 x a2), we can generalise to y. t1. t2.p (t1) P (t2) P (Node t1 y t2). Having showed P (Nul) and y. t1. t2.p (t1) P (t2) P (Node t1 y t2), we have t.p (t). 2. Show that reversing a tree does not increase or decrease the number of its nodes, that is, establish that holds for all trees t of type Tree a. count(revt t) = count (t) We prove t.p (t) by induction on t where P (t) = count(revt t) = count (t). Base Case count(revt Nul) = count Nul = count Nul -- by T1 Step Case Assume

2 count(revt a1) = count a1 count(revt a2) = count a2 -- (IH1) -- (IH2) Prove count (revt (Node a1 x a2)) = count (Node a1 x a2) count (revt (Node a1 x a2)) = count (Node (revt a2) x (revt a1)) -- by T2 = 1 + count (revt a2) + count (revt a1) -- by C2 = 1 + (count a2) + (count a1) -- by IH2, IH1 = 1 + (count a1) + (count a2) -- by commutativity of + = count (Node a1 x a2) -- by C2 Having showed P (a1) P (a2) P (Node a1 x a2), we can generalise to y. t1. t2.p (t1) P (t2) P (Node t1 y t2). Having showed P (Nul) and y. t1. t2.p (t1) P (t2) P (Node t1 x t2), we have t.p (t). Exercise 2 Flattening a Tree We can turn a tree into a list containing the same entries with the tail recursive function flat, where flat t acc returns the result of flattening the tree t, appended to the front of the list acc. For example, flat (Node (Node Nul 3 Nul) 5 (Node Nul 6 Nul)) [1,2] = [3,5,6,1,2] flat :: Tree a -> [a] -> [a] flat Nul acc = acc -- (F1) flat (Node t1 a t2) acc = flat t1 (a : flat t2 acc) -- (F2) We can get the sum of entries in a list by the function suml suml :: [Int] -> Int suml [] = 0 -- (S1) suml (x:xs) = x + suml xs -- (S2) We can get the sum of entries in a tree by the function sumt sumt :: Tree Int -> Int sumt Nul = 0 -- (T1) sumt (Node t1 n t2) = n + sumt t1 + sumt t2 -- (T2) Prove (using tree induction) that for all t and acc, suml (flat t acc) = sumt t + suml acc Base case: t = Nul. Show that suml (flat Nul acc) = sumt Nul + suml acc Proof: suml (flat Nul acc) = suml acc -- by (F1) = 0 + suml acc -- by arithmetic = sumt Nul + suml acc -- by (T1) The inductive hypotheses: acc suml (flat t1 acc) = sumt t1 + suml acc -- (IH1) suml (flat t2 acc) = sumt t2 + suml acc -- (IH2)

3 Step case: Show (assuming the IHs), that acc, suml (flat (Node t1 y t2) acc = sumt (Node t1 y t2) + suml acc Proof: suml (flat (Node t1 y t2) acc) = suml (flat t1 (y : flat t2 acc)) -- by (F2) = sumt t1 + suml (y : flat t2 acc) -- by (IH1) = sumt t1 + y + suml (flat t2 acc) -- by (S2) = sumt t1 + y + sumt t2 + suml acc -- by (IH2) = sumt (Node t1 y t2) + suml acc -- by (T2) Note: (IH1) is instantiated so that acc becomes (y : flat t2 acc), but the acc of (IH2) is just instantiated to the acc of the proof. Note: the proof involves steps which use associativity or commutativity of +; these steps are not explicitly shown. Exercise 3 Soup Induction In the military, there are very strict rules regarding how to make soup: an empty pot of water is a soup, and given a soup, a new soup can be created by adding (precisely) two carrots and one turnip. We can model these soups using the inductive data type Soup that takes the type of carrots and the type of turnips as parameters: data Soup carrot turnip = Water MkSoup carrot carrot turnip (Soup carrot turnip) 1. Let s call the induction principle for the above type soup induction. Assuming that you want to establish that P (s) holds for all elements of this data type, what do you need to establish in terms of the constructors? We need to show that P (Water) c 1. c 2. t. s.p (s) P (MkSoup c 1 c 2 t s). 2. We are given the following functions that count the number of carrots and turnips in a soup. noturnips :: Soup carrot turnip -> Int noturnips Water = 0 noturnips (MkSoup c1 c2 t s) = 1 + noturnips s nocarrots :: Soup carrot turnip -> Int nocarrots Water = 0 nocarrots (MkSoup c1 c2 t s) = 2 + nocarrots s -- NT1 -- NT2 -- NC1 -- NC2 Establish, using soup induction, that nocarrots s = 2 * noturnips s holds for all s of type Soup carrot turnip. We go through both cases of the induction principle for soups above. Base case. Show that nocarrots Water = 2 * noturnips Water.

4 nocarrots Water = 0 -- NC1 = 2 * 0 -- arith = 2 * noturnips Water -- NT1 Step Case. Assume that nocarrots s = 2 * noturnips s -- IH for an arbitrary soup s and let c1, c2 and t be arbitrary elements of the types carrot and turnip, respectively. We need to show that nocarrots (MkSoup c1 c2 t s) = 2 * noturnips (MkSoup c1 c2 t s) Our reasoning is as follows: nocarrots (MkSoup c1 c2 t s) = 2 + nocarrots s -- NC2 = * noturnips s -- IH = 2 * (1 + noturnips s) -- arith = 2 * noturnips (MkSoup c1 c2 t s) -- NT2 Exercise 4 Tree Reversal, Again Consider the function revt given in the first exercise, along with the function mapt discussed in the lectures: mapt f Nul = Nul -- (M1) mapt f (Node t1 x t2) = Node (mapt f t1) (f x) (mapt f t2) -- (M2) Establish, using tree induction, that mapt f (revt t) = revt (mapt f t) holds for all functions f :: a -> b and all trees t of type Tree a. Fix an arbitrary function f: a -> b. Base Case. We need to show that This is easy: mapt f (revt Nul) = mapt f (Nul) -- T1 = Nul -- M1 = revt (Nul) -- T1 = revt (mapt f Nul) -- M1 mapt f (revt Nul) = revt (mapt f Nul) Step Case. Assume that, for arbitrary trees l and r of type Tree a mapt f (revt l) = revt (mapt f l) mapt f (revt r) = revt (mapt f r) -- IH1 -- IH2 holds. We show that holds, as well. We argue as follows: mapt f (revt (Node l x r)) = revt (mapt f (Node l x r) mapt f (revt (Node l x r)) = mapt f (Node (revt r) x (revt l)) -- T2 = Node (mapt f (revt r)) (f x) (mapt f (revt l)) -- M2 = Node (revt (mapt f r)) (f x) (revt (mapt f r)) -- IH1, IH2 = revt (Node (mapt f l) (f x) (mapt f r)) -- T2 = revt (mapt f (Node l x r)) -- M2

5 Exercise 5 Sorted Lists and Insertion The goal of this exercise is to show inserting an element into a sorted list using the function insert :: Int -> [Int] -> [Int] insert x [] = [x] insert x (y:ys) x < y = x:y:ys otherwise = y:(insert x ys) produces an sorted list as a result. We don t define what sorted means precisely (in logic) but use informal reasoning instead. The goal of the exercise is to demonstrate how we can use induction to reason about a subset of an inductively defined type (such as the set of all sorted lists). 1. Use a predicate sorted(l) that expresses that the list l is sorted, to express the statement Inserting an arbitrary element x into a sorted list l using the insert-function produces a sorted list. 2. Establish this property using list induction. You may assume basic properties of the predicate sorted, such as the fact that x:y:ys is sorted if y:ys is sorted, and x < y. 1. We re-formulate the property to say for all lists l and all integers x, if l is sorted, then insert x l is sorted. This gives the formula l. x.sorted(l) sorted(insert x l). 2. We now establish this property using list induction. Base Case. We show that x.sorted([]) sorted(insert x []). This follows, because insert x [] = [x] is clearly a sorted list. Step Case. Assume that and show that x.sorted(ys) sorted(insert x ys) x.sorted(y : ys) sorted(insert x y : ys). Let x be arbitrary. We need to establish an implication sorted(y : ys) sorted(insert x (y : ys)) and hence assume that y:ys is sorted, and we need to show that insert x (y:ys) is sorted. We distinguish two cases: Case 1. x < y. Then insert x (y:ys) = x:y:ys by definition of insert, and as y:ys is sorted and x < y we obtain that x:y:ys is sorted. Case 2. x >= ys. Then insert x (y:ys) = y:(insert x ys) by definition of sorted. By inductive hypothesis, we have that insert x ys is sorted, therefore y:(insert x ys) is sorted, too, as y is the smallest element of y:ys (as ys is sorted) and also y <= x. Exercise 6 Leaf Nodes and Tree Height Consider the following two functions that determine the height of a tree, and the number of its leaves, respectively: height :: Tree a -> Int height Nul = 1 -- H1 height (Node l x r) = 1 + max (height l) (height r) -- H2 leaves :: Tree a -> Int leaves Nul = 1 leaves (Node l x r) = (leaves l) + (leaves r) -- L1 -- L2

6 Show, using tree induction, that holds for all trees t of type Tree a. 1 + leaves t <= 2ˆ(height t) Clearly state what you need to prove for the base case, the inductive hypothesis, and what you need to show in the step case. Marks. 1 for base case, and 2 for step case: 0.5 for stating IH and proof goal, and 1.5 for the reasoning. Base Case. Show that 1 + leaves Nul <= 2ˆ(height Nul). 1 + leaves Nul = L1 = 2ˆ1 -- arith = 2ˆ(height Nul) -- H1 <= 2ˆ(height Nul) -- arith Step Case. Assume that for arbitrary trees l and r we have that Show that 1 + leaves l <= 2ˆ(height l) -- IHl 1 + leaves r <= 2ˆ(height r) -- IHr 1 + leaves (Node l x r) <= 2ˆ(height (Node l x r)). for an arbitrary element x of type a. This holds, and can be seen e.g. as follows: Exercise leaves (Node l x r) <= (leaves l) + (leaves r) -- L2 <= 2ˆ(height l) + 2ˆ(height r) -- IHl, IHr <= 2 * 2ˆ(max (height l) (height r)) -- arith = 2ˆ (1 + max (height l) (height r)) -- arith = 2ˆ(height (Node l x r)) -- H2 Flattening and Elem Consider the (non tail-recursive) function flatten that flattens a tree into a list: flatten :: Tree a -> [a] flatten Nul = [] flatten (Node l x r) = (flatten l) ++ [x] ++ (flatten r) -- SF1 -- SF2 together with the function elemt given by elemt :: Eq a => a -> Tree a -> Bool elemt y Nul = False -- ET1 elemt y (Node l x r) x == y = True -- ET2 otherwise = (elemt y l) (elemt y r) -- ET3 Show, using tree induction, that for all t of type Tree a and all e of type a. elmt e t = elem e (flatten t) Hint. You may want to use Exercise 5 on Tutorial Sheet 4. You may also want to use the equality proved there. It may be helpful to first establish the value of elem e [x]. Clearly state what you need to prove for the base case, the inductive hypothesis, and what you need to show in the step case. Marks. 1 for the base case, 3 for each of the cases in the step case: 1 for demonstrating the elem x [e] case, 0.5 for stating IH and proof goal, and 1.5 for the reasoning. Base Case. Show that elemt e Nul = elem e (flatten Nul).

7 elemt e Nul = False -- ET1 = elem e [] -- E1 = elem e (flatten Nul) -- SF1 Step Case. We distinguish two cases, and first consider the case where x e. We first show that elem e [x] = False. This follows, as elem e [x] = elem e (x::[]) = elem e [] -- E2 = False and [x] = x:[]. This gives the following reasoning for the case of x e: elemt e (Node l x r) = = (elemt e l) (elemt e r) = -- ET3 = (elem e (flatten l)) elem e (flatten r) = -- IH = (elem e (flatten l)) (False elem e (flatten r)) = -- O2 = (elem e (flatten l) (elem e [x]) elem e (flatten r) -- as before = (elem e (flatten l) (elem e ([x] ++ flatten r) -- Ex 5, Tut 4 = (elem e (flatten l) ++ [x] ++ (flatten r) -- Ex 5, Tut 4 = elem e (flatten (Node l x r) -- SF2 Now, for the case x = e we show that elem e [x] = True: elem e [x] = elem e (x:[]) = True -- E2 This gives the following reasoning for the case where x = e: elemt e (Node l x r) = True -- ET1 = (elem e (flatten l)) True -- O1 = (elem e (flatten l)) True (elem e (flatten r)) -- O1 = (elem e (flatten l)) (elem e [x]) (elem e (flatten r)) -- as before = (elem e (flatten l) (elem e ([x] ++ (elem e (flatten r)) -- Ex 5, Tut 4 = (elem e (flatten l) ++ [x] ++ (flatten r) -- Ex 5, Tut 4 = elem e (flatten (Node l x r)

8 Appendix: Function definitions count :: Tree a -> Int count Nul = 0 -- C1 count (Node t1 x t2) = 1 + count t1 + count t2 -- C2 map :: (a -> b) -> [a] -> [b] map f [] = [] -- M1 map f (x:xs) = f x : map f xs -- M2 (++) :: [a] -> [a] -> [a] [] ++ ys = ys -- A1 (x:xs) ++ ys = x : (xs ++ ys) -- A2 elem :: Eq a => a -> [a] -> Bool elem y [] = False -- E1 elem y (x:xs) x == y = True -- E2 otherwise = elem y xs -- E3 ( ) :: Bool -> Bool -> Bool True _ = True -- O1 False x = x -- O2