I made two animated renderings of the Circle Map.

Video: Circle Map

The circle map is a particular iterative function that maps a point on a circle to another point on the circle.

*x* ← *x* + Ω - K * sin(2π*x*) / 2π mod 1

This takes a point *x* in the range 0 to 1, and maps it to another point in the same range. What makes it circular is the "mod 1", which means when you go past 1 you wrap back around to 0.

This function was developed by Andrey Kolmogorov, and I believe the original intent was to simulate the effect of a spring attached to a rotating device. The value Ω represents the speed of rotation, every iteration it tries to move forward by this amount. The value K represents a spring that resists that motion and pushes back.

When you look at the result of this function with various parameters of Ω and K, some curious properties will arise. For some speeds and spring strengths, the rotor will want to "lock" into various positions instead of progressing around the circle.

In the video above, the strength of the spring K increases from right to left. Each column is rendered by taking a bunch of starting points of *x* and tracking all the positions they iterate to through this function. The image becomes bright wherever *x* ends up most often. Over time, the Ω value changes across the video, producing the animation.

So we notice that at the right side, for a very low K we have a small region of very flat blue colour that indicates that *x* is travelling freely. However, at some point as the spring gets stronger it will start to lock into a single position. As it keeps getting stronger though, suddenly it will split into 2, then 4, then 8 positions... as it keeps going it subdivides so much that it becomes impossible to see all the branches... but then suddenly it will have moments of clarity where it returns to just 2 positions, then begins branching again, but on a smaller scale.

It's a very interesting behaviour! There are many chaotic systems that may produce these kind of bifurcation patterns when charted a certain way. I particularly like how the Circle Map ends up with a ghostly self-overlap from the way these things wrap around on the circle.

Video: dɐW ǝlɔɹᴉƆ

I made a second video about this, which I like to think of as the Circle Map's evil twin.

This exchanges time with the vertical axis. Now over time the starting value of *x* is changing, and instead we are graphing different values of Ω from top to bottom. However this leaves the question of what to do with the iterations of *x*. Instead of tracking where it goes, we count how many iterations *x* takes to return to its original pixel as we keep iterating.

We try many iterations for each, but sometimes it never seems to return. Those areas of the image are black. Areas where it seems to have a very short recurrence are brighter. This has a different pattern, apparently known as Arnold Tongues (after Vladimir Arnold).

This image takes a lot more computation to render effectively. Detail does not resolve without many iterations, and the resulting video ends up having a noisy, kind of spooky texture to it. I chose a level of detail that took about 18 hours for my computer to render. (The first video took only an hour or two.)

If you're curious about this, I've provided a Python program to try this out, which will produce a PNG image of each type of graph. You can modify the code to experiment with it further.

Program: circlemap.py

I learned about the Circle Map when I stumbled on this image at Wikipedia while reading about chaotic systems and the bifurcation property. I'm thankful to its author for creating this small and beautiful picture that captured my interest. After investigating it, I realized there was a whole family of continuous images that could make a very nice animation, so... I made them.

The music, if you're wondering, is just an old composition/recording of mine that I had lying around.