# Back to Drac’ #2

Boring, dull, staid, stiff, everyday, ordinary, unimaginative, unexceptional, crashingly conventional — the only interesting thing about squares is the number of ways you can say how uninteresting they are. Unlike triangles, which vary endlessly and entertainingly, squares are square in every sense of the word.

And they don’t get any better if you tilt them, as here:

Sub-squares from gray square (with corner-numbers)

Nothing interesting can emerge from that set of squares. Or can it? As I showed in Curvous Energy, it can. Suppose that the gray square is dividing into the colored squares like a kind of amoeba. And suppose that the colored squares divide in their turn. So square divides into sub-squares and sub-squares divide into sub-sub-squares. And so on. And all the squares keep the same relative orientation.

What happens if the gray square divides into sub-squares sq2 and sq9? And then sq2 and sq9 each divide into their own sq2 and sq9? And so on. Something very unsquare-like happens:

Square-split stage #1

Stage #2

Square-split #3

Square-split #4

Square-split #5

Square-split #6

Square-split #7

Square-split #8

Square-split #9

Square-split #10

Square-split #11

Square-split #12

Square-split #13

Square-split #14

Square-split #15

Square-split #16

Square-split (animated)

The square-split creates a beautiful fractal known as a dragon-curve:

Dragon-curve

Dragon-curve (red)

And dragon-curves, at various angles and in various sizes, emerge from every other possible pair of sub-squares:

Lots of dragon-curves

And you get other fractals if you manipulate the sub-squares, so that the corners are rotated or reverse-rotated:

Rotation = 1,2 (sub-square #1 unchanged, in sub-square #2 corner 1 becomes corner 2, 2 → 3, 3 → 4, 4 → 1)

rot = 1,2 (animated)

rot = 1,2 (colored)

rot = 1,5 (in sub-square #2 corner 1 stays the same, 4 → 2, 3 stays the same, 2 → 4)

rot = 1,5 (anim)

rot = 4,7 (sub-square #2 flipped and rotated)

rot = 4,7 (anim)

rot = 4,7 (col)

rot = 4,8

rot = 4,8 (anim)

rot = 4,8 (col)

sub-squares = 2,8; rot = 5,6

sub-squares = 2,8; rot = 5,6 (anim)

sub-squares = 2,8; rot = 5,6 (col)

Another kind of dragon-curve — rot = 3,2

rot = 3,2 (anim)

rot = 3,2 (col)

sub-squares = 4,5; rot = 3,9

sub-squares = 4,5; rot = 3,9 (anim)

sub-squares = 4,5; rot = 3,9 (col)

Elsewhere other-accessible…

Curvous Energy — a first look at dragon-curves
Back to Drac’ — a second look at dragon-curves

# 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]

Elsewhere other-engageable

# 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

# Boole(b)an #2

In “Boole(b)an”, I looked at some of the things that happen when you impose bans of different kinds on a point jumping half-way towards a randomly chosen vertex of a square. If the point can’t jump towards the same vertex twice (or more) in a row, you get the fractal below (or rather, you get a messier version of the fractal below, because I’ve used an algorithm that finds all possible routes to create the fractals in this post):

ban = v(i) + 0

If the point can’t jump towards the vertex one place clockwise of the point it has just jumped towards, you get this fractal:

ban = v(i) + 1

If the point can’t jump towards the vertex two places clockwise (or anti-clockwise) of the point it has just jumped towards, you get this fractal:

ban = v(i) + 2

Finally, you get a mirror-image of the one-place-clockwise fractal when the ban is on jumping towards the vertex three places clockwise (or one place anti-clockwise) of the previous vertex:

ban = v(i) + 3

Now let’s introduce the concept of “vertex-history”. The four fractals above use a vertex-history of 1, vh = 1, because they look one step into the past, at the previously chosen vertex. Because there are four vertices, there are four possible previous vertices. But when vh = 2, you’re taking account of both the previous vertex, v(i), and what you might call the pre-previous vertex, v(i-1). There are sixteen possible combinations of previous vertex and pre-previous vertex (16 = 4 x 4).

Now, suppose the jump-ban is imposed when one of two conditions is met: the vertex is 1) one place clockwise of the previous vertex and the same as the pre-previous vertex; 2) three places clockwise of the previous chosen vertex and the same as the pre-previous vertex. So the boolean test is (condition(1) AND condition(2)) OR (condition(3) AND condition(4)). When you apply the test, you get this fractal:

ban = v(i,i-1) + [0,1] or v(i,i-1) + [0,3]

The fractal looks more complex, but I think it’s a blend of some combination of the four classic fractals shown at the beginning of this post. Here are more multiple-ban fractals using vh = 2 and bani = 2:

ban = [0,1] or [1,1]

ban = [0,2] or [2,0]

ban = [0,2] or [2,2]

ban = [1,0] or [3,0]

ban = [1,1] or [3,3]

ban = [1,2] or [2,2]

ban = [1,2] or [3,2]

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

ban = [1,3] or [3,1]

ban = [2,0] or [2,2]

ban = [2,1] or [2,3]

For the fractals below, vh = 2 and bani = 3 (i.e., bans are imposed when one of three possible conditions is met). Again, I think the fractals are blends of some combination of the four classic ban-fractals shown at the beginning of this post:

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

ban = [0,0] or [1,3] or [3,1]

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

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

ban = [0,1] or [0,3] or [1,1]

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

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

ban = [0,1] or [1,1] or [1,2]

ban = [0,1] or [1,1] or [3,0]

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

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

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

ban = [0,2] or [1,2] or [2,2]

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

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

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

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

ban = [0,2] or [2,0] or [2,2]

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

ban = [0,2] or [2,2] or [3,2]

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

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

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

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

ban = [1,1] or [2,1] or [3,1]

ban = [1,1] or [2,2] or [3,3]

ban = [1,1] or [2,3] or [3,3]

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

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

ban = [1,2] or [2,1] or [2,3]

ban = [1,2] or [2,3] or [3,2]

ban = [1,2] or [3,2] or [3,3]

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

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

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

ban = [1,3] or [2,2] or [3,1]

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

ban = [2,1] or [2,3] or [3,2]

Previously pre-posted

Boole(b)an — an early look at ban-fractals

# Fink Frakt

Pre-previously on Overlord-In-Terms-of-Issues-Around-Engagement-with-the-Über-Feral, I’ve looked at various ways of creating fractals by restricting the moves of a point jumping towards the vertices of a polygon. For example, the point can be banned from jumping towards the same vertex twice in a row. This time, I want to look at fractals created not by restriction, but by compulsion. If the point jumps towards vertex v and then tries to jump towards vertex v again, it will be forced to jump towards vertex v+1 instead, and so on.

You could call vv+1 a forced increment or finc. So these are finc fractals. In some cases, restriction and compulsion create the same fractals, but I’ve found some new fractals using compulsion. Consider the fractal created by the rule v[-2]+1, v[-1] → +0,+1, where the subscripts refer to the history of jumps: v[-2] is the jump-before-last, v[-1] is the last jump. If the new vertex, v[0], chosen is the same as v[-2]+1 (e.g., v[0] = 2 = v[-2]+1 = 1+1), then the forced increment is 0, i.e., the point is allowed to choose that jump. However, if v[0] = v[-1], then the forced increment is 1 and the point must jump towards v[-1]+1.

Here is the fractal in question:

v[-2]+1, v[-1] → +0,+1 (black-and-white)

v[-2]+1, v[-1] → +0,+1 (colour)

1,0 → +0,+1 (animated)

1,0 → +1,+0 (bw)

1,0 → +1,+0 (col)

1,0 → +1,+0 (anim)

1,0 → +1,+1 (bw)

1,0 → +1,+1 (col)

1,0 → +1,+1 (animated)

0,1 → +2,+1 (anim)

0,1 → +3,+1

1,0 → +0,+1

1,0 → +1,+0

1,1 → +0,+1

1,1 → +1,+2

1,1 → +1,+3

1,1 → +2,+1

1,2 → +0,+3

1,3 → +0,+1

2,2 → +0,+1

But suppose the history of jumps records not actual jumps, but the jumps the point wanted to make instead. In some cases, the jump made will be the same as the jump originally chosen, but in other cases it won’t. Here are some fractals using this method:

0 → +2

0 → +3

2 → +1

2 → +2

# 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):

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

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

v = 4, ban = prox(3)

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):

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

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

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

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

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:

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

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:

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

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

When sweep = 3, an attractive new fractal appears:

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

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:

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

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

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)):

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

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:

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

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

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

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

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

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

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-triomino rep-tile

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-triomino fractal stage #1

L-triomino fractal stage #2

L-triomino fractal stage #3

L-triomino fractal stage #4

L-triomino fractal stage #5

L-triomino fractal (animated)

L-triomino fractal (close-up)

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

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:

# Polymorphous Perverticity

As I’ve explained before on Overlord of the Über-Feral, the planet’s premier purveyor of polygonic performativity (probably (possibly (perspectivistically))), it works with triangles and pentagons, but not with squares. And what is “it”? A simple procedure in which you create a polygon, choose a point inside it, then repeatedly move half-way towards a vertex chosen at random, marking each new position as you go.

When the polygon has three vertices, you get a Sierpiński triangle. When it has five, you get what might be called a  Sierpiński pentagon. When it has four, you get nothing. Or rather: you get everything, because the whole interior of the square gradually fills with points. But, as I’ve also explained before, there’s a simple way to change this. You can adapt the procedure so that a vertex can’t be chosen twice in a row, and so on.

When the rule is “No vertex twice in a row”, you get this fractal (colours change as a pixel is selected again):

But you can also use what might be a vertex increment, or vi, whereby you disallow vertices that are next to the previously chosen vertex, or two positions away, and so on. When the rule is “No vertex twice in a row”, the disallowed vertex is (v + 0), that is, vi = 0. If vi = 2 and the rule is disallow(v + 2), this fractal appears (when vi = 1, there’s no fractal):

v = 4, vi = 2

You can extend these rules to apply not just to the previously chosen vertex, but also to the vertex chosen before that. Here are some fractals produced by the rule disallow(v[1] + vi[1], v[2] + vi[2]), where v[1] is the vertex previously chosen and v[2] is the vertex chosen before that:

v = 4, vi[1] = 1, vi[2] = 2

v = 4, vi[1] = 2, vi[2] = 0

v = 4, vi[1] = 2, vi[2] = 1

v = 4, vi[1] = 2, vi[2] = 2

And here are some fractals produced by the rule disallow(v[1] + vi[1], v[2] + vi[2], v[3] + vi[3]):

v = 4, vi[1] = 1, vi[2] = 1, vi[3] = 0

v = 4, vi[1] = 1, vi[2] = 1, vi[3] = 2

Applying these rules to pentagons rather than squares doesn’t produce such a dramatic difference, because the original procedure – choose any vertex at random, taking no account of previous choices – produces a fractal when v = 5, as noted above, but not when v = 4. Nevertheless, here are some fractals for v > 4:

v = 5, vi = 0

v = 5, vi = 1

v = 5, vi = 2

v = 5, vi[1] = 0, vi[2] = 0

v = 5, vi[1] = 1, vi[2] = 0

v = 5, vi[1] = 2, vi[2] = 0

v = 5, vi[1] = 1, vi[2] = 1

v = 5, vi[1] = 1, vi[2] = 1, vi[3] = 1

v = 5, vi = various

v = 6, vi = 1

# Hex Appeal

A polyiamond is a shape consisting of equilateral triangles joined edge-to-edge. There is one moniamond, consisting of one equilateral triangle, and one diamond, consisting of two. After that, there are one triamond, three tetriamonds, four pentiamonds and twelve hexiamonds. The most famous hexiamond is known as the sphinx, because it’s reminiscent of the Great Sphinx of Giza:

It’s famous because it is the only known pentagonal rep-tile, or shape that can be divided completely into smaller copies of itself. You can divide a sphinx into either four copies of itself or nine copies, like this (please open images in a new window if they fail to animate):

So far, no other pentagonal rep-tile has been discovered. Unless you count this double-triangle as a pentagon:

It has five sides, five vertices and is divisible into sixteen copies of itself. But one of the vertices sits on one of the sides, so it’s not a normal pentagon. Some might argue that this vertex divides the side into two, making the shape a hexagon. I would appeal to these ancient definitions: a point is “that which has no part” and a line is “a length without breadth” (see Neuclid on the Block). The vertex is a partless point on the breadthless line of the side, which isn’t altered by it.

But, unlike the sphinx, the double-triangle has two internal areas, not one. It can be completely drawn with five continuous lines uniting five unique points, but it definitely isn’t a normal pentagon. Even less normal are two more rep-tiles that can be drawn with five continuous lines uniting five unique points: the fish that can be created from three equilateral triangles and the fish that can be created from four isosceles right triangles: