Recursion

Recursion, in mathematics and computer science, is a method of defining functions in which the function being defined is applied within its own definition. The term is also used more generally to describe a process of repeating objects in a self-similar way. For instance, when the surfaces of two mirrors are almost parallel with each other the nested images that occur are a form of recursion.

Formal definitions of recursion
In mathematics and computer science, recursion specifies (or constructs) a class of objects or methods (or an object from a certain class) by defining a few very simple base cases or methods (often just one), and then defining rules to break down complex cases into simpler cases.

For example, the following is a recursive definition of person's ancestors:
 * One's parents are one's ancestors (base case);
 * The parents of any ancestor are also ancestors of the person under consideration (recursion  step).

It is convenient to think that a recursive definition defines objects in terms of "previously defined" objects of the class to define.

Definitions such as these are often found in mathematics. For example, the formal definition of natural numbers in set theory is: 0 is a natural number, and each natural number has a successor, which is also a natural number.

Recursion in language
See: Recursive language

The use of recursion in linguistics, and the use of recursion in general, dates back to the ancient Indian linguist in the 5th century BC, who made use of recursion in his grammar rules of Sanskrit.

Linguist Noam Chomsky theorizes that unlimited extension of a language such as English is possible only by the recursive device of embedding sentences in sentences. Thus, a chatty little girl may say, "Dorothy, who met the wicked Witch of the West in Munchkin Land where her wicked Witch sister was killed, liquidated her with a pail of water." Clearly, two simple sentences &mdash; "Dorothy met the Wicked Witch of the West in Munchkin Land" and "Her sister was killed in Munchkin Land" &mdash; can be embedded in a third sentence, "Dorothy liquidated her with a pail of water," to obtain a very verbose sentence.

Here is another, perhaps simpler way to understand recursive processes:


 * 1) Are we done yet? If so, return the results. Without such a termination condition a recursion would go on forever.
 * 2) If not, simplify the problem, solve the simpler problem(s), and assemble the results into a solution for the original problem. Then return that solution.

A more humorous illustration goes: "In order to understand recursion, one must first understand recursion." Or perhaps more accurate is the following, from Andrew Plotkin: "If you already know what recursion is, just remember the answer. Otherwise, find someone who is standing closer to Douglas Hofstadter than you are; then ask him or her what recursion is."

Examples of mathematical objects often defined recursively are functions, sets, and especially fractals.

The idea that recursion is necessary for the unlimited extension of a language is challenged by linguist Daniel Everett in his work Cultural Constraints on Grammar and Cognition in Pirahã: Another Look at the Design Features of Human Language in which he hypothesizes that cultural factors made recursion unnecessary in the development of the Pirahã language. This concept challenges Chomsky's idea and accepted linguistic doctrine that recursion is the only trait which differentiates human and animal communication and is currently under intense debate.

Recursion in plain English
Recursion is the process a procedure goes through when one of the steps of the procedure involves rerunning the entire same procedure. A procedure that goes through recursion is said to be recursive. Something is also said to be recursive when it is the result of a recursive procedure.

To understand recursion, one must recognize the distinction between a procedure and the running of a procedure. A procedure is a set of steps that are to be taken based on a set of rules. The running of a procedure involves actually following the rules and performing the steps. An analogy might be that a procedure is like a menu in that it is the possible steps, while running a procedure is actually choosing the courses for the meal from the menu.

A procedure is recursive if one of the steps that makes up the procedure calls for a new running of the procedure. Therefore a recursive four course meal would be a meal in which one of the choices of appetizer, salad, entrée, or dessert was an entire meal unto itself. So a recursive meal might be potato skins, baby greens salad, chicken parmesan, and for dessert, a four course meal, consisting of crab cakes, Caesar salad, for an entrée, a four course meal, and chocolate cake for dessert, so on until each of the meals within the meals is completed.

A recursive procedure must complete every one of its steps. Even if a new running is called in one of its steps, each running must run through the remaining steps. What this means is that even if the salad is an entire four course meal unto itself, you still have to eat your entrée and dessert.

Recursive humor
A common geeky joke (for example ) is the following "definition" of recursion.


 * Recursion
 * See "Recursion".

Another example occurs in Kernighan and Ritchie's "The C Programming Language." The following index entry is found on page 269:


 * recursion   86, 139, 141, 182, 202, 269

This is a parody on references in dictionaries, which in some careless cases may lead to circular definitions. Jokes often have an element of wisdom, and also an element of misunderstanding. This one is also the second-shortest possible example of an erroneous recursive definition of an object, the error being the absence of the termination condition (or lack of the initial state, if looked at from an opposite point of view). Newcomers to recursion are often bewildered by its apparent circularity, until they learn to appreciate that a termination condition is key. A variation is:


 * Recursion
 * If you still don't get it, See: "Recursion".

Other examples are recursive acronyms, such as GNU, PHP or TTP (Dilbert; "The TTP Project").

Recursively defined sets
The canonical example of a recursively defined set is given by the natural numbers:
 * Example: the natural numbers


 * 1 is in N
 * if n is in N, then n + 1 is in N
 * The set of natural numbers is the smallest set satisfying the previous two properties.

Another interesting example is the set of all true "reachable" propositions in an axiomatic system.
 * Example: The set of true reachable propositions


 * if a proposition is an axiom, it is a true reachable proposition.
 * if a proposition can be obtained from true reachable propositions by means of inference rules, it is a true reachable proposition.
 * The set of true reachable propositions is the smallest set of reachable propositions satisfying these conditions.

This set is called 'true reachable propositions' because: in non-constructive approaches to the foundations of mathematics, the set of true propositions is larger than the set recursively constructed from the axioms and rules of inference. See also Gödel's incompleteness theorems.

(Note that determining whether a certain object is in a recursively defined set is not an algorithmic task.)

Functional recursion
A function may be partly defined in terms of itself. A familiar example is the Fibonacci number sequence: F(n) = F(n &minus; 1) + F(n &minus; 2). For such a definition to be useful, it must lead to values which are non-recursively defined, in this case F(0) = 0 and F(1) = 1.

A famous recursive function is the Ackermann function which, unlike the Fibonacci sequence, is rather difficult to express without recursion.

Recursive proofs
The standard way to define new systems of mathematics or logic is to define objects (such as "true" and "false", or "all natural numbers"), then define operations on these. These are the base cases. After this, all valid computations in the system are defined with rules for assembling these. In this way, if the base cases and rules are all proven to be calculable, then any formula in the mathematical system will also be calculable.

This sounds unexciting, but this type of proof is the normal way to prove that a calculation is impossible. This can often save a lot of time. For example, this type of proof was used to prove that the area of a circle is not a simple ratio of its diameter, and that no angle can be trisected with compass and straightedge -- both puzzles that fascinated the ancients.

Recursion in computer science
A common method of simplification is to divide a problem into subproblems of the same type. As a computer programming technique, this is called divide and conquer and is key to the design of many important algorithms, as well as being a fundamental part of dynamic programming.

Recursion in computer programming is exemplified when a function is defined in terms of itself. One example application of recursion is in parsers for programming languages. The great advantage of recursion is that an infinite set of possible sentences, designs or other data can be defined, parsed or produced by a finite computer program.

Recurrence relations are equations to define one or more sequences recursively. Some specific kinds of recurrence relation can be "solved" to obtain a non-recursive definition.

A classic example of recursion is the definition of the factorial function, given here in C code:

unsigned int factorial(unsigned int n) { if (n <= 1) return 1; return n * factorial(n-1); }

The function calls itself recursively on a smaller version of the input (n - 1) and multiplies the result of the recursive call by n, until reaching the base case, analogously to the mathematical definition of factorial.

Use of recursion in an algorithm has both advantages and disadvantages. The main advantage is usually simplicity. The main disadvantage is often that the algorithm may require large amounts of memory if the depth of the recursion is very large. It has been claimed that recursive algorithms are easier to understand because they do not contain the clutter (e.g., extra variables) associated with looping algorithms. There is no experimental evidence for this claim.

It is often possible to replace a recursive call with a simple loop, as the following example of factorial shows:

unsigned int factorial(unsigned int n) { unsigned int result = 1; if (n <= 1) return 1; while (n--) result *= n;    return result; }

An example of recursive algorithm is procedure that processes (does something with) all the nodes of a tree data structure:

void ProcessTree(node x) { unsigned int i = 0; while (i < x.count) { ProcessTree(x.children[i]); i++; }    ProcessNode(x);    // now perform the operation with the node itself }

To process the whole tree, procedure is called with root node representing the tree as an initial parameter. The procedure calls itself recursively on all child nodes of the given node (i.e. sub-trees of the given tree), until reaching the base case that is node with no child nodes (i.e. tree having no branches usually called "leaf").

Tree data structure itself can be defined recursively (and so predestinated for recursive processing) like this:

typedef struct { unsigned int count; node* children; } node

The recursion theorem
In set theory, this is a theorem guaranteeing that recursively defined functions exist. Given a set $$X$$, an element $$a$$ of $$X$$ and a function $$f: X \rightarrow X$$, the theorem states that there is a unique function $$F: N \rightarrow X$$ (where $$N$$ denotes the set of natural numbers) such that
 * $$F(0) = a$$
 * $$F(n + 1) = f(F(n))$$

for any natural number $$n$$.

Proof of uniqueness
Take two functions $$f$$ and $$g$$ of domain $$N$$ and codomain $$A$$ such that:


 * $$f(0) = a$$
 * $$g(0) = a$$
 * $$f(n + 1) = F(f(n))$$
 * $$g(n + 1) = F(g(n))$$

where $$a$$ is an element of $$A$$. We want to prove that $$f = g$$. Two functions are equal if they:


 * i. have equal domains/codomains;
 * ii. have the same graphic.


 * i. Done!
 * ii. Mathematical induction: for all $$n$$ in $$N$$, $$f(n) = g(n)$$? (We shall call this condition, say, $$Eq(n))$$:
 * 1.$$Eq(0)$$ if and only if $$f(0) = g(0)$$ if and only if $$a = a$$. Done!
 * 2.Let $$n$$ be an element of $$N$$. Assuming that $$Eq(n)$$ holds, we want to show that $$Eq(n + 1)$$ holds as well, which is easy because: $$f(n + 1) = F(f(n)) = F(g(n)) = g(n + 1)$$. Done!

you should consider N union {0} as a domain of F.

Proof of existence

 * See Hungerford, "Algebra", first chapter on set theory.

Some common recurrence relations are:


 * Factorial -- $$n! = n (n - 1)! = n (n - 1)\cdots 1$$
 * Fibonacci numbers -- $$f(n) = f(n - 1) + f(n - 2)$$
 * Catalan numbers -- $$C_0=1$$, $$C_{n+1} = (4n+2)C_n/(n+2)$$


 * Computing compound interest
 * The tower of Hanoi
 * Ackermann function
 * Population growth rate