Polymorphous Pursuit

Suppose four mice are standing on the corners of a large square. Each mouse begins running at the same speed towards the mouse one place away, reckoning clockwise. The mice will meet at the centre of the square and the path taken by each mouse will be what is known as a pursuit curve:

v4_mi1

vertices = 4, mouse-increment = 1


v4_mi1_animated

v = 4, mi = 1 (animated)


As I showed in “Persecution Complex”, it’s easy to find variants on the basic pursuit curve. If mi = 2, i.e. each mouse runs towards the mouse two places away, the mice will run in straight lines direct to the centre of the square:

v4_mi2

v = 4, mi = 2


v4_mi2_animated

v = 4, mi = 2 (animated)


That variant is trivial, but suppose there are eight mice, four starting on the corners of the square and four starting on the midpoints of the sides. Mice starting on the corners will run different pursuit curves to those starting on the midpoints, because the corners are further from the centre than the midpoints are:

v4_si1_mi1

v = 4, si = 1, mi = 1


v4_si1_mi1_extra


If mi = 3, the pursuit curves look like this:

v4_si1_mi3

v = 4, si = 1, mi = 3


v4_si1_mi3_animated

v = 4, si = 1, mi = 3 (animated)


Suppose there are twelve mice, four on each corner and two more on each side. If each mouse runs towards the mouse four places away, then the pursuit curves don’t all meet in the centre of the square. Instead, they meet in groups of three at four points equidistant from the centre, like this:

v4_si2_mi4

v4_si2_mi4_curves

v = 4, si = 2, mi = 4


v4_si2_mi4_animated

v = 4, si = 2, mi = 4 (animated)


v4_si4_mi4_animated

v = 4, si = 4, mi = 4 (animated)


v4_si4_mi4_large

v = 4, si = 4, mi = 4 (zoom)


Now suppose each mouse become sophisticated and runs toward the combined positions of two other mice, one two places away, the other three places away, like this:

v4_si1_mi2_3

v = 4, si = 1, mi = (2, 3)


v4_si1_mi2_3_animated

v = 4, si = 1, mi = (2, 3) (animated)


These polypursuits, as they could be called, can have complicated central regions:

v4_si2_mi1_4

v = 4, si = 2, mi = (1, 4)


v4_si2_mi1_4_animated

v = 4, si = 2, mi = (1, 4) (animated)


v4_si_va_mi_va

v = 4, si = various, mi = various


And what if you have two teams of mice, running towards one or more mice on the other team? For example, suppose two mice, one from each team, start on each corner of a square. Each mouse on team 1 runs towards the mouse on team 2 that is one place away, while each mouse on team 2 runs towards the mouse on team 1 that is two places away. If the pursuits curves of team 1 are represented in white and the pursuit curves of team 2 in green, the curves look like this:

2v4_mi1_mi2

v = 4 * 2, vmi = 1, vmi = 2


2v4_mi1_mi2_green

v = 4 * 2, vmi = 1, vmi = 2


2v4_mi1_mi2_animated

v = 4 * 2, vmi = 1, vmi = 2 (animated)


Now suppose the four mice of team 1 start on the corners while the mice of team 2 start at the centre of the square.

v4_c4_vmi1_cmi2_white

v = 4, centre = 4, vmi = 1, cmi = 2 (white team)


v4_c4_vmi1_cmi2_green

v = 4, centre = 4, vmi = 1, cmi = 2 (green team)


v4_c4_vmi1_cmi2_both

v = 4, centre = 4, vmi = 1, cmi = 2 (both teams)


v4_c4_vmi1_cmi2_animated

v = 4, centre = 4, vmi = 1, cmi = 2 (animated)


Here are more variants on pursuit curves formed by two teams of mice, one starting on the corners, one at the centre:

v4_c4_vmi0_1_cmi0

v = 4, centre = 4, vmi = (0, 1), cmi = 0


v4_c4_vmi0_2_cmi0

v = 4, centre = 4, vmi = (0, 2), cmi = 0


v4_c4_vmi0_3_cmi0

v = 4, centre = 4, vmi = (0, 3), cmi = 0


2v4_mi1_mi2_both

Get Your Ox Off

Boustrophedon (pronounced “bough-stra-FEE-dun” or “boo-stra-FEE-dun”) is an ancient Greek word literally meaning “as the ox turns (in ploughing)”, that is, moving left-right, right-left, and so on. The word is used of writing that runs down the page in the same way. To see what that means, examine two versions of the first paragraph of Clark Ashton Smith’s story “The Demon of the Flower” (1933). The first is written in the usual way, the second is written boustrophedon:

Not as the plants and flowers of Earth, growing peacefully beneath a simple sun, were the blossoms of the planet Lophai. Coiling and uncoiling in double dawns; tossing tumultuously under vast suns of jade green and balas-ruby orange; swaying and weltering in rich twilights, in aurora-curtained nights, they resembled fields of rooted servants that dance eternally to an other-worldly music.


Not as the plants and flowers of Earth, growing peacefully
.iahpoL tenalp eht fo smossolb eht erew ,nus elpmis a htaeneb
Coiling and uncoiling in double dawns; tossing tumultuously
;egnaro ybur-salab dna neerg edaj fo snus tsav rednu
swaying and weltering in rich twilights, in aurora-curtained
ecnad taht stnavres detoor fo sdleif delbmeser yeht ,sthgin
eternally to an other-worldly music.


Boustrophedon writing was once common and sometimes the left-right lines would also be mirror-reversed, like this:


You could also use the term “boustrophedon” to describe the way this table of numbers is filled:

primes_table


The table begins with “1” in the top left-hand corner, then moves right for “2”, then down for “3”, then right-and-up for “4”, “5” and “6”, then right for “7”, then left-and-down for “8”, “9” and “10”, and so on. You could also say that the numbers snake through the table. I’ve marked the primes among them, because I was interested in the patterns made by the primes when the numbers were represented as blocks on a grid, like this:

primes_large


Primes are in solid white (compare the Ulam spiral). Here’s the boustrophedon prime-grid on a finer scale:

primes

(click for full image)


And what about other number-tests? Here are the even numbers marked on the grid (i.e. n mod 2 = 0):

mod2

n mod 2 = 0


And here are some more examples of a modulus test:

mod3

n mod 3 = 0


mod5

n mod 5 = 0


mod9

n mod 9 = 0


mod15

n mod 15 = 0


mod_various

n mod various = 0 (animated gif)


Next I looked at reciprocals (numbers divided into 1) marked on the grid, with the digits of a reciprocal marking the number of blank squares before a square is filled in (if the digit is “0”, the square is filled immediately). For example, in base ten 1/7 = 0.142857142857142857…, where the block “142857” repeats for ever. When represented on the grid, 1/7 has 1 blank square, then a filled square, then 4 blank squares, then a filled square, then 2 blank squares, then a filled square, and so on:

recip7_base10

1/7 in base 10


And here are some more reciprocals (click for full images):

recip9_base2

1/9 in base 2


recip13_base10

1/13 in base 10


recip27_base10

1/27 in base 10


recip41_base10

1/41 in base 10


recip63_base10

1/63 in base 10


recip82_base10

1/82 in base 10


recip101_base10

1/101 in base 10


recip104_base10

1/104 in base 10


recip124_base10

1/124 in base 10


recip143_base10

1/143 in base 10


recip175_base10

1/175 in base 10


recip604_base8

1/604 in base 8


recip_various

1/n in various bases (animated gif)


Radical Sheet

If you take a sheet of standard-sized paper and fold it in half from top to bottom, the folded sheet has the same proportions as the original, namely √2 : 1. In other words, if x = √2 / 2, then 1 / x = √2:

√2 = 1.414213562373…, √2 / 2 = 0.707106781186…, 1 / 0.707106781186… = 1.414213562373…

So you could say that paper has radical sheet (the square or other root of a number is also called its radix and √ is known as the radical sign). When a rectangle has the proportions √2 : 1, it can be tiled with an infinite number of copies of itself, the first copy having ½ the area of the original, the second ¼, the third ⅛, and so on. The radical sheet below is tiled with ten diminishing copies of itself, the final two having the same area:

papersizes

papersizes_static

You can also tile a radical sheet with six copies of itself, two copies having ¼ the area of the original and four having ⅛:

paper_6div_static

paper_6div

This tiling is when you might say the radical turns crucial, because you can create a fractal cross from it by repeatedly dividing and discarding. Suppose you divide a radical sheet into six copies as above, then discard two of the ⅛-sized rectangles, like this:

paper_cross_1

Stage 1


Then repeat with the smaller rectangles:

paper_cross_2

Stage 2


paper_cross_3

Stage 3


paper_cross_4

Stage 4


paper_cross_5

Stage 5


paper_cross

Animated version

paper_cross_static

Fractile cross

The cross is slanted, but it’s easy to rotate the original rectangle and produce an upright cross:

paper_cross_upright

paper_cross_upright_static

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

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

fractal4_1
A pentagon without a central point using numbers in a zero-less base 7 looks like this:
fractal5_0single

fractal5_0
A pentagon with a central point looks like this:
fractal5_1single

fractal5_1
Hexagons using a zero-less base 8 look like this:
fractal6_1single

fractal6_1


fractal6_0single

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


fractal5


fractal6789

The Choice of the Circle

Here’s an elementary mathematical problem: how many ways are there to choose three numbers from a set of six numbers? If the set is (1, 2, 3, 4, 5, 6), these are the possible choices (or combinations):

(1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 2, 6), (1, 3, 4), (1, 3, 5), (1, 3, 6), (1, 4, 5), (1, 4, 6), (1, 5, 6), (2, 3, 4), (2, 3, 5), (2, 3, 6), (2, 4, 5), (2, 4, 6), (2, 5, 6), (3, 4, 5), (3, 4, 6), (3, 5, 6), (4, 5, 6) (c = 20)

So 6C3 = 20 (C stands for “combination”). The general formula is nCr = (n! / (n-r)!) / r!, where n is the number to choose from, r is the number of choices and n! is factorial n, or n multiplied by all numbers less than itself. For example, 6! = 6 * 5 * 4 * 3 * 2 * 1 = 720. When n = 6 and c = 3, 6C3 = (6! / (6-3)!) / 3! = (720 / 6) / 6 = 20.

There isn’t much visual appeal in the choices above, but there’s a simple way to change that. Take the ways of choosing two numbers from a set of ten. They start like this:

(1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 4), (3, 5), (3, 6)…

Suppose each choice represents the midpoint of two points chosen from a set of ten points around a pentagon, so that (1, 2) is half-way between points 1 and 2, (3, 5) is half-way between points 3 and 5, and so on:

pent_10_2

Now take the ways of choosing three numbers from a set of ten:

(1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 2, 6), (1, 2, 7), (1, 2, 8), (1, 2, 9), (1, 2, 10), (1, 3, 4), (1, 3, 5), (1, 3, 6), (1, 3, 7), (1, 3, 8), (1, 3, 9), (1, 3, 10)…

Now the pentagon looks like this, with (1, 2, 3) representing the point midway between 1, 2 and 3, (1, 3, 9) representing the point midway between 1, 3 and 9, and so on:

pent_10_3

Now here are 10C4, 10C5 and 10C6 for the pentagon:

pent_10_4

pent_10_5

pent_10_6

You can also generate the points 5C4 = 5, then add them to the original five points and generate 10C4:

pent4_1

5C4


pent4_2

10C4


And here are 5C5, 6C5 and 12C5:

pent5

Here are 7C7 and 8C8, adding points as for 5C4:

hept7

octo8

And here is 12C6 using a dodecagon:

dodeca_6

And various nCr for dodecagons and other polygons:

various

This method can also be used to represent the partitions of n, or the number of sets whose members sum to n. The partitions of 5 are these:

(5), (4, 1), (3, 2), (3, 1, 1), (2, 2, 1), (2, 1, 1, 1), (1, 1, 1, 1, 1)

There are seven partitions, so p(5) = 7. Partitions start small and get very large, starting with p(1), p(2), p(3) and so on:

1, 2, 3, 5, 7, 11, 15, 22, 30, 42, 56, 77, 101, 135, 176, 231, 297, 385, 490, 627, 792, 1002, 1255, 1575, 1958, 2436, 3010, 3718, 4565, 5604, 6842, 8349, 10143, 12310, 14883, 17977, 21637, 26015, 31185, 37338, 44583, 53174, 63261, 75175, 89134, 105558, 124754, 147273, 173525, 204226, 239943, 281589, 329931, 386155, 451276, 526823, 614154, 715220, 831820, 966467, 1121505, 1300156…

Suppose the partitions of n are treated as sets of points around a polygon with n vertices. Each set is then used to generate the point midway between its members. For example, (5, 4, 4, 2) is one partition of 15 and would represent the point midway between 5, 4, 4 and 2 of a pentadecagon. Here is a graphical representation of p(30):

partition30

Here are graphical representations for the partitions 5 to 15, then 15 to 60 in increments of 5 (15, 20, 25, etc):

partitions5_60

And here are some close-ups for the partitions of 35 and 40:

partitions40

Lette’s Roll

A roulette is a little wheel or little roller, but it’s much more than a game in a casino. It can also be one of a family of curves created by tracing the path of a point on a rotating circle. Suppose a circle rolls around another circle of the same size. This is the resultant roulette:
roulette1

roulette1static
The shape is called a cardioid, because it looks like a heart (kardia in Greek). Now here’s a circle with radius r rolling around a circle with radius 2r:
roulette2

roulette2static

That shape is a nephroid, because it looks like a kidney (nephros in Greek).

This is a circle with radius r rolling around a circle with radius 3r:
roulette3

roulette3static
And this is r and 4r:
roulette4

roulette4static
The shapes above might be called outer roulettes. But what if a circle rolls inside another circle? Here’s an inner roulette whose radius is three-fifths (0.6) x the radius of its rollee:
roulette5

roulette5static
The same roulette appears inverted when the inner circle has a radius two-fifths (0.4) x the radius of the rollee:
roulette5a
But what happens when the circle rolling “inside” is larger than the rollee? That is, when the rolling circle is effectively swinging around the rollee, like a bunch of keys being twirled on an index finger? If the rolling radius is 1.5 times larger, the roulette looks like this:
roulette6
If the rolling radius is 2 times larger, the roulette looks like this:
roulette2over

Here are more outer, inner and over-sized roulettes:

roulette_outer

roulette_inner

roulette_over

And you can have circles rolling inside circles inside circles:

roulette7

roulette0616

roulette0616all

And here’s another circle-in-a-circle in a circle:

roulette07c015c

M.i.P. Trip

The Latin phrase multum in parvo means “much in little”. It’s a good way of describing the construction of fractals, where the application of very simple rules can produce great complexity and beauty. For example, what could be simpler than dividing a square into smaller squares and discarding some of the smaller squares?

Yet repeated applications of divide-and-discard can produce complexity out of even a 2×2 square. Divide a square into four squares, discard one of the squares, then repeat with the smaller squares, like this:

2x2square2


2x2square3


Increase the sides of the square by a little and you increase the number of fractals by a lot. A 3×3 square yields these fractals:

3x3square2


3x3square3


3x3square6


3x3square7


3x3square8


3x3square9


3x3square10


And the 4×4 and 5×5 fractals yield more:
4x4square1


4x4square2



4x4square4


4x4square5


4x4square6


4x4square7


4x4square8


5x5square1


5x5square2


5x5square3


5x5square4


5x5square5


5x5square6


5x5square7


The Hex Fractor

A regular hexagon can be divided into six equilateral triangles. An equilateral triangle can be divided into three more equilateral triangles and a regular hexagon. If you discard the three triangles and repeat, you create a fractal, like this:

hexring
Adjusting the sides of the internal hexagon creates new fractals:
hexring2
hexring1
Discarding a hexagon after each subdivision creates new shapes:

hexring4
hexring5
hexring6
And you can start with another regular polygon, divide it into triangles, then proceed with the hexagons:
hexring3