No posts for the last two days. I have no excuses, I simply did not make the time. I will try to make up with multiple posts today.

The next few pictures are success out-zooms of Bugs #16 to get an idea of what the neighborhood looks like.

Today's image is a zoom out by a factor of two.

For a quick recap, this formula is bugR, defined back in Bugs #14 , with parameter a = 2.5.

At the next intersection to the east is a mini-tricorn. The minibrots and tricorns alternate.

Yesterday's image was a deep zoom into a "quiet" area. It appears that an infinite grid with ever finer lines is everywhere. At every intersection, a deep zoom holds something interesting. Here is a distorted minibrot.

With z^2+c and a little algebra, you can show that if |z| > 2 + |c| then z escapes. Yesterday I showed a similar argument for bugI() which concludes that if |x| > a + 1 + |c| then z =x + yi escapes. So for both of these formulas, there are easily identified large areas where the orbit is guaranteed to escape. Also we saw that this type of simple algebra argument breaks down for bugR(). That does not prove that no such area exists, only that if it does, it will be difficult to find. Let's dig deeper

Since this is a blog, not a book, I should recap frequently. We are iterating

$ bugR(z^2+c) \quad where \\ bugR(x+yi) = u(x)+yi, \\ u=a*sin(x/a), a>0$

Recall that $ |u(x)|<= a \text{ and } u(a*n\pi)=0$

If a>.5 (an easy assumption, it has been true for every picture so far), u(p)=-.5 has a solution. In fact many solutions when you find one, $ p+a*n\pi$ is also a solution for any integer n.

Look at $ c=c_r+c_i i = p+a*m\pi + \pm \sqrt{p+.25+a*n\pi} i $. where n and m are arbitrary integers.

These points lie on a grid. Equal space horizontally, decreasing spacing vertically because of the square root. But extending to infinity in all directions. Where ever you are in the plane you are surrounded by these points. The following will show that none of these points escape, in fact every one is a 2-cycle.

Lets iterate bugR(z^2+c)

$ \begin{matrix} z_0 & = & 0 \\ z_1 & = & bugR(c)\\ & = & -.5 & + & c_i i \\ z_2 & = & u(.25 - c_i^2+c_r) & + & (2*(-.5)*c_i + c_i)i \\ & = & u(.25 - (p +.25+an\pi)+p+am\pi) & + & (-c_i+c_i)i \\ & = & u(a*(m-n)\pi) & + & 0i \\ & = & 0 \end{matrix}$

So every one of these points generates a two cycle.

It is embarrassing to admit how much time I spent on this. My math skills are rusty.

I wanted visual confirmation that the webbing is everywhere. Here is a deep zoom into the nearly empty area in the top right of yesterday's image. The color has been changed from previous image to enhance the features. The lines get thin very quickly. You see a horizontal line, intersected by many vertical lines, and each of them connected by almost invisible horizontal lines. Because the lines in this third set are thinner than the pixels in the image, Moiré patterns appear.

To save typing and simplify some calculations, define $ u(x) = a * sin(x/a)$. Note that $ u(a*n*\pi) = 0, \text{ and } |u(x)| < a$.

With this notation, $ bugI(x+yi) = x + u(y)i$. Set $ c = c_r+c_i i$ and expand the iteration $ z' = x' + y'i =bugI(z^2+c)$ .

$ x' = x^2-y^2+c_r\\y' = u(2*x*y+c_i)$

After the first step, we always have $ |y'| < a$. With a little algebra, it is seen that if $ x > a + 1 + |c_r| \text{ then } x' > x$. So the real part of the iteration keeps getting larger, and we have many orbits escaping to infinity.

A similar analysis fails with $ bugR(x+yi) = u(x)+yi$. On each iteration step,

$ x' = u(x^2-y^2+c_r)\\y' = 2 * u(x) * y + c_i$

The real part is always bounded, $ |x'| < a$, so the only hope of escape lies with the imaginary part. But if x is a multiple of a*pi, then u(x) = 0, and y has to start over.

As was done earlier with bugI, the next few posts explore bugR from a more mechanical or mathematical perspective.

Compare this image with Bugs #8. Same location, zoom, and color, same parameter a = 2.5,  but with the R version replacing the I version of bug. The webbing appears to be everywhere, although it quickly becomes too thin to see at this image resolution.

Here is another more artistic rendering of bugR. a = 2.0. Compare the web like structures with the bugI images, such as Bugs #12 and Bugs #6. Here the strands are thinner, but are everywhere.

There are several pictures on my hard drive that are queued up to post here. The plan was to introduce the bug formula, provide some nerdy math descriptions and examples, then start posting the more artistic images. I am done with the nerd stuff, and then noticed a problem with that plan; most of the images I have are based on another version of the bug formula. I won't keep you in suspense. You may have guessed the other variation. I added a letter to the name to keep track of which part is gets modified.

$ bugI(x+yi) = x + a * sin(y/a)i \\ bugR(x+yi) = a*sin(x/a) + yi$

As a quick recap, the bug formula is combined with the usual $ z^2+c$, and the images are generated in a typical escape-time fashion. There are two variations of the combined formula, depending on who goes first.

$ (bugX(z))^2+c \\ bugX(z^2+c)$

Most of the pictures here use the second "bug last" variant.

The pictures of the last two weeks have been based on bugI(). Today's picture is based on bugR(), with a = 1.5.

Here is a deep zoom of a bugs fractal. Parameter a = 2.0, viewport center at -0.7871755+0.1839239i, width = 5e-7. Please see the earlier posts, Bugs #3 and Bugs #8 for a description of the formula.

I am short on time today, but still striving for a post a day. So just a picture with very few words. Bugs fractal, parameter a=1.2. Viewport center -1.279+0.371i, width = .008.

This is a zoom into yesterday's image, getting a closer look at the tricorn. The parameter is still a = 2.5. The image center is at $ a*\pi*i$.

Recall the definition of the parameter version of bug: $ bug(x+y i) = x + a * sin(y/a) i$. Then, a little algebra,

$ \begin{matrix} bug(z+a \pi i) & = & bug( x + (y+a \pi)i) \\ & = & x + a *sin(y/a+\pi)i \\& = & x - a * sin(y/a) i \\ & = & \overline{bug(z)} \end{matrix} $

If you are a little rusty the definition of complex conjugate is $ \overline{x+yi} = x-yi$, and a well known trig identity is $ sin(\theta+\pi) = -sin(\theta)$.

Also recall that near z=0 for large a it is almost true that bug(z) = z. More formally, for any $ \epsilon, R > 0$ if a is large enough then $ |bug(z)-z|< \epsilon \text{ whenever } z < R$. Now we can also say $ |bug(z+\pi i)- \overline{z}|< \epsilon \text{ whenever } z < R$

There is a little more to be done, I will skip the details. If you track what is going on in the iteration of $ bug(z)^2+c$ near $ c = a * \pi i$ you will see that it behaves like the tricorn, $ \overline z^2+c$ near $ c = 0$.

Given the periodicity of the sin function, the same is true for c near $ c = n * a * \pi i$ for any integer n. Even n looks like a Mandelbrot set, odd n looks like the Tricorn.

Here is a zoom out by a factor of two from yesterday's picture. The triangular shape at the top is called a Tricorn or Mandelbar. The parameter a is 2.5. (See Bugs #8 for a description of the formula.) The image is centered at $ (a * \pi /2) * i$.

The Tricorn set is generated by $ \bar{z}^2+c$. The standard formula is modified to use the complex conjugate of z. Here is a non-paywall academic paper on Tricorns

Zoom out by a factor of 2 from yesterday's image, we see the rope/web supports extend above and below the main body.

The rest of this post is for the more mathematically inclined readers. Yesterday I stated that the bug function is close to the identity. The real part is already there, so let's focus on the imaginary part, and treat just the imaginary part as a real valued function.

Here is a table of values for three function and their first few derivatives evaluated at 0.

Notice that for the parameterized sin function, a*sin(x/a), with a large value of a, all of the derivatives are close to the derivatives of the identity function, x. Using  Taylor series, the difference can be made arbitrarily small of an arbitrary large neighborhood of the origin.

For example, $ \text{ for } \epsilon, R \text{ where }0 < e < 1 < R, \text{ set }a = R^2/\epsilon$ and use Taylor series to show that

$ |x-a*sin(x/a)| < \epsilon \text{ whenever } |x| < R$

The same result carries over to the complex bug function.

Today's image uses the parameterized version of the bug formula with parameter a = 2.5.

The parameterized version of the bug formula is $ bug_a(x+iy) = x + i*a*sin(y/a)$. When a = 1.0, this is the same as the non-parameterized version.

For large values of a, the bug formula gets close to the identity function, and the images get closer to the Mandelbrot set. By adjusting the parameter a, you can control the degree of distortion / similarity when compared to $ z^2+c$.

In this view, with a = 2.5, the non-cyclic, non-escaping chaotic region in the upper right and lower right of Bugs #3 and Bugs #4 are gone. The body looks pretty normal. Surrounding the body is a bifurcating webbing that is characteristic of the bug formula.

Another image showing the interconnecting webbing. This one surrounding a distorted mini.

Here is a closer look zoom at the ropes/webbing. This is a magnification of the top left of Bugs #3

View port center (-1.65, 0.49), width 0.25

The main characteristic of the bugs fractal series is the "web" network surrounding and connecting the areas of stability. That will be the focus for this series. However, they also often contain regions of chaotic behavior. So today we take a digression to look at the chaos.

First the TL;DR version. Fractal images based on the ubiquitous $ z^2+c$, are clean and orderly. Complex yes, but also clean. Fractal based on non-holomorphic functions, (and many rational functions) are messy with dust and brush strokes, like today's image.

In a dynamical systems, orbits either (see Stability of orbits.)

• escape to infinity
• converge to single point or a finite periodic cycle
• are non-escaping, non-periodic (chaotic)

For a dynamical system based on polynomials, almost all orbits fall into the first two buckets. In the usual $ z^2+c$ fractals, the orbits of the third type lie on the thin one dimension boundary between escaping and periodic regions, and the one dimensional filaments. Much too small to see.

But when you get away from well behaved polynomials, two dimensional regions with chaotic orbits of the third type appear.

While the bug formula, $ bug(x+iy) = x + i* sin(y)$ seems simple, it is not differentiable as a complex function. So adding this to the fractal calculation produces a non-holomorphic formula with potential for two dimensional chaos.

In general, fractals with two dimension chaos is a worthy topic to study in its own right. I am sure I will return to it from time to time. But tomorrow, focus returns to the webs in the cleaner areas of the bugs fractals.

Here is the same image as yesterday, but with "black inside" turned off.

Traditionally for fractals only the escaping points are colored, and the color indicates how quickly the point escapes. The non-escaping, or "inside" points are colored black. For traditional fractals, the insides are boring. The orbits of the points in the non-escaping region flow towards a single fixed point, or an attracting cycle. A solid inside color helps shifts the viewer's focus to the swirls surrounding the fractal body.

With non-traditional fractals, especially fractals based on non-holomorphic functions, the inside area is more interesting. The orbits can bounce around in chaotic fashion, never settling into a fixed point or cycle. It is not easy to find a meaningful way to color such regions. But that makes it all the more rewarding when you discover a way to visualize the area.

Time for some nerd talk.

First, let's meet the bug formula: $ bug(x+iy) = x + i* sin(y)$.

Typical fractals iterate the formula $ z \to z^2 + c$. Here the basic fractal formula is combined with the bug formula. There are two ways to combine them.

bug first: $ z \to bug(z)^2 + c$
bug last: $ z \to bug(z^2+c)$

Mathematically the order matters, but for pictures the order makes very little difference. I am not consistent in choosing one or the other. This image happens to use the "bug first" variation.

The image is the "Mandelbrot set" for the combined formula. Technically speaking, if you are not using z^2+c, then it is not the Mandelbrot set. A proper description would be the "parameter space" view. But just this once I will indulge in sloppy language since the process is exactly like creating a Mandelbrot set image, but with the slight change in the formula. Compare to basic fractal.

The image is centered at (-1,0) with width 3.0 and height set to maintain a 1:1 mathematical aspect aspect ratio. (Meaning each pixel represents a square in the complex plane.)

I played with these bug fractals a lot in the 90s. Many images on the old site were bug fractals. I return to the formula often, especially when nothing else seems to be working. Two months ago I started playing with them again. There are several images on my hard drive, that need to be sorted and organized. I plan on doing that over the next few days. The first two are presented without explanation as a visual introduction to the series.

This one starts the Bugs series.

I will provide all the nerdy details on how I create these in a later post. For now, just enjoy the image without thinking about how or why.