Extending the Definition of a Burning Ship

[wes]

The Mandelbrot set is the set of all values for c in the iterated function f(z) = z ^ 2 + c which don't cause z to diverge to infinity. The Burning Ship set is exactly the same, but the imaginary and real parts of z are set to their absolute values before squaring. The Burning Ship's formula can be written as f(z) = (|Re(z)| + |Im(z)|i) ^ 2 + c. A popular variant of the Burning ship, f(z) = (Re(z) + |Im(z)|i) ^ 2 + c is the same as the classic Burning Ship, but only the imaginary part of z is set to it's absolute value. Setting either the real or the imaginary part of z to its absolute value can be visualized as folding the complex plane of zon one of the axis. After folding, all points are moved to one half of the space (the positive half). I will call these two Burning Ship variants the Single-Fold Burning Ship and the Double-Fold Burning Ship.

If you imagine absolute values as folds, then the Single-Fold Burning Ship can be thought of as f(z) = fold(z) ^ 2 + c. The fold function sets the imaginary part of z to its absolute value. The Double-Fold Burning Ship can be thought of as folding, rotating by 90 degrees, folding again, then rotating back to the original orientation or f(z) = unrotate(fold(rotate(fold(z)))) ^ 2 + c. In this case, the rotate function rotates z on the complex plane around the origin by 90 degrees and the unrotate function undoes the rotation by rotating z by negative 90 degrees.

What about a Triple-Fold Burning Ship? A Triple-Fold Burning Ship can now be thought of as f(z) = unrotate(fold(rotate(fold(rotate(fold(z)))))) where, in this case, the rotate function rotates z by 60 degrees and the unrotate function rotates z by negative 120 degrees.

Quad-fold? Octo-Fold? 100-fold? Burning Ships can be extend to n-folds by just folding and rotating z n times where your rotation function rotates z by 180 / n degrees and your unrotate rotates z by 180 - 180 / n degrees. With this definition of a Burning Ship, you can fold Burning Ships as many times as you want. What do these n-fold Burning Ships look like? Here are the first 7 Burning Ships!









In gif form:
Note that the view is adjusted for each image for the sake of consistent composition. (In contrast to the gifs at the end)


You might be wondering if the order of folding matters. I wondered this. I'm pretty sure it doesn't though. If you fold a piece of paper an arbitrary number of times at equal angles then poke a hole through it, you can unfold it and fold it back up in any order you want and all the holes still line up. Please correct me if order actually does matter.

Here are some animations demonstrating what happens when you rotate z by a constant amount before the first fold (and back again after folding) effectively rotating all the fold-lines around the origin. Note the Celtic fish is just a Double-Fold Burning Ship with the folding-lines rotate 45 degrees. These animations are being rotated clockwise to counteract the apparent counterclockwise rotation from the rotating folding axis. Each loop of the animation is only 180 / n degrees of rotation of the folding axis.



Here are some zooms for a few of the Burning Ships:
Five-Fold Burning Ship 



Seven-Fold Burning Ship 



Eight-Fold Burning Ship   


EDIT: As suggested by kram1032, I made some animations of moving the folding lines around. I wanted to move the lines around in both dimensions, but just moving the lines along the imaginary axis alone created interesting enough results. So far, I've barely experimented with moving the lines along the real axis. Here is what it looks like if you move the folding lines for the Single-Fold Burning Ship in the positive direction from -1i to around 3i. Each gif is a different angle of the folding line. In reading order: -45, 0, and 45 degrees:


The Burning Ship gives birth a Mandelbar and transforms into a Mandelbrot! The Mandelbar is the same as the Mandelbrot, but the imaginary part of z is multiplied by -1 every iteration. I guess it's sorta like the anti-Mandelbrot. It shows up a lot more in the following gifs. Here is what the Mandelbar looks like by itself:


Here's more animations, but of the Double-Fold Burning Ship rotated at -45, 0, 45, and 90 degrees:


  Wow, the Double-Fold Burning Ship splits into two Single-Fold Burning Ship at 0 degrees, but at -45 degrees it disappears as dust and at 45 degrees it splits into two Mandelbars and two Mandlebrots. Crazy! What about the Tripple-Fold Burning Ship? Since the fold lines are at 60 degree angles of each-other I rotated by them in 30 degree increments. Here are some animations of the Tripple-Fold Burning Ship at -30, 0, 30, and 60 degrees:


I think the pattern is obvious now. The Tripple-Fold Burning Ship either explodes into dust, explodes into 3 Single-Fold Burning Ships, or explodes into 3 Mandelbars and 3 Mandelbrots. Here are bigger and better-composed gifs:


At first I was confused about why it sometimes splits into many parts, and other times disappears as dust. I may still be confused, but I think it's easiest to visualize the complex plane of z as a piece of paper. Adding complex numbers to z is like sliding the paper, multiplying complex numbers with z is like rotating and scaling the paper, and taking an absolute value of one of z's parts is like folding the paper. The splitting only happens if 0 + 0i lands inside the folded paper at the end of all the transformations.

Finally, here are some stills of the six-way explosion:






Added bonus, the plain Single-Fold at 0 degrees mid-birth:


Thanks to kram1032 once again for suggesting translating the folding lines. I'm going to experiment with these Burning Ships even more and post more pictures/gifs if they are relevant.

If you want to better understand how the Burning Ship works, here's an amazing visualization  of all the transformations during iterations of the Burning Ship from chaosTube:
<a href="http://www.youtube.com/v/oJjjoCe5MY0&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/oJjjoCe5MY0&rel=1&fs=1&hd=1</a>
Absolutely stunning work on that channel.

[kram1032]

Pretty stuff!
Since this is the Theory/Research thread, I think it's somewhat appropriate to repeat here what I said over in the image showcase thread: Three more extensions:

• Rotated fold at arbitrary angles (rather than evenly spaced ones)
• fold along not just angles but also off-center edges
• change the folding edges(s) at each iteration

The general process if you want to do both would be:

• Rotate such that the desired fold line goes along, say, the real axis
• Shift along (in that case) the imaginary axis (by subtracting an arbitrary offset value from the imaginary part)
• fold (take the absolute value of the imaginary part)
• shift back
• rotate back
• Either go back to the first point and repeat with a different angle and offset, or if you are done, do the whole squaring plus constant business.
• optionally don't stick with the same folds but keep switching them up in some fashion, for instance randomly

Presumably each of those extensions will be more chaotic and less predictable than the last. It'll likely be harder to find interesting stuff but there likely will be interesting stuff to be found.

[wes]

Pretty stuff!
Since this is the Theory/Research thread, I think it's somewhat appropriate to repeat here what I said over in the image showcase thread: Three more extensions:

• Rotated fold at arbitrary angles (rather than evenly spaced ones)
• fold along not just angles but also off-center edges
• change the folding edges(s) at each iteration

The general process if you want to do both would be:

• Rotate such that the desired fold line goes along, say, the real axis
• Shift along (in that case) the imaginary axis (by subtracting an arbitrary offset value from the imaginary part)
• fold (take the absolute value of the imaginary part)
• shift back
• rotate back
• Either go back to the first point and repeat with a different angle and offset, or if you are done, do the whole squaring plus constant business.
• optionally don't stick with the same folds but keep switching them up in some fashion, for instance randomly

Presumably each of those extensions will be more chaotic and less predictable than the last. It'll likely be harder to find interesting stuff but there likely will be interesting stuff to be found.

I still want to try this. The only thing stopping me (besides time) is the fact that it adds so many variables to the formula. I'd have to make a huge number of animations to explore it fully lol. I was drawn to fold-count because it only adds one variable to the formula and it's a natural number. The rotation adds another variable, but it's a real number. Translations, if you allow fold lines to be translated by arbitrary amounts an one of the axis, adds n-number of variables to the formula where n is the number of folds. To minimize the number of variables, I'd propose just a single complex variable that acts as a constant offset for each fold. With that, all the folds still make a cross-heir, just not at 0 + 0i. When I try offsets, I think this is what I want to try first.

Also I'm divided between spending time working on my fractal exploring software and spending time exploring fractals  

PS I wanted to respond to you last night, but I decided to wait until morning after I had drank coffee

[kram1032]

No worries, I didn't actually expect an explicit reply to that Technically we're talking about two extra dimensions to explore (the rotation being one, though a finitely constrained/ periodic one, the translation being another completely unbounded one) so the full object, if you were to attempt to build it, would then be four-dimensional. - Considering just a single fold. If you were to explore all of it, each extra fold would add another two dimensions to explore. Clearly not gonna happen beyond maybe two folds deep, unless it's a clear pattern like you picked or it's entirely random.

[wes]

No worries, I didn't actually expect an explicit reply to that Technically we're talking about two extra dimensions to explore (the rotation being one, though a finitely constrained/ periodic one, the translation being another completely unbounded one) so the full object, if you were to attempt to build it, would then be four-dimensional. - Considering just a single fold. If you were to explore all of it, each extra fold would add another two dimensions to explore. Clearly not gonna happen beyond maybe two folds deep, unless it's a clear pattern like you picked or it's entirely random.

So many dimensions to explore and so little time! Curse you for having such interesting ideas!

[wes]

I made some animations for translating the folding lines along the imaginary axis. I edited them into the bottom of the OP. I don't want to get your hopes up, but they're awsome!

[kram1032]

Oh wow, that's really unexpected but it does make sense. These look amazing!

[wes]

Oh wow, that's really unexpected but it does make sense. These look amazing!

I wasn't expecting it either and I'm glad you like them. I want you to understand something if you don't already. You might want to use a piece of paper, but if you do the translations and rotations and folds you'll find that sometimes the origin lands outside the folded paper at the end. When that happens the set becomes dust, but if the origin lands inside the paper, it becomes n * 2 parts. I didn't anticipate that at all. I thought my code was broken when I saw certain angles caused no splitting at all.

[kram1032]

What is your paper here? You mean, like a piece of paper shaped like the MSet?
I bet, as would usually be the case, the most visually interesting variants would happen whenever the origin lands right on the edge of the paper. That would then mean you suddenly reduced the two dimensional search space back down to one dimension and you could potentially explore the space just by randomly (or methodically) sampling that edge.

[wes]

What is your paper here? You mean, like a piece of paper shaped like the MSet?
I bet, as would usually be the case, the most visually interesting variants would happen whenever the origin lands right on the edge of the paper. That would then mean you suddenly reduced the two dimensional search space back down to one dimension and you could potentially explore the space just by randomly (or methodically) sampling that edge.

Sorry, the paper is the complex plane during an iteration. And I think I may have been wrong about what I said about the origin falling outside the folded area. I'm not sure it's possible for the origin to fall outside the area. Something else may going on. I'm going to have to sleep on it, sorry  I love the idea of reducing the number of dimensions by the way.

[Kalles Fraktaler]

Amazing.
Would be nice to know how the Formulas looks like for the still images

[matsoljare]

The symmetrical moment of this one looks interesting....

[wes]

Amazing.
Would be nice to know how the Formulas looks like for the still images

I'm glad you like them and I'm glad you asked. I'm struggling to write these in terms of math, but here's what I've got in terms of c++. If you're using std::complex from the standard library, then the Mandelbrot function takes two std::complex's (z and c) and  looks like this:

Code:

return pow(z, 2) + c;

From this, the classic burning ship (Double Fold) is:

Code:

z = {fabs(z.real()), fabs(z.imag())}; // fold
return pow(z, 2) + c;

And the Single-Fold is:

Code:

z = {z.real(), fabs(z.imag())}; // only fabs z.imag()
return pow(z, 2) + c;

Finally, my extension takes three additional parameters but they can be constants if you don't want to animate them. They are fold_n (unsigned), fold_offset (complex), and fold_angle (real).
These are used for transforming z before and after folding. First, z is translated by fold_offset, then rotated by fold_angle, then repeatedly rotated and folded before being transformed back.
My implementation in c++ looks like this:

Code:

z += fold_offset; // translate
z = std::polar(abs(z), arg(z) - fold_angle); // rotate
for(int n = 0; n < fold_n; ++n){
	z = std::polar(abs(z), arg(z) - M_PI / fold_n); // rotate
	z = {z.real(), fabs(z.imag())}; // fold
}
z = std::polar(abs(z), arg(z) + fold_angle + M_PI); //unrotate
z -= fold_offset; // untranslate
return pow(z, 2) + c;

Note that if you switch the order of rotate and fold inside the for-loop you'll get a Burning Ship which is inverted along the real axis.
I made some changes to the code to make it more readable here, so forgive me if there's errors in it (I'm fairly certain there aren't)
If you're good with math formulas, I'd appreciate some help making these into math formulas  

PS Sorry about how incoherent the OP is getting. I'm going to spend some time editing it so people can understand it easier and so I can add more to it easier. I think I worked on it too late an night lol

EDIT: If you want to specifically create the 6-way explosion, you would want to set fold_n to 3, fold_angle to 0 and fold_offset to around 0 + 3i

The symmetrical moment of this one looks interesting....

I love it. That's why I made it my profile pic   Did you know about the Celtic? It blew my mind when I learned the Celtic was just a Burning Ship which was rotated pre-folding

[kram1032]

Basically you need functions (pseudocode)

Code:

rotate(z, alpha) = z * e^(i * alpha)

Code:

shift(z, a) = z - i * a // the negative sign means "move origin to this point", also, since you only have to move perpenticular to the fold line, only the imaginary direction is important and thus a is a real number, not a complex one. (You could shift either way but it would not make a difference!)

Code:

fold_along_reals(z) = real(z) + i * abs(imag(z))  // the real axis is the completely unchanged fold-line. In that sense it's "fold_along_reals" rather than "fold_along_imags"

,
Then a single arbitrary fold would be:

Code:

fold(z,a,alpha) =
    rotate(
        shift(
            fold_along_reals(
                shift(
                    rotate(z,alpha), a
                      )
                  ),
           -a),
    -alpha)

Beyond those it's just your usual MSet formulation.

Code:

as = (...) //keep a list of all your shifts in here
alphas = (...) //keep a list of all your rotation angles in here

for a, alpha in zip(as, alphas):
    z = fold(z, a, alpha) //apply all the folds
z = z^2 + c  //mandelbrot set transform

[greentexas]

Thanks for all of these fractals! The "multiplying z by a constant" technique actually gives the set of all of the minibrots of the given fractals.

The 1-folded Burning Ship is also called the Perpendicular Burning Ship by some. The 2-folded Burning Ship is obviously the Burning Ship, and the 4-folded Burning Ship is also called the Buffalo. I personally am interested in the 3-folded Burning Ship, since it is a "transition" between the Burning Ship and Buffalo.

I also enjoyed watching the fractals "explode" into Mandelbrots, Mandelbars, and Perpendiculars. I've personally witnessed it before, but only when dealing with the double-folded Burning Ship.

I will experiment with these fractals when I get the chance.