Fylfy Fractals

An equilateral triangle is a rep-tile, because it can be tiled completely with smaller copies of itself. Here it is as a rep-4 rep-tile, tiled with four smaller copies of itself:

Equilateral triangle as rep-4 rep-tile


If you divide and discard one of the sub-copies, then carry on dividing-and-discarding with the sub-copies and sub-sub-copies and sub-sub-sub-copies, you get the fractal seen below. Alas, it’s not a very attractive or interesting fractal:

Divide-and-discard fractal stage #1


Stage #2


Stage #3


Stage #4


Stage #5


Stage #6


Stage #7


Stage #8


Stage #9


Divide-and-discard fractal (animated)


You can create more attractive and interesting fractals by rotating the sub-triangles clockwise or anticlockwise. Here are some examples:









Now try dividing a square into four right triangles, then turning each of the four triangles into a divide-and-discard fractal. The resulting four-fractal shape is variously called a swastika, a gammadion, a cross cramponnée, a Hakenkreuz and a fylfot. I’m calling it a fylfy fractal:

Divide-and-discard fractals in the four triangles of a divided square stage #1


Fylfy fractal #2


Fylfy fractal #3


Fylfy fractal #4


Fylfy fractal #5


Fylfy fractal #6


Fylfy fractal #7


Fylfy fractal #8


Fylfy fractal (animated)


Finally, you can adjust the fylfy fractals so that each point in the square becomes the equivalent point in a circle:



















Game of Throwns

In “Scaffscapes”, I looked at these three fractals and described how they were in a sense the same fractal, even though they looked very different:

Fractal #1


Fractal #2


Fractal #3


But even if they are all the same in some mathematical sense, their different appearances matter in an aesthetic sense. Fractal #1 is unattractive and seems uninteresting:

Fractal #1, unattractive, uninteresting and unnamed


Fractal #3 is attractive and interesting. That’s part of why mathematicians have given it a name, the T-square fractal:

Fractal #3 — the T-square fractal


But fractal #2, although it’s attractive and interesting, doesn’t have a name. It reminds me of a ninja throwing-star or shuriken, so I’ve decided to call it the throwing-star fractal or ninja-star fractal:

Fractal #2, the throwing-star fractal


A ninja throwing-star or shuriken


This is one way to construct a throwing-star fractal:

Throwing-star fractal, stage 1


Throwing-star fractal, #2


Throwing-star fractal, #3


Throwing-star fractal, #4


Throwing-star fractal, #5


Throwing-star fractal, #6


Throwing-star fractal, #7


Throwing-star fractal, #8


Throwing-star fractal, #9


Throwing-star fractal, #10


Throwing-star fractal, #11


Throwing-star fractal (animated)


But there’s another way to construct a throwing-star fractal. You use what’s called the chaos game. To understand the commonest form of the chaos game, imagine a ninja inside an equilateral triangle throwing a shuriken again and again halfway towards a randomly chosen vertex of the triangle. If you mark each point where the shuriken lands, you eventually get a fractal called the Sierpiński triangle:

Chaos game with triangle stage 1


Chaos triangle #2


Chaos triangle #3


Chaos triangle #4


Chaos triangle #5


Chaos triangle #6


Chaos triangle #7


Chaos triangle (animated)


When you try the chaos game with a square, with the ninja throwing the shuriken again and again halfway towards a randomly chosen vertex, you don’t get a fractal. The interior of the square just fills more or less evenly with points:

Chaos game with square, stage 1


Chaos square #2


Chaos square #3


Chaos square #4


Chaos square #5


Chaos square #6


Chaos square (anim)


But suppose you restrict the ninja’s throws in some way. If he can’t throw twice or more in a row towards the same vertex, you get a familiar fractal:

Chaos game with square, ban on throwing towards same vertex, stage 1


Chaos square, ban = v+0, #2


Chaos square, ban = v+0, #3


Chaos square, ban = v+0, #4


Chaos square, ban = v+0, #5


Chaos square, ban = v+0, #6


Chaos square, ban = v+0 (anim)


But what if the ninja can’t throw the shuriken towards the vertex one place anti-clockwise of the vertex he’s just thrown it towards? Then you get another familiar fractal — the throwing-star fractal:

Chaos square, ban = v+1, stage 1


Chaos square, ban = v+1, #2


Chaos square, ban = v+1, #3


Chaos square, ban = v+1, #4


Chaos square, ban = v+1, #5


Game of Throwns — throwing-star fractal from chaos game (static)


Game of Throwns — throwing-star fractal from chaos game (anim)


And what if the ninja can’t throw towards the vertex two places anti-clockwise (or two places clockwise) of the vertex he’s just thrown the shuriken towards? Then you get a third familiar fractal — the T-square fractal:

Chaos square, ban = v+2, stage 1


Chaos square, ban = v+2, #2


Chaos square, ban = v+2, #3


Chaos square, ban = v+2, #4


Chaos square, ban = v+2, #5


T-square fractal from chaos game (static)


T-square fractal from chaos game (anim)


Finally, what if the ninja can’t throw towards the vertex three places anti-clockwise, or one place clockwise, of the vertex he’s just thrown the shuriken towards? If you can guess what happens, your mathematical intuition is much better than mine.


Post-Performative Post-Scriptum

I am not now and never have been a fan of George R.R. Martin. He may be a good author but I’ve always suspected otherwise, so I’ve never read any of his books or seen any of the TV adaptations.

Scaffscapes

A fractal is a shape that contains copies of itself on smaller and smaller scales. You can find fractals everywhere in nature. Part of a fern looks like the fern as a whole:

Fern as fractal (source)


Part of a tree looks like the tree as a whole:

Tree as fractal (source)


Part of a landscape looks like the landscape as a whole:

Landscape as fractal (source)


You can also create fractals for yourself. Here are three that I’ve constructed:

Fractal #1


Fractal #2


Fractal #3 — the T-square fractal


The three fractals look very different and, in one sense, that’s exactly what they are. But in another sense, they’re the same fractal. Each can morph into the other two:

Fractal #1 → fractal #2 → fractal #3 (animated)


Here are two more fractals taken en route from fractal #2 to fractal #3, as it were:

Fractal #4


Fractal #5


To understand how the fractals belong together, you have to see what might be called the scaffolding. The construction of fractal #3 is the easiest to understand. First you put up the scaffolding, then you take it away and leave the final fractal:

Fractal #3, scaffolding stage 1


Fractal #3, stage 2


Fractal #3, stage 3


Fractal #3, stage 4


Fractal #3, stage 5


Fractal #3, stage 6


Fractal #3, stage 7


Fractal #3, stage 8


Fractal #3, stage 9


Fractal #3, stage 10


Fractal #3 (scaffolding removed)


Construction of fractal #3 (animated)


Now here’s the construction of fractal #1:

Fractal #1, stage 1


Fractal #1, stage 2


Fractal #1, stage 3

Construction of fractal #1 (animated)


Fractal #1 (static)


And the constructions of fractals #2, #4 and #5:

Fractal #2, stage 1


Fractal #2, stage 2


Fractal #2, stage 3

Fractal #2 (animated)


Fractal #2 (static)


Fractal #4, stage 1


Fractal #4, stage 2


Fractal #4, stage 3

Fractal #4 (animated)


Fractal #4 (static)


Fractal #5, stage 1


Fractal #5, stage 2


Fractal #5, stage 3

Fractal #5 (animated)


Fractal #5


Middlemath

Suppose you start at the middle of a triangle, then map all possible ways you can jump eight times half-way towards one or another of the vertices of the triangle. At the end of the eight jumps, you mark your final position with a dot. You could jump eight times towards the same vertex, or once towards vertex 1, once towards vertex 2, and once again towards vertex 1. And so on. If you do this, the record of your jumps looks something like this:


The shape is a fractal called the Sierpiński triangle. But if you try the same thing with a square — map all possible jumping-routes you can follow towards one or another of the four vertices — you simply fill the interior of the square. There’s no interesting fractal:


So you need a plan with a ban. Try mapping all possible routes where you can’t jump towards the same vertex twice in a row. And you get this:

Ban on jumping towards same vertex twice in a row, v(t) ≠ v(t-1)


If you call the current vertex v(t) and the previous vertex v(t-1), the ban says that v(t) ≠ v(t-1). Now suppose you can’t jump towards the vertex one place clockwise of the previous vertex. Now the ban is v(t)-1 ≠ v(t-1) or v(t) ≠ v(t-1)+1 and this fractal appears:

v(t) ≠ v(t-1)+1


And here’s a ban on jumping towards the vertex two places clockwise (or counterclockwise) of the vertex you’ve just jumped towards:

v(t) ≠ v(t-1)+2


And finally the ban on jumping towards the vertex three places clockwise (or one place counterclockwise) of the vertex you’ve just jumped towards:

v(t) ≠ v(t-1)+3 (a mirror-image of v(t) ≠ v(t-1)+1, as above)


Now suppose you introduce a new point to jump towards at the middle of the square. You can create more fractals, but you have to adjust the kind of ban you use. The central point can’t be included in the ban or the fractal will be asymmetrical. So you continue taking account of the vertices, but if the previous jump was towards the middle, you ignore that jump. At least, that’s what I intended, but I wonder whether my program works right. Anyway, here are some of the fractals that it produces:

v(t) ≠ v(t-1) with central point (wcp)


v(t) ≠ v(t-1)+1, wcp


v(t) ≠ v(t-1)+2, wcp


And here are some bans taking account of both the previous vertex and the pre-previous vertex:

v(t) ≠ v(t-1) & v(t) ≠ v(t-2), wcp


v(t) ≠ v(t-1) & v(t-2)+1, wcp


v(t) ≠ v(t-1)+2 & v(t-2), wcp


v(t) ≠ v(t-1) & v(t-2)+1, wcp


v(t) ≠ v(t-1)+1 & v(t-2)+1, wcp


v(t) ≠ v(t-1)+2 & v(t-2)+1, wcp


v(t) ≠ v(t-1)+3 & v(t-2)+1, wcp


v(t) ≠ v(t-1) & v(t-2)+2, wcp


v(t) ≠ v(t-1)+1 & v(t-2)+2, wcp


v(t) ≠ v(t-1)+2 & v(t-2)+2, wcp


Now look at pentagons. They behave more like triangles than squares when you map all possible jumping-routes towards one or another of the five vertices. That is, a fractal appears:

All possible jumping-routes towards the vertices of a pentagon


But the pentagonal-jump fractals get more interesting when you introduce jump-bans:

v(t) ≠ v(t-1)


v(t) ≠ v(t-1)+1


v(t) ≠ v(t-1)+2


v(t) ≠ v(t-1) & v(t-2)


v(t) ≠ v(t-1)+2 & v(t-2)


v(t) ≠ v(t-1)+1 & v(t-2)+1


v(t) ≠ v(t-1)+3 & v(t-2)+1


v(t) ≠ v(t-1)+1 & v(t-2)+2


v(t) ≠ v(t-1)+2 & v(t-2)+2


v(t) ≠ v(t-1)+3 & v(t-2)+2


Finally, here are some pentagonal-jump fractals using a central point:








Post-Performative Post-Scriptum

I’m not sure if I’ve got the order of some bans right above. For example, should v(t) ≠ v(t-1)+1 & v(t-2)+2 really be v(t) ≠ v(t-1)+2 & v(t-2)+1? I don’t know and I’m not going to check. But the idea of jumping-point bans is there and that’s all you need if you want to experiment with these fractal methods for yourself.

Triangular Squares

The numbers that are both square and triangular are beautifully related to the best approximations to √2:

Number

Square Root

Factors of root

1 1 1
36 6 2 * 3
1225 35 5 * 7
41616 204 12 * 17

and so on.

In each case the factors of the root are the numerator and denominator of the next approximation to √2. — David Wells, The Penguin Dictionary of Curious and Interesting Mathematics (1986), entry for “36”.


Elsewhere other-accessible

A001110 — Square triangular numbers: numbers that are both triangular and square

Square’s Flair

If you want to turn banality into beauty, start here with three staid and static squares:

Stage #1


Now replace each red and yellow square with two new red and yellow squares orientated in the same way to the original square:

Stage #2


And repeat:

Stage #3


Stage #4


Stage #5


Stage #6


Stage #7


Stage #8


Stage #9


Stage #10


Stage #11


Stage #12


Stage #13


Stage #14


Stage #15


Stage #16


Stage #17


Stage #18


And you arrive in the end at a fractal called a dragon curve:

Dragon curve


Dragon curve (animated)


Elsewhere other-engageable

Curvous Energy — an introduction to dragon curves
All Posts — about dragon curves

Bent Pent

This is a beautiful and interesting shape, reminiscent of a piece of jewellery:

Pentagons in a ring


I came across it in this tricky little word-puzzle:

Word puzzle using pentagon-ring


Here’s a printable version of the puzzle:

Printable puzzle


Let’s try placing some other regular polygons with s sides around regular polygons with s*2 sides:

Hexagonal ring of triangles


Octagonal ring of squares


Decagonal ring of pentagons


Dodecagonal ring of hexagons


Only regular pentagons fit perfectly, edge-to-edge, around a regular decagon. But all these polygonal-rings can be used to create interesting and beautiful fractals, as I hope to show in a future post.

Think Inc #2

In a pre-previous post called “Think Inc”, I looked at the fractals created by a point first jumping halfway towards the vertex of a square, then using a set of increments to decide which vertex to jump towards next. For example, if the inc-set was [0, 1, 3], the point would jump next towards the same vertex, v[i]+0, or the vertex immediately clockwise, v[i]+1, or the vertex immediately anti-clockwise, v[i]+3. And it would trace all possible routes using that inc-set. Then I added refinements to the process like giving the point extra jumping-targets half-way along each side.

Here are some more variations on the inc-set theme using two and three extra jumping-targets along each side of the square. First of all, try two extra jumping-targets along each side and a set of three increments:

inc = 0, 1, 6


inc = 0, 2, 6


inc = 0, 2, 8


inc = 0, 3, 6


inc = 0, 3, 9


inc = 0, 4, 8


inc = 0, 5, 6


inc = 0, 5, 7


inc = 1, 6, 11


inc = 2, 6, 10


inc = 3, 6, 9


Now try two extra jumping-targets along each side and a set of four increments:

inc = 0, 1, 6, 11


inc = 0, 2, 8, 10


inc = 0, 3, 7, 9


inc = 0, 4, 8, 10


inc = 0, 5, 6, 7


inc = 0, 5, 7, 8


inc = 1, 6, 7, 9


inc = 1, 4, 6, 11


inc = 1, 5, 7, 11


inc = 2, 4, 8, 10


inc = 3, 5, 7, 9


And finally, three extra jumping-targets along each side and a set of three increments:

inc = 0, 3, 13


inc = 0, 4, 8


inc = 0, 4, 12


inc = 0, 5, 11

inc = 0, 6, 9


inc = 0, 7, 9


Previously Pre-Posted

Think Inc — an earlier look at inc-set fractals

Think Inc

This is a T-square fractal:

T-square fractal


Or you could say it’s a T-square fractal with the scaffolding taken away, because there’s nothing to show how it was made. And how is a T-square fractal made? There are many ways. One of the simplest is to set a point jumping 1/2 of the way towards one or another of the four vertices of a square. If the point is banned from jumping towards the vertex two places clockwise (or counter-clockwise) of the vertex, v[i=1..4], it’s just jumped towards, you get a T-square fractal by recording each spot where the point lands.

You also get a T-square if the point is banned from jumping towards the vertex most distant from the vertex, v[i], it’s just jumped towards. The most distant vertex will always be the diagonally opposite vertex, or the vertex, v[i+2], two places clockwise of v[i]. So those two bans are functionally equivalent.

But what if you don’t talk about bans at all? You can also create a T-square fractal by giving the point three choices of increment, [0,1,3], after it jumps towards v[i]. That is, it can jump towards v[i+0], v[i+1] or v[i+3] (where 3+2 = 5 → 5-4 = 1; 3+3 = 6 → 2; 4+1 = 5 → 1; 4+2 = 6 → 2; 4+3 = 7 → 3). Vertex v[i+0] is the same vertex, v[i+1] is the vertex one place clockwise of v[i], and v[i+3] is the vertex two places clockwise of v[i].

So this method is functionally equivalent to the other two bans. But it’s easier to calculate, because you can take the current vertex, v[i], and immediately calculate-and-use the next vertex, without having to check whether the next vertex is forbidden. In other words, if you want speed, you just have to Think Inc!

Speed becomes important when you add a new jumping-target to each side of the square. Now the point has 8 possible targets to jump towards. If you impose several bans on the next jump, e.g the point can’t jump towards v[i+2], v[i+3], v[i+5], v[i+6] and v[i+7], you will have to check for five forbidden targets. But using the increment-set [0,1,4] you don’t have to check for anything. You just inc-and-go:

inc = 0, 1, 4


Here are more fractals created with the speedy inc-and-go method:

inc = 0, 2, 3


inc = 0, 2, 5


inc = 0, 3, 4


inc = 0, 3, 5


inc = 1, 4, 7


inc = 2, 4, 7


inc = 0, 1, 4, 7


inc = 0, 3, 4, 5


inc = 0, 3, 4, 7


inc = 0, 4, 5, 7


inc = 1, 2, 6, 7


With more incs, there are more possible paths for the jumping point and the fractals become more “solid”:

inc = 0, 1, 2, 4, 5


inc = 0, 1, 2, 6, 7


inc = 0, 1, 3, 5, 7


Now try applying inc-and-go to a pentagon:

inc = 0, 1, 2

(open in new window if blurred)


inc = 0, 2, 3


And add a jumping-target to each side of the pentagon:

inc = 0, 2, 5


inc = 0, 3, 6


inc = 0, 3, 7


inc = 1, 5, 9


inc = 2, 5, 8


inc = 5, 6, 9


And add two jumping-targets to each side of the pentagon:

inc = 0, 1, 7


inc = 0, 2, 12


inc = 0, 3, 11


inc = 0, 3, 12


inc = 0, 4, 11


inc = 0, 5, 9


inc = 0, 5, 10


inc = 2, 7, 13


inc = 2, 11, 13


inc = 3, 11, 13


After the pentagon comes the hexagon:

inc = 0, 1, 2


inc = 0, 1, 5


inc = 0, 3, 4


inc = 0, 3, 5


inc = 1, 3, 5


inc = 2, 3, 4


Add a jumping-target to each side of the hexagon:

inc = 0, 2, 5


inc = 0, 2, 9


inc = 0, 6, 11


inc = 0, 3, 6


inc = 0, 3, 8


inc = 0, 3, 9


inc = 0, 4, 7


inc = 0, 4, 8


inc = 0, 5, 6


inc = 0, 5, 8


inc = 1, 5, 9


inc = 1, 6, 10


inc = 1, 6, 11


inc = 2, 6, 8


inc = 2, 6, 10


inc = 3, 5, 7


inc = 3, 6, 9


inc = 6, 7, 11


Boole(b)an #3

In the posts “Boole(b)an #1″ and “Boole(b)an #2” I looked at fractals created by certain kinds of ban on a point jumping (quasi-)randomly towards the four vertices, v=1..4, of a square. For example, suppose the program has a vertex-history of 2, that is, it remembers two jumps into the past, the previous jump and the pre-previous jump. There are sixteen possible combinations of pre-previous and previous jumps: [1,1], [1,2], 1,3] … [4,2], [4,3], [4,4].

Let’s suppose the program bans 4 of those 16 combinations by reference to the current possible jump. For example, it might ban [0,0]; [0,1]; [0,3]; [2,0]. To see what that means, let’s suppose the program has to decide at some point whether or not to jump towards v=3. It will check whether the combination of pre-previous and previous jumps was [3+0,3+0] = [3,3] or [3+0,3+1] = [3,4] or [3+0,3+3] = [3,2] or [3+2,3+0] = [1,3] (when the sum > 4, v = sum-4). If the previous combination is one of those pairs, it bans the jump towards v=3 and chooses another vertex; otherwise, it jumps towards v=3 and updates the vertex-history. This is the fractal that appears when those bans are used:

ban = [0,0]; [0,1]; [0,3]; [2,0]


And here are more fractals using a vertex-history of 2 and a ban on 4 of 16 possible combinations of pre-previous and previous jump:

ban = [0,0]; [0,1]; [0,3]; [2,2]


ban = [0,0]; [0,2]; [1,0]; [3,0]


ban = [0,0]; [0,2]; [1,1]; [3,3]


ban = [0,0]; [0,2]; [1,3]; [3,1]


ban = [0,0]; [1,0]; [2,2]; [3,0]


ban = [0,0]; [1,1]; [1,2]; [3,2]

Continue reading “Boole(b)an #3”…


Elsewhere other-engageable

Boole(b)an #1
Boole(b)an #2