Bent for the Pent

A triangle can be tiled with triangles and a square with squares, but a pentagon can’t be tiled with pentagons. At least, not in the same way, using smaller copies of the same shape. The closest you can get is this:

Pentaflake #1

If you further subdivide the pentagon, you create what is known as a pentaflake:

Pentaflake #2

Pentaflake #3

Pentaflake #4

Pentaflake (animated)

Pentaflake (static)

But if you bend the rules and use irregular smaller pentagons, you can tile a pentagon like this, creating what I called a pentatile:

Pentatile stage 1

Further subdivisions create an interesting final pattern:

Pentatile #2

Pentatile #3

Pentatile #4

Pentatile #5

Pentatile #6

Pentatile (animated)

Pentatile (static)

By varying the size of the central pentagon, you can create other patterns:

Pentatile #1 (animated)

Pentatile #2 (animated)

Pentatile #2

Pentatile with no central pentagon

And here are various pentatiles in an animated gif:

And here are some variations on the pentaflake:

Elsewhere other-posted:

Bent for the Rent (1976) — the title of the incendiary intervention above is of course a reference to the “first and last glitter-rock album” by England’s loudest band, Spinal In Terms Of Tap
Phrallic Frolics — more on pentaflakes


Phrallic Frolics

It’s a classic of low literature:

There was a young man of Devizes
Whose balls were of different sizes:
     The one was so small
     ’Twas no use at all;
But t’other won several prizes.

But what if he had been a young man with balls of different colours? This is a core question I want to interrogate issues around in terms of the narrative trajectory of this blog-post. Siriusly. But it’s not the keyliest core question. More corely keyly still, I want to ask what a fractal phallus might look like. Or a phrallus, for short. The narrative trajectory initializes with this fractal, which is known as a pentaflake (so-named from its resemblance to a snowflake):

Pentaflake — a pentagon-based fractal

It’s created by repeatedly replacing pentagons with six smaller pentagons, like this:

Pentaflake stage 0

Pentaflake stage 1

Pentaflake stage 2

Pentaflake stage 3

Pentaflake stage 3

Pentaflake stage 4

Pentaflake (animated)

Pentaflake (static)

This is another version of the pentaflake, missing the central pentagon of the six used in the standard pentaflake:

No-Center Pentaflake stage 0

No-Center Pentaflake stage 1

Stage 2

Stage 3

Stage 4

No-Center Pentaflake (animated)

No-Center Pentaflake (static #1)

No-Center Pentaflake (static #2)

The phrallus, or fractal phallus, begins with an incomplete version of the first stage of the pentaflake (note balls of different colours):

Phrallus stage 1

Phrallus stage 1 (monochrome)

Phrallus stage 2

Phrallus stage 3

Stage 4

Stage 5

Stage 6

Stage 7

Stage 8

And there you have it: a fractal phallus, or phrallus. Here is an animated version:

Phrallus (animated)

Phrallus (static)

But the narrative trajectory is not over. The center of the phrallus can be rotated to yield mutant phralloi. Stage #1 of the mutants looks like this:

Phrallus (mutation #1)

Phrallus (mutation #2)

Phrallus (mutation #3)

Phrallus (mutation #4)

Phrallus (mutation #5)

Mutant phralloi (rotating)

Here are some animations of the mutant phralloi:

Phrallus (mutation #3) (animated)

Phrallus (mutation #5) (animated)

This mutation doesn’t position the pentagons in the usual way:

Phrallus (another upright version) (animated)

The static mutant phralloi look like this:

Phrallus (mutation #2)

Phrallus (mutation #3)

Phrallus (upright #2)

And if the mutant phralloi are combined in a single image, they rotate like this:

Mutant phralloi (rotating)

Coloured mutant rotating phralloi #1

Coloured mutant rotating phralloi #2

The Swing’s the Thing

Order emerges from chaos with a triangle or pentagon, but not with a square. That is, if you take a triangle or a pentagon, chose a point inside it, then move the point repeatedly halfway towards a vertex chosen at random, a fractal will appear:


Sierpiński triangle from point jumping halfway to randomly chosen vertex


Sierpiński pentagon from point jumping halfway to randomly chosen vertex

But it doesn’t work with a square. Instead, the interior of the square slowly fills with random points:


Square filling with point jumping halfway to randomly chosen vertex

As I showed in Polymorphous Perverticity, you can create fractals from squares and randomly moving points if you ban the point from choosing the same vertex twice in a row, and so on. But there are other ways. You can take the point, move it towards a vertex at random, then swing it around the center of the square through some angle before you mark its position, like this:


Point moves at random, then swings by 90° around center


Point moves at random, then swings by 180° around center

You can also adjust the distance of the point from the center of the square using a formula like dist = r * rmdist, where dist is the distance, r is the radius of the circle in which the circle is drawn, and rm takes values like 0.1, 0.25, 0.5, 0.75 and so on:


Point moves at random, dist = r * 0.05 – dist


Point moves at random, dist = r * 0.1 – dist


Point moves at random, dist = r * 0.2 – dist

But you can swing the point while applying a vertex-ban, like banning the previously chosen vertex, or the vertex 90° or 180° away. In fact, swinging the points converts one kind of vertex ban into the others.


Point moves at random towards vertex not chosen previously


Point moves at random, then swings by 45°


Point moves at random, then swings by 360°


Point moves at random, then swings by 697.5°


Point moves at random, then swings by 720°


Point moves at random, then swings by 652.5°


Animated angle swing

You can also reverse the swing at every second move, swing the point around a vertex instead of the center or around a point on the circle that encloses the square. Here are some of the fractals you get applying these techniques.

Point moves at random, then swings alternately by 45°, -45°


Point moves at random, then swings alternately by 90°, -90°


Point moves at random, then swings alternately by 135°, -135°


Point moves at random, then swings alternately by 180°, -180°


Point moves at random, then swings alternately by 225°, -225°


Point moves at random, then swings alternately by 315°, -315°


Point moves at random, then swings alternately by 360°, -360°


Animated alternate swing


Point moves at random, then swings around point on circle by 45°


Point moves at random, then swings around point on circle by 67.5°


Point moves at random, then swings around point on circle by 90°


Point moves at random, then swings around point on circle by 112.5°


Point moves at random, then swings around point on circle by 135°


Point moves at random, then swings around point on circle by 180°


Animated circle swing

For Revver and Fevver

This shape reminds me of the feathers on an exotic bird:


(click or open in new window for full size)


(animated version)

The shape is created by reversing the digits of a number, so you could say it involves revvers and fevvers. I discovered it when I was looking at the Halton sequence. It’s a sequence of fractions created according to a simple but interesting rule. The rule works like this: take n in base b, reverse it, and divide reverse(n) by the first power of b that is greater thann.

For example, suppose n = 6 and b = 2. In base 2, 6 = 110 and reverse(110) = 011 = 11 = 3. The first power of 2 that is greater than 6 is 2^3 or 8. Therefore, halton(6) in base 2 equals 3/8. Here is the same procedure applied to n = 1..20:

1: halton(1) = 1/10[2] → 1/2
2: halton(10) = 01/100[2] → 1/4
3: halton(11) = 11/100[2] → 3/4
4: halton(100) = 001/1000[2] → 1/8
5: halton(101) = 101/1000[2] → 5/8
6: halton(110) = 011/1000 → 3/8
7: halton(111) = 111/1000 → 7/8
8: halton(1000) = 0001/10000 → 1/16
9: halton(1001) = 1001/10000 → 9/16
10: halton(1010) = 0101/10000 → 5/16
11: halton(1011) = 1101/10000 → 13/16
12: halton(1100) = 0011/10000 → 3/16
13: halton(1101) = 1011/10000 → 11/16
14: halton(1110) = 0111/10000 → 7/16
15: halton(1111) = 1111/10000 → 15/16
16: halton(10000) = 00001/100000 → 1/32
17: halton(10001) = 10001/100000 → 17/32
18: halton(10010) = 01001/100000 → 9/32
19: halton(10011) = 11001/100000 → 25/32
20: halton(10100) = 00101/100000 → 5/32…

Note that the sequence always produces reduced fractions, i.e. fractions in their lowest possible terms. Once 1/2 has appeared, there is no 2/4, 4/8, 8/16…; once 3/4 has appeared, there is no 6/8, 12/16, 24/32…; and so on. If the fractions are represented as points in the interval [0,1], they look like this:


point = 1/2


point = 1/4


point = 3/4


point = 1/8


point = 5/8


point = 3/8


point = 7/8


(animated line for base = 2, n = 1..63)

It’s apparent that Halton points in base 2 will evenly fill the interval [0,1]. Now compare a Halton sequence in base 3:

1: halton(1) = 1/10[3] → 1/3
2: halton(2) = 2/10[3] → 2/3
3: halton(10) = 01/100[3] → 1/9
4: halton(11) = 11/100[3] → 4/9
5: halton(12) = 21/100[3] → 7/9
6: halton(20) = 02/100 → 2/9
7: halton(21) = 12/100 → 5/9
8: halton(22) = 22/100 → 8/9
9: halton(100) = 001/1000 → 1/27
10: halton(101) = 101/1000 → 10/27
11: halton(102) = 201/1000 → 19/27
12: halton(110) = 011/1000 → 4/27
13: halton(111) = 111/1000 → 13/27
14: halton(112) = 211/1000 → 22/27
15: halton(120) = 021/1000 → 7/27
16: halton(121) = 121/1000 → 16/27
17: halton(122) = 221/1000 → 25/27
18: halton(200) = 002/1000 → 2/27
19: halton(201) = 102/1000 → 11/27
20: halton(202) = 202/1000 → 20/27
21: halton(210) = 012/1000 → 5/27
22: halton(211) = 112/1000 → 14/27
23: halton(212) = 212/1000 → 23/27
24: halton(220) = 022/1000 → 8/27
25: halton(221) = 122/1000 → 17/27
26: halton(222) = 222/1000 → 26/27
27: halton(1000) = 0001/10000 → 1/81
28: halton(1001) = 1001/10000 → 28/81
29: halton(1002) = 2001/10000 → 55/81
30: halton(1010) = 0101/10000 → 10/81

And here is an animated gif representing the Halton sequence in base 3 as points in the interval [0,1]:


Halton points in base 3 also evenly fill the interval [0,1]. What happens if you apply the Halton sequence to a two-dimensional square rather a one-dimensional line? Suppose the bottom left-hand corner of the square has the co-ordinates (0,0) and the top right-hand corner has the co-ordinates (1,1). Find points (x,y) inside the square, with x supplied by the Halton sequence in base 2 and y supplied by the Halton sequence in base 3. The square will gradually fill like this:


x = 1/2, y = 1/3


x = 1/4, y = 2/3


x = 3/4, y = 1/9


x = 1/8, y = 4/9


x = 5/8, y = 7/9


x = 3/8, y = 2/9


x = 7/8, y = 5/9


x = 1/16, y = 8/9


x = 9/16, y = 1/27…


animated square

Read full page: For Revver and Fevver

Performativizing the Polygonic

Maths is a mountain: you can start climbing in different places and reach the same destination. There are many ways of proving the irrationality of √2 or the infinitude of the primes, for example. But you can also arrive at the same destination by accident. I’ve found that when I use different methods of creating fractals. The same fractals appear, because apparently different algorithms are actually the same underneath.

But different methods can create unique fractals too. I’ve found some new ones by using what might be called point-to-point recursion. For example, there are ten ways to select three vertices from the five vertices of a pentagon: (1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 3, 4), (1, 3, 5), (1, 4, 5), (2, 3, 4), (2, 3, 5), (2, 4, 5), (3, 4, 5). Find the midpoint of the first three-point set, (1, 2, 3). Then select two vertices to go with this midpoint, creating a new three-point set, and find the midpoint again. And so on. The process looks like this, with the midpoints shown for all the three-point sets found at each stage:


vertices = 5, choose sets of 3 points, find mid-point of each



At stage 5, the fractal looks like this:


v = 5, p = 3

Note that when pixels are used again, the colour changes. That’s another interesting thing about maths: limits can sometimes produce deeper results. If these fractals were drawn at very high resolution, pixels would only be used once and the colour would never change. As it is, low resolution means that pixels are used again and again. But some are used more than others, which is why interesting colour effects appear.

If the formation of the fractal is animated, it looks like this (with close-ups of even deeper stages):

Here are some more examples:


v = 4 + central point, p = 2 (cf. Fingering the Frigit)


v = 4c, p = 2 (animated)


v = 4, p = 3



v = 5, p = 4



v = 5 + central point, p = 3



v = 5c, p = 4


v = 5c, p = 5


v = 6 + 1 point between each pair of vertices, p = 6


v = 6, p = 2


v = 6, p = 3



v = 6, p = 4


v = 6c, p = 2 (cf. Fingering the Frigit)



v = 6c, p = 3



v = 6c, p = 4


v = 7, p = 3


v = 7, p = 4



v = ,7 p = 5



v = 7c, p = 4


v = 3+1, p = 2


v = 3+1, p = 3


v = 3+1, p = 4


v = 3+2, p = 5


v = 3c+1, p = 2


v = 3c+1, p = 4


v = 3c, p = 2


v = 3c, p = 3


v = 4+1, p = 3


v = 4+1, p = 4


v = 4+1, p = 6


v = 4+1, p = 2


v = 4c+1, p = 4


v = 4c, p = 3



v = 5+1, p = 4 (and more)


v = 5, p = 2

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


Fingering the Frigit

Fingers are fractal. Where a tree has a trunk, branches and twigs, a human being has a torso, arms and fingers. And human beings move in fractal ways. We use our legs to move large distances, then reach out with our arms over smaller distances, then move our fingers over smaller distances still. We’re fractal beings, inside and out, brains and blood-vessels, fingers and toes.

But fingers are fractal are in another way. A digit – digitus in Latin – is literally a finger, because we once counted on our fingers. And digits behave like fractals. If you look at numbers, you’ll see that they contain patterns that echo each other and, in a sense, recur on smaller and smaller scales. The simplest pattern in base 10 is (0, 1, 2, 3, 4, 5, 6, 7, 8, 9). It occurs again and again at almost very point of a number, like a ten-hour clock that starts at zero-hour:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9…
10, 11, 12, 13, 14, 15, 16, 17, 18, 19…
200… 210… 220… 230… 240… 250… 260… 270… 280… 290…

These fractal patterns become visible if you turn numbers into images. Suppose you set up a square with four fixed points on its corners and a fixed point at its centre. Let the five points correspond to the digits (1, 2, 3, 4, 5) of numbers in base 6 (not using 0, to simplify matters):

1, 2, 3, 4, 5, 11, 12, 13, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55, 61, 62, 63, 64, 65… 2431, 2432, 2433, 2434, 2435, 2441, 2442, 2443, 2444, 2445, 2451, 2452…

Move between the five points of the square by stepping through the individual digits of the numbers in the sequence. For example, if the number is 2451, the first set of successive digits is (2, 4), so you move to a point half-way between point 2 and point 4. Next come the successive digits (4, 5), so you move to a point half-way between point 4 and point 5. Then come (5, 1), so you move to a point half-way between point 5 and point 1.

When you’ve exhausted the digits (or frigits) of a number, mark the final point you moved to (changing the colour of the pixel if the point has been occupied before). If you follow this procedure using a five-point square, you will create a fractal something like this:

A pentagon without a central point using numbers in a zero-less base 7 looks like this:

A pentagon with a central point looks like this:

Hexagons using a zero-less base 8 look like this:



But the images above are just the beginning. If you use a fixed base while varying the polygon and so on, you can create images like these (here is the program I used):



Get Your Prox Off

Create a triangle. Find a point somewhere inside it. Choose a corner at random and move halfway towards it. Mark the new point. Repeat the procedure: choose, move, mark. Repeat again and again. In time, a fractal will appear:


However, if you try the same thing with a square – choose a corner at random, move halfway towards it, mark the new point, repeat – no fractal appears. Instead, the points fill the interior of the square:


But what happens if you impose restrictions on the randomly chosen corner (or chorner)? Suppose you can’t choose the same corner twice in a row. If this rule is applied to the square, this fractal appears:



Now apply the no-corner-twice-in-a-row rule to a square that contains a central chorner. This fractal appears:


And if the rule is that you can choose a corner twice in a row but not thrice? This fractal appears:



Here is the rule is that a corner can’t be chosen if it was chosen two moves ago:


But what if the restriction is based not on how often or when a corner is chosen, but on its proximity, i.e. how near it is to the marked point? If the nearest corner can’t be chosen, the result is the same as the no-corner-twice-in-a-row rule:


But if the second-nearest corner can’t be chosen, this fractal appears:


This is the fractal when the third-nearest corner can’t be chosen:


And this is the fractal when the fourth-nearest, or most distant, corner can’t be chosen:


Here are the same restrictions applied to a pentagon:


Nearest corner forbidden


Second-nearest corner forbidden


Third corner forbidden


Fourth corner forbidden


Fifth corner forbidden


Fifth corner forbidden (animated)

And a pentagon with a central chorner:


Now try excluding more than one corner. Here are pentagons excluding the n-nearest and n+1-nearest corners (for example, the nearest and second-nearest corners; the second-nearest and third-nearest; and so on):


But what if the moving point is set equal to the n-nearest corner before it moves again? If the corner is the second-nearest and the shape is a triangle with a central chorner, this is the fractal that appears:



Animated version

And here is the same rule applied to various n-nearest corners in a pentagon:


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:



V for Vertex

To create a simple fractal, take an equilateral triangle and divide it into four more equilateral triangles. Remove the middle triangle. Repeat the process with each new triangle and go on repeating it. You’ll end up with a shape like this, which is known as the Sierpiński triangle, after the Polish mathematician Wacław Sierpiński (1882-1969):

Sierpinski triangle

But you can also create the Sierpiński triangle one pixel at a time. Choose any point inside an equilateral triangle. Pick a corner of the triangle at random and move half-way towards it. Mark this spot. Then pick a corner at random again and move half-way towards the corner. And repeat. The result looks like this:


A simple program to create the fractal looks like this:

until false

function initial()
  v = 3 [v for vertex]
  r = 500
  lm = 0.5

function fractal()
  th = 2 * pi / v
[the following loop creates the corners of the triangle]
  for l = 1 to v
    x[l]=xcenter + sin(l*th) * r
    y[l]=ycenter + cos(l*th) * r
  next l
  fx = xcenter
  fy = ycenter
    rv = random(v)
    fx = fx + (x[rv]-fx) * lm
    fy = fy + (y[rv]-fy) * lm
  until keypressed

function altervariables()
[change v, lm, r etc]

In this case, more is less. When v = 4 and the shape is a square, there is no fractal and plot(fx,fy) covers the entire square.


When v = 5 and the shape is a pentagon, this fractal appears:


But v = 4 produces a fractal if a simple change is made in the program. This time, a corner cannot be chosen twice in a row:


function initial()
  v = 4
  r = 500
  lm = 0.5
  ci = 1 [i.e, number of iterations since corner previously chosen]

function fractal()
  th = 2 * pi / v
  for l = 1 to v
    x[l]=xcenter + sin(l*th) * r
    y[l]=ycenter + cos(l*th) * r
  next l
  fx = xcenter
  fy = ycenter
      rv = random(v)
    until chosen[rv]=0
    for l = 1 to v
      if chosen[l]>0 then chosen[l] = chosen[l]-1
    next l
    chosen[rv] = ci
    fx = fx + (x[rv]-fx) * lm
    fy = fy + (y[rv]-fy) * lm
  until keypressed

One can also disallow a corner if the corner next to it has been chosen previously, adjust the size of the movement towards the chosen corner, add a central point to the polygon, and so on. Here are more fractals created with such variations: