Jonglietzsche


Post-Performative Post-Scriptum

“Jonglietzsche” is a portmanteau of German Jongleur / jonglieren, “juggler, juggling”, and the surname of core counter-cultural philosopher Friedrich Nietzsche (1844-1900). Jongleur is pronounced something like “zhawngloer”, as in French.

Boole(b)an

Suppose you allow a point to jump at random half-way towards one of the four vertices of a square. But not entirely at random — you ban the point from jumping towards the same vertex twice (or more) in a row. You get this pattern:

ban on v(i) + 0


It’s a fractal, that is, a shape that contains smaller and smaller copies of itself. Next you ban the point from jumping towards the vertex one place clockwise of the vertex it last jumped towards (i.e., it can jump towards, say, vertex 2 as many times as it likes, but it can’t jump towards vertex 2+1 = 3, and so on). You get this fractal:

ban on v(i) + 1


Now ban it from jumping towards the vertex two places clockwise of the vertex it last jumped towards (i.e., it can’t jump towards the diagonally opposite vertex). You get this fractal:

ban on v(i) + 2


And if you ban the point from jumping towards the vertex three places clockwise of the last vertex, you get a mirror-image of the v(i)+1 fractal (see above):

ban on v(i) + 3


The fractals above have a memory one vertex into the past: the previous vertex. Let’s try some fractals with a memory two vertices into the past: the previous vertex and the pre-previous vertex (and even the pre-pre-previous vertex).

But this time, let’s suppose that sometimes the point can’t jump if the previous or pre-previous isn’t equal to v(i) + n. So sometimes the jump is banned when the test is true, sometimes when the test is false — you might call it a boolean ban or boole(b)an. Using boole(b)ans, you can get this set of fractals:
















With these fractals, the boolean test sends the point back to the center of the square:










Trifylfots

Here’s a simple fractal created by dividing an equilateral triangle into smaller equilateral triangles, then discarding (and rotating) some of those sub-triangles, then doing the same to the sub-triangles:

Fractangle (triangle-fractal) (stage 1)


Fractangle #2


Fractangle #3


Fractangle #4


Fractangle #5


Fractangle #6


Fractangle #7


Fractangle #8


Fractangle #9


Fractangle (animated)


I’ve used the same fractangle to create this shape, which is variously known as a swastika (from Sanskrit svasti, “good luck, well-being”), a gammadion (four Greek Γs arranged in a circle) or a fylfot (from the shape being used to “fill the foot” of a stained glass window in Christian churches):

Trifylfot


Because it’s a fylfot created ultimately from a triangle, I’m calling it a trifylfot (TRIFF-ill-fot). Here’s how you make it:

Trifylfot (stage 1)


Trifylfot #2


Trifylfot #3


Trifylfot #4


Trifylfot #5


Trifylfot #6


Trifylfot #7


Trifylfot #8


Trifylfot #9


Trifylfot (animated)


And here are more trifylfots created from various forms of fractangle:













































Elsewhere other-accessible

Fractangular Frolics — more on fractals from triangles

Digital Dissection

As I never tire of pointing out, the three most powerful drugs in the universe are water, maths and language. And I never tire of snorting the fact that numbers can come in many different guises. You can take a trivial, everyday number like a hundred and see it transform like this:


100 = 1100100 in base 2; 10201 in base 3; 1210 in base 4; 400 in base 5; 244 in base 6; 202 in base 7; 144 in base 8; 121 in base 9; 100 in b10; 91 in b11; 84 in b12; 79 in b13; 72 in b14; 6A in b15; 64 in b16; 5F in b17; 5A in b18; 55 in b19; 50 in b20; 4G in b21; 4C in b22; 48 in b23; 44 in b24; 40 in b25; 3M in b26; 3J in b27; 3G in b28; 3D in b29; 3A in b30; 37 in b31; 34 in b32; 31 in b33; 2W in b34; 2U in b35; 2S in b36; 2Q in b37; 2O in b38; 2M in b39; 2K in b40; 2I in b41; 2G in b42; 2E in b43; 2C in b44; 2A in b45; 28 in b46; 26 in b47; 24 in b48; 22 in b49; 20 in b50; 1[49] in b51; 1[48] in b52; 1[47] in b53; 1[46] in b54; 1[45] in b55; 1[44] in b56; 1[43] in b57; 1[42] in b58; 1[41] in b59; 1[40] in b60; 1[39] in b61; 1[38] in b62; 1[37] in b63; 1[36] in b64; 1Z in b65; 1Y in b66; 1X in b67; 1W in b68; 1V in b69; 1U in b70; 1T in b71; 1S in b72; 1R in b73; 1Q in b74; 1P in b75; 1O in b76; 1N in b77; 1M in b78; 1L in b79; 1K in b80; 1J in b81; 1I in b82; 1H in b83; 1G in b84; 1F in b85; 1E in b86; 1D in b87; 1C in b88; 1B in b89; 1A in b90; 19 in b91; 18 in b92; 17 in b93; 16 in b94; 15 in b95; 14 in b96; 13 in b97; 12 in b98; 11 in b99

I like the shifts from 1100100 to 10201 to 1210 to 400 to 244 to 202 to 144 to 121. How can 1100100 and 244 be the same number? Well, they are — or they’re not, as you please. In base 2, 1100100 = 244 in base 6 = 100 in base 10. But if all those numbers are in the same base, they’re completely different and 1100100 dwarfs the other two.

But some things you can’t please yourself about. Suppose you take the different representations of 6561 in bases 2..6560 and add up the 1s, the 2s, the 3s and so on, like this:


n=6561

digsum(1,6561,b=2..6560) = 3343 (50.95% of 6561)
digsum(2,6561,b=2..6560) = 2246 (34.23% of 6561)
digsum(3,6561,b=2..6560) = 1680 (25.61% of 6561)
digsum(4,6561,b=2..6560) = 1368 (20.85% of 6561)
digsum(5,6561,b=2..6560) = 1185 (18.06% of 6561)
digsum(6,6561,b=2..6560) = 1074 (16.37% of 6561)
digsum(7,6561,b=2..6560) = 875 (13.34% of 6561)
digsum(8,6561,b=2..6560) = 768 (11.71% of 6561)
digsum(9,6561,b=2..6560) = 1080 (16.46% of 6561)
[...]
digcount(0,6561,b=2..6560) = 31

Is there a pattern in the percentages? Let’s apply the same process to some bigger numbers (and note that 0 does not behave like the other digits):


n=59049

digsum(1,59049) = 29648 (50.21%)
digsum(2,59049) = 19790 (33.51%)
digsum(3,59049) = 14901 (25.23%)
digsum(4,59049) = 11956 (20.25%)
digsum(5,59049) = 9970 (16.88%)
digsum(6,59049) = 8550 (14.48%)
digsum(7,59049) = 7539 (12.77%)
digsum(8,59049) = 6672 (11.30%)
digsum(9,59049) = 6579 (11.14%)
digcount(0,59049) = 41


n=531441

digsum(1,531441) = 266065 (50.06%)
digsum(2,531441) = 177394 (33.38%)
digsum(3,531441) = 133128 (25.05%)
digsum(4,531441) = 106532 (20.05%)
digsum(5,531441) = 88815 (16.71%)
digsum(6,531441) = 76224 (14.34%)
digsum(7,531441) = 66661 (12.54%)
digsum(8,531441) = 59320 (11.16%)
digsum(9,531441) = 53928 (10.15%)
digcount(0,531441) = 62


n=4782969

digsum(1,4782969) = 2392219 (50.02%)
digsum(2,4782969) = 1595000 (33.35%)
digsum(3,4782969) = 1196370 (25.01%)
digsum(4,4782969) = 957300 (20.01%)
digsum(5,4782969) = 797700 (16.68%)
digsum(6,4782969) = 683850 (14.30%)
digsum(7,4782969) = 598444 (12.51%)
digsum(8,4782969) = 531944 (11.12%)
digsum(9,4782969) = 480870 (10.05%)
digcount(0,4782969) = 66

Yes, the pattern’s getting stronger. Let’s try even bigger numbers:


n=43046721

digsum(1,43046721) = 21525521 (50.01%)
digsum(2,43046721) = 14350754 (33.34%)
digsum(3,43046721) = 10763496 (25.00%)
digsum(4,43046721) = 8610980 (20.00%)
digsum(5,43046721) = 7175955 (16.67%)
digsum(6,43046721) = 6150924 (14.29%)
digsum(7,43046721) = 5382167 (12.50%)
digsum(8,43046721) = 4784232 (11.11%)
digsum(9,43046721) = 4306257 (10.00%)
digcount(0,43046721) = 86


n=387420489

digsum(1,387420489) = 193716365 (50.00%)
digsum(2,387420489) = 129145522 (33.33%)
digsum(3,387420489) = 96859980 (25.00%)
digsum(4,387420489) = 77488588 (20.00%)
digsum(5,387420489) = 64574220 (16.67%)
digsum(6,387420489) = 55349742 (14.29%)
digsum(7,387420489) = 48431250 (12.50%)
digsum(8,387420489) = 43050264 (11.11%)
digsum(9,387420489) = 38748357 (10.00%)
digcount(0,387420489) = 95

To the given precision, the sum of 1s is 1/2 of n; the sum of 2s is 1/3; the sum of 3 is 1/4; and the sum of 4s is 1/5. It looks as though the sum of a given digit d → 1/(d+1) of n as n → ∞. But why? My mathematical intuition is bad, so it took me a while to see what some people will see in a flash. To see what’s going on, let’s go back to the all-base representations of 100:


100 = 1100100 in base 2; 10201 in base 3; 1210 in base 4; 400 in base 5; 244 in base 6; 202 in base 7; 144 in base 8; 121 in base 9; 100 in b10; 91 in b11; 84 in b12; 79 in b13; 72 in b14; 6A in b15; 64 in b16; 5F in b17; 5A in b18; 55 in b19; 50 in b20; 4G in b21; 4C in b22; 48 in b23; 44 in b24; 40 in b25; 3M in b26; 3J in b27; 3G in b28; 3D in b29; 3A in b30; 37 in b31; 34 in b32; 31 in b33; 2W in b34; 2U in b35; 2S in b36; 2Q in b37; 2O in b38; 2M in b39; 2K in b40; 2I in b41;
2G in b42; 2E in b43; 2C in b44; 2A in b45; 28 in b46; 26 in b47; 24 in b48; 22 in b49; 20 in b50; 1[49] in b51; 1[48] in b52; 1[47] in b53; 1[46] in b54; 1[45] in b55; 1[44] in b56; 1[43] in b57; 1[42] in b58; 1[41] in b59; 1[40] in b60; 1[39] in b61; 1[38] in b62; 1[37] in b63; 1[36] in b64; 1Z in b65; 1Y in b66; 1X in b67; 1W in b68; 1V in b69; 1U in b70; 1T in b71; 1S in b72; 1R in b73; 1Q in b74; 1P in b75; 1O in b76; 1N in b77; 1M in b78; 1L in b79; 1K in b80; 1J in b81
; 1I in b82; 1H in b83; 1G in b84; 1F in b85; 1E in b86; 1D in b87; 1C in b88; 1B in b89; 1A in b90; 19 in b91; 18 in b92; 17 in b93; 16 in b94; 15 in b95; 14 in b96; 13 in b97; 12 in b98; 11 in b99

When the base b is higher than half of 100, the representations of 100 consist of a digit 1 followed by another digit. Half of a hundred = 50, therefore 100 in base 10 = 1[49] in b51, 1[48] in b52, 1[47] in b53, 1[46] in b54, 1[45] in b55, 1[44] in b56, 1[43] in b57, 1[42] in b58, 1[41] in b59… If you take binary and so on into account, 1 is the first digit of slightly over half the representations of 100. And 1 also occurs in other positions. Therefore digsum(1,100,b=2..99) > 50. As the number n gets larger and larger, the contribution of leading 1s in bases b > n/2 begins to swamp the contributions of 1s in other positions, therefore digsum(1,n) → 1/2 of n as n → ∞.

And what about 2s and 3s? Similar reasoning applies. One hundred has a leading digit of 2 in bases b where b > 1/3 of 100 and b <= 1/2 of 100. So 100 = 2W in b34, 2U in b35, 2S in b36, 2Q in b37, 2O in b38… In other words, roughly 1/2 – 1/3 of the representations of 100 have a leading 2. Now, 1/2 – 1/3 = 3/6 – 2/6 = 1/6 and 1/6 * 2 = 1/3 (i.e., 1/6 of the representations contribute a leading 2 to the sum of 2s). Therefore the all-base digsum(2,n) → 1/3 of n as n → ∞. Next, one hundred has a leading digit of 3 in bases b where b > 1/4 of 100 and b <= 1/3. So 100 = 3M in b26, 3J in b27, 3G in b28, 3D in b29, 3A in b30… Now, 1/3 – 1/4 = 4/12 – 3/12 = 1/12 and 1/12 * 3 = 1/4. Therefore the all-base digsum(3,n) → 1/4 of n as n → ∞.

And so on.

Hour Re-Re-Re-Re-Powered

In “Dissing the Diamond” I looked at some of the fractals I found by selecting lines from a dissected diamond. Here’s another of those fractals:

Fractal from dissected diamond


It’s a distorted and incomplete version of the hourglass fractal:

Hourglass fractal


Here’s how to create the distorted form of the hourglass fractal:

Distorted hourglass from dissected diamond (stage 1)


Distorted hourglass #2


Distorted hourglass #3


Distorted hourglass #4


Distorted hourglass #5


Distorted hourglass #6


Distorted hourglass #7


Distorted hourglass #8


Distorted hourglass #9


Distorted hourglass #10


Distorted hourglass (animated)


When I de-distorted and doubled the dissected-diamond method, I got this:

Hourglass fractal #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 (animated)


Elsewhere other-engageable:

 

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

Dissing the Diamond

In “Fractangular Frolics” I looked at how you could create fractals by choosing lines from a dissected equilateral or isosceles right triangle. Now I want to look at fractals created from the lines of a dissected diamond, as here:

Lines in a dissected diamond


Let’s start by creating one of the most famous fractals of all, the Sierpiński triangle:

Sierpiński triangle stage 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


Sierpiński triangle #10


Sierpiński triangle (animated)


However, you can get an infinite number of Sierpiński triangles with three lines from the diamond:

Sierpińfinity #1


Sierpińfinity #2


Sierpińfinity #3


Sierpińfinity #4


Sierpińfinity #5


Sierpińfinity #6


Sierpińfinity #7


Sierpińfinity #8


Sierpińfinity #9


Sierpińfinity #10


Sierpińfinity (animated)


Here are some more fractals created from three lines of the dissected diamond (sometimes the fractals are rotated to looked better):



















And in these fractals one or more of the lines are flipped to create the next stage of the fractal:




Previously pre-posted:

Fractangular Frolics — fractals created in a similar way

Dissecting the Diamond — fractals from another kind of diamond

Circus Trix

Here’s a trix, or triangle divided into six smaller triangles:

Trix, or triangle divided into six smaller triangles


Now each sub-triangle becomes a trix in its turn:

Trix stage #2


And again:

Trix #3


Trix #4


Trix #5


Trix divisions (animated)


Now try dividing the trix and discarding sub-triangles, then repeating the process. A fractal appears:

Trix fractal #1


Trix fractal #2


Trix fractal #3


Trix fractal #4


Trix fractal #5


Trix fractal #6


Trix fractal #7


Trix fractal (animated)


But what happens if you delay the discarding, first dividing the trix completely into sub-triangles, then dividing completely again? You get a more attractive and symmetrical fractal, like this:

Trix fractal (delayed discard)


And it’s easy to convert the triangle into a circle, creating a fractal like this:

Delayed-discard trix fractal converted into circle


Delayed-discard trix fractal to circular fractal (animated)


Now a trix fractal that looks like a hawk-god:

Trix hawk-god #1


Trix hawk-god #2


Trix hawk-god #3


Trix hawk-god #4


Trix hawk-god #5


Trix hawk-god #6


Trix hawk-god #7


Trix hawk-god (animated)


Trix hawk-god converted to circle


Trix hawk-god to circle (animated)


If you delay the discard, you get this:

Trix hawk-god circle (delayed discard)


And here are more delayed-discard trix fractals:







Various circular trix-fractals (animated)


Post-Performative Post-Scriptum

In Latin, circus means “ring, circle” — the English word “circle” is actually from the Latin diminutive circulus, meaning “little circle”.

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. First of all, it can be divided completely into three copies of itself (each corresponding to a line of the fractangle seed, as shown below):

The shape contains three smaller versions of itself


The blue sub-fractal is slightly larger than the other two (1.154700538379251…x larger, to be more exact, or √(4/3)x to be exactly exact). And because each sub-fractal can be divided into three sub-sub-fractals, the shape contains smaller and smaller copies of itself:

Five more sub-fractals


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 (the three lines correspond to the three sub-fractals seen above)


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