# Root Routes

Suppose a point traces all possible routes jumping half-way towards the three vertices of an equilateral triangle. A special kind of shape appears — a fractal called the Sierpiński triangle that contains copies of itself at smaller and smaller scales:

Sierpiński triangle, jump = 1/2

And what if the point jumps 2/3rds of the way towards the vertices as it traces all possible routes? You get this dull fractal:

Triangle, jump = 2/3

But if you add targets midway along each side of the triangle, you get this fractal with the 2/3rds jump:

Triangle, jump = 2/3, side-targets

Now try the 1/2-jump triangle with a target at the center of the triangle:

Triangle, jump = 1/2, central target

And the 2/3-jump triangle with side-targets and a central target:

Triangle, jump = 2/3, side-targets, central target

But why stop at simple jumps like 1/2 and 2/3? Let’s take the distance to the target, td, and use the function 1-(sqrt(td/7r)), where sqrt() is the square-root and 7r is 7 times the radius of the circumscribing circle:

Triangle, jump = 1-(sqrt(td/7r))

Here’s the same jump with a central target:

Triangle, jump = 1-(sqrt(td/7r)), central target

Now let’s try squares with various kinds of jump. A square with a 1/2-jump fills evenly with points:

Square, jump = 1/2 (animated)

The 2/3-jump does better with a central target:

Square, jump = 2/3, central target

Or with side-targets:

Square, jump = 2/3, side-targets

Now try some more complicated jumps:

Square, jump = 1-sqrt(td/7r)

Square, jump = 1-sqrt(td/15r), side-targets

And what if you ban the point from jumping twice or more towards the same target? You get this fractal:

Square, jump = 1-sqrt(td/6r), ban = prev+0

Now try a ban on jumping towards the target two places clockwise of the previous target:

Square, jump = 1-sqrt(td/6r), ban = prev+2

And the two-place ban with a central target:

Square, jump = 1-sqrt(td/6r), ban = prev+2, central target

And so on:

Square, jump = 1-sqrt(td/6.93r), ban = prev+2, central target

Square, jump = 1-sqrt(td/7r), ban = prev+2, central target

These fractals take account of the previous jump and the pre-previous jump:

Square, jump = 1-sqrt(td/4r), ban = prev+2,2, central target

Square, jump = 1-sqrt(td/5r), ban = prev+2,2, central target

Square, jump = 1-sqrt(td/6r), ban = prev+2,2, central target

Elsewhere other-accessible

Boole(b)an #2 — fractals created in similar ways

# This Charming Dis-Arming

One of the charms of living in an old town or city is finding new routes to familiar places. It’s also one of the charms of maths. Suppose a three-armed star sprouts three half-sized arms from the end of each of its three arms. And then sprouts three quarter-sized arms from the end of each of its nine new arms. And so on. This is what happens:

Three-armed star

3-Star sprouts more arms

Sprouting 3-Star #3

Sprouting 3-Star #4

Sprouting 3-Star #5

Sprouting 3-Star #6

Sprouting 3-Star #7

Sprouting 3-Star #8

Sprouting 3-Star #9

Sprouting 3-Star #10

Sprouting 3-Star #11 — the Sierpiński triangle

Sprouting 3-star (animated)

The final stage is a famous fractal called the Sierpiński triangle — the sprouting 3-star is a new route to a familiar place. But what happens when you trying sprouting a four-armed star in the same way? This does:

Four-armed star #1

Sprouting 4-Star #2

Sprouting 4-Star #3

Sprouting 4-Star #4

Sprouting 4-Star #5

Sprouting 4-Star #6

Sprouting 4-Star #7

Sprouting 4-Star #8

Sprouting 4-Star #9

Sprouting 4-Star #10

Sprouting 4-star (animated)

There’s no obvious fractal with a sprouting 4-star. Not unless you dis-arm the 4-star in some way. For example, you can ban any new arm sprouting in the same direction as the previous arm:

Dis-armed 4-star (+0) #1

Dis-armed 4-Star (+0) #2

Dis-armed 4-Star (+0) #3

Dis-armed 4-Star (+0) #4

Dis-armed 4-Star (+0) #5

Dis-armed 4-Star (+0) #6

Dis-armed 4-Star (+0) #7

Dis-armed 4-Star (+0) #8

Dis-armed 4-Star (+0) #9

Dis-armed 4-Star (+0) #10

Dis-armed 4-star (+0) (animated)

Once again, it’s a new route to a familiar place (for keyly committed core components of the Overlord-of-the-Über-Feral community, anyway). Now try banning an arm sprouting one place clockwise of the previous arm:

Dis-armed 4-Star (+1) #1

Dis-armed 4-Star (+1) #2

Dis-armed 4-Star (+1) #3

Dis-armed 4-Star (+1) #4

Dis-armed 4-Star (+1) #5

Dis-armed 4-Star (+1) #6

Dis-armed 4-Star (+1) #7

Dis-armed 4-Star (+1) #8

Dis-armed 4-Star (+1) #9

Dis-armed 4-Star (+1) #10

Dis-armed 4-Star (+1) (animated)

Again it’s a new route to a familiar place. Now trying banning an arm sprouting two places clockwise (or anti-clockwise) of the previous arm:

Dis-armed 4-Star (+2) #1

Dis-armed 4-Star (+2) #2

Dis-armed 4-Star (+2) #3

Dis-armed 4-Star (+2) #4

Dis-armed 4-Star (+2) #5

Dis-armed 4-Star (+2) #6

Dis-armed 4-Star (+2) #7

Dis-armed 4-Star (+2) #8

Dis-armed 4-Star (+2) #9

Dis-armed 4-Star (+2) #10

Dis-armed 4-Star (+2) (animated)

Once again it’s a new route to a familiar place. And what happens if you ban an arm sprouting three places clockwise (or one place anti-clockwise) of the previous arm? You get a mirror image of the Dis-armed 4-Star (+1):

Dis-armed 4-Star (+3)

Here’s the Dis-armed 4-Star (+1) for comparison:

Dis-armed 4-Star (+1)

Elsewhere other-accessible

Boole(b)an #2 — other routes to the fractals seen above

# Dissing the Diamond

In “Fractangular Frolics” I looked at how you could create fractals by choosing lines from a dissected equilateral or isosceles right triangle. Now I want to look at fractals created from the lines of a dissected diamond, as here:

Lines in a dissected diamond

Let’s start by creating one of the most famous fractals of all, the Sierpiński triangle:

Sierpiński triangle stage 1

Sierpiński triangle #2

Sierpiński triangle #3

Sierpiński triangle #4

Sierpiński triangle #5

Sierpiński triangle #6

Sierpiński triangle #7

Sierpiński triangle #8

Sierpiński triangle #9

Sierpiński triangle #10

Sierpiński triangle (animated)

However, you can get an infinite number of Sierpiński triangles with three lines from the diamond:

Sierpińfinity #1

Sierpińfinity #2

Sierpińfinity #3

Sierpińfinity #4

Sierpińfinity #5

Sierpińfinity #6

Sierpińfinity #7

Sierpińfinity #8

Sierpińfinity #9

Sierpińfinity #10

Sierpińfinity (animated)

Here are some more fractals created from three lines of the dissected diamond (sometimes the fractals are rotated to looked better):

And in these fractals one or more of the lines are flipped to create the next stage of the fractal:

Previously pre-posted:

Fractangular Frolics — fractals created in a similar way

Dissecting the Diamond — fractals from another kind of diamond

# Agnathous Analysis

In Mandibular Metamorphosis, I looked at two distinct fractals and how you could turn one into the other in one smooth sweep. The Sierpiński triangle was one of the fractals:

Sierpiński triangle

The T-square fractal was the other:

T-square fractal (or part thereof)

And here they are turning into each other:

Sierpiński ↔ T-square (anim)
(Open in new window if distorted)

But what exactly is going on? To answer that, you need to see how the two fractals are created. Here are the stages for one way of constructing the Sierpiński triangle:

Sierpiński triangle #1

Sierpiński triangle #2

Sierpiński triangle #3

Sierpiński triangle #4

Sierpiński triangle #5

Sierpiński triangle #6

Sierpiński triangle #7

Sierpiński triangle #8

Sierpiński triangle #9

When you take away all the construction lines, you’re left with a simple Sierpiński triangle:

Constructing a Sierpiński triangle (anim)

Now here’s the construction of a T-square fractal:

T-square fractal #1

T-square fractal #2

T-square fractal #3

T-square fractal #4

T-square fractal #5

T-square fractal #6

T-square fractal #7

T-square fractal #8

T-square fractal #9

Take away the construction lines and you’re left with a simple T-square fractal:

T-square fractal

Constructing a T-square fractal (anim)

And now it’s easy to see how one turns into the other:

Sierpiński → T-square #1

Sierpiński → T-square #2

Sierpiński → T-square #3

Sierpiński → T-square #4

Sierpiński → T-square #5

Sierpiński → T-square #6

Sierpiński → T-square #7

Sierpiński → T-square #8

Sierpiński → T-square #9

Sierpiński → T-square #10

Sierpiński → T-square #11

Sierpiński → T-square #12

Sierpiński → T-square #13

Sierpiński ↔ T-square (anim)
(Open in new window if distorted)

Post-Performative Post-Scriptum

Mandibular Metamorphosis also looked at a third fractal, the mandibles or jaws fractal. Because I haven’t included the jaws fractal in this analysis, the analysis is therefore agnathous, from Ancient Greek ἀ-, a-, “without”, + γνάθ-, gnath-, “jaw”.

# Mandibular Metamorphosis

Here’s the famous Sierpiński triangle:

Sierpiński triangle

And here’s the less famous T-square fractal:

T-square fractal (or part of it, at least)

How do you get from one to the other? Very easily, as it happens:

From Sierpiński triangle to T-square (and back again) (animated)
(Open in new window if distorted)

Now, here are the Sierpiński triangle, the T-square fractal and what I call the mandibles or jaws fractal:

Sierpiński triangle

T-square fractal

Mandibles / Jaws fractal

How do you cycle between them? Again, very easily:

From Sierpiński triangle to T-square to Mandibles (and back again) (animated)
(Open in new window if distorted)

Elsewhere other-accessible…

Agnathous Analysis — a closer look at these shapes

# Controlled Chaos

The chaos game is a simple mathematical technique for creating fractals. Suppose a point jumps over and over again 1/2 of the distance towards a randomly chosen vertex of a triangle. This shape appears, the so-called Sierpiński triangle:

Sierpiński triangle created by the chaos game

But the jumps don’t have to be random: you can use an array to find every possible combination of jumps and so create a more even image. I call this controlled chaos. However, if you try the chaos game (controlled or otherwise) with a square, no fractal appears unless you restrict the vertex chosen in some way. For example, if the point can’t jump towards the same vertex twice or more in a row, this fractal appears:

Ban on jumping towards previously chosen vertex, i.e. v + 0

And if the point can’t jump towards the vertex one place clockwise of the previously chosen vertex, this fractal appears:

Ban on v + 1

If the point can’t jump towards the vertex two places clockwise of the previously chosen vertex, this fractal appears:

Ban on v + 2

If the point can’t jump towards the vertex three places clockwise, or one place anticlockwise, of the previously chosen vertex, this fractal appears (compare v + 1 above):

Ban on v + 3

You can also ban vertices based on how close the point is to them at any given moment. Suppose that the point can’t jump towards the nearest vertex, which means that it must choose to jump towards either the 2nd-nearest, 3rd-nearest or 4th-nearest vertex. A fractal we’ve already seen appears:

In effect, not jumping towards the nearest vertex means not jumping towards a vertex twice or more in a row. Another familiar fractal appears if the point can’t jump towards the most distant vertex:

d = 1,2,3

But new fractals also appear when the jumps are determined by distance:

d = 1,2,4

d = 1,3,4

And you can add more targets for the jumping point midway between the vertices of the square:

d = 1,2,8

d = 1,4,6

d = 1,6,8

d = 1,7,8

d = 2,3,6

d = 2,3,8

d = 2,4,8

d = 2,5,6

And what if you choose the next vertex by incrementing the previously chosen vertex? Suppose the initial vertex is 1 and the possible increments are 1, 2 and 2. This new fractal appears:

increment = 1,2,2 (for example, 1 + 1 = 2, 2 + 2 = 4, 4 + 2 = 6, and 6 is adjusted thus: 6 – 4 = 2)

And with this set of increments, it’s déjà vu all over again:

i = 2,2,3

And again:

i = 2,3,2

With more possible increments, familiar fractals appear in unfamiliar ways:

i = 1,3,2,3

i = 1,3,3,2

i = 1,4,3,3

i = 2,1,2,2

i = 2,1,3,4

i = 2,2,3,4

i = 3,1,1,2

Now try increments with midpoints on the sides:

v = 4 + midpoints, i = 1,2,4

As we saw above, this incremental fractal can also be created from a square with four vertices and no midpoints:

i = 1,3,3; initial vertex = 1

But the fractal changes when the initial vertex is set to 2, i.e. to one of the midpoints:

i = 1,3,3; initial vertex = 2

And here are more inc-fractals with midpoints:

i = 1,4,2 (cf. inc-fractal 1,2,4 above)

i = 1,4,8

i = 2,6,3

i = 3,2,6

i = 4,7,8

i = 1,2,3,5

i = 1,4,5,4

i = 6,2,4,1

i = 7,6,2,2

i = 7,8,2,4

i = 7,8,4,2

# Hour Power

Would it be my favorite fractal if I hadn’t discovered it for myself? It might be, because I think it combines great simplicity with great beauty. I first came across it when I was looking at this rep-tile, that is, a shape that can be divided into smaller copies of itself:

Rep-4 L-Tromino

It’s called a L-tromino and is a rep-4 rep-tile, because it can be divided into four copies of itself. If you divide the L-tromino into four sub-copies and discard one particular sub-copy, then repeat again and again, you’ll get this fractal:

Tromino fractal #1

Tromino fractal #2

Tromino fractal #3

Tromino fractal #4

Tromino fractal #5

Tromino fractal #6

Tromino fractal #7

Tromino fractal #8

Tromino fractal #9

Tromino fractal #10

Tromino fractal #11

Hourglass fractal (animated)

I call it an hourglass fractal, because it reminds me of an hourglass:

A real hourglass

The hourglass fractal for comparison

I next came across the hourglass fractal when applying the same divide-and-discard process to a rep-4 square. The first fractal that appears is the Sierpiński triangle:

Square to Sierpiński triangle #1

Square to Sierpiński triangle #2

Square to Sierpiński triangle #3

[…]

Square to Sierpiński triangle #10

Square to Sierpiński triangle (animated)

However, you can rotate the sub-squares in various ways to create new fractals. Et voilà, the hourglass fractal appears again:

Square to hourglass #1

Square to hourglass #2

Square to hourglass #3

Square to hourglass #4

Square to hourglass #5

Square to hourglass #6

Square to hourglass #7

Square to hourglass #8

Square to hourglass #9

Square to hourglass #10

Square to hourglass #11

Square to hourglass (animated)

Finally, I was looking at variants of the so-called chaos game. In the standard chaos game, a point jumps half-way towards the randomly chosen vertices of a square or other polygon. In this variant of the game, I’ve added jump-towards-able mid-points to the sides of the square and restricted the point’s jumps: it can only jump towards the points that are first-nearest, seventh-nearest and eighth-nearest. And again the hourglass fractal appears:

Chaos game to hourglass #1

Chaos game to hourglass #2

Chaos game to hourglass #3

Chaos game to hourglass #4

Chaos game to hourglass #5

Chaos game to hourglass #6

Chaos game to hourglass (animated)

But what if you want to create the hourglass fractal directly? You can do it like this, using two isosceles triangles set apex-to-apex in the form of an hourglass:

Triangles to hourglass #1

Triangles to hourglass #2

Triangles to hourglass #3

Triangles to hourglass #4

Triangles to hourglass #5

Triangles to hourglass #6

Triangles to hourglass #7

Triangles to hourglass #8

Triangles to hourglass #9

Triangles to hourglass #10

Triangles to hourglass #11

Triangles to hourglass #12

Triangles to hourglass (animated)

# Dilating the Delta

A circle with a radius of one unit has an area of exactly π units = 3.141592… units. An equilateral triangle inscribed in the unit circle has an area of 1.2990381… units, or 41.34% of the area of the unit circle.

In other words, triangles are cramped! And so it’s often difficult to see what’s going on in a triangle. Here’s one example, a fractal that starts by finding the centre of the equilateral triangle:

Triangular fractal stage #1

Next, use that central point to create three more triangles:

Triangular fractal stage #2

And then use the centres of each new triangle to create three more triangles (for a total of nine triangles):

Triangular fractal stage #3

And so on, trebling the number of triangles at each stage:

Triangular fractal stage #4

Triangular fractal stage #5

As you can see, the triangles quickly become very crowded. So do the central points when you stop drawing the triangles:

Triangular fractal stage #6

Triangular fractal stage #7

Triangular fractal stage #8

Triangular fractal stage #9

Triangular fractal stage #10

Triangular fractal stage #11

Triangular fractal stage #12

Triangular fractal stage #13

Triangular fractal (animated)

The cramping inside a triangle is why I decided to dilate the delta like this:

Triangular fractal

Circular fractal from triangular fractal

Triangular fractal to circular fractal (animated)

Formation of the circular fractal (animated)

And how do you dilate the delta, or convert an equilateral triangle into a circle? You use elementary trigonometry to expand the perimeter of the triangle so that it lies on the perimeter of the unit circle. The vertices of the triangle don’t move, because they already lie on the perimeter of the circle, but every other point, p, on the perimeter of the triangles moves outward by a fixed amount, m, depending on the angle it makes with the center of the triangle.

Once you have m, you can move outward every point, p(1..i), that lies between p on the perimeter and the centre of the triangle. At least, that’s the theory between the dilation of the delta. In practice, all you need is a point, (x,y), inside the triangle. From that, you can find the angle, θ, and distance, d, from the centre, calculate m, and move (x,y) to d * m from the centre.

You can apply this technique to any fractal created in an equilateral triangle. For example, here’s the famous Sierpiński triangle in its standard form as a delta, then as a dilated delta or circle:

Sierpiński triangle

Sierpiński triangle to circular Sierpiński fractal

Sierpiński triangle to circle (animated)

But why stop at triangles? You can use the same elementary trigonometry to convert any regular polygon into a circle. A square inscribed in a unit circle has an area of 2 units, or 63.66% of the area of the unit circle, so it too is cramped by comparison with the circle. Here’s a square fractal that I’ve often posted before:

Square fractal, jump = 1/2, ban on jumping towards any vertex twice in a row

It’s created by banning a randomly jumping point from moving twice in a row 1/2 of the distance towards the same vertex of the square. When you dilate the fractal, it looks like this:

Circular fractal from square fractal, j = 1/2, ban on jumping towards vertex v(i) twice in a row

Circular fractal from square (animated)

And here’s a related fractal where the randomly jumping point can’t jump towards the vertex directly clockwise from the vertex it’s previously jumped towards (so it can jump towards the same vertex twice or more):

Square fractal, j = 1/2, ban on vertex v(i+1)

When the fractal is dilated, it looks like this:

Circular fractal from square, i = 1

Circular fractal from square (animated)

In this square fractal, the randomly jumping point can’t jump towards the vertex directly opposite the vertex it’s previously jumped towards:

Square fractal, ban on vertex v(i+2)

And here is the dilated version:

Circular fractal from square, i = 2

Circular fractal from square (animated)

And there are a lot more fractals where those came from. Infinitely many, in fact.

# Performativizing the Polygonic #2

Suppose a café offers you free drinks for three days. You can have tea or coffee in any order and any number of times. If you want tea every day of the three, you can have it. So here’s a question: how many ways can you choose from two kinds of drink in three days? One simple way is to number each drink, tea = 1, coffee = 2, then count off the choices like this:

1: 111
2: 112
3: 121
4: 122
5: 211
6: 212
7: 221
8: 222

Choice #1 is 111, which means tea every day. Choice #6 is 212, which means coffee on day 1, tea on day 2 and coffee on day 3. Now look at the counting again and the way the numbers change: 111, 112, 121, 122, 211… It’s really base 2 using 1 and 2 rather than 0 and 1. That’s why there are 8 ways to choose two drinks over three days: 8 = 2^3. Next, note that you use the same number of 1s to count the choices as the number of 2s. There are twelve 1s and twelve 2s, because each number has a mirror: 111 has 222, 112 has 221, 121 has 212, and so on.

Now try the number of ways to choose from three kinds of drink (tea, coffee, orange juice) over two days:

11, 12, 13, 21, 22, 23, 31, 32, 33 (c=9)

There are 9 ways to choose, because 9 = 3^2. And each digit, 1, 2, 3, is used exactly six times when you write the choices. Now try the number of ways to choose from three kinds of drink over three days:

111, 112, 113, 121, 122, 123, 131, 132, 133, 211, 212, 213, 221, 222, 223, 231, 232, 233, 311, 312, 313, 321, 322, 323, 331, 332, 333 (c=27)

There are 27 ways and (by coincidence) each digit is used 27 times to write the choices. Now try three drinks over four days:

1111, 1112, 1113, 1121, 1122, 1123, 1131, 1132, 1133, 1211, 1212, 1213, 1221, 1222, 1223, 1231, 1232, 1233, 1311, 1312, 1313, 1321, 1322, 1323, 1331, 1332, 1333, 2111, 2112, 2113, 2121, 2122, 2123, 2131, 2132, 2133, 2211, 2212, 2213, 2221, 2222, 2223, 2231, 2232, 2233, 2311, 2312, 2313, 2321, 2322, 2323, 2331, 2332, 2333, 3111, 3112, 3113, 3121, 3122, 3123, 3131, 3132, 3133, 3211, 3212, 3213, 3221, 3222, 3223, 3231, 3232, 3233, 3311, 3312, 3313, 3321, 3322, 3323, 3331, 3332, 3333 (c=81)

There are 81 ways to choose and each digit is used 108 times. But the numbers don’t have represent choices of drink in a café. How many ways can a point inside an equilateral triangle jump four times half-way towards the vertices of the triangle? It’s the same as the way to choose from three drinks over four days. And because the point jumps toward each vertex in a symmetrical way the same number of times, you get a nice even pattern, like this:

vertices = 3, jump = 1/2

Every time the point jumps half-way towards a particular vertex, its position is marked in a unique colour. The fractal, also known as a Sierpiński triangle, actually represents all possible choices for an indefinite number of jumps. Here’s the same rule applied to a square. There are four vertices, so the point is tracing all possible ways to choose four vertices for an indefinite number of jumps:

v = 4, jump = 1/2

As you can see, it’s not an obvious fractal. But what if the point jumps two-thirds of the way to its target vertex and an extra target is added at the centre of the square? This attractive fractal appears:

v = 4 + central target, jump = 2/3

If the central target is removed and an extra target is added on each side, this fractal appears:

v = 4 + 4 midpoints, jump = 2/3

That fractal is known as a Sierpiński carpet. Now up to the pentagon. This fractal of endlessly nested contingent pentagons is created by a point jumping 1/φ = 0·6180339887… of the distance towards the five vertices:

v = 5, jump = 1/φ

With a central target in the pentagon, this fractal appears:

v = 5 + central, jump = 1/φ

The central red pattern fits exactly inside the five that surround it:

v = 5 + central, jump = 1/φ (closeup)

v = 5 + c, jump = 1/φ (animated)

For a fractal of endlessly nested contingent hexagons, the jump is 2/3:

v = 6, jump = 2/3

With a central target, you get a filled variation of the hexagonal fractal:

v = 6 + c, jump = 2/3

And for a fractal of endlessly nested contingent octagons, the jump is 1/√2 = 0·7071067811… = √½:

v = 8, jump = 1/√2

Previously pre-posted:

# Square Routes Revisited

Take a square, divide it into four smaller squares, and discard the smaller square on the top right. Do the same to each of the subsquares, dividing it into four sub-subsquares, then discarding the one on the top right. And repeat with the sub-subsquares. And the sub-sub-squares. And the sub-sub-sub-squares. And so on. The result is a fractal like this:

Stage 1

Stage 2

Stage 3

Stage 4

Animated fractal

Final fractal (static)

It looks as though this procedure isn’t very fertile. But you can enrich it by rotating each of the subsquares in a different way, so that the discarded sub-subsquare is different. Here’s an example:

Stage 1

Stage 2

Stage 3

Stage 4

Stage 5

Stage 6

Stage 7

Animated fractal

Final fractal (static)

Here are more examples of how rotating the subsquares in different ways produces different fractals:

Animated fractal

Static fractal

Animated fractal

Static fractal

Animated fractal

Static fractal

Animated fractal

Static fractal

Animated fractal

Static fractal

Animated fractal

Static fractal

Animated fractal

Static fractal

Animated fractal

Static fractal

Animated fractal

Static fractal

Animated fractal

Static fractal

Animated fractal

Static fractal

Animated fractal

Static fractal

Animated fractal

Static fractal

Animated fractal

Static fractal

Animated fractal

Static fractal

Previously pre-posted:

Square Routes — first look at this kind of fractal