# Jumping Jehosophracts!

As I’ve shown pre-previously on Overlord-in-terms-of-issues-around-the-Über-Feral, you can create interesting fractals by placing restrictions on a point jumping inside a fractal towards a randomly chosen vertex. For example, the point can be banned from jumping towards the same vertex twice in a row, and so on.

But you can use other restrictions. For example, suppose that the point can jump only once or twice towards any vertex, that is, (j = 1,2). It can then jump towards the same vertex again, but not the same number of times as it previously jumped. So if it jumps once, it has to jump twice next time; and vice versa. If you use this rule on a pentagon, this fractal appears:

v = 5, j = 1,2 (black-and-white)

v = 5, j = 1,2 (colour)

If the point can also jump towards the centre of the pentagon, this fractal appears:

v = 5, j = 1,2 (with centre)

And if the point can also jump towards the midpoints of the sides:

v = 5, j = 1,2 (with midpoints)

v = 5, j = 1,2 (with midpoints and centre)

And here the point can jump 1, 2 or 3 times, but not once in a row, twice in a row or thrice in a row:

v = 5, j = 1,2,3

v = 5, j = 1,2,3 (with centre)

Here the point remembers its previous two moves, rather than just its previous move:

v = 5, j = 1,2,3, hist = 2 (black-and-white)

v = 5, j = 1,2,3, hist = 2

v = 5, j = 1,2,3, hist = 2 (with center)

v = 5, j = 1,2,3, hist = 2 (with midpoints)

v = 5, j = 1,2,3, hist = 2 (with midpoints and centre)

And here are hexagons using the same rules:

v = 6, j = 1,2 (black-and-white)

v = 6, j = 1,2

v = 6, j = 1,2 (with centre)

And octagons:

v = 8, j = 1,2

v = 8, j = 1,2 (with centre)

v = 8, j = 1,2,3, hist = 2

v = 8, j = 1,2,3, hist = 2

v = 8, j = 1,2,3,4 hist = 3

v = 8, j = 1,2,3,4 hist = 3 (with center)

# The Hex Fractor

Pre-previously on Overlord-in-terms-of-issues-around-the-Über-Feral, I looked at the fractals created when various restrictions are placed on a point jumping at random half-way towards the vertices of a square. For example, the point can be banned from jumping towards the same vertex twice in a row or towards the vertex to the left of the vertex it has just jumped towards, and so on.

Today I want to look at what happens to a similar point moving inside pentagons and hexagons. If the point can’t jump twice towards the same vertex of a pentagon, this is the fractal that appears:

Ban second jump towards same vertex (v + 0)

Ban second jump towards same vertex (color)

If the point can’t jump towards the vertex immediately to the left of the one it’s just jumped towards, this is the fractal that appears:

Ban jump towards v + 1 (color)

And this is the fractal when the ban is on the vertex two places to the left:

Ban jump towards v + 2 (color)

You can also ban more than one vertex:

Ban jump towards v + 1,4 (color)

And here are fractals created in similar ways inside hexagons:

Ban jump towards v + 0,1,2 (color)

Ban jump towards v + 0,2,4 (color)

Ban jump towards v + 1,2,3 (color)

Ban jump towards v + 1,2,4, (color)

Ban jump towards v + 1,3,5 (color)

Ban jump towards v + 1,3 (color)

Ban jump towards v + 1,5 (color)

Ban jump towards v + 2,3 (color)

Ban jump towards v + 2,4 (color)

Elsewhere other-accessible:

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