(Ordinary) mathematical induction is a way to prove things about natural numbers. We can write it as a rule: φ(0) x. φ(x) φ(succ(x)) x.

Transcription

1 1 Ordinary Induction (Ordinary) mathematical induction is a way to prove things about natural numbers. We can write it as a rule: φ(0) x. φ(x) φ(succ(x)) x. φ(x) where φ(x) is a statement involving a number x. Proving φ(0) is called the base case, and proving that φ(succ(x)) follows from φ(x), for any x, is called the induction step (or case). There is a good source of examples of mathematical induction in (what are known as) primitive recursive definitions. Here is an example, we define addition by the following two equations: 0 + y = y succ(x) + y = succ(x + y) where succ(x) is the next number after x, its successor. Note that these equations completely determine addition. The first one tells you how to add 0 to something and the second one tells you how to add the successor of something to something else, provided you know how to add the something to the something else. Looking at them as recursive definitions, we say that the recursion is on the first argument. Using mathematical induction we can then prove the associativity of addition, which is this statement: x, y, z. x + (y + z) = (x + y) + z Here is the proof, which we write out in detail. We take φ(x) to be: y, z. x + (y + z) = (x + y) + z The first thing we have to do is the base case, i.e., we have to prove φ(0) which is: y, z. 0 + (y + z) = (0 + y) + z To this end we choose y and z and we have to prove: 0 + (y + z) = (0 + y) + z To show this we first work on the left-hand-side of the equation: 0 + (y + z) = (y + z) (by the definition of +) and then on the right-hand-side: (0 + y) + z = (y + z) (again, by the definition of +) and we are done with the base case as we have got to the same place. 1

2 Now we have to do the induction step. So we choose a number x, assume y, z. x + (y + z) = (x + y) + z (this is called the induction hypothesis) and we have to prove that x, y, z. succ(x) + (y + z) = (succ(x) + y) + z So we choose y and z and we now have to prove: succ(x) + (y + z) = (succ(x) + y) + z We again do this by working on both sides of the equation. Starting on the left: succ(x) + (y + z) = succ(x + (y + z)) (by the definition of +) and on the right: (succ(x) + y) + z = succ(x + y) + z (by the definition of +) = succ((x + y) + z) (again, by the definition of +) So we still have to prove: succ(x + (y + z)) = succ((x + y) + z) but that follows because we know from the induction hypothesis (instantiating the universal quantifiers) that: x + (y + z) = (x + y) + z In this example we did induction on x. We could also have tried induction on y when we would have taken φ(y) to be: x, z. x + (y + z) = (x + y) + z But that would not have worked so well. The reason is that the definition of + is on the first of its two arguments, so if we look at x + (y + z) the definition works on x, and if we look at (x + y) + z) the definition works on x + y and there it works on x. So x comes up on both sides of the equation and is therefore the natural choice of induction variable. Here is an example you can try: Commutativity x, y.x + y = y + x 2

3 This one is hard since either of x or y are equally natural as induction variables, one from looking at the left and the other from looking at the right. In fact whichever one you choose in doing the base case (and also in doing the induction step) you will need to prove something about the other which will require another induction. But it works in the end! To get more examples one can define multiplication and exponentiation by: and 0 y = 0 succ(x) y = y + (x y) y 0 = 1 y succ(x) = y (y x ) and there are lots of things for you to prove: x. x 1 = x x, y, z. x (y + z) = (x y) + (x z) x, y. (x y) = (y x) x, y, z. x (y z) = (x y) z x, y, z. (y z) x = y x z x x, y, z. y x z = (y z ) x x, y, z. y x+z = y x y z The order they are written in here is deliberate: you will find that, to prove later ones in the list, you will sometimes need earlier ones; you will also sometimes need the properties of addition, +, discussed above. The third example is the hardest; if you can t do it, just go on to the others. 2 List Induction Here we consider lists (same thing as strings) over an alphabet Σ; that is we are interested in Σ rather than the natural numbers. So what now is the right kind of induction principle to prove things about all lists? Well natural numbers are built up from 0 by continually taking successors: you get 0,1,2,3, etc. In the same way lists are built up from the empty list ɛ by adding on elements of Σ at the front. For example, take the case where Σ has just two elements a and b. Then starting from ɛ we first get a and b; then we get aa and bb and also ab and bb. The next time round we get eight things, starting at aaa and finishing at bbb. The function which adds an element of Σ to the beginning of a list is called cons and is written with a raised dot, thus: l x, so that, for example, b aa is baa. So the natural induction principle says that if however you build up your list what you want to prove remains true, then it is true for all lists. In symbols we have the following principle of list induction for Σ : φ(ɛ) l, x. φ(x) φ(l x) x. φ(x) 3

4 Once we have the empty list and consing we can define other functions by the list version of primitive recursion. For example list concatenation is called append and it is defined by: append(ɛ, y) = y append(l.x, y) = l.append(x, y) (for l in Σ) (In CS2 we wrote append(x, y) simply as xy, but here it helps to have the append function made visible. ) Then a natural thing to try to prove by list induction is again associativity, but of append this time: x, y, z. append(x, append(y, z)) = append(append(x, y), z) It turns out that this is very similar indeed to the situation with addition. It is again natural to try the induction formula: y, z. append(x, append(y, z)) = append(append(x, y), z) since both sides of the equation work on x. The base case is: y, z. append(ɛ, append(y, z)) = append(append(ɛ, y), z) and is left to you to do as an exercise (a rather small one!). For the induction step, we assume: y, z. append(x, append(y, z)) = append(append(x, y), z) and we have to prove, for any l in Σ, that: y, z. append(l x, append(y, z)) = append(append(l x, y), z) To that end we choose y and z and we now have to prove: append(l x, append(y, z)) = append(append(l x, y), z) To do this we work on both sides of the equation, just like before, but now using the definition of append: the left-hand-side reduces to: and the right-hand-side reduces to: l append(x, append(y, z)) l append(append(x, y), z) and we use the induction hypothesis and we are done. You might like to fill in the details here they are just as in the case of addition. The reverse function does as its name suggests, so that, for example: rev(abc) = bca 4

5 It can be defined by: rev(ɛ) = ɛ rev(l.x) = append(rev(x), l) (for l in Σ) where l is really a short way of writing l ɛ: it is an element of Σ thought of as a (short) list. Here are a couple of things that can be proved by list induction (exercises). 3 Tree Induction x, y. rev(append(x, y)) = append(rev(y), rev(x)) x. rev(rev(x)) = x Lists are a generalisation of numbers, as numbers can be thought of as lists over an alphabet Σ with a single element, say 1. The idea is that 0 corresponds to ɛ and succ(x) corresponds to l x, so that, for example 3 = succ(succ(succ(0))) corresponds to 111 = ɛ. One then sees that ordinary induction and primitive recursion correspond to list induction and primitive recursion for these unary lists. We now see that in just the same way trees generalise lists. Trees are also built from alphabets Σ, but the alphabets are graded, meaning that each element of the alphabet has a rank, also called an arity, given by a function rank : Σ N The elements of the alphabet Σ are called letters or function symbols. Given that, the Σ-trees are defined by saying that if t 1,..., t n are Σ-trees and a is a letter of rank n then: (tree picture missing here: it has a tip labelled by a and n branches pointing to t 1... t n ) is a Σ-tree. One can equivalently talk about Σ-terms, which are defined by saying that if t 1,..., t n are Σ-terms and a is a letter of rank n then a(t 1,..., t n ) is a Σ- term. Such terms can be alternatively defined by a context-free grammar with a nonterminal T and a production of the form: T a(t,..., T ) for each letter a of arity n, where there are n T s. (If you have done 1st-order logic you will see that these are exactly the terms of first-order logic with the given function symbols containing no variables.) Usually we know what Σ is and we just talk of trees or terms, rather than Σ-trees or Σ-terms. Here are some examples. Natural numbers Here Σ = {succ:1, zero:0} 5

6 where we have shown both the letters and their arity. Here the context-free grammar is: T succ(t ) zero() The possible numbers in this sense are zero(), succ(zero()), succ(succ(zero())), etc, evidently corresponding to 0, 1, 2 etc. Lists (of a s and b s) Here: Here the context-free grammar is: Σ = {a:1, b:1, NIL:0} T s(t ) b(t ) NIL() The possible lists in this sense are NIL, a(nil()), b(nil()), a(a(nil())), a(b(nil())), b(a(nil())), etc, corresponding to ɛ, a, b, aa, ab, ba etc. Binary Trees (with a and b at their leaves.here: Here the context-free grammar is: Σ = {P :2, a:0, b:0, } T P (T, T ) a() b() Let us consider the substitution sub a (t, u) of one binary tree u for all occurrences of a in another binary tree t. For example: sub a (P (P (b, a), a), P (b, a)) = P (P (b, P (b, a)), P (b, a)) This can be defined using a tree form of primitive recursion: sub a (P (t 1, t 2 ), u) = P (sub a (t 1, u), sub a (t 2, u)) sub a (a(), u) = u sub a (b(), u) = b() Now suppose that we want to prove the following: t, u, v. sub a (sub a (t, u), v) = sub a (t, sub a (u, v)) To do this we are going to use the principle of tree induction, also called structural induction, here for binary trees: t 1, t 2,. φ(t 1 ) φ(t 2 ) φ(p (t 1, t 2 )) φ(a()) φ(b()) t. φ(t) In this case we are going to take the induction formula φ(t) to be: u, v. sub a (sub a (t, u), v) = sub a (t, sub a (u, v)) So, we have first to prove that φ(p (t 1, t 2 )), assuming that φ(t 1 ) and φ(t 2 ). So fixing u and v we have to prove that: sub a (sub a (P (t 1, t 2 ), u), v) = sub a (P (t 1, t 2 ), sub a (u, v)) 6

7 starting on the left, we calculate: sub a (sub a (P (t 1, t 2 ), u), v) = sub a (P (sub a (t 1, u), sub a (t 2, u)), v) (by the definition of sub a ) = P (sub a (sub a (t 1, u), v), sub a (sub a (t 2, u), v)) (by the definition of sub a ) = P (sub a (t 1, sub a (u, v)), sub a (t 2, sub a (u, v))) (by induction hypothesis) and, now starting on the right, we calculate: sub a (P (t 1, t 2 ), sub a (u, v)) = P (sub a (t 1, sub a (u, v)), sub a (t 2, sub a (u, v))) (by the definition of sub a ) Next we have to prove that φ(a()). So fixing u and v we have to prove that: sub a (sub a (a(), u), v) = sub a (a(), sub a (u, v)) which is easy as both sides work out to sub a (u, v), using the definition of sub a. Finally we have to prove that φ(b()). So fixing u and v we have to prove that: sub a (sub a (b(), u), v) = sub a (b(), sub a (u, v)) which is also easy as both sides work out to b(), again using the definition of sub a. We can make use things more readable by using the notation: for sub a (t, u). Then we can write: as: t[u/a] t, u, v. sub a (sub a (t, u), v) = sub a (t, sub a (u, v)) t, u, v. t[u/a][v/a] = t[u[v/a]/a] Try rewriting the above proof using this notation: it should look a lot clearer! Here is another such law of substitution: t, u. t[u/a] = t (if a is not in t) Try proving it by tree induction; show too that the condition that a is not in t is needed, in the sense that if you remove it, then the statement becomes false. Obviously, one can also define sub b (t, u), and use the corresponding notation t[u/b]. Then, what happens if we do a substitution on, say, a, followed by a substitution on b? We get the following law: t, u, v. t[u/a][v/b] = t[v/b][u[v/b]/a] (if a is not in v) Try proving it by tree induction; show too that the condition that a is not in v is needed, in the sense that if you remove it, then the statement becomes false. Tree induction for binary trees is obviously a special case of tree induction for any graded alphabet Σ. This is as follows: to prove x.φ(x) 7

8 where x is ranging over all Σ-trees, one proves x 1,... x n. φ(x 1 )... φ(x n ) φ(a(x 1,..., x n )) for all letters a, where n is the arity of a. Check that, using the above tree representations of natural numbers and lists, ordinary induction and list induction are special cases of this general form of tree induction. Abstract syntax In his notes, Pitts uses abstract syntax. For example, LC arithmetic expressions are given by E ::= n!l E iop E where n ranges over integers and l over locations and iop over arithmetic operations. This should not be read as a context-free grammar but rather as giving a graded alphabet, viz: Σ = {n n Z} {!l l L} {iop iop Iop} See Pitts notes, pp. 4,5. All the n and!l have rank 0 and all the arithmetic operations have rank 2. One other small point: our official notation for trees, viz terms, results in many parentheses. The abstract syntax also gives notational conventions to avoid this, such as, here, using infix to write arithmetic operations (and one should add parentheses or use standard priorities to deal with any resulting ambiguities). So structural induction (= tree induction) for arithmetic expressions is as follows: n. φ(n) l. φ(!l) E 1, E 2. iop. φ(e 1 ) φ(e 2 ) φ(e 1 iop E 2 ) E. φ(e) This is exactly what Pitts has on his p. 13. Note that his leaf nodes correspond to our letters of degree 0 8