1. Recursive Definitions and Structural Induction
CS/APMA 202
Rosen section 3.4
Aaron Bloomfield

2. Recursion
Recursion means defining something, such as a function, in terms of itself
For example, let f(x) = x!
We can define f(x) as f(x) = x * f(x-1)

3. Recursion example Rosen, section 3.4, question 1
Find f(1), f(2), f(3), and f(4), where f(0) = 1
Let f(n+1) = f(n) + 2
f(1) = f(0) + 2 = = 3
f(2) = f(1) + 2 = = 5
f(3) = f(2) + 2 = = 7
f(4) = f(3) + 2 = = 9
Let f(n+1) = 3f(n)
f(1) = 3 * f(0) = 3*1 = 3
f(2) = 3 * f(1) = 3*3 = 9
f(3) = 3 * f(2) = 3*9 = 27
f(4) = 3 * f(3) = 3*27 = 81

4. Recursion example Rosen, section 3.4, question 1
Find f(1), f(2), f(3), and f(4), where f(0) = 1
Let f(n+1) = 2f(n)
f(1) = 2f(0) = 21 = 2
f(2) = 2f(1) = 22 = 4
f(3) = 2f(2) = 24 = 16
f(4) = 2f(3) = 216 = 65536
Let f(n+1) = f(n)2 + f(n) + 1
f(1) = f(0)2 + f(0) + 1 = = 3
f(2) = f(1)2 + f(0) + 1 = = 13
f(3) = f(2)2 + f(0) + 1 = = 183
f(4) = f(3)2 + f(0) + 1 = = 33673

5. Fractals A fractal is a pattern that uses recursion
The pattern itself repeats indefinitely

6. Fractals

7. Fibonacci sequence Definition of the Fibonacci sequence
Non-recursive:
Recursive: F(n) = F(n-1) + F(n-2)
or: F(n+1) = F(n) + F(n-1)
Must always specify base case(s)!
F(1) = 1, F(2) = 1
Note that some will use F(0) = 1, F(1) = 1

8. Fibonacci sequence in Java
long Fibonacci (int n) {
if ( (n == 1) || (n == 2) )
return 1;
else
return Fibonacci (n-1) + Fibonacci (n-2); }
long Fibonacci2 (int n) {
return (long) ((Math.pow((1.0+Math.sqrt(5.0)),n)-
Math.pow((1.0-Math.sqrt(5.0)),n)) /
(Math.sqrt(5) * Math.pow(2,n)));

9. Recursion definition From “The Hacker’s Dictionary”:
recursion n. See recursion. See also tail recursion.

10. Bad recursive definitions
Consider:
f(0) = 1
f(n) = 1 + f(n-2)
What is f(1)?
f(n) = 1+f(-n)

11. Defining sets via recursion
Same two parts:
Base case (or basis step)
Recursive step
Example: the set of positive integers
Basis step: 1  S
Recursive step: if x  S, then x+1  S

12. Defining sets via recursion
Rosen, section 3.4, question 24: give recursive definitions for:
The set of odd positive integers
1  S
If x  S, then x+2  S
The set of positive integer powers of 3
3  S
If x  S, then 3*x  S
The set of polynomials with integer coefficients
0  S
If p(x)  S, then p(x) + cxn  S
c  Z, n  Z and n ≥ 0

13. Defining strings via recursion
Terminology
 is the empty string: “”
 is the set of all letters: { a, b, c, …, z }
The set of letters can change depending on the problem
We can define a set of strings * as follows
Base step:   *
If w  * and x  , then wx  *
Thus, * s the set of all the possible strings that can be generated with the alphabet
Is this countably infinite or uncountably infinite?

14. Defining strings via recursion
Let  = { 0, 1 }
Thus, * is the set of all binary numbers
Or all binary strings
Or all possible computer files

15. String length via recursion
How to define string length recursively?
Basis step: l() = 0
Recursive step: l(wx) = l(w) + 1 if w  * and x  
Example: l(“aaa”)
l(“aaa”) = l(“aa”) + 1
l(“aa”) = l(“a”) + 1
l(“a”) = l(“”) + 1
l(“”) = 0
Result: 3

16. Today’s demotivators

17. Strings via recursion example
Rosen, section 3.4, question 38: Give a recursive definition for the set of string that are palindromes
We will define set P, which is the set of all palindromes
Basis step:   P
Second basis step: x  P when x  
Recursive step: xpx  P if x   and p  P

18. Strings and induction example
This requires structural induction, which will be covered later in this slide set

19. Recursion pros
Easy to program
Easy to understand

20. Recursion cons Consider the recursive Fibonacci generator
How many recursive calls does it make?
F(1): 1
F(2): 1
F(3): 3
F(4): 5
F(5): 9
F(10): 109
F(20): 13,529
F(30): 1,664,079
F(40): 204,668,309
F(50): 25,172,538,049
F(100): 708,449,696,358,523,830,149  7 * 1020
At 1 billion recursive calls per second (generous), this would take over 22,000 years
But that would also take well over 1012 Gb of memory!

21. Trees Rooted trees: A graph containing nodes and edges
Cannot contain a cycle!
Cycle not allowed in a tree

22. Rooted trees Recursive definition:
Basis step: A single vertex r is a rooted tree
Recursive step:
Let T1, T2, …, Tn be rooted trees
Form a new tree with a new root r that contains an edge to the root of each of the trees T1, T2, …, Tn

23. (Extended) Binary trees
Recursive definition
Basis step: The empty set is an extended binary tree
Recursive step:
Let T1, and T2 be extended binary trees
Form a new tree with a new root r
Form a new tree such that T1 is the left subtree, and T2 is the right subtree

24. Full binary trees
Recursive definition
Basis step: A full binary tree consisting only of the vertex r
Recursive step:
Let T1, and T2 be extended binary trees
Form a new tree with a new root r
Form a new tree T such that T1 is the left subtree, and T2 is the right subtree
This is denoted by T = T1∙T2
Note the only difference between a regular binary tree and a full one is the basis step

25. Binary tree height h(T) denotes the height of tree T
Recursive definition:
Basis step: The height of a tree with only one node r is 0
Recursive step:
Let T1 and T2 be binary trees
The binary tree T = T1∙T2 has height h(T) = 1 + max ( h(T1), h(T2) )
This definition can be generalized to non-binary trees

26. Binary tree size n(T) denotes the number of vertices in tree T
Recursive definition:
Basis step: The number of vertices of an empty tree is 0
Basis step: The number of vertices of a tree with only one node r is 1
Recursive step:
Let T1 and T2 be binary trees
The number of vertices in binary tree T = T1∙T2 is: n(T) = 1 + n(T1) + n(T2)
This definition can be generalized to non- binary trees

27. A bit of humor: Computer terminology

28. Recursion vs. induction
Consider the recursive definition for factorial:
f(0) = 1
f(n) = n * f(n-1)
Sort of like induction
Base case
The “step”

29. Recursion vs. induction
Rosen, section 3.4, example 7 (page 262)
Consider the set of all integers that are multiples of 3
{ 3, 6, 9, 12, 15, … }
{ x | x = 3k and k  Z+ }
Recursive definition:
Basis step: 3  S
Recursive step: If x  S and y  S, then x+y  S

30. Recursion vs. induction
Proof via induction: prove that S contains all the integers that are divisible by 3
Let A be the set of all ints divisible by 3
Show that S = A
Two parts:
Show that S  A
Let P(n) = 3n  S
Base case: P(1) = 3*1  S
By the basis step of the recursive definition
Inductive hypothesis: assume P(k) = 3*k  S is true
Inductive step: show that P(k+1) = 3*(k+1) is true
3*(k+1) = 3k+3
3k  S by the inductive hypothesis
3  S by the base case
Thus, 3k+3  S by the recursive definition
Show that A  S
Done in the text, page 267 (not reproduced here)

31. What did we just do? Notice what we did:
Showed the base case
Assumed the inductive hypothesis
For the inductive step, we:
Showed that each of the “parts” were in S
The parts being 3k and 3
Showed that since both parts were in S, by the recursive definition, the combination of those parts is in S
i.e., 3k+3  S
This is called structural induction

32. Structural induction
A more convenient form of induction for recursively defined “things“
Used in conjunction with the recursive definition
Three parts:
Basis step: Show the result holds for the elements in the basis step of the recursive definition
Inductive hypothesis: Assume that the statement is true for some existing elements
Usually, this just means assuming the statement is true
Recursive step: Show that the recursive definition allows the creation of a new element using the existing elements

33. End of lecture on 24 March 2005
Although I want to start two slides back

34. Tree structural induction example
Rosen, section 3.4, question 43
Show that n(T) ≥ 2h(T) + 1
Basis step: Let T be the full binary tree of just one node r
h(T) = 0
n(T) = 1
n(T) ≥ 2h(T) + 1
1 ≥ 2*0 + 1
1 ≥ 1

35. Tree structural induction example
Show that n(T) ≥ 2h(T) + 1
Inductive hypothesis:
Let T1 and T2 be full binary trees
Assume that n(T1) ≥ 2h(T1) + 1 for some tree T1
Assume that n(T2) ≥ 2h(T2) + 1 for some tree T2
Recursive step:
Let T = T1 ∙ T2
Here the ∙ operator means creating a new tree with a root note r and subtrees T1 and T2
New element is T
By the definition of height and size, we know:
n(T) = 1 + n(T1) + n(T2)
h(T) = 1 + max ( h(T1), h(T2) )
Therefore:
≥ 1 + 2h(T1) h(T2) + 1
≥ 1 + 2*max ( h(T1), h(T2) ) the sum of two non-neg #’s is at least
as large as the larger of the two
= 1 + 2*h(T)
Thus, n(T) ≥ 2h(T) + 1

36. String structural induction example
Rosen, section 3.4, question 32
Part (a): Give the definition for ones(s), which counts the number of ones in a bit string s
Let  = { 0, 1 }
Basis step: ones() = 0
Recursive step: ones(wx) = ones(w) + x
Where x   and w  *
Note that x is a bit: either 0 or 1

37. String structural induction example
Part (b): Use structural induction to prove that ones(st) = ones(s) + ones(t)
Basis step: t = 
ones (s∙) = ones(s) = ones(s)+0 = ones(s) + ones()
Inductive hypothesis: Assume ones(s∙t) = ones(s) + ones(t)
Recursive step: Want to show that ones(s∙t∙x) = ones(s) + ones(t∙x)
Where s, t  * and x  
New element is ones(s∙t∙x)
ones (s∙t∙x) = ones ((s∙t)∙x)) by associativity of concatenation
= x+ones(s∙t) by recursive definition
= x + ones(s) + ones(t) by inductive hypothesis
= ones(s) + (x + ones(t)) by commutativity and assoc. of +
= ones(s) + ones(t∙x) by recursive definition
Proven!

38. Quick survey I feel I understand structural induction… Very well
With some review, I’ll be good
Not really
Not at all

39. Human stupidity

40. Induction methods compared
Weak mathematical
Strong
Mathematical
Structural
Used for
Usually formulae
Usually formulae not provable via mathematical induction
Only things defined via recursion
Assumption
Assume P(k)
Assume P(1), P(2), …, P(k)
Assume statement is true for some "old" elements
What to prove
True for P(k+1)
Statement is true for some "new" elements created with "old" elements
Step 1 called
Base case
Basis step
Step 3 called
Inductive step
Recursive step

41. Induction types compared
Show that F(n) < 2n
Where F(n) is the nth Fibonacci number
Actually F(n) < 20.7*n, but we won’t prove that here
Fibonacci definition:
Basis step: F(1) = 1 and F(2) = 1
Recursive step: F(n) = F(n-1) + F(n-2)
Base case (or basis step): Show true for F(1) and F(2)
F(1) = 1 < 21 = 2
F(2) = 1 < 22 = 4

42. Via weak mathematical induction
Inductive hypothesis: Assume F(k) < 2k
Inductive step: Prove F(k+1) < 2k+1
F(k+1) = F(k) + F(k-1)
We know F(k) < 2k by the inductive hypothesis
Each term is less than the next, therefore F(k) > F(k-1)
Thus, F(k-1) < F(k) < 2k
Therefore, F(k+1) = F(k) + F(k-1) < 2k + 2k = 2k+1
Proven!

43. Via strong mathematical induction
Inductive hypothesis: Assume F(1) < 21, F(2) < 22, …, F(k-1) < 2k-1, F(k) < 2k
Inductive step: Prove F(k+1) < 2k+1
F(k+1) = F(k) + F(k-1)
We know F(k) < 2k by the inductive hypothesis
We know F(k-1) < 2k-1 by the inductive hypothesis
Therefore, F(k) + F(k-1) < 2k + 2k-1 < 2k+1
Proven!

44. Via structural induction
Inductive hypothesis: Assume F(n) < 2n
Recursive step:
Show true for “new element”: F(n+1)
We know F(n) < 2n by the inductive hypothesis
Each term is less than the next, therefore F(n) > F(n-1)
Thus, F(n-1) < F(n) < 2n
Therefore, F(n) + F(n-1) < 2n + 2n = 2n+1
Proven!

45. Another way via structural induction
Inductive hypothesis: Assume F(n) < 2n and F(n-1) < 2n-1
The difference here is we are using two “old” elements versus one, as in the last slide
Recursive step:
Show true for “new element”: F(n+1)
F(n+1) = F(n) + F(n-1)
We know F(n) < 2n by the inductive hypothesis
We know F(n-1) < 2n-1 by the inductive hypothesis
Therefore, F(n) + F(n-1) < 2k + 2k-1 < 2k+1
Proven!

46. But wait!
In this example, the structural induction proof was essentially the same as the weak or strong mathematical induction proof
It’s hard to find an example that works well for all of the induction types
Structural induction will work on some recursive problems which weak or strong mathematical induction will not
Trees, strings, etc.

47. A bit of humor…

48. Section 3.4, question 8
Give the recursive definition of the following sequences
Note that many answers are possible!
an = 4n – 2
Terms: 2, 6, 10, 14, 16, etc.
a1 = 2
an = an-1 + 4
an = 1 + (-1)n
Terms: 0, 2, 0, 2, 0, 2, etc.
a1 = 0, a2 = 2
an = an-2
an = n(n+1)
Terms: 2, 6, 12, 20, 30, 42, etc.
an = an-1 + 2*n
an = n2
Terms: 1, 4, 9, 16, 25, 36, 49, etc.
a1 = 1
an = an-1 + 2n - 1

49. Section 3.4, question 12 Show that f12 + f22 + f32 + … + fn2 = fnfn+1
Base case: n = 1
f12 = f1f2
12 = 1*1
Inductive hypothesis: Assume
f12 + f22 + f32 + … + fk2 = fkfk+1
Inductive step: Prove
f12 + f22 + f32 + … + fk2 + fk+12 = fk+1fk+2

50. Section 3.4, question 12 Inductive hypothesis: Assume
f12 + f22 + f32 + … + fk2 = fkfk+1
Inductive step: Prove
f12 + f22 + f32 + … + fk2 + fk+12 = fk+1fk+2
fkfk+1 + fk+12 = fk+1fk+2
fkfk+1 + fk+12 = fk+1 (fk + fk+1)
fkfk+1 + fk+12 = fkfk+1 + fk+12

51. Section 3.4, question 13 Show that f1 + f2 + f3 + … + f2n-1 = f2n
Base case: n = 1
f1 = f2*1
1 = 1
Inductive hypothesis: Assume
f1 + f2 + f3 + … + f2k-1 = f2k
Inductive step: Prove
f1 + f2 + f3 + … + f2k-1 + f2(k+1)-1 = f2(k+1)
f1 + f2 + f3 + … + f2k-1 + f2k+1 = f2k+2

52. Section 3.4, question 13 Inductive hypothesis: Assume
f1 + f2 + f3 + … + f2k-1 = f2k
Inductive step: Prove
f1 + f2 + f3 + … + f2k-1 + f2k+1 = f2k+2
f2k + f2k+1 = f2k+2
True by definition of f2k+2

53. Section 3.4, question 22 Show that the set S defined by
Basis step: 1  S
Recursive step: s + t  S when s  S and t  S
is the set of positive integers:
Z+ = { 1, 2, 3, … }
Note the (somewhat recursive) definition of the positive integers:
1 is a positive integer
For any arbitrary n that is a positive integer, n+1 is also a positive integer
Proof by structural induction
Basis step: 1  S and 1  Z+
Inductive hypothesis: Assume k  S
Recursive step: Show k+1  S
k  S by the inductive hypothesis
1  S by the base case
k+1  S by the recursive step of the recursive definition above

54. Section 3.4, question 35
Give a recursive definition of the reversal of a string
Basis step: R = 
Note that the superscripted R means reversal of a string
Recursive step: Consider a string w  *
Rewrite w as vy where v  * and y  
v is the first n-1 characters in w
y is the last character in w
wR = y(vR)
Parentheses are for our benefit

55. Quick survey I felt I understood the material in this slide set…
Very well
With some review, I’ll be good
Not really
Not at all

56. Quick survey The pace of the lecture for this slide set was… Fast
About right
A little slow
Too slow

57. Quick survey
How interesting was the material in this slide set? Be honest!
Wow! That was SOOOOOO cool!
Somewhat interesting
Rather borting
Zzzzzzzzzzz

58. Today’s demotivators