In chaos theory, one often defines sequences of real or complex numbers iteratively: For example,

defines a sequence of complex numbers z_{0}, z_{1}, z_{2}, … The famous Mandelbrot set corresponds to the set of complex numbers c for which this sequence is bounded.

This raises an obvious question: can we make sense of terms like z_{1/2}, i.e., is there a natural and perhaps unique way to iterate a function a *non-integer* number of times? At age 16, I developed a method to do this, for a large class of functions f that are to be iterated. For this work, I was awarded a second prize in 1995 at the German youth science competition “Jugend forscht” (more here).

By Fedi for de.wikipedia.org, licensed under CC BY-SA 3.0. No changes have been made to this image.

As an entertaining example, consider the *Verhulst* growth model

Depending on the constant a>0, different behaviors of this iterated sequence can be demonstrated. Let us begin with the somewhat “boring” case of **a=0.05**. The plot on the left (x-axis: n, y-axis: m_{n}) shows the monotonous behavior of the resulting sequence of real numbers.

How, then, should we think of the values “in between” these points? Many ideas for coming up with a natural interpolation method are either arbitrary or based on analogies with, say, the extension of the definition of a^{b} to non-integer b which turn out not to be applicable in this case.

However, there is a way to do it, resting on two observation. The first observation is that there is a unique natural way to extend the definition of the sequence to *negative integer n*, which can be done by “iterating backwards”:

This allows us to determine m_{-1}, m_{-2}, and so on.

The second observation is that m_{n} behaves very regularly as n tends to minus infinity: the fraction m_{n}/m_{n-1} is almost constant on large intervals of n. Consequently,

If this is true for integer c, it should also be true for *non-integer* c, and this allows us to approximate, for example, the values of m_{n+1/2} for negative integer n, expecting that this approximation gets better in some sense as n tends to minus infinity. But once we have the approximate value of, say, m_{-100.5}, we can iterate our way forward to m_{-99.5}, m_{-98.5} and so on, assuming that the defining iteration law above is still valid, and arrive at m_{0.5}. We can then define this value as what we obtain from this process in the limit of n tending to minus infinity.

What we get looks like a very natural interpolation indeed, and it is guaranteed to satisfy the recursion law above, see Plot 2. Values for integer arguments are shown as the red dots.

Note that we have not formally proven that this limit procedure converges. It would be nice to demonstrate this, and to show that the resulting function is smooth (or analytic – this prescription admits also *complex* numbers of iterations).

It should also be possible to show that this interpolation is the *unique* function that satisfies the recursion law *and* that behaves regularly in some particular sense at minus infinity (say, its logarithm is approximately linear, or concave, at small enough arguments). This might be similar to the well-known uniqueness statements on the interpolation of the factorial by the Gamma function.

The results of this method become much more interesting for larger values of a. Chaotic behavior is known to occur at integer values of iterations, but what does it look like at non-integer arguments? The plots below show that the behavior is quite interesting and surprising indeed.

## Higher-order operations: pentation and hexation at non-integer arguments

The idea of higher-order operations is described in this Wikipedia article (see also the references therein) – however, standard treatments overlook the fact that the number of different operations doubles at each level, as we will see. First, note that multiplication can be understood as repeated addition, and exponentiation is repeated multiplication:

This suggests that we continue the construction, and define a new operation in terms of “power towers” that has been termed **tetration**. There are, however, two natural options for how to do this:

Typically, the first option is used as the definition, and the second option is dismissed, because But in my opinion, this is a mistake: after all, if we go to even higher-order operation (pentation, hexation, …), the number of operation will double, but *both* options will be non-trivial. Therefore, there are four different **pentation** operations They are characterized by four different recursion relations

One of the questions that arise naturally is how the case of non-integer b can be treated. In the case of exponentiation, the idea of “repeated multiplication” will not tell you what a^{1/2} is, *but* there are laws like a^m a^n = a^(m+n) which immediately allow you to find the unique definition that makes sense. However, for tetration and higher-order operations, no such laws are available.

In my “Jugend forscht” work, I have applied the idea of above (see the Verhulst process interpolation) to this question. It turns out that this idea, unfortunately, does not work for (the non-trivial version of) tetration. However, it seems to work, for example, for the **binary pentation function**

This function is characterized by the recursion relation

This very old PDF document describes how it can be done, and gives several further observations. An evaluation of non-integer exponents is also possible for the **binary hexation function**

The results are shown in the graphs below. Apologies for the bad graph quality from old teenage days. The only remarkable aspect of the plots is that they look smooth; other than that, they just depict functions that grow extremely quickly beyond x=2.