Bugs #17

Bugs Fractal 91

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.

Bugs #16

Bugs Fractal 90

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.

Bugs #14

Bugs Fractal 88

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.

Bugs #11

Bugs Fractal 85

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.

Bugs #9

Bugs Fractal 83

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.

a*sin(x/a)010-1/a^20 1/a^4

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.

Bugs #8

Bugs Fractal 78

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.