The fractal nature of iterated ln(x) [Bandwidth warning: lots of images!]

[jaydfox]

The following graphs show successive iterations of the natural logarithm of the real unit interval (0, 1).

The first graph shows the second iteration, which returns a straight line with endpoints \( +\infty + \pi i, -\infty + \pi i \).

   

The second graph shows the third iteration, which is a sort of trigonometric curve (real part is logarithm of cosecant, I think) with endpoints at \( +\infty, \infty + \pi i \).

   

The iterations after that don't have as symmetric a structure. But they sure are fascinating. Here's the fourth iteration (leaving the previous iterations in place for reference):

   

Please note that all the successive iterations after the third will snake between the previous and next iterations to reach endpoints at positive infinity. Here's the fifth and sixth iterations:

   

   

[jaydfox]

The seventh iteration is the first to wrap back up towards \( \pi i \) as an upper asymptote:

   

But the 8th is the really interesting one:

   

Zooming in now, here's the 9th iteration:

   

Zooming in further, here's the 10th iteration (in yellow):

   

I get one more attachment for this post, so here's the 11th iteration at the same zoom:

   

[jaydfox]

Skipping a few, here's the 15th iteration, zoomed in a little more:

   

And finally, here's the 18th iteration, zoomed in once more:

   

[jaydfox]

For each iteration, the point closest to the fixed point corresponds to something around 0.35 or 0.4, probably close to 1/e. However, the point that interests me is the point tangent to a logarithmic spiral that glances each iteration on the way out. This point corresponds to 0.4890195613601270345796506844621354... if you exponentiate it back out to the real interval (0, 1).

[bo198214]

Cool thing, this!
Now it becomes clear what you meant in the "continuous iteration" post at all.

[Gottfried]

Skipping a few, here's the 15th iteration, zoomed in a little more:

And finally, here's the 18th iteration, zoomed in once more:

Cool!

I'm not sure, what iteration do you actually mean? x->ln(x) ? And then, the x-coordinate is real(x) and the y-coordinate is real(ln(x))?

Gottfried

[jaydfox]

Sorry, I should have explained the images a little better. The x axis is the real part, and the y-axis is the imaginary part.

And yes, these are iterated natural logarithms: x, ln(x), ln(ln(x)), ln(ln(ln(x))), etc. I'm using the real interval (0, 1) as the 0th iteration, so the first iteration is the real interval \( (-\infty, 0) \), which isn't shown. The second iteration is then as described for the first image I showed, and so on.

Note that I only showed the primary branch. I'll get around to doing a version with several branches, but it's hard to decide how to do it, as the number of curves would grow exponentially if I used multiple branches for each iteration. Someday, if this still interests me, I'll write a version with GMP where I can create a large bitmap with various colors representing how many iterations are required to get back to reals. This should reveal a fractal which should cover most if not all of the complex plane, though the measure of the union of these curves should remain 0.

If my understanding is correct (and it probably isn't), for any complex number, there is a number arbitrarily close to it in the complex plane that can be exponentiated iteratively to recover a real number. This is similar to saying that for any real number, there is a number arbitrarily close to it which can be multiplied by an integer to recover an integer.

The measure of the rationals is 0, but they are dense. Similarly, the measure of the set of all complex numbers that can be exponentiated iteratively to recover a real number should be 0, but it should be dense over most if not all of the complex plane.

Not sure how this helps with tetration, but I have a rough idea (more like a vague hunch)...

[jaydfox]

I'm not sure, what iteration do you actually mean? x->ln(x) ? And then, the x-coordinate is real(x) and the y-coordinate is real(ln(x))?

Gottfried

If we were four-dimensional beings, I could try to create a 4-D graph of the iteration of complex x -> complex ln(x).

Alas, we are three-dimensional beings, so such a graph would be difficult to do...

[jaydfox]

In fact, now that I think about it, if you pick any complex number at random, the probability is 1 (i.e., almost certain) that if you iteratively exponentiate it, you will eventually cover the entire complex plane in a dense set of measure 0.

There is a small chance (probability of 0) that you will end up on a real number after some finite number of iterations, after which, of course, this behavior ceases. In most cases, however, a small imaginary part will grow exponentially until it reaches a value very near (k+1/2)*pi, in which case the next iteration will become a large imaginary number with small real part, and the next iteration will tend towards a root of unity. Just as likely is that the imaginary part will grow to (2k+1)*pi, in which case the next iteration will tend towards a large negative number, and the next iteration will tend to 0. If the imaginary part approaches 2k*pi, then the next iteration will have a small imaginary part, which brings us back to the beginning of this thought exercise.

These cycles are what allow us to eventually cover the entire complex plane in most cases. There are loops which repeat with a certain periodicity (every 2nd iteration, or every 3rd, or every 4th, etc.), but these will be unstable because the fixed points are repelling.

This assumes that there aren't any attracting fixed points. I haven't found any yet, but I haven't been looking for them specifically. Has anyone else found attracting fixed points?

[jaydfox]

I can't be the first to have made this observation, so I was wondering if anyone knew of any websites devoted to exploring this fascinating topic. I know it's a bit off topic, but not by too much.

In thinking about it, as we iterate a complex number, its modulus grows exponentially so long as the argument is close to 0. Eventually, the imaginary part will grow sufficiently to boost it up to unit sized or bigger.

Assume a random input. After several exponentiations, assume we have a number with a "large" real part and "small" imaginary part. For example, 123.45 + 0.00012345i. The next iterate will therefore have a "large" imaginary part and a "very large" real part. The "large" imaginary part is essentially i times a random number centered at zero but possibly several hundred (or several trillion, etc.) multiples of pi times i. Therefore, there is essentially a 50% chance that it's imaginary part is between \( (2k-{\small \frac{1}{2}})\pi \) and \( (2k+{\small \frac{1}{2}})\pi \), in which case the next iterate will have a larger modulus, and again the imaginary part is large and essentially random.

There is essentially a 50% chance that the imaginary part is in the other range, which produces complex numbers with negative real part. Regardless of the magnitude of the real and imaginary parts, the next iteration will necessarily be within a unit circle, with a high probability of being close to 0.

This behavior is fascinating! Once an iterate gets "large" (greater than 5, greater than 100, take your pick), each successive iterate has a 50% chance of continuing to get larger, or a 50% of shrinking back towards 0, where we repeat this process. Since these numbers will act randomly (assuming a random input), we should cover all complex numbers eventually, though the numbers less than 1 are far more likely to occur, and the numbers close to fixed points are also far more likely to occur.

The question is, can we graphically show how likely each point in the complex plane is to appear in such an iteration sequence? Assuming a random input gives essentially random outputs, it shouldn't matter what the input value is (except in the 0% chance that we pick a point that loops or eventually becomes real). I'm thinking that a logarithmic (or superlogarithmic) scaling of the probability would help bring out the details.

We wouldn't need a whole lot of precision in our math library, because once we get into the range of "large" numbers, if the exponentiation exceeds the precision of our library, we could just pick a random modulus with an appropriate distribution around 0, and a random argument, and start over.