# Yet Another Haskell Tutorial/Recursion

# Recursion and Induction[edit | edit source]

Informally, a function is recursive if its definition depends on itself. The prototypical example is factorial, whose definition is:

Here, we can see that in order to calculate , we need to calculate , but in order to calculate, we need to calculate , and so on.

Recursive function definitions always contain a number of non-recursive base cases and a number of recursive cases. In the case of factorial, we have one of each. The base case is when and the recursive case is when .

One can actually think of the natural numbers themselves as recursive
(in fact, if you ask set theorists about this, they'll say this
*is* how it is). That is, there is a zero element and then for
every element, it has a successor. That is ```
1=succ(0), 2=succ(1),
..., 573=succ(572), ...
```

and so on forever. We can actually
implement this system of natural numbers in Haskell:

data Nat = Zero | Succ Nat

This is a recursive type definition. Here, we represent one as
`Succ Zero`

and three as `Succ (Succ (Succ Zero))`

. One thing
we might want to do is be able to convert back and forth beween
`Nat`

s and `Int`

s. Clearly, we can write a base case as:

natToInt Zero = 0

In order to write the recursive case, we realize that we're going to
have something of the form `Succ n`

. We can make the assumption
that we'll be able to take `n`

and produce an `Int`

. Assuming
we can do this, all we need to do is add one to this result. This
gives rise to our recursive case:

natToInt (Succ n) = natToInt n + 1

There is a close connection between recursion and mathematical induction. Induction is a proof technique which typically breaks problems down into base cases and "inductive" cases, very analogous to our analysis of recursion.

Let's say we want to prove the statement for all . First we formulate a base case: namely, we wish to prove the statement when . When , by definition. Since , we get that as desired.

Now, suppose that . Then for some value . We now
invoke the *inductive hypothesis* and claim that the statement
holds for . That is, we assume that . Now, we use
to formate the statement for our value of . That is, if and only iff . We now apply the definition
of factorial and get . Now, we know ,
so if and only if . But we know
that , which means . Thus it is proven.

It may seem a bit counter-intuitive that we are assuming that the claim is true for in our proof that it is true for . You can think of it like this: we've proved the statement for the case when . Now, we know it's true for so using this we use our inductive argument to show that it's true for . Now, we know that it is true for so we reuse our inductive argument to show that it's true for . We can continue this argument as long as we want and then see that it's true for all .

It's much like pushing down dominoes. You know that when you push down the first domino, it's going to knock over the second one. This, in turn will knock over the third, and so on. The base case is like pushing down the first domino, and the inductive case is like showing that pushing down domino will cause the st domino to fall.

In fact, we can use induction to prove that our `natToInt`

function
does the right thing. First we prove the base case: does ```
natToInt
Zero
```

evaluate to ? Yes, obviously it does. Now, we can assume
that `natToInt n`

evaluates to the correct value (this is the
inductive hypothesis) and ask whether `natToInt (Succ n)`

produces
the correct value. Again, it is obvious that it does, by simply
looking at the definition.

Let's consider a more complex example: addition of `Nat`

s. We can
write this concisely as:

addNat Zero m = m addNat (Succ n) m = addNat n (Succ m)

Now, let's prove that this does the correct thing. First, as the base
case, suppose the first argument is `Zero`

. We know that
regardless of what is; thus in the base case the algorithm does
the correct thing. Now, suppose that `addNat n m`

does the correct
thing for all `m`

and we want to show that `addNat (Succ n) m`

does the correct thing. We know that and thus
since `addNat n (Succ m)`

does the correct thing (by the inductive
hypothesis), our program is correct.