Fractangular Frolics

Here’s an interesting shape that looks like a distorted and dissected capital S:

A distorted and dissected capital S


If you look at it more closely, you can see that it’s a fractal, a shape that contains itself over and over on smaller and smaller scales:

The shape contains smaller versions of itself


But how do you create the shape? You start by selecting three lines from this divided equilateral triangle:

A divided equilateral triangle


These are the three lines you need to create the shape:

Fractangle seed


Now replace each line with a half-sized set of the same three lines:

Fractangle stage #2


And do that again:

Fractangle stage #3


And again:

Fractangle stage #4


And carry on doing it as you create what I call a fractangle, i.e. a fractal derived from a triangle:

Fractangle stage #5


Fractangle stage #6


Fractangle stage #7


Fractangle stage #8


Fractangle stage #9


Fractangle stage #10


Fractangle stage #11


Here’s an animation of the process:

Creating the fractangle (animated)


And here are more fractangles created in a similar way from three lines of the divided equilateral triangle:

Fractangle #2


Fractangle #2 (anim)

(open in new window if distorted)


Fractangle #2 (seed)


Fractangle #3


Fractangle #3 (anim)


Fractangle #3 (seed)


Fractangle #4


Fractangle #4 (anim)


Fractangle #4 (seed)


You can also use a right triangle to create fractangles:

Divided right triangle for fractangles


Here are some fractangles created from three lines chosen of the divided right triangle:

Fractangle #5


Fractangle #5 (anim)


Fractangle #5 (seed)


Fractangle #6


Fractangle #6 (anim)


Fractangle #6 (seed)


Fractangle #7


Fractangle #7 (anim)


Fractangle #7 (seed)


Fractangle #8


Fractangle #8 (anim)


Fractangle #8 (seed)


Hour Re-Re-Re-Powered

Here’s a set of three lines:

Three lines


Now try replacing each line with a half-sized copy of the original three lines:

Three half-sized copies of the original three lines


What shape results if you keep on doing that — replacing each line with three half-sized new lines — over and over again? I’m not sure that any human is yet capable of visualizing it, but you can see the shape being created below:

Morphogenesis #3


Morphogenesis #4


Morphogenesis #5


Morphogenesis #6


Morphogenesis #7


Morphogenesis #8


Morphogenesis #9


Morphogenesis #10


Morphogenesis #11 — the Hourglass Fractal


Morphogenesis of the Hourglass Fractal (animated)


The shape that results is what I call the hourglass fractal. Here’s a second and similar method of creating it:

Hourglass fractal, method #2 stage #1


Hourglass fractal #2


Hourglass fractal #3


Hourglass fractal #4


Hourglass fractal #5


Hourglass fractal #6


Hourglass fractal #7


Hourglass fractal #8


Hourglass fractal #9


Hourglass fractal #10


Hourglass fractal #11


Hourglass fractal (animated)


And below are both methods in one animated gif, where you can see how method #1 produces an hourglass fractal twice as large as the hourglass fractal produced by method #2:

Two routes to the hourglass fractal (animated)


Elsewhere other-engageable:

Hour Power
Hour Re-Powered
Hour Re-Re-Powered

Tri Again (Again (Again))

Like the moon, mathematics is a harsh mistress. In mathematics, as on the moon, the slightest misstep can lead to disaster — as I’ve discovered again and again. My latest discovery came when I was looking at a shape called the L-tromino, created from three squares set in an L-shape. It’s a rep-tile, because it can be tiled with four smaller copies of itself, like this:

Rep-4 L-tromino


And if it can be tiled with four copies of itself, it can also be tiled with sixteen copies of itself, like this:

Rep-16 L-tromino


My misstep came when I was trying to do to a rep-16 L-tromino what I’d already done to a rep-4 L-tromino. And what had I already done? I’d created a beautiful shape called the hourglass fractal by dividing-and-discarding sub-copies of a rep-4 L-tromino. That is, I divided the L-tromino into four sub-copies, discarded one of the sub-copies, then repeated the process with the sub-sub-copies of the sub-copies, then the sub-sub-sub-copies of the sub-sub-copies, and so on:

Creating an hourglass fractal #1


Creating an hourglass fractal #2


Creating an hourglass fractal #3


Creating an hourglass fractal #4


Creating an hourglass fractal #5


Creating an hourglass fractal #6


Creating an hourglass fractal #7


Creating an hourglass fractal #8


Creating an hourglass fractal #9


Creating an hourglass fractal #10


Creating an hourglass fractal (animated)


The hourglass fractal


Next I wanted to create an hourglass fractal from a rep-16 L-tromino, so I reasoned like this:

• If one sub-copy of four is discarded from a rep-4 L-tromino to create the hourglass fractal, that means you need 3/4 of the rep-4 L-tromino. Therefore you’ll need 3/4 * 16 = 12/16 of a rep-16 L-tromino to create an hourglass fractal.

So I set up the rep-16 L-tromino with twelve sub-copies in the right pattern and began dividing-and-discarding:

A failed attempt at an hourglass fractal #1


A failed attempt at an hourglass fractal #2


A failed attempt at an hourglass fractal #3


A failed attempt at an hourglass fractal #4


A failed attempt at an hourglass fractal #5


A failed attempt at an hourglass fractal (animated)


Whoops! What I’d failed to take into account is that the rep-16 L-tromino is actually the second stage of the rep-4 triomino, i.e. that 4 * 4 = 16. It follows, therefore, that 3/4 of the rep-4 L-tromino will actually be 9/16 = 3/4 * 3/4 of the rep-16 L-tromino. So I tried again, setting up a rep-16 L-tromino with nine sub-copies, then dividing-and-discarding:

A third attempt at an hourglass fractal #1


A third attempt at an hourglass fractal #2


A third attempt at an hourglass fractal #3


A third attempt at an hourglass fractal #4


A third attempt at an hourglass fractal #5


A third attempt at an hourglass fractal #6


A third attempt at an hourglass fractal (animated)



Previously (and passionately) pre-posted:

Tri Again
Tri Again (Again)

Count Amounts

One of my favourite integer sequences is what I call the digit-line. You create it by taking this very familiar integer sequence:

• 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20…

And turning it into this one:

• 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 0, 1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 2, 0… (A033307 in the Online Encyclopedia of Integer Sequences)

You simply chop all numbers into single digits. What could be simpler? Well, creating the digit-line couldn’t be simpler, but it is in fact a very complex object. There are hidden depths in its patterns, as even a brief look will uncover. For example, you can try counting the digits as they appear one-by-one in the line and seeing whether the digit-counts compare. Do the 1s of the digit-line always outnumber the 0s, as you might expect? Yes, they do (unless you start the digit-line 0, 1, 2, 3…). But do the 2s always outnumber the 0s? No: at position 2, there’s a 2, and at position 11 there’s a 0. So that’s one 2 and one 0. Does it happen again? Yes, it happens again at the 222nd digit of the digit-line, as below:

1, 2count=1, 3, 4, 5, 6, 7, 8, 9, 1, 0count=1, 1, 1, 1, 22, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 23, 02, 24, 1, 25, 26, 27, 3, 28, 4, 29, 5, 210, 6, 211, 7, 212, 8, 213, 9, 3, 03, 3, 1, 3, 214, 3, 3, 3, 4, 3, 5, 3, 6, 3, 7, 3, 8, 3, 9, 4, 04, 4, 1, 4, 215, 4, 3, 4, 4, 4, 5, 4, 6, 4, 7, 4, 8, 4, 9, 5, 05, 5, 1, 5, 216, 5, 3, 5,4, 5, 5, 5, 6, 5, 7, 5, 8, 5, 9, 6, 06, 6, 1, 6, 217, 6, 3, 6, 4, 6, 5, 6, 6, 6, 7, 6, 8, 6, 9, 7, 07, 7, 1, 7, 218, 7, 3, 7, 4, 7, 5, 7, 6, 7, 7, 7, 8, 7, 9, 8, 08, 8, 1, 8, 219, 8, 3, 8, 4, 8, 5, 8, 6, 8, 7, 8, 8, 8, 9, 9, 09, 9, 1, 9, 220, 9, 3, 9, 4, 9, 5, 9, 6, 9, 7, 9, 8, 9, 9, 1, 010, 011, 1, 012, 1, 1, 013, 221, 1, 014, 3, 1, 015, 4, 1, 016, 5, 1, 017, 6, 1, 018, 7, 1, 019, 8, 1, 020, 9, 1, 1, 021

So count(2) = count(0) = 1 at digit 11 of the digit-line in the 0 of what was originally 10. And count(2) = count(0) = 21 @ digit 222 in the 0 of what was originally 110. Is a pattern starting to emerge? Yes, it is. Here are the first few points at which the count(2) = count(0) in the digit-line of base 10:

1 @ 11 in 10
21 @ 222 in 110
321 @ 3333 in 1110
4321 @ 44444 in 11110
54321 @ 555555 in 111110
654321 @ 6666666 in 1111110
7654321 @ 77777777 in 11111110
87654321 @ 888888888 in 111111110
987654321 @ 9999999999 in 1111111110
10987654321 @ 111111111110 in 11111111110
120987654321 @ 1222222222221 in 111111111110
[...]

The count(2) = count(0) = 321 at position 3333 in the digit-line, and 4321 at position 44444, and 54321 at position 555555, and so on. I don’t understand why these patterns occur, but you can predict the count-and-position of 2s and 0s easily until position 9999999999, after which things become more complicated. Related patterns for 2 and 0 occur in all other bases except binary (which doesn’t have a 2 digit). Here’s base 6:

1 @ 11 in 10 (1 @ 7 in 6)
21 @ 222 in 110 (13 @ 86 in 42)
321 @ 3333 in 1110 (121 @ 777 in 258)
4321 @ 44444 in 11110 (985 @ 6220 in 1554)
54321 @ 555555 in 111110 (7465 @ 46655 in 9330)
1054321 @ 11111110 in 1111110 (54121 @ 335922 in 55986)
12054321 @ 122222221 in 11111110 (380713 @ 2351461 in 335922)
132054321 @ 1333333332 in 111111110 (2620201 @ 16124312 in 2015538)
1432054321 @ 14444444443 in 1111111110 (17736745 @ 108839115 in 12093234)
15432054321 @ 155555555554 in 11111111110 (118513705 @ 725594110 in 72559410)
205432054321 @ 2111111111105 in 111111111110 (783641641 @ 4788921137 in 435356466)
2205432054321 @ 22222222222220 in 1111111111110 (5137206313 @ 31345665636 in 2612138802)

And what about comparing other pairs of digits? In fact, the count of all digits except 0 matches infinitely often. To write the numbers 1..9 takes one of each digit (except 0). To write the numbers 1 to 99 takes twenty of each digit (except 0). Here’s the proof:

11, 21, 31, 41, 51, 61, 71, 81, 91, 12, 01, 13, 14, 15, 22, 16, 32, 17, 42, 18, 52, 19, 62, 110, 72, 111, 82, 112, 92, 23, 02, 24, 113, 25, 26, 27, 33, 28, 43, 29, 53, 210, 63, 211, 73, 212, 83, 213, 93, 34, 03, 35, 114, 36, 214, 37, 38, 39, 44, 310, 54, 311, 64, 312, 74, 313, 84, 314, 94, 45, 04, 46, 115, 47, 215, 48, 315, 49, 410, 411, 55, 412, 65, 413, 75, 414, 85, 415, 95, 56, 05, 57, 116, 58, 216, 59, 316, 510, 416, 511, 512, 513, 66, 514, 76, 515, 86, 516, 96, 67, 06, 68, 117, 69, 217, 610, 317, 6
11
, 417, 612, 517, 613, 614, 615, 77, 616, 87, 617, 97, 78, 07, 79, 118, 710, 218, 711, 318, 712, 418, 713, 518, 714, 618, 715, 716, 717, 88, 718, 98, 89, 08, 810, 119, 811, 219, 812, 319, 813, 419, 814, 519, 815, 619, 816, 719, 817, 818, 819, 99, 910, 09, 911, 120, 912, 220, 913, 320, 914, 420, 915, 520, 916, 620, 917, 720, 918, 820, 919, 920

And what about writing 1..999, 1..9999, and so on? If you think about it, for every pair of non-zero digits, d1 and d2, all numbers containing one digit can be matched with a number containing the other. 100 → 200, 111 → 222, 314 → 324, 561189571 → 562289572, and so on. So in counting 1..999, 1..9999, 1..99999, you use the same number of non-zero digits. And once again a pattern emerges:

count(0) = 0; count(1) = 1; count(2) = 1; count(3) = 1; count(4) = 1; count(5) = 1; count(6) = 1; count(7) = 1; count(8) = 1; count(9) = 1 (writing 1..9)
count(0) = 9; count(1) = 20; count(2) = 20; count(3) = 20; count(4) = 20; count(5) = 20; count(6) = 20; count(7) = 20; count(8) = 20; count(9) = 20 (writing 1..99)
0: 189; 1: 300; 2: 300; 3: 300; 4: 300; 5: 300; 6: 300; 7: 300; 8: 300; 9: 300 (writing 1..999)
0: 2889; 1: 4000; 2: 4000; 3: 4000; 4: 4000; 5: 4000; 6: 4000; 7: 4000; 8: 4000; 9: 4000 (writing 1..9999)
0: 38889; 1: 50000; 2: 50000; 3: 50000; 4: 50000; 5: 50000; 6: 50000; 7: 50000; 8: 50000; 9: 50000 (writing 1..99999)
0: 488889; 1: 600000; 2: 600000; 3: 600000; 4: 600000; 5: 600000; 6: 600000; 7: 600000; 8: 600000; 9: 600000 (writing 1..999999)
0: 5888889; 1: 7000000; 2: 7000000; 3: 7000000; 4: 7000000; 5: 7000000; 6: 7000000; 7: 7000000; 8: 7000000; 9: 7000000 (writing 1..9999999)
[...]

And here’s base 6 again:

0: 0; 1: 1; 2: 1; 3: 1; 4: 1; 5: 1 (writing 1..5)
0: 5; 1: 20; 2: 20; 3: 20; 4: 20; 5: 20 (writing 1..55 in base 6)
0: 145; 1: 300; 2: 300; 3: 300; 4: 300; 5: 300 (writing 1..555)
0: 2445; 1: 4000; 2: 4000; 3: 4000; 4: 4000; 5: 4000 (writing 1..5555)
0: 34445; 1: 50000; 2: 50000; 3: 50000; 4: 50000; 5: 50000 (writing 1..55555)
0: 444445; 1: 1000000; 2: 1000000; 3: 1000000; 4: 1000000; 5: 1000000 (writing 1..555555)
0: 5444445; 1: 11000000; 2: 11000000; 3: 11000000; 4: 11000000; 5: 11000000 (writing 1..5555555)
0: 104444445; 1: 120000000; 2: 120000000; 3: 120000000; 4: 120000000; 5: 120000000 (writing 1..55555555)
0: 1144444445; 1: 1300000000; 2: 1300000000; 3: 1300000000; 4: 1300000000; 5: 1300000000 (writing 1..555555555)

At the Mountings of Mathness

Mounting n. a backing or setting on which a photograph, work of art, gem, etc. is set for display. — Oxford English Dictionary

Viewer’s advisory: If you are sensitive to flashing or flickering images, you should be careful when you look at the last couple of animated gifs below.


H.P. Lovecraft in some Mountings of Mathness






Paradoxical Puzzle Pair

Two interesting puzzles, one of which looks hard and is in fact easy, while the other looks easy and is in fact hard.

1. Three Cards

The values attached to a deck of bridge cards start with the Two of Clubs as lowest, with Diamonds, Hearts and Ace of Spades as highest.

If you draw three cards at random from the deck, what is the probability that they will be drawn in order of increasing value? (Answer 1)


2. The Hungry Hunter

A hunter, having run out of food, met two shepherds. One of the shepherd had three loaves of bread and the other had five loaves. When the hunter asked for food, the shepherds agreed to divide the eight identical loaves equally between the three of them. The hunter thanked them and gave them $8. How should the shepherds divide the money? (Answer 2)

• Puzzles and answers from Erwin Brecher’s How Do You Survive a Duel? And Other Mathematical Diversions, Puzzles and Brainteasers (Carlton Books 2018)

*

*

*

*

*

*

*

*

*


Answer #1: The puzzle sounds far more complicated than it is. The deck of cards is a red herring. The question reduces to this: Take three cards, say 2, 3 and 4 of clubs, facedown. What is the probability of turning them over in the order 2, 3, 4? There are six possible ways of arranging three cards. Therefore the probability is one-sixth.

*

*

*

*

*

*

*

*

*

Answer #2: It would be wrong to split the money into $3 and $5. Each of the three ended up with 2⅔ loaves. In other words, the first shepherd parted with ⅓ of a loaf and the other shepherd with 2⅓ or 7/3 loaves. The first shepherd should therefore get $1 and the second shepherd $7.

Agnathous Analysis

In Mandibular Metamorphosis, I looked at two distinct fractals and how you could turn one into the other in one smooth sweep. The Sierpiński triangle was one of the fractals:

Sierpiński triangle


The T-square fractal was the other:

T-square fractal (or part thereof)


And here they are turning into each other:

Sierpiński ↔ T-square (anim)
(Open in new window if distorted)


But what exactly is going on? To answer that, you need to see how the two fractals are created. Here are the stages for one way of constructing the Sierpiński triangle:

Sierpiński triangle #1


Sierpiński triangle #2


Sierpiński triangle #3


Sierpiński triangle #4


Sierpiński triangle #5


Sierpiński triangle #6


Sierpiński triangle #7


Sierpiński triangle #8


Sierpiński triangle #9


When you take away all the construction lines, you’re left with a simple Sierpiński triangle:


Constructing a Sierpiński triangle (anim)


Now here’s the construction of a T-square fractal:

T-square fractal #1


T-square fractal #2


T-square fractal #3


T-square fractal #4


T-square fractal #5


T-square fractal #6


T-square fractal #7


T-square fractal #8


T-square fractal #9


Take away the construction lines and you’re left with a simple T-square fractal:

T-square fractal


Constructing a T-square fractal (anim)


And now it’s easy to see how one turns into the other:

Sierpiński → T-square #1


Sierpiński → T-square #2


Sierpiński → T-square #3


Sierpiński → T-square #4


Sierpiński → T-square #5


Sierpiński → T-square #6


Sierpiński → T-square #7


Sierpiński → T-square #8


Sierpiński → T-square #9


Sierpiński → T-square #10


Sierpiński → T-square #11


Sierpiński → T-square #12


Sierpiński → T-square #13


Sierpiński ↔ T-square (anim)
(Open in new window if distorted)


Post-Performative Post-Scriptum

Mandibular Metamorphosis also looked at a third fractal, the mandibles or jaws fractal. Because I haven’t included the jaws fractal in this analysis, the analysis is therefore agnathous, from Ancient Greek ἀ-, a-, “without”, + γνάθ-, gnath-, “jaw”.

Mandibular Metamorphosis

Here’s the famous Sierpiński triangle:

Sierpiński triangle


And here’s the less famous T-square fractal:

T-square fractal (or part of it, at least)


How do you get from one to the other? Very easily, as it happens:

From Sierpiński triangle to T-square (and back again) (animated)
(Open in new window if distorted)


Now, here are the Sierpiński triangle, the T-square fractal and what I call the mandibles or jaws fractal:

Sierpiński triangle


T-square fractal


Mandibles / Jaws fractal


How do you cycle between them? Again, very easily:

From Sierpiński triangle to T-square to Mandibles (and back again) (animated)
(Open in new window if distorted)


Math Matters

“Physics is mathematical not because we know so much about the physical world, but because we know so little; it is only its mathematical properties that we can discover.” — Bertrand Russell, An Outline of Philosophy (1927), ch. 15, “The Nature of our Knowledge of Physics”

FractAlphic Frolix

A fractal is a shape that contains smaller (and smaller) versions of itself, like this:

The hourglass fractal


Fractals also occur in nature. For example, part of a tree looks like the tree as whole. Part of a cloud or a lung looks like the cloud or lung as a whole. So trees, clouds and lungs are fractals. The letters of an alphabet don’t usually look like that, but I decided to create a fractal alphabet — or fractalphabet — that does.

The fractalphabet starts with this minimal standard Roman alphabet in upper case, where each letter is created by filling selected squares in a 3×3 grid:


The above is stage 1 of the fractalphabet, when it isn’t actually a fractal alphabet at all. But if each filled square of the letter “A”, say, is replaced by the letter itself, the “A” turns into a fractal, like this:








Fractal A (animated)


Here’s the whole alphabet being turned into fractals:

Full fractalphabet (black-and-white)


Full fractalphabet (color)


Full fractalphabet (b&w animated)


Full fractalphabet (color animated)


Now take a full word like “THE”:



You can turn each letter into a fractal using smaller copies of itself:







Fractal THE (b&w animated)


Fractal THE (color animated)


But you can also create a fractal from “THE” by compressing the “H” into the “T”, then the “E” into the “H”, like this:




Compressed THE (animated)



The compressed “THE” has a unique appearance and is both a letter and a word. Now try a complete sentence, “THE CAT BIT THE RAT”. This is the sentence in stage 1 of the fractalphabet:



And stage 2:



And further stages:





Fractal CAT (b&w animated)


Fractal CAT (color animated)


But, as we saw with “THE” above, that’s not the only fractal you can create from “THE CAT BIT THE RAT”. Here’s what I call a 2-compression of the sentence, where every second letter has been compressed into the letter that precedes it:


THE CAT BIT THE RAT (2-comp color)


THE CAT BIT THE RAT (2-comp b&w)


And here’s a 3-compression of the sentence, where every third letter has been compressed into every second letter, and every second-and-third letter has been compressed into the preceding letter:

THE CAT BIT THE RAT (3-comp color)


THE CAT BIT THE RAT (3-comp b&w)


As you can see above, each word of the original sentence is now a unique single letter of the fractalphabet. Theoretically, there’s no limit to the compression: you could fit every word of a book in the standard Roman alphabet into a single letter of the fractalphabet. Or you could fit an entire book into a single letter of the fractalphabet (with additional symbols for punctuation, which I haven’t bothered with here).

To see what the fractalphabeting of a longer text in the standard Roman alphabet might look like, take the first verse of a poem by A.E. Housman:

On Wenlock Edge the wood’s in trouble;
His forest fleece the Wrekin heaves;
The gale it plies the saplings double,
And thick on Severn snow the leaves. (“Poem XXXI” of A Shropshire Lad, 1896)

The first line looks like this in stage 1 of the fractalphabet:


Here’s stage 2 of the standard fractalphabet, where each letter is divided into smaller copies of itself:


And here’s stage 3 of the standard fractalphabet:


Now examine a colour version of the first line in stage 1 of the fractalphabet:


As with “THE” above, let’s try compressing each second letter into the letter that precedes it:


And here’s a 3-comp of the first line:


Finally, here’s the full first verse of Housman’s poem in 2-comp and 3-comp forms:

On Wenlock Edge the wood’s in trouble;
His forest fleece the Wrekin heaves;
The gale it plies the saplings double,
And thick on Severn snow the leaves. (“Poem XXXI of A Shropshire Lad, 1896)

“On Wenlock Edge” (2-comp)


“On Wenlock Edge” (3-comp)


Appendix

This is a possible lower-case version of the fractalphabet: