Download presentation

Presentation is loading. Please wait.

Published byCayden Held Modified about 1 year ago

1
Chapter 11 Proof by Induction

2
Induction and Recursion Two sides of the same coin. Induction usually starts with small things, and then generalizes to the large. E.g. inductive definition of a list: [] is a list; and if xs is a list, then so is x : xs. Recursion usually starts with the large thing, working its way back to the small. E.g. recursion over lists: Start with non-empty list x : xs; do something with x, then recurse on xs. It is not surprising then, that proof by induction is closely tied to recursion: it is usually needed when proving properties about recursive functions.

3
Proof by Induction on Lists To prove property P by induction on the length of a list: 1.Prove P([])-- the base case. 2.Assume P(xs) is true –- the induction hypothesis and prove that P(x:xs) is true -– the induction step

4
Example 1: A Property About foldr Recall this property about foldr: foldr (:) [] xs = xs A proof by induction: Base case: xs = [] foldr (:) [] [] [] (immediate from the definition of foldr) Induction step: assume foldr (:) [] xs = xs foldr (:) [] (x:xs) x : foldr (:) [] xs-- unfold foldr x : xs-- by the induction hypothesis

5
Example 2: A Property About length Prove that: length (xs++ys) = length xs + length ys Question: Over which list (xs or ys) should we perform the induction? Hint: look at the definitions of length and (++), which recurse over the front of their arguments – thus we should use xs above.

6
Example 2, cont’d Base case: xs = [] length ([] ++ ys) length ys 0 + length ys length [] + length ys Induction step: assume length (xs++ys) = length xs + length ys length ((x:xs) ++ ys) length (x : (xs ++ ys)) 1 + length (xs ++ ys) 1 + (length xs + length ys) (1 + length xs) + length ys length (x:xs) + length ys

7
Proving Function Equivalence Remember the mantra: “get it right first”. Later, we can improve our programs for efficiency reasons. But how do we know that the new program is the same as the old? Answer: by proving them so. And in the case of recursive functions, we will need induction.

8
Example 3: Equivalence of reverse Def’ns Recall these three definitions of reverse: reverse1 [] = [] reverse1 (x:xs) = reverse1 xs ++ [x] reverse2 xs = rev [] xs where rev acc [] = acc rev acc (x:xs) = rev (x:acc) xs reverse3 = foldl (flip (:)) [] reverse1 is the obvious, but inefficient version. reverse2 is the recursive, efficient version. reverse3 is the non-recursive, efficient version.

9
Example 3, cont’d Let’s prove that reverse1 = reverse3. Base case: xs = [] reverse1 [] []-- unfold reverse1 foldl (flip (:)) [] []-- fold foldl reverse3 []-- fold reverse3 Induction step: assume reverse1 xs = reverse3 xs reverse1 (x:xs) reverse1 xs ++ [x]-- unfold reverse1 reverse3 xs ++ [x]-- induction hypothesis foldl (flip (:)) [] xs ++ [x]-- unfold reverse3 foldl (flip (:)) [] (x:xs)-- LEMMA!!! reverse3 (x:xs)-- fold reverse3 The lemma states: foldl (flip (:)) [] xs ++ [x] = foldl (flip (:)) [] (x:xs) How do we prove this?

10
Generalizing Lemmas The lemma: foldl (flip (:)) [] xs ++ [x] = foldl (flip (:)) [] (x:xs) is actually hard to prove directly. It ‘s easier to prove this generalization: foldl (flip (:)) ys xs ++ [y] = foldl (flip (:)) (ys++[y]) xs from which the first lemma is easy to prove. Knowing when to introduce a lemma, and when to generalize it, it is a skill in proving theorems in any context. (See text for proofs of lemmas.)

11
Laws of Lists There are many useful properties of functions such as (++), map, foldl, and foldr on lists. These properties can be used as “lemmas” in proving other properties of larger programs that use these functions. Some of them depend on function “strictness”: A function f is strict if f _|_ = _|_.

12
Laws of Map map (\x->x) = \x->x map (f. g) = map f. map g map f. tail = tail. map f map f. reverse = reverse. map f map f. concat = concat. map (map f) map f (xs ++ ys) = map f xs ++ map f ys For all strict f: f. head = head. map f

13
Laws of fold If op is associative, e `op` x = x, and x `op` e = x, then for all finite xs: foldr op e xs = foldl op e xs If the following are true: x `op1` (y `op2` z) = (x `op1` y) `op2` z x `op1` e = e `op2` x then for all finite xs: foldr op1 e xs = foldl op2 e xs For all finite xs: foldr op e xs = foldl (flip op) e (reverse xs)

14
Induction on Other Data Types Proof by induction is not limited to lists. Indeed, it is usually taught on natural numbers first. Example: Exponentiation, defined by: (^) :: Integer -> Integer -> Integer x^0 = 1 x^n = x * x^(n-1) Suppose we wish to prove that, for all natural numbers m and n: x^(n+m) = x^n * x^m

15
Example 4: A Property About Exponentiation As before, we proceed by induction. Base case: n = 0 x^(0+m) x^m 1 * (x^m) x^0 * x^m Induction step: assume x^(n+m) = x^n * x^m x^((n+1)+m) x * x^(n+m) x * (x^n * x^m) (x * x^n) * x^m x^(n+1) * x^m

16
Induction Over User-Defined Data Types Recall the tree data type: data Tree a = Leaf a | Branch (Tree a) (Tree a) And define these functions on it: flatten :: Tree a -> [a] flatten (Leaf x) = [x] flatten (Branch t1 t2) = flatten t1 ++ flatten t2 sumTree :: Tree Int -> Int sumTree (Leaf x) = x sumTree (Branch t1 t2) = sumTree t1 + sumTree t2 Further, assume that: sum = foldl (+) 0 Lemma: sum (xs++ys) = sum xs + sum ys

17
Example 5: A Property About Trees Theorem: sum. flatten = sumTree Proof by induction: Base case: t = Leaf x sum (flatten (Leaf x)) sum [x]-- unfold flatten foldl (+) 0 (x:[])-- syntax, and unfold sum x + (foldl (+) 0 [])-- unfold foldl x unfold foldl x-- arithmetic sumTree (Leaf x)-- fold sumTree

18
Example 5, cont’d Induction step: assume that sum (flatten t1) = sumTree t1 sum (flatten t2) = sumTree t2 sum (flatten (Branch t1 t2)) sum (flatten t1 ++ flatten t2)-- unfold flatten sum (flatten t1) + sum (flatten t2)-- lemma sumTree t1 + sumTree t2-- induction hyp. sumTree (Branch t1 t2)-- fold sumTree

Similar presentations

© 2016 SlidePlayer.com Inc.

All rights reserved.

Ads by Google