Continuous iterations of fractals

I made some pictures od contuinuous iterations of the map
z -> z^2 + c at:

http://www.xs4all.nl/~westy31/ContFract/Continuous_iteration_of_fractals.html


Like many others, I was intrigued when I first saw pictures of Julia sets and Mandelbrod sets, and I had lots of fun making generating them on a computer.

But does this have anything to do with physics? Is there a dynamic system whose behavior is modeled by the startlingly simple equation that so surprisingly generates all those pretty pictures:

z -> z^2 + c

To get a continuous time-evolution, we need the "Nth iterative root" of this map, a map f(z), such that:

z->f(z)->f2(z)->f3(z)-> ... ->fN(z) = z^2 + c

For large N, we would start to get something like a dynamic system in continuous time.

Taking the Nth iterative root of a function is apparently a difficult subject. I'll just list a few cases where the answer is simple.

The map
z-> z + c
has as Nth root
z-> z+c/N

The map
z-> az
has as Nth root
z-> (a^(1/N)) z

Note that already, we come across multi-valuedness: there are N Nth roots of a complex number. We will come back to multi-valuedness later.

Mobius transformations:
z-> (az+b)/(cz+d)
Form a group, and they are a representation of the group of 2X2 matrices

( a b )
( c d )

So taking the Nth root of this matrix, will produce coefficients for an Nth root Mobius transformation.

Actually, finding a group of matrices which have the same group structure as functions under composition, is an interesting approach. An online article on this is by
Aldrovandi and Freitas
http://arxiv.org/abs/physics/9712026

Consider a non-linear dynamical system with 1 variable:

dz/dt = f(z)

Expand f(z) into a Taylor polynomial:

f(z) = a0z^0 + a1z^1 + a2z^2 + ....

Using some fairly easy differentiation rules, we can write this in a matrix form:


(z^0) ( 0 0 0 0 ...........) (z^0)
(z^1) (a0 a1 a2 a3............) (z^1)
d/dt (z^2) = ( 0 2a0 2a1 2a2 2a3 .......) (z^2)
(z^3) ( 0 0 3a0 3a1 3a2 3a3 ...) (z^3)
(...) (...........................) (...)

In a slightly modified form this matrix is called the Bell matrix of the function f.
It turns out that Bell matrices form a group, and that compositions of functions correspond to multiplications of their Bell matrices and vice versa.

So all we need to do is find the Nth root of the Bell matrix, and we will have the required Nth iterative root!

The problem is, that to truncate the infinite Bell matrix into a finite one, we need the higher columns and rows to get progressively less important. But in our case, they don't.

At this point, I found the web site of Markus Mueller.
http://www.math.tu-berlin.de/%7Emueller/verhulst.html

Apparently, he had succeeded in making continuous iterations of the real case (V.erhulst dynamics). He has some nice pictures of it on his web page, and he was kind enough to explain his method to me.

First, he either reverse-iterates a point a number of times by using the inverse iteration: z->sqrt(z-c). It turns out the reverse iteration has an attractive fixed point (z0). Near this fixed point, it becomes increasingly well approximated by linear dynamics:

(z-z0) -> lambda * (z-z0)

So near this point, we can find continuous iterates. The nice idea that Markus Mueller had was to then simply forward iterate back to the original point, using "ordinary" iteration.

Because Markus Mueller uses real numbers, the multi-valuedness of the square roots and the Nth roots of lambda are not so worrying. Each choice of either the positive square root or the negative square root leads to a different fixed point. We choose a combination with a small real-valued Nth root of lambda, since that's the only one that will give smooth real-valued continuous iterates.

This method appears to work quite well numerically.

However, the time evolution generated in this way apparently cannot be that of a dynamical system in 1 variable. This can be seen by the fact that for example it crosses the line z=0 may times in time, but each time follows a different trajectory afterwards: The value of z(t) itself does not define a state from which z(t+dt) is uniquely determined.

I decided to try the method on complex numbers instead of just reals. After all, it is the complex numbers which give the nice Julia pictures. Again, we run into a multi-valuedness problem. To produce some pictures, I initially just ignored the multi-value problem, by simply choosing roots. Again, the method works numerically, and soon I was having Lissajous-like curves on my screen, that winded through the complex plane. But unfortunately, there were usually self intersections. These intersections are bad, because they means that we do not have a dynamical system uniquely defined by z(t).

After some thought, I realized that he self-intersections were in fact linked to the multi-valuedness: If all maps and their inverses the story were single-valued, then we should not get self intersections.

There is a way to get rid of multi-valuedness: Use a Riemann surface! In our case, we need a Riemann surface that I will call "unwrapped-C". It is basically the Riemann surface of the complex logarithm.
In unwrapped-C, each number (u) can be written as 2 real numbers u=(R,theta). These are just polar coordinates of the complex plane, except that theta is no longer limited to a 2pi interval.

To multiply in unwrapped-C, we use

u1*u2 = (R1*R2,theta1+theta2)

This is the same as in ordinary C, but we retain the extra multiples of 2pi.

There is now a unique Nth root, or pth power:

u1^p = (R1^p, p*theta)

The tricky part is now to add a constant (c). On the ordinary complex plane, adding a constant is just a translation. If we construct the Riemann surface of unwrapped-C, we make a number of copies of C, cut them open along a line from infinity to the origin, and the glue them together like multi-story spiraling parking garage. On this surface, we can do a translation by a constant (c) just as in C. But look at the line extending from -c to the origin. If we take a small region that contains part of this line, and translate it by c, we see that the small region gets sliced in 2: each half ending in a different floor of the parking garage.
We will just accept the fact there is a discontinuity in this map, and define z->z+c as a translation in the local copy of C within unwrapped-C.

OK, so we now have a map z->z^2+c whose inverse is single valued, at the cost of a discontinuity. So lets make pictures!

The picures are at
http://www.xs4all.nl/~westy31/ContFract/Continuous_iteration_of_fractals.html

It seems that the dynamical systems we find, are pretty weird. An extraordinary propery is "stroboscopy", infinite oscillation that appears finite when viewed through a stroboscope.


Gerard

.

Relevant Pages

  • Re: Readline using foreach and while
    ... condition is checked at the start of each iteration, if the array ... map doesn't recheck the count ... the passed list for each iteration. ... @ary, which comes from a scope outside this sub, now contains (h, a, b, ...
    (comp.lang.perl.misc)
  • Re: Readline using foreach and while
    ... condition is checked at the start of each iteration, if the array is ... the line with the map statement, it does indeed contain 'd' at the end. ... passed list for each iteration. ...
    (comp.lang.perl.misc)
  • Re: [Map]modifying a map through an iteration
    ... that within the loop modifying values attached to a key is not a problem ... and the Map itself is unchanged. ... items when through iteration you want to remove an item other than the one ... public class MapTest { ...
    (comp.lang.java.help)
  • Re: "Higher order" bifurcation of discrete map
    ... It is just a discrete iteration, ... the nature of the intended map, ... If you want to transform this map into a "real" trifurcation, ... projection through Re or Im of a complex map, the answer is I don't know. ...
    (sci.math)