What does a fractal phallus look like?

*Millions* of people have *axed* this corely key *question*.

The Overlord of the Über-Feral can *answer* it — keyly, corely and *comprehensively* dot dot dot

And here *is* the answer: Phrallic Frolics…

What does a fractal phallus look like?

*Millions* of people have *axed* this corely key *question*.

The Overlord of the Über-Feral can *answer* it — keyly, corely and *comprehensively* dot dot dot

And here *is* the answer: Phrallic Frolics…

Here is a very simple tree with two branches:

Two-branch tree

These are the steps that a simple computer program follows to draw the tree, with a red arrow indicating where the computer’s focus is at each stage:

Two-branch tree stage 1

2-Tree stage 2

2-Tree stage 3

2-Tree stage 4

2-Tree (animated)

If you had to give the computer an explicit instruction at each stage, the instructions might look something like this:

1. Start at node 1, draw a left branch to node 2 and colour the node green.

2. Return to node 1.

3. Draw a right branch to node 3 and colour the node green.

4. Finish.

Now try a slightly less simple tree with branches that fork twice:

Four-branch tree (static)

These are the steps that a simple computer program follows to draw the tree, with a red arrow indicating where the computer’s focus is at each stage:

4-Tree #1

4-Tree #2

4-Tree #3

4-Tree #4

4-Tree #5

4-Tree #6

4-Tree #7

4-Tree #8

4-Tree #9

4-Tree #10

4-Tree #11

4-Tree (animated)

If you had to give the computer an explicit instruction at each stage, the instructions might look something like this:

1. Start at node 1 and draw a left branch to node 2.

2. Draw a left branch to node 3 and colour it green.

3. Return to node 2.

4. Draw a right branch to node 4 and colour it green.

5. Return to node 2.

6. Return to node 1.

7. Draw a right branch to node 5.

8. Draw a left branch to node 6.

9. Draw a left branch to node 7 and colour it green.

10. Return to node 6.

11. Draw a left branch to node 8 and colour it green.

12. Finish.

It’s easy to see that the list of instructions would be much bigger for a tree with branches that fork three times, let alone four times or you. But you don’t need to give a full set of explicit instructions: you can use a program, or a list of instructions using variables. Suppose the tree has branches that fork

1. li = 1, level(1) = 0, level(2) = 0, ... level(f+1) = 0

2. level(li) = level(li) + 1

3. If level(li) = 1, draw a branch to the left and jump to step 7

4. If level(li) = 2, draw a branch to the right and jump to step 7

5. li = li - 1 (note that this line is reached if the tests fail in lines 3 and 4)

6. If li > 0, jump to step 2, otherwise jump to step 11

7. If li = f, draw a green node and jump to step 5

9. li = li + 1

10. Jump to step 2

11. Finish.

By changing the value of

16-Tree (static)

16-Tree (animated)

With simple adjustments, the program can be used for other shapes whose underlying structure can be represented symbolically as a tree. The program is in fact a fractalizer, that is, it draws a fractal. So if you use a version of the program to draw fractals based on right-triangles, you can say you are “tright treeing” (tright = triangle-that-is-right).

Here is some tright treeing. Start with a simple isoceles right-triangle. It can be divided into smaller isoceles right-triangles by finding the midpoint of the hypotenuse, then repeating:

Right-triangle rep-2 stage 1

Right-triangle #2

Tright #3

Tright #4

Tright #5

Tright #6

Tright #7

Tright #7 (no internal lines)

You can distort the isoceles right-triangle in interesting ways by finding the midpoint of a side other than the hypotenuse, like this:

Right-triangle (distorted) #1

Distorted tright #2

Distorted tright #3

Distorted tright #4

Distorted tright #5

Distorted tright #6

Distorted tright #7

Distorted tright #8

Distorted tright #9

Distorted tright #10

Distorted tright #11

Distorted tright #12

Distorted tright #13

Distorted tright (animated)

Here’s a different right-triangle. When you divide it regularly, it looks like this:

Right-triangle rep-3 stage 1

Rep-3 Tright #2

3-Tright #3

3-Tright #4

3-Tright #5

3-Tright #6

3-Tright #7

3-Tright #8

3-Tright #9

3-Tright (one colour)

When you distort the divisions, you can create interesting fractals (click on images for larger versions):

Distorted 3-Tright

Distorted 3-Tright

Distorted 3-Tright

Distorted 3-Tright

Distorted 3-Tright

Distorted 3-Tright

Distorted 3-Tright (animated)

And when four of the distorted right-triangles (rep-2 or rep-3) are joined in a diamond, you can create shapes like these:

Creating a diamond #1

Creating a diamond #2

Creating a diamond #3

Creating a diamond #4

Creating a diamond (animated)

Rep-3 right-triangle diamond (divided)

Rep-3 right-triangle diamond (single colour)

Distorted rep-3 right-triangle diamond

Distorted 3-tright diamond

Distorted 3-tright diamond

Distorted 3-tright diamond

Distorted 3-tright diamond

Distorted 3-tright diamond

Distorted 3-tright diamond

Distorted 3-tright diamond

Distorted 3-tright diamond

Distorted 3-tright diamond

Distorted 3-tright diamond

Distorted 3-tright diamond (animated)

Distorted rep-2 right-triangle

Distorted 2-tright diamond

Distorted 2-tright diamond

Distorted 2-tright diamond

Distorted 2-tright diamond

Distorted 2-tright diamond (animated)

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 v_{i} 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 v_{i+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 v_{i+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

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

10111 in base 2

212 in base 3

113 in base 4

43 in base 5

35 in base 6

32 in base 7

27 in base 8

25 in base 9

23 in base 10

21 in base 11

1B in base 12

1A in base 13

19 in base 14

18 in base 15

17 in base 16

16 in base 17

15 in base 18

14 in base 19

13 in base 20

12 in base 21

11 in base 22

10 in base 23

N in all bases >= 24

√23 = 4.7958315__23__31…

• φασὶ γοῦν Ἵππαρχον τὸν Πυθαγόρειον, αἰτίαν ἔχοντα γράψασθαι τὰ τοῦ Πυθαγόρου σαφῶς, ἐξελαθῆναι τῆς διατριβῆς καὶ στήλην ἐπ’ αὐτῷ γενέσθαι οἷα νεκρῷ. — Κλήμης ὁ Ἀλεξανδρεύς, *Στρώματα*.

• They say, then, that Hipparchus the Pythagorean, being guilty of writing the tenets of Pythagoras in plain language, was expelled from the school, and a pillar raised for him as if he had been dead. — Clement of Alexandria, *The Stromata*, 2.5.9.57.3-4

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 3 = 0, 1, 2 (coloured)

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

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

“Describe yourself.” You can say it to people. And you can say it to numbers too. For example, here’s the number 3412 describing the positions of its own digits, starting at 1 and working upward:

3412 – the 1 is in the 3rd position, the 2 is in the 4th position, the 3 is in the 1st position, and the 4 is in the 2nd position.

In other words, the positions of the digits 1 to 4 of 3412 recreate its own digits:

3412 → (3,4,1,2) → 3412

The number 3412 describes itself – it’s autonomatic (from Greek *auto*, “self” + *onoma*, “name”). So are these numbers:

1

21

132

2143

52341

215634

7243651

68573142

321654798

More precisely, they’re __pan__autonomatic numbers, because they describe the positions of all their own digits (Greek *pan* or *panto*, “all”). But what if you use the positions of only, say, the 1s or the 3s in a number? In base ten, only one number describes itself like that: 1. But we’re not confined to base 10. In base 2, the positions of the 1s in 110 (= 6) are 1 and 10 (= 2). So 110 is __mon__autonomatic in binary (Greek *mono*, “single”). 10 is also monautonomatic in binary, if the digit being described is 0: it’s in 2nd position or position 10 in binary. These numbers are monoautonomatic in binary too:

110100 = 52 (digit = 1)

10100101111 = 1327 (d=0)

In 110100, the 1s are in 1st, 2nd and 4th position, or positions 1, 10, 100 in binary. In 10100101111, the 0s are in 2nd, 4th, 5th and 7th position, or positions 10, 100, 101, 111 in binary. Here are more monautonomatic numbers in other bases:

21011 in base 4 = 581 (digit = 1)

11122122 in base 3 = 3392 (d=2)

131011 in base 5 = 5131 (d=1)

2101112 in base 4 = 9302 (d=1)

11122122102 in base 3 = 91595 (d=2)

13101112 in base 5 = 128282 (d=1)

210111221 in base 4 = 148841 (d=1)

For example, in 131011 the 1s are in 1st, 3rd, 5th and 6th position, or positions 1, 3, 10 and 11 in quinary. But these numbers run out quickly and the only monautonomatic number in bases 6 and higher is 1. However, there are infinitely long monoautonomatic integer sequences in all bases. For example, in binary this sequence at the Online Encyclopedia of Integer Sequences describes itself using the positions of its 1s:

A167502: 1, 10, 100, 111, 1000, 1001, 1010, 1110, 10001, 10010, 10100, 10110, 10111, 11000, 11010, 11110, 11111, 100010, 100100, 100110, 101001, 101011, 101100, 101110, 110000, 110001, 110010, 110011, 110100, 111000, 111001, 111011, 111101, 11111, …

In base 10, it looks like this:

A167500: 1, 2, 4, 7, 8, 9, 10, 14, 17, 18, 20, 22, 23, 24, 26, 30, 31, 34, 36, 38, 41, 43, 44, 46, 48, 49, 50, 51, 52, 56, 57, 59, 61, 62, 63, 64, 66, 67, 68, 69, 70, 71, 75, 77, 80, 83, 86, 87, 89, 91, 94, 95, 97, 99, 100, 101, 103, 104, 107, 109, 110, 111, 113, 114, 119, 120, 124, … (see A287515 for a similar sequence using 0s)

In any base, you can find some sequence of integers describing the positions of any of the digits in that base – for example, the 1s or the 7s. But the numbers in the sequence get very large very quickly in higher bases. For example, here are some opening sequences for the digits 0 to 9 in base 10:

3, 10, 1111110, … (d=0)

1, 3, 10, 200001, … (d=1)

3, 12, 100000002, … (d=2)

2, 3, 30, 10000000000000000000000003, … (d=3)

2, 4, 14, 1000000004, … (d=4)

2, 5, 105, … (d=5)

2, 6, 1006, … (d=6)

2, 7, 10007, … (d=7)

2, 8, 100008, … (d=8)

2, 9, 1000009, … (d=9)

In the sequence for d=0, the first 0 is in the 3rd position, the second 0 is in the 10th position, and the third 0 is in the 1111110th position. That’s why I’ve haven’t written the next number – it’s 1,111,100 digits long (= 1111110 – 10). But it’s theoretically possible to write the number. In the sequence for d=3, the next number is utterly impossible to write, because it’s 9,999,999,999,999,999,999,999,973 digits long (= 10000000000000000000000003 – 30). In the sequence for d=5, the next number is this:

1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005 (100 digits long = 105 – 5).

And in fact there are an infinite number of such sequences for any digit in any base – except for d=1 in binary. Why is binary different? Because 1 is the only digit that can start a number in that base. With 0, you can invent a sequence starting like this:

111, 1110, 1111110, …

Or like this:

1111, 11111111110, …

Or like this:

11111, 1111111111111111111111111111110, …

And so on. But with 1, there’s no room for manoeuvre.

Mathematics, rightly viewed, possesses not only truth, but supreme beauty — a beauty cold and austere, like that of sculpture, without appeal to any part of our weaker nature, without the gorgeous trappings of painting or music, yet sublimely pure, and capable of a stern perfection such as only the greatest art can show. The true spirit of delight, the exaltation, the sense of being more than man, which is the touchstone of the highest excellence, is to be found in mathematics as surely as in poetry. What is best in mathematics deserves not merely to be learnt as a task, but to be assimilated as a part of daily thought, and brought again and again before the mind with ever-renewed encouragement. Real life is, to most men, a long second-best, a perpetual compromise between the ideal and the possible; but the world of pure reason knows no compromise, no practical limitations, no barrier to the creative activity embodying in splendid edifices the passionate aspiration after the perfect from which all great work springs. Remote from human passions, remote even from the pitiful facts of nature, the generations have gradually created an ordered cosmos, where pure thought can dwell as in its natural home, and where one, at least, of our nobler impulses can escape from the dreary exile of the actual world. — Bertrand Russell, “The Study Of Mathematics” (1902)

The title of this incendiary intervention is of course a paronomasia on these lines from Led Zeppelin’s magisterial “Stairway to Heaven”:

“If there’s a bustle in your hedgerow, don’t be alarmed now:

It’s just a spring-clean for the May Queen…”

And “head-roe” is a kenning for “brain”.

Pre-previously on Overlord-in-terms-of-the-Über-Feral, I’ve ~~looked at~~ intensively interrogated issues around the L-triomino, a shape created from three squares that can be divided into four copies of itself:

An L-triomino divided into four copies of itself

I’ve also interrogated issues around a shape that yields a bat-like fractal:

A fractal full of bats

Bat-fractal (animated)

Now, to end the year in spectacular fashion, I want to combine the two concepts pre-previously interrogated on Overlord-in-terms-of-the-Über-Feral (i.e., L-triominoes and bats). The L-triomino can also be divided into nine copies of itself:

An L-triomino divided into nine copies of itself

If three of these copies are discarded and each of the remaining six sub-copies is sub-sub-divided again and again, this is what happens:

Fractal stage 1

Fractal stage 2

Fractal #3

Fractal #4

Fractal #5

Fractal #6

L-triomino bat-fractal (static)

L-triomino bat-fractal (animated)

Elsewhere other-posted:

• Tri-Way to L

• Bats and Butterflies

• Square Routes

• Square Routes Revisited

• Square Routes Re-Revisited

• Square Routes Re-Re-Revisited

The Tridentine Mass is the Roman Rite Mass that appears in typical editions of the Roman Missal published from 1570 to 1962. — Tridentine Mass, Wikipedia

A 30°-60°-90° right triangle, with sides 1 : √3 : 2, can be divided into three identical copies of itself:

30°-60°-90° Right Triangle — a rep-3 rep-tile…

And if it can be divided into three, it can be divided into nine:

…that is also a rep-9 rep-tile

Five of the sub-copies serve as the seed for an interesting fractal:

Fractal stage #1

Fractal stage #2

Fractal stage #3

Fractal #4

Fractal #5

Fractal #6

Fractal #6

Tridentine cross (animated)

Tridentine cross (static)

This is a different kind of rep-tile:

Noniamond trapezoid

But it yields the same fractal cross:

Fractal #1

Fractal #2

Fractal #3

Fractal #4

Fractal #5

Fractal #6

Tridentine cross (animated)

Tridentine cross (static)

Elsewhere other-available:

• Holey Trimmetry — another fractal cross