Square Routes

One of the pleasures of exploring an ancient city like York or Chester is that of learning new routes to the same destination. There are byways and alleys, short-cuts and diversions. You set off intending to go to one place and end up in another.

Maths is like that, even at its simplest. There are many routes to the same destination. I first found the fractal below by playing with the L-triomino, or the shape created by putting three squares in the shape of an L. You can divide it into four copies of the same shape and discard one copy, then do the same to each of the sub-copies, then repeat. I’ve decided to call it the hourglass fractal:

l-triomino_124

Hourglass fractal (animated)


l-triomino_124_upright_static1

Hourglass fractal (static)


Then I unexpectedly came across the fractal again when playing with what I call a proximity fractal:
v4_ban15_sw3_anim

Hourglass animated (proximity fractal)


v4_ban15_sw3_col

(Static image)


Now I’ve unexpectedly come across it for a third time, playing with a very simple fractal based on a 2×2 square. At first glance, the 2×2 square yields only one interesting fractal. If you divide the square into four smaller squares and discard one square, then do the same to each of the three sub-copies, then repeat, you get a form of the Sierpiński triangle, like this:

sq2x2_123_1

Sierpiński triangle stage 1


sq2x2_123_2

Sierpiński triangle #2


sq2x2_123_3

Sierpiński triangle #3


sq2x2_123_4

Sierpiński triangle #4


sq2x2_123

Sierpiński triangle animated


sq2x2_123_static

(Static image)


The 2×2 square seems too simple for anything more, but there’s a simple way to enrich it: label the corners of the sub-squares so that you can, as it were, individually rotate them 0°, 90°, 180°, or 270°. One set of rotations produces the hourglass fractal, like this:

sq2x2_123_013_1

Hourglass stage 1


sq2x2_123_013_2

Hourglass #2


sq2x2_123_013_3

Fractal #3


sq2x2_123_013_4

Hourglass #4


sq2x2_123_013_5

Hourglass #5


sq2x2_123_013_6

Hourglass #6


sq2x2_123_013

Hourglass animated


sq2x2_123_013_static

(Static image)


Here are some more fractals from the 2×2 square created using this technique (I’ve found some of them previously by other routes):

sq2x2_123_022


sq2x2_123_022_static

(Static image)


sq2x2_123_031


sq2x2_123_031_static

(Static image)


sq2x2_123_102


sq2x2_123_102_static

(Static image)


sq2x2_123_2011


sq2x2_123_201_static

(Static image)


sq2x2_123_211


sq2x2_123_211_static

(Static image)


sq2x2_123_213


sq2x2_123_213_static

(Static image)


sq2x2_123_033_-111


sq2x2_123_033_-111_static

(Static image)


sq2x2_123_201_1-11_static

(Static image)


sq2x2_200_1-11_static

(Static image)


sq2x2_123_132

(Static image)


Advertisements

Tri-Way to L

The name is more complicated than the shape: L-triomino. The shape is simply three squares forming an L. And it’s a rep-tile — it can be divided into four smaller copies of itself.

l-triomino

An L-triomino — three squares forming an L


l-triomino_anim

L-triomino as rep-tile


That means it can also be turned into a fractal, as I’ve shown in Rep-Tiles Revisited and Get Your Prox Off #2. First you divide an L-triomino into four sub-copies, then discard one sub-copy, then repeat. Here are the standard L-triomino fractals produced by this technique:

l-triomino_123_134

Fractal from L-triomino — divide and discard


l-triomino_234


l-triomino_124


l-triomino_124_upright


l-triomino_124_upright_static1

(Static image)


l-triomino_124_upright_static2

(Static image)


But those fractals don’t exhaust the possibilities of this very simple shape. The standard L-triomino doesn’t have true chirality. That is, it doesn’t come in left- and right-handed forms related by mirror-reflection. But if you number its corners for the purposes of sub-division, you can treat it as though it comes in two distinct orientations. And when the orientations are different in the different sub-copies, new fractals appear. You can also delay the stage at which you discard the first sub-copy. For example, you can divide the L-triomino into four sub-copies, then divide each sub-copy into four more sub-copies, and only then begin discarding.

Here are the new fractals that appear when you apply these techniques:

l-triomino_124_exp

Delay before discarding


l-triomino_124_exp_static

(Static image)


l-triomino_124_tst2_static1

(Static image)


l-triomino_124_tst2_static2

(Static image)


l-triomino_124_tst1


l-triomino_124_tst1_static1

(Static image)


l-triomino_124_tst1_static2

(Static image)


l-triomino_134_adj1

Adjust orientation


l-triomino_134_adj2


l-triomino_134_adj3


l-triomino_134_adj3_tst3

(Static image)


l-triomino_134_adj4


l-triomino_134_exp_static

(Static image)


l-triomino_234_exp

Get Your Prox Off #2

Serendipity is the art of making happy discoveries by accident. I made a mistake writing a program to create fractals and made the happy discovery of an attractive new fractal. And also of a new version of an attractive fractal I had seen before.

As I described in Get Your Prox Off, you can create a fractal by 1) moving a point towards a randomly chosen vertex of a polygon, but 2) forbidding a move towards the nearest vertex or the second-nearest vertex or third-nearest, and so on. If the polygon is a square, the four possible basic fractals look like this (note that the first fractal is also produced by banning a move towards a vertex that was chosen in the previous move):

v4_ban1

v = 4, ban = prox(1)
(ban move towards nearest vertex)


v4_ban2

v = 4, ban = prox(2)
(ban move towards second-nearest vertex)


v4_ban3

v = 4, ban = prox(3)


v4_ban4

v = 4, ban = prox(4)


This program has to calculate what might be called the order of proximity: that is, it creates an array of distances to each vertex, then sorts the array by increasing distance. I was using a bubble-sort, but made a mistake so that the program ran through the array only once and didn’t complete the sort. If this happens, the fractals look like this (note that vertex 1 is on the right, with vertex 2, 3 and 4 clockwise from it):
v4_ban1_sw1

v = 4, ban = prox(1), sweep = 1


v4_ban2_sw1

v = 4, ban = prox(2), sweep = 1


v4_ban3_sw1

v = 4, ban = prox(3), sweep = 1


v4_ban3_sw1_anim

(Animated version of v4, ban(prox(3)), sw=1)


v4_ban4_sw1

v = 4, ban = prox(4), sweep = 1


Note that in the last case, where ban = prox(4), a bubble-sort needs only one sweep to identify the most distant vertex, so the fractal looks the same as it does with a complete bubble-sort.

These new fractals looked interesting, so I had the idea of adjusting the number of sweeps in the incomplete bubble-sort: one sweep or two or three and so on (with enough sweeps, the bubble-sort becomes complete, but more sweeps are needed to complete a sort as the number of vertices increases). If there are two sweeps, then ban(prox(1)) and ban(prox(2)) look like this:

v4_ban1_sw2

v = 4, ban = prox(1), sweep = 2


v4_ban2_sw1

v = 4, ban = prox(2), sweep = 2


But the fractals produced by sweep = 2 for ban(prox(3)) and ban(prox(4)) are identical to the fractals produced by a complete bubble sort. Now, suppose you add a central point to the polygon and treat that as an additional vertex. If the bubble-sort is incomplete, a ban(prox(1)) fractal with a central point looks like this:

v4c_ban1_sw1

v = 4+c, ban = prox(1), sw = 1


v4c_ban1_sw2

v = 4+c, ban = prox(1), sw = 2


When sweep = 3, an attractive new fractal appears:

v4c_ban1_sw3

v = 4+c, ban = prox(1), sw = 3


v4c_ban1_sw3_anim

v = 4+c, ban = prox(1), sw = 3 (animated)


If you ban two vertices, the nearest and second-nearest, i.e. ban(prox(1), prox(2)), a complete bubble-sort produces a familiar fractal:

v4_ban12

v = 4+c, ban = prox(1), prox(2)


And here is ban(prox(2), prox(4)), with a complete bubble-sort:

v4c_ban24

v = 4, ban = prox(2), prox(4)


If the bubble-sort is incomplete, sweep = 1 and sweep = 2 produce these fractals for ban(prox(1), prox(2)):

v4_ban12_sw1

v = 4, ban = prox(1), prox(2), sw = 1


v4_ban12_sw2

v = 4, ban = prox(1), prox(2), sw = 2*

*The second of those fractals is identical to v = 4, ban(prox(2), prox(3)) with a complete bubble-sort.


Here is ban(prox(1), prox(5)) with a complete bubble-sort:

4c_ban15

v = 4, ban = prox(1), prox(5)


Now try ban(prox(1), prox(5)) with an incomplete bubble-sort:

v4_ban15_sw1

v = 4, ban = prox(1), prox(5), sw = 1


v4_ban15_sw2

v = 4, ban = prox(1), prox(5), sw = 2


When sweep = 3, the fractal I had seen before appears:

v4_ban15_sw3

v = 4, ban = prox(1), prox(5), sw = 3


v4_ban15_sw3_anim

v = 4, ban = prox(1), prox(5), sw = 3 (animated)


Where had I seen it before? While investigating this rep-tile (a shape that can be tiled with smaller versions of itself):

L-reptile

L-triomino rep-tile


L-reptile_anim

L-triomino rep-tile (animated)


The rep-tile is technically called an L-triomino, because it looks like a capital L and is one of the two distinct shapes you can create by joining three squares at the edges. You can create fractals from an L-triomino by dividing it into four copies, discarding one of the copies, then repeating the divide-and-discard at smaller and smaller scales:

L-reptile_1

L-triomino fractal stage #1


L-reptile_2

L-triomino fractal stage #2


L-reptile_3

L-triomino fractal stage #3


L-reptile_4

L-triomino fractal stage #4


L-reptile_5

L-triomino fractal stage #5


L-reptile_fractal_anim

L-triomino fractal (animated)

L-reptile_fractal_static

L-triomino fractal (close-up)

And here’s part of the ban(prox(1), prox(5)) fractal for comparison:

v4_ban15_sw3_mono


v4_ban15_sw3_col

So you can get to the same fractal (or versions of it), by two apparently different routes: random movement of a point inside a square or repeatedly dividing-and-discarding the sub-copies of an L-triomino. That’s serendipity!


Previously pre-posted:

Get Your Prox Off