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.

Square Routes Re-Re-Re-Re-Revisited

Pre-previously in my post-passionate portrayal of polygonic performativity, I’ve usually looked at what happens when a moving point is banned from jumping twice-in-a-row (and so on) towards the same vertex of a square or other polygon. But what happens when the point isn’t banned but compelled to do something different? For example, if the point usually jumps 1/2 of the distance towards the vertex for the second (third, fourth…) time, you could make it jump 2/3 of the way, like this:

usual jump = 1/2, forced jump = 2/3


And here are the fractals created when the vertex currently chosen is one or two places clockwise from the vertex chosen before:

usual jump = 1/2, forced jump = 2/3, vertex-inc = +1


j1 = 1/2, j2 = 2/3, vi = +2


Or you can make the point jump towards a different vertex to the one chosen, without recording the different vertex in the history of jumps:

v1 = +0, v2 = +1, j = 1/2


v1 = +0, v2 = +1, vi = +2


v1 = 0, v2 = +2


v1 = 0, v2 = +2, vi = +1


Or you can make the point jump towards the center of the square:

v1 = 0, v2 = center, j = 1/2


v1 = 0, v2 = center, vertex-inc = +1


v1 = 0, v2 = center, vertex-inc = +2


And so on:

v1 = +1, v2 = +1, vi = +1


v1 = +1, v2 = +1, vi = +2


v1 = +0, v2 = +1, reverse test


v1 = +0, v2 = +1, vi = +1, reverse test


v1 = +0, v2 = +1, vi = +2, reverse test


v1 = +0, v2 = +2, reverse test


v1 = +0, v2 = +2, vi = +1, reverse test


v1 = +2, v2 = +2, vi = +1, reverse test


j1 = 1/2, j2 = 2/3, vi = +0,+0 (record previous two jumps in history)


j1 = 1/2, j2 = 2/3, vi = +0,+2


j1 = 1/2, j2 = 2/3, vi = +2,+2


j1 = 1/2, j2 = 2/3, vi = +0,+0,+0 (previous three jumps)


Previously pre-posted (please peruse):

Square Routes
Square Routes Revisited
Square Routes Re-Revisited
Square Routes Re-Re-Revisited
Square Routes Re-Re-Re-Revisited

Get Your Prox Off #3

I’ve looked at lot at the fractals created when you randomly (or quasi-randomly) choose a vertex of a square, then jump half of the distance towards it. You can ban jumps towards the same vertex twice in a row, or jumps towards the vertex clockwise or anticlockwise from the vertex you’ve just chosen, and so on.

But you don’t have to choose vertices directly: you can also choose them by distance or proximity (see “Get Your Prox Off” for an earlier look at fractals-by-distance). For example, this fractal appears when you can jump half-way towards the nearest vertex, the second-nearest vertex, and the third-nearest vertex (i.e., you can’t jump towards the fourth-nearest or most distant vertex):

vertices = 4, distance = (1,2,3), jump = 1/2


It’s actually the same fractal as you get when you choose vertices directly and ban jumps towards the vertex diagonally opposite from the one you’ve just chosen. But this fractal-by-distance isn’t easy to match with a fractal-by-vertex:

v = 4, d = (1,2,4), j = 1/2


Nor is this one:

v = 4, d = (1,3,4)


This one, however, is the same as the fractal-by-vertex created by banning a jump towards the same vertex twice in a row:

v = 4, d = (2,3,4)


The point can jump towards second-nearest, third-nearest and fourth-nearest vertices, but not towards the nearest. And the nearest vertex will be the one chosen previously.

Now let’s try squares with an additional point-for-jumping-towards on each side (the points are numbered 1 to 8, with points 1, 3, 5, 7 being the true vertices):

v = 4 + s1 point on each side, d = (1,2,3)


v = 4 + s1, d = (1,2,5)


v = 4 + s1, d = (1,2,7)


v = 4 + s1, d = (1,3,8)


v = 4 + s1, d = (1,4,6)


v = 4 + s1, d = (1,7,8)


v = 4 + s1, d = (2,3,8)


v = 4 + s1, d = (2,4,8)


And here are squares where the jump is 2/3, not 1/2, and you can choose only the nearest or third-nearest jump-point:

v = 4, d = (1,3), j = 2/3


v = 4 + s1, d = (1,3), j = 2/3


Now here are some pentagonal fractals-by-distance:

v = 5, d = (1,2,5), j = 1/2


v = 5 + s1, d = (1,2,7)


v = 5 + s1, d = (1,2,8)


v = 5 + s1, d = (1,2,9)


v = 5 + s1, d = (1,9,10)


v = 5 + s1, d = (1,10), j = 2/3


v = 5 + s1, d = (various), j = 2/3 (animated)


And now some hexagonal fractals-by-distance:

v = 6, d = (1,2,4), j = 1/2


v = 6, d = (1,3,5)


v = 6, d = (1,3,6)


v = 6, d = (1,2,3,4)


v = 6 + central point, d = (1,2,3,4)


v = 6, d = (1,2,3,6)


v = 6, d = (1,2,4,6)


v = 6, d = (1,3,4,5)


v = 6, d = (1,3,4,6)


v = 6, d = (1,4,5,6)


Elsewhere other-accessible:

Get Your Prox Off — an earlier look at fractals-by-distance
Get Your Prox Off # 2 — and another

Performativizing the Polygonic #3

Pre-previously in my passionate portrayal of polygonic performativity, I showed how a single point jumping randomly (or quasi-randomly) towards the vertices of a polygon can create elaborate fractals. For example, if the point jumps 1/φth (= 0.6180339887…) of the way towards the vertices of a pentagon, it creates this fractal:

Point jumping 1/φth of the way to a randomly (or quasi-randomly) chosen vertex of a pentagon


But as you might expect, there are different routes to the same fractal. Suppose you take a pentagon and select a single vertex. Now, measure the distance to each vertex, v(1,i=1..5), of the original pentagon (including the selected vertex) and reduce it by 1/φ to find the position of a new vertex, v(2,i=1..5). If you do this for each vertex of the original pentagon, then to each vertex of the new pentagons, and so on, in the end you create the same fractal as the jumping point does:

Shrink pentagons by 1/φ, stage #1


Stage #2


Stage #3


Stage #4


Stage #5


Stage #6


Shrink by 1/φ (animated) (click for larger if blurred)


And here is the route to a centre-filled variant of the fractal:

Central pentagon, stage #1


Stage #2


Stage #3


Stage #4


Stage #5


Stage #6


Central pentagon (animated) (click for larger if blurred)


Using this shrink-the-polygon method, you can reach the same fractals by a third route. This time, use vertex v(1,i) of the original polygon as the centre of the new polygon with its vertices v(2,i=1..5). Creation of the fractal looks like this:

Pentagons over vertices, shrink by 1/φ, stage #1 (no pentagons over vertices)


Stage #2


Stage #3


Stage #4


Stage #4


Stage #5


Stage #7


Pentagons over vertices (animated) (click for larger if blurred)


And here is a third way of creating the centre-filled pentagonal fractal:

Pentagons over vertices and central pentagon, stage #1


Stage #2


Stage #3


Stage #4


Stage #5


Stage #6


Stage #7


Pentagons over vertices with central pentagon (animated) (click for larger if blurred)


And here is a fractal created when there are three pentagons to a side and the pentagons are shrunk by 1/φ^2 = 0.3819660112…:

Pentagon at vertex + pentagon at mid-point of side, shrink by 1/φ^2


Final stage


Pentagon at vertex + pentagon at mid-point of side (animated) (click for larger if blurred)


Pentagon at vertex + pentagon at mid-point of side + central pentagon, shrink by 1/φ^2 and c. 0.5, stage #1


Stage #2


Stage #3


Stage #4


Stage #5


Pentagon at vertex + mid-point + center (animated) (click for larger if blurred)


Previously pre-posted:

Performativizing the Polygonic #2
Performativizing the Polygonic #1

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:

Performativizing the Polygonic

Square Routes Re-Re-Re-Revisited

Discovering something that’s new to you in recreational maths is good. But so is re-discovering it by a different route. I’ve long been passionate about what happens when a point is allowed to jump repeatedly halfway towards the randomly chosen vertices of a square. If the point can choose any vertex any number of times, the interior of the square fills slowly and completely with points, like this:

Point jumping at random halfway towards vertices of a square


However, if the point is banned from jumping towards the same vertex twice or more in a row, an interesting fractal appears:

Fractal #1 — ban on jumping towards vertex vi twice or more


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

Fractal #2 — ban on jumping towards vertex vi+1


If the point can’t jump towards the vertex two places clockwise of the vertex it’s just jumped towards, this fractal appears (two places clockwise is also two places anticlockwise, i.e. the banned vertex is diagonally opposite):

Fractal #3 — ban on jumping towards vertex vi+2


Now I’ve discovered a new way to create these fractals. You take a filled square, divide it into smaller squares, then remove some of them in a systematic way. Then you do the same to the smaller squares that remain. For fractal #1, you do this:

Fractal #1, stage #1


Stage #2


Stage #3


Stage #4


Stage #5


Stage #6


Stage #7


Stage #8


Fractal #1 (animated)


For fractal #2, you do this:

Fractal #2, stage #1


Stage #2


Stage #3


Stage #4


Stage #5


Stage #6


Stage #7


Stage #8


Fractal #2 (animated)


For fractal #3, you do this:

Fractal #3, stage #1


Stage #2


Stage #3


Stage #4


Stage #5


Stage #6


Stage #7


Stage #8


Fractal #3 (animated)


If the sub-squares are coloured, it’s easier to understand how, say, fractal #1 is created:

Fractal #1 (coloured), stage #1


Stage #2


Stage #3


Stage #4


Stage #5


Stage #6


Stage #7


Stage #8


Fractal #1 (coloured and animated)


The fractal is actually being created in quarters, with one quarter rotated to form the second, third and fourth quarters:

Fractal #1, quarter









Here’s an animation of the same process for fractal #3:

Fractal #3 (coloured and animated)


So you can create these fractals either with a jumping point or by subdividing a square. But in fact I discovered the subdivided-square route by looking at a variant of the jumping-point route. I wondered what would happen if you took a point inside a square, allowed it to trace all possible routes towards the vertices without marking its position, then imposed the restriction for Fractal #1 on its final jump, namely, that it couldn’t jump towards the vertex it jumped towards on its previous jump. If the point is marked after its final jump, this is what appears (if the routes chosen had been truly random, the image would be similar but messier):

Fractal #1, restriction on final jump


Then I imposed the same restriction on the point’s final two jumps:

Fractal #1, restriction on final 2 jumps


And final three jumps:

Fractal #1, restriction on final 3 jumps


And so on:

Fractal #1, restriction on final 4 jumps


Fractal #1, restriction on final 5 jumps


Fractal #1, restriction on final 6 jumps


Fractal #1, restriction on final 7 jumps


Here are animations of the same process applied to fractals #2 and #3:

Fractal #2, restrictions on final 1, 2, 3… jumps


Fractal #3, restrictions on final 1, 2, 3… jumps


The longer the points are allowed to jump before the final restriction is imposed on their n final jumps, the more densely packed the marked points will be:

Fractal #1, packed points #1


Packed points #2


Packed points #3


Eventually, the individual points will form a solid mass, like this:

Fractal #1, solid mass of points


Fractal #1, packed points (animated)


Previously pre-posted (please peruse):

Square Routes
Square Routes Revisited
Square Routes Re-Revisited
Square Routes Re-Re-Revisited