There was such a positive response to last week’s post, I thought I’d write more about creating fractal images. In the spirit of this blog, what follows is a mathematical “stream of consciousness” — that is, my thoughts as they occurred to me and I pursued them. Or at least a close approximation — thoughts tend to jump *very* nonlinearly, and I do want the reader to be able to follow along….

Let’s begin at the beginning, with one of my first experiments. Here, the counterclockwise turns are 80 degrees, and the clockwise turns are 140 degrees.

One observation I had made in watching PostScript generate such images was that there was “overlap”: the recursive algorithm kept going even if the image was completely generated. Now the number of segments drawn by the recursive algorithm is a power of 4, since each segment is replaced by 4 others in the recursive process. So if the number of segments needed to complete a figure is not a power of 4, the image generation has to be stopped in the middle of a recursive call.

This reminded me of something I had investigated years ago — the Tower of Hanoi problem. This is a well-known example of a problem which can be solved recursively, but there is also an iterative solution. So I was confident there had to be an iterative way to generate these fractal images as well.

I needed to know — at any step along the iteration — whether to turn counterclockwise or clockwise. If I could figure this out, the rest would be easy. So I wrote a snippet of code which implemented the recursive routine, and output a 0 if there was a counterclockwise turn, and a 1 if there was a clockwise turn. For 2 levels of recursion, this sequence is

0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0.

The ones occur in positions 2, 6, 8, 10, and 14.

I actually looked at 1024 steps in the iteration, and noticed that the ones occur in exactly those positions whose largest power of 2 is odd. Each of 2, 6, 10, and 14 has one power of 2, and 8 has three.

You might be wondering, “How did you notice that?” Well, the iterative solution of the Tower of Hanoi does involve looking at the powers of 2 within numbers, so past experience suggested looking along those lines. This is a nice example of how learning neat math can enlarge your mathematical “toolbox.” You never know when something might come in handy….

There was other interesting behavior as well — but it’s simpler if you just watch the video to see what’s happening.

First, you probably noticed that each of the 18 star arms takes 32 steps to create. And that some of the star arms — eight of them — were traversed *twice.* This means that 18 + 8 = 26 arms were drawn before the figure was complete, for a total of 832 steps. Note that the recursive algorithm would need 1024 steps to make sure that all 832 steps were traversed — but that means an overlap of 192 steps.

Now let’s see why some of the arms were traversed twice. The 32nd step of the first arm is produced after 31 turns, and so the 32nd turn dictates what happens here. Now the highest power of 2 in 32 is 5, which is odd – so a clockwise turn of 140 degrees is made. You can see by looking at the first 33 steps that this is exactly what happens. The 32nd step takes you back to the center, and then a 140 degree clockwise turn is made.

Now after the next arm is drawn, the turn is determined by the 64th angle. But 6 is the highest power of two here, and so an 80 degree counterclockwise turn is made — but this takes you over the same arm again!

Note that we can’t keep traversing the same arm over and over. If we add 32 to a number whose highest power of 2 is 6:

we get a number whose highest power of 2 is 5 again (since 2m + 1 must be odd). Since this power is odd, a clockwise turn will be made.

So when do we repeat an arm? This will happen when we have a counterclockwise turn of 80 degrees, which will happen when the highest power of 2 is even (since an odd power takes you clockwise) — when looking at every 32nd turn, that is. So, we need to look at turns

32, 64, 96, 128, 160, 192, 224, etc.

But observe that this is just

32 x (1, 2, 3, 4, 5, 6, 7, etc.).

Since 32 is an odd power of two, the even powers of two must occur when there is an *odd* power of 2 in 1, 2, 3, 4, 5, 6, 7, etc. In other words, in positions 2, 6, 8, 10, 14, etc.

To summarize this behavior, we can state the following simple rule: arms move seven points counterclockwise around the circle, except in the case of the 2nd, 6th, 8th, 10th, 14th, etc., arms, which repeat before moving seven points around. Might be worth taking a minute to watch the video again….

We can use this rule to recreate the order in which the star arms are traversed. Start with 1. The next arm is 1 + 7 = 8. But 8 is the 2nd arm, so it is repeated — and so 8 is *also* the third arm. The fourth arm is 8 + 7 = 15, and the fifth is seven positions past 15, which is 4. Mathematically, we say 15 + 7 = 4 *modulo 18**,* meaning we add 15 and 7, and then take the remainder upon dividing by 18. This is know as *modular arithmetic,* and is one of the first things you learn when studying a branch of mathematics called *number theory.*

The sixth arm is 4 + 7 = 11, which is repeated as the seventh arm. You can go on from here….

There are still some questions which remain. Why 32 steps to complete an arm? Why skip every seventh arm? Why are the arms 20 degrees apart? These questions remain to be investigated more thoroughly. But I can’t stress what we’re doing strongly enough — using the computer to make observations which can be stated mathematically *very* precisely, and then looking at a well-defined algorithm to (hopefully!) *prove* that our observations are accurate. More and more — with the advent of technology — mathematics is becoming an *experimental* science.

I’ll leave you with one more video, which shows PostScript creating a fractal image. But laying a mathematical foundation was important — so next week, we can look at how you can make your own fractals in Python using an iterative procedure. This way, you can explore this fascinating world all on your own….

There are 10 levels of recursion here, and so 1,048,576 segments to draw. To see the final image, visit my Twitter feed for October 9. Enjoy!