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

For a good example of how more can be less, try the chaos game. You trace a point jumping repeatedly 1/n of the way towards a randomly chosen vertex of a regular polygon. When the polygon is a triangle and 1/n = 1/2, this is what happens:

Chaos triangle #1


Chaos triangle #2


Chaos triangle #3


Chaos triangle #4


Chaos triangle #5


Chaos triangle #6


Chaos triangle #7


As you can see, this simple chaos game creates a fractal known as the Sierpiński triangle (or Sierpiński sieve). Now try more and discover that it’s less. When you play the chaos game with a square, this is what happens:

Chaos square #1


Chaos square #2


Chaos square #3


Chaos square #4


Chaos square #5


Chaos square #6


Chaos square #7


As you can see, more is less: the interior of the square simply fills with points and no attractive fractal appears. And because that was more is less, let’s see how less is more. What happens if you restrict the way in which the point inside the square can jump? Suppose it can’t jump twice towards the same vertex (i.e., the vertex v+0 is banned). This fractal appears:

Ban on choosing vertex [v+0]


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

Ban on vertex [v+1] (or [v-1], depending on how you number the vertices)


And if the point can’t jump towards two places clockwise or anti-clockwise of the currently chosen vertex, this fractal appears:

Ban on vertex [v+2], i.e. the diagonally opposite vertex


At least, that is one possible route to those three particular fractals. You see another route, start with this simple fractal, where dividing and discarding parts of a square creates a 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 #4


[…]


Square to Sierpiński triangle #10


Square to Sierpiński triangle (animated)


By taking four of these square-to-Sierpiński-triangle fractals and rotating them in the right way, you can re-create the three chaos-game fractals shown above. Here’s the [v+0]-ban fractal:

[v+0]-ban fractal #1


[v+0]-ban #2


[v+0]-ban #3


[v+0]-ban #4


[v+0]-ban #5


[v+0]-ban #6


[v+0]-ban #7


[v+0]-ban #8


[v+0]-ban #9


[v+0]-ban (animated)


And here’s the [v+1]-ban fractal:

[v+1]-ban fractal #1


[v+1]-ban #2


[v+1]-ban #3


[v+1]-ban #4


[v+1]-ban #5


[v+1]-ban #6


[v+1]-ban #7


[v+1]-ban #8


[v+1]-ban #9


[v+1]-ban (animated)


And here’s the [v+2]-ban fractal:

[v+2]-ban fractal #1


[v+2]-ban #2


[v+2]-ban #3


[v+2]-ban #4


[v+2]-ban #5


[v+2]-ban #6


[v+2]-ban #7


[v+2]-ban #8


[v+2]-ban #9


[v+2]-ban (animated)

And taking a different route means that you can find more fractals — as I will demonstrate.


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
Square Routes Re-Re-Re-Re-Revisited

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.

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

Fractal + Star = Fractar

Here’s a three-armed star made with three lines radiating at intervals of 120°:

Triangular fractal stage #1


At the end of each of the three lines, add three more lines at half the length:

Triangular fractal #2


And continue like this:

Triangular fractal #3


Triangular fractal #4


Triangular fractal #5


Triangular fractal #6


Triangular fractal #7


Triangular fractal #8


Triangular fractal #9


Triangular fractal #10


Triangular fractal (animated)


Because this fractal is created from a series of star, you could call it a fractar. Here’s a black-and-white version:

Triangular fractar (black-and-white)


Triangular fractar (black-and-white) (animated)
(Open in a new window for larger version if the image seems distorted)


A four-armed star doesn’t yield an easily recognizable fractal in a similar way, so let’s try a five-armed star:

Pentagonal fractar stage #1


Pentagonal fractar #2


Pentagonal fractar #3


Pentagonal fractar #4


Pentagonal fractar #5


Pentagonal fractar #6


Pentagonal fractar #7


Pentagonal fractar (animated)


Pentagonal fractar (black-and-white)


Pentagonal fractar (bw) (animated)


And here’s a six-armed star:

Hexagonal fractar stage #1


Hexagonal fractar #2


Hexagonal fractar #3


Hexagonal fractar #4


Hexagonal fractar #5


Hexagonal fractar #6


Hexagonal fractar (animated)


Hexagonal fractar (black-and-white)


Hexagonal fractar (bw) (animated)


And here’s what happens to the triangular fractar when the new lines are rotated by 60°:

Triangular fractar (60° rotation) #1


Triangular fractar (60°) #2


Triangular fractar (60°) #3


Triangular fractar (60°) #4


Triangular fractar (60°) #5


Triangular fractar (60°) #6


Triangular fractar (60°) #7


Triangular fractar (60°) #8


Triangular fractar (60°) #9


Triangular fractar (60°) (animated)


Triangular fractar (60°) (black-and-white)


Triangular fractar (60°) (bw) (animated)


Triangular fractar (60°) (no lines) (black-and-white)


A four-armed star yields a recognizable fractal when the rotation is 45°:

Square fractar (45°) #1


Square fractar (45°) #2


Square fractar (45°) #3


Square fractar (45°) #4


Square fractar (45°) #5


Square fractar (45°) #6


Square fractar (45°) #7


Square fractar (45°) #8


Square fractar (45°) (animated)


Square fractar (45°) (black-and-white)


Square fractar (45°) (bw) (animated)


Without the lines, the final fractar looks like the plan of a castle:

Square fractar (45°) (bw) (no lines)


And here’s a five-armed star with new lines rotated at 36°:

Pentagonal fractar (36°) #1


Pentagonal fractar (36°) #2


Pentagonal fractar (36°) #3


Pentagonal fractar (36°) #4


Pentagonal fractar (36°) #5


Pentagonal fractar (36°) #6


Pentagonal fractar (36°) #7


Pentagonal fractar (36°) (animated)


Again, the final fractar without lines looks like the plan of a castle:

Pentagonal fractar (36°) (no lines) (black-and-white)


Finally, here’s a six-armed star with new lines rotated at 30°:

Hexagonal fractar (30°) #1


Hexagonal fractar (30°) #2


Hexagonal fractar (30°) #3


Hexagonal fractar (30°) #4


Hexagonal fractar (30°) #5


Hexagonal fractar (30°) #6


Hexagonal fractar (30°) (animated)


And the hexagonal castle plan:

Hexagonal fractar (30°) (black-and-white) (no lines)


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

Horn Again

Pre-previously on Overlord-in-terms-of-Core-Issues-around-Maximal-Engagement-with-Key-Notions-of-the-Über-Feral, I interrogated issues around this shape, the horned triangle:

unicorn_reptile_static

Horned Triangle (more details)


Now I want to look at the tricorn (from Latin tri-, “three”, + -corn, “horn”). It’s like a horned triangle, but has three horns instead of one:

Tricorn, or three-horned triangle


These are the stages that make up the tricorn:

Tricorn (stages)


Tricorn (animated)


And there’s no need to stop at triangles. Here is a four-horned square, or quadricorn:

Quadricorn


Quadricorn (animated)


Quadricorn (coloured)


And a five-horned pentagon, or quinticorn:

Quinticorn, or five-horned pentagon


Quinticorn (anim)


Quinticorn (col)


And below are some variants on the shapes above. First, the reversed tricorn:

Reversed Tricorn


Reversed Tricorn (anim)


Reversed Tricorn (col)


The nested tricorn:

Nested Tricorn (anim)


Nested Tricorn (col)


Nested Tricorn (red-green)


Nested Tricorn (variant col)


The nested quadricorn:

Nested Quadricorn (anim)


Nested Quadricorn


Nested Quadricorn (col #1)


Nested Quadricorn (col #2)


Finally (and ferally), the pentagonal octopus or pentapus:

Pentapus (anim)


Pentapus


Pentapus #2


Pentapus #3


Pentapus #4


Pentapus #5


Pentapus #6


Pentapus (col anim)


Elsewhere other-engageable:

The Art Grows Onda — the horned triangle and Katsushika Hokusai’s painting The Great Wave off Kanagawa (c. 1830)

Mod’s Chosen

When you divide one integer by another, one of two things happens. Either the second number goes perfectly into the first or there’s a remainder:


15 / 5 = 3
18 / 5 = 3⅗

In the first case, there’s no remainder, that is, the remainder is 0. In the second case, there’s a remainder of 3. And all that gives you the basis for what’s called modular arithmetic. It returns the remainder when one number is divided by another:


15 mod 5 = 0
16 mod 5 = 1
17 mod 5 = 2
18 mod 5 = 3
19 mod 5 = 4
20 mod 5 = 0
21 mod 5 = 1
22 mod 5 = 2...

It looks simple but a lot of mathematics is built on it. I don’t know much of that maths, but I know one thing I like: the patterns you can get from modular arithmetic. Suppose you draw a square, then find a point and measure the distances from that point to all the vertices of the square. Then add the distances up, turn the result into an integer if necessary, and test whether the result is divisible by 2 or not. If it is divisible, colour the point in. If it isn’t, leave the point blank.

Then move on to another point and perform the same test. This is modular arithematic, because for each point you’re asking whether d mod 2 = 0. The result looks like this:

d mod 2 = 0


Here are more divisors:

d mod 3 = 0


d mod 4 = 0


d mod 5 = 0


d mod 6 = 0


d mod 7 = 0


d mod 8 = 0


d mod 9 = 0


d mod 10 = 0


d mod various = 0 (animated)


You can also use modular arithmetic to determine the colour of the points. For example, if d mod n = 0, the point is black; if d mod n = 1, the point is red; if d mod n = 2, the point is green; and so on.

d mod 3 = 0, 1, 2 (coloured)


d mod 4 = 0, 1, 2, 3 (coloured)


d mod 5 = 0, 1, 2, 3, 4 (coloured)



d mod 5 = 0, 1, 2, 3, 4 (animated and expanding)


For Revver and Fevver

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

feathers

(click or open in new window for full size)


feathers_anim

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

line1_1_2

point = 1/2


line2_1_4

point = 1/4


line3_3_4

point = 3/4


line4_1_8

point = 1/8


line5_5_8

point = 5/8


line6_3_8

point = 3/8


line7_7_8

point = 7/8


line_b2_anim

(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]:

line_b3_anim


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:

square1

x = 1/2, y = 1/3


square2

x = 1/4, y = 2/3


square3

x = 3/4, y = 1/9


square4

x = 1/8, y = 4/9


square5

x = 5/8, y = 7/9


square6

x = 3/8, y = 2/9


square7

x = 7/8, y = 5/9


square8

x = 1/16, y = 8/9


square9

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


square_anim

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:

v5_p3_stage1

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

v5_p3_stage2

v5_p3_stage3


At stage 5, the fractal looks like this:

v5_p3_static

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


Here are some more examples:

v4c_p2_static

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

v4c_p2

v = 4c, p = 2 (animated)


v4_p3_static

v = 4, p = 3

v4_p3


v5_p4_static

v = 5, p = 4

v5_p4


v5c_p3_static

v = 5 + central point, p = 3

v5c_p3


v5c_p4

v = 5c, p = 4


v5c_p5

v = 5c, p = 5


v6_1_p6

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


v6_p2

v = 6, p = 2


v6_p3_static

v = 6, p = 3

v6_p3


v6_p4

v = 6, p = 4


v6c_p2_static

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

v6c_p2


v6c_p3_static

v = 6c, p = 3

v6c_p3


v6c_p4

v = 6c, p = 4


v7_p3

v = 7, p = 3


v7_p4_static

v = 7, p = 4

v7_p4


v7_p5_static

v = ,7 p = 5

v7_p5


v7_p4

v = 7c, p = 4


v3_1_p2

v = 3+1, p = 2


v3_1_p3

v = 3+1, p = 3


v3_1_p4

v = 3+1, p = 4


v3_2_p5

v = 3+2, p = 5


v3c_1_p2

v = 3c+1, p = 2


v3c_1_p4

v = 3c+1, p = 4


v3c_p2

v = 3c, p = 2


v3c_p3

v = 3c, p = 3


v4_1_p3

v = 4+1, p = 3


v4_1_p4

v = 4+1, p = 4


v4_1_p5

v = 4+1, p = 6


v4_1_p6

v = 4+1, p = 2


v4c_1_p4

v = 4c+1, p = 4


v4c_p3_static

v = 4c, p = 3

v4c_p3


v5_1_p4_va

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


v5_p2

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.

pol3_4_5

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

pol4_0

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

pol4_2

v = 4, vi = 2

pol4_2_anim


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:

pol4_1_2

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

pol4_1_2_anim


pol4_2_0

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

pol4_2_0_anim

pol4_2_0_white


pol4_2_1

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

pol4_2_1_anim


pol4_2_2

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

pol4_2_2_anim


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

pol4_1_1_0

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

pol4_1_1_0_anim


pol4_1_1_2

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

pol4_1_1_2_anim


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:

pol5_0

v = 5, vi = 0


pol5_1

v = 5, vi = 1

pol5_1_anim


pol5_2

v = 5, vi = 2

pol5_2_anim


pol5_0_0

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


pol5_1_0

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


pol5_2_0

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

pol5_2_0_anim


pol5_1_1

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

pol5_1_1_anim


pol5_1_1_1

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


pol5_va2

v = 5, vi = various


pol6_1

v = 6, vi = 1

pol6_1_anim