Category Archives: Geometry

The Wyrm Ferns

by in Aesthetics, Dragon Curves, Fractals, Geometry, Mathematics and tagged , , , , , , | Leave a comment

A fern is a fractal, a shape that contains copies of itself at smaller and smaller scales. That is, part of a fern looks like the fern as a whole:

Fern as fractal (source)

Millions of years after Mother Nature, man got in on the fract, as it were:

The Sierpiński triangle, a 2d fractal

The Sierpiński triangle is a fractal created in two dimensions by a point jumping halfway towards one or another of the three vertices of a triangle. And here is a fractal created in one dimension by a point jumping halfway towards one or another of the two ends of a line:

A 1d fractal

In one dimension, the fractality of the fractal isn’t obvious. But you can try draggin’ out (or dragon out) the fractality of the fractal by ferning the wyrm, as it were. Suppose that after the point jumps halfway towards one or another of the two points, it’s rotated by some angle around the midpoint of the two original points. When you do that, the fractal becomes more and more obvious. In fact, it becomes what’s called a dragon curve (in Old English, “dragon” was wyrm or worm):

Fractal with angle = 5°

Fractal 10°

Fractal 15°

Fractal 20°

Fractal 25°

Fractal 30°

Fractal 35°

Fractal 40°

Fractal 45°

Fractal 50°

Fractal 55°

Fractal 60°

Fractal 0° to 60° (animated at ezGif)

But as the angle gets bigger, an interesting aesthetic question arises. When is the ferned wyrm, the dragon curve, at its most attractive? I’d say it’s when angle ≈ 55°:

Fractal 50°

Fractal 51°

Fractal 52°

Fractal 53°

Fractal 54°

Fractal 55°

Fractal 56°

Fractal 57°

Fractal 58°

Fractal 59°

Fractal 60°

Fractal 50° to 60° (animated)

At angle >= 57°, I think the dragon curve starts to look like some species of bristleworm, which are interesting but unattractive marine worms:

A bristleworm, Nereis virens (see polychaete at Wikipedia)

Finally, here’s what the ferned wyrm looks like in black-and-white and when it’s rotating:

Fractal 0° to 60° (b&w, animated)

Fractal 56° (rotating)

Fractal 56° (b&w, rotating)

Double fractal 56° (b&w, rotating)

Previously Pre-Posted (Please Peruse)…

• Curvous Energy — a first look at dragon curves
• Back to Drac’ — another look at dragon curves

Squaring the Triangle

by in Circles, Fractals, Geometry, Mathematics, Sierpiński triangle, Triangles and tagged , , , , , | Leave a comment

It’s an interesting little exercise in elementary trigonometry to turn the Sierpiński triangle…

A Sierpiński triangle

…into its circular equivalent:

A Sierpiński trisc

You could call that a trisc, because it’s a triangle turned into a disc. And here’s triangle-and-trisc in one image:

Sierpiński triangle + Sierpiński trisc

But what’s the square equivalent of a Sierpiński triangle? This is:

Square from Sierpiński triangle

You can do that directly, as it were:

Sierpiński triangle → square

Or you can convert the triangle into a disc, then the disc into a square, like this:

Sierpiński triangle → trisc → square

Now try converting the triangle into a pentagon:

Pentagon from Sierpiński triangle

Sierpiński triangle → pentagon

Sierpiński triangle → trisc → pentagon

And a hexagon:

Hexagon from Sierpiński triangle

Sierpiński triangle → hexagon

Sierpiński triangle → trisc → hexagon

But you can also convert the Sierpiński trisc back into a Sierpiński triangle, then into a Sierpiński trisc again:

Sierpiński triangle → trisc → triangle → trisc

Sierpiński triangle → trisc → triangle → trisc (animated at Ezgif)

Sierpiński triangle → trisc → triangle → trisc (b&w)

Sierpiński triangle → trisc → triangle → trisc (b&w) (animated at Ezgif)

After triangles come squares. Here’s a shape called a T-square fractal:

T-square fractal

And here’s the circular equivalent of a T-square fractal:

T-square fractal → T-squisc

T-square fractal + T-squisc

If a disc from a triangle is a trisc, then a disc from a square is a squisc (it would be pentisc, hexisc, heptisc for pentagonal, hexagonal and heptagonal fractals). Here’s the octagonal equivalent of a T-square fractal:

Octagon from T-square fractal

As with the Sierpiński trisc, you can use the T-squisc to create the T-octagon:

T-square fractal → T-squisc → T-octagon (color)

Or you can convert the T-square directly into the T-octagon:

T-square fractal to T-octagon fractal

But using the squisc makes for interesting multiple images:

T-square fractal → T-squisc → T-octagon (b&w)

T-square fractal → T-squisc → T-octagon → T-squisc

T-square fractal → T-squisc → T-octagon → T-squisc (animated at Ezgif)

The conversions from polygon to polygon look best when the number of sides in the higher polygon are a multiple of the number of sides in the lower, like this:

Sierpiński triangle → Sierpiński hexagon → Sierpiński nonagon

Scout the Routes

by in Chaos Game, Fractals, Geometry, Mathematics, Squares and tagged , , , , , , , , | Leave a comment

Triangles? Yes. Squares? No. If you scout the routes with a triangle, you get a beautiful fractal. If you scout the routes with a square, you don’t. Here’s what you get with a triangle:

A Sierpiński triangle

But how do you scout the routes? (That phrase works best in the American dialects where “scout” rhymes with “route”.) Simple: you mark the final positions reached when a point traces all possible ways of jumping, say, eight times 1/2-way towards the vertices of a polygon. Here’s an animation of a point scouting the routes of eight jumps towards the vertices of a triangle (it starts each time at the center):

Creating a Sierpiński triangle by scouting the routes (animated at Ezgif)

If you scout the routes with a square, you don’t get a fractal. Instead, the interior of the square fills evenly (and boringly) with the end-points of the routes:

Scouting the routes with a square (animated at Ezgif)

But you can create fractals with a square if you out routes as you scout routes. That is, if you exclude some routes and don’t mark their end-points. One way to do this is to compare the proposed next jump-vertex (vertex-jumped-towards) with the previous jump-vertex. For example, if the proposed jump-vertex, jv[t], is the same as the previous jump-vertex, jv[t-1], you don’t jump towards jv[t] or you jump towards it in a different way. The test is jv[t] = jv[t-1] + vi. If vi = 0 and you jump towards the clockwise neighbor of jv when the test is true, you get a fractal looking like this:

vi = 0, action = jv → jv + 1

Here’s the fractal if you jump towards the clockwise-neighbor-but-one when the test is true:

vi = 0, action = jv + 2

Now try varying the vi of the jv[t-1] + vi:

vi = 2, action = jv + 2

vi = 2, action = jv + 1

vi = 3, action = jv + 1

Or what about jumping in a different way towards jv when the test is true? If you jump 2/3 of the way rather 1/2, you get his fractal:

vi = 2, action = jump 2/3

And if you jump 4/3 of the way (i.e., you overshoot the vertex jv), you get this fractal:

vi = 0, action = jump 4/3rds to vertex

vi = 0, jump 4/3 (guide-square removed)

vi = 2, jump 4/3rds (guide-square removed)

And in this fractal the point jumps 2/3 of the way to the center of the square when the test is true:

vi = 2, action = jump 2/3rds of way to center of square

But why apply only one test to jv[1] and use only when one alternative jump? If jv[t] = jv[t-1] + 1 or jv[t] = jv[t-1] + 3, jv[t] becomes jv[t]+1 or jv[t]+3, respectively, you get this fractal:

vi = 1, jv + 1; vi = 3, jv + 3

Here are more fractals created by single and double tests:

vi = 1, jv + 1

vi = 0, jump 2/3

vi = 0, jump towards center 2/3rds

vi = 1, jump-center 2/3

vi = 2, jump 1/3; vi = 3, jump 1/1 (i.e, 1)

vi = 0, jv + 2; vi = 2, jump-center 1/2

vi = 0, jv + 2; vi = 2, jump-center 2/3

vi = 0, jv + 2; vi = 2, jump-center 4/3

vi = 0, jv + 1; vi = 2, jump 2/3

vi = 0, jv + 2; vi = 2, jump 2/3

vi = 0, jump 4/3; vi = 2, jv + 2

vi = 0, jump 2/3; vi = 2, jv + 1

vi = 0, jump 4/3; vi = 1, jv + 2

vi = 0, jump 2/3; vi = 2, jump 1/3

vi =0, jump 1/3; vi = 2, jump 2/3

vi = 0, jump 0/1 (i.e, 0); vi = 2, jump 1/3

Lime Time

by in Arithmetic, Circles, Fractals, Geometry, Integer Sequences, Mathematics and tagged , , , , , , , , , , | Leave a comment

What do you get if you list every successive pair of entries in this sequence?

1, 2, 1, 3, 2, 3, 1, 4, 3, 4, 1, 5, 2, 5, 3, 5, 4, 5, 1, 6, 5, 6, 1, 7, 2, 7, 3, 7, 4, 7, 5, 7, 6, 7, 1, 8, 3, 8, 5, 8, 7, 8, 1, 9, 2, 9, 4, 9, 5, 9, 7, 9, 8, 9, 1, 10, 3, 10, 7, 10, 9, 10, 1, 11, 2, 11, 3, 11, 4, 11, 5, 11, 6, 11, 7, 11, 8, 11, 9, 11, 10, 11, 1, 12, 5, 12, 7, 12, 11, 12, 1, 13, … — A038568 at the Online Encyclopedia of Integer Sequence

You get the rational fractions ordered by denominator in their simplest form: 1/2, 1/3, 2/3, 1/4, 3/4, 1/5, 2/5, 3/5… There are no pairs like 2/4 and 5/35, because those can be simplified: 2/4 → 1/2; 15/35 → 3/7. You can get the same set of rational fractions by listing every successive pair in this sequence, the Stern-Brocot sequence:

1, 2, 1, 3, 2, 3, 1, 4, 3, 5, 2, 5, 3, 4, 1, 5, 4, 7, 3, 8, 5, 7, 2, 7, 5, 8, 3, 7, 4, 5, 1, 6, 5, 9, 4, 11, 7, 10, 3, 11, 8, 13, 5, 12, 7, 9, 2, 9, 7, 12, 5, 13, 8, 11, 3, 10, 7, 11, 4, 9, 5, 6, 1, 7, 6, 11, 5, 14, 9, 13, 4, 15, 11, 18, 7, 17, 10, 13, 3, 14, 11, 19, 8, 21, 13, 18, 5, 17, 12, 19, … — A002487 at the OEIS

But the fractions don’t come ordered by denominator this time. In fact, they seem to come at random: 1/2, 1/3, 2/3, 1/4, 3/5, 2/5, 3/4, 1/5, 4/7, 3/8, 5/7, 2/7, 5/8… But they’re not random at all. There’s a complicated way of generating them and a simple way. An amazingly simple way, I think:

Moshe Newman proved that the fraction a(n+1)/a(n+2) can be generated from the previous fraction a(n)/a(n+1) = x by 1/(2*floor(x) + 1 – x). The successor function f(x) = 1/(floor(x) + 1 – frac(x)) can also be used. — A002487, “Stern-Brocot Sequence”, at the OEIS

In another form, the Stern-Brocot sequence is generated by what’s called the Calkin-Wilf Tree. Now suppose you use the Stern-Brocot sequence to supply the x co-ordinate of an L-graph whose arms run from 0 to 1. And you use the Calkin-Wilf Tree to supply the y co-ordinate of the L-tree. What do you get? As I described in “I Like Gryke”, you get this fractal:

Limestone fractal

I call it a limestone fractal or pavement fractal or gryke fractal, because it reminds me of the fissured patterns you see in the limestone pavements of the Yorkshire Dales:

Fissured limestone pavement, Yorkshire Dales (Wikipedia)

But what happens when you plot the (x,y) of the Stern-Brocot sequence and the Calkin-Wilf Tree on a circle instead? You get an interestingly distorted limestone fractal:

Limestone fractal on circle

You can also plot the (x,y) around the perimeter of a polygon, then stretch the polygon into a circle. Here’s a square:

Limestone fractal on square

⇓

Limestone square stretched to circle

And here are a pentagon, hexagon, heptagon and octagon — note the interesting perspective effects:

Limestone fractal on pentagon

⇓

Limestone pentagon stretched to circle

Limestone fractal on hexagon

⇓

Limestone hexagon stretched to circle

Limestone fractal on heptagon

⇓

Limestone heptagon stretched to circle

Limestone fractal on octagon

⇓

Limestone octagon stretched to circle

And finally, here are animations of limestone polygons stretching to circles:

Limestone square stretched to circle (animated at EZgif)

Limestone pentagon to circle (animated)

Limestone hexagon to circle (animated)

Limestone heptagon to circle (animated)

Limestone octagon to circle (animated)

Previously Pre-Posted (Please Peruse)

• I Like Gryke — a first look at the limestone fractal

Punctuated Pairimeters

by in Arithmetic, Circles, Geometry, Mathematics and tagged , , , , | Leave a comment

Imagine using the digits of n in two different bases to generate two fractions, a/b and c/d, where a/b < 1 and c/d < 1 (see Appendix for a sample program). Now use the fractions to find a pair of points on the perimeter of a circle, (x1, y1) and (x2, y2), then calculate and mark the midpoint of (x1, y1) and (x2, y2). If the bases have a prime factor in common, pretty patterns will appear from this punctuated pairimetry:

b1 = 2; b2 = 6

b1 = 2; b2 = 10

b1 = 2; b2 = 14

b1 = 4; b2 = 10

b1 = 4; b2 = 20

b1 = 4; b2 = 28

b1 = 6; b2 = 42

b1 = 12; b2 = 39

b1 = 24; b2 = 28

b1 = 28; b2 = 40

b1 = 32; b2 = 36

b1 = 42; b2 = 78

Appendix: Sample Program for Pairimetry

GetXY(xyi)=

fr = 0
recip = 1
bs = base[xyi]
for gi = 1 to di[xyi]
recip = recip/bs
fr += d[xyi,gi] * recip
next gi

x[xyi] = xcenter + sin(pi2 * fr) * radius
y[xyi] = ycenter + cos(pi2 * fr) * radius

endproc

Dinc(i1) =

d[i1,1]++;
if d[i1,1] == base[i1] then

i2 = 1

while d[i1,i2] == base[i1]

d[i1,i2] = 0
i2++;
d[i1,i2]++;

endwhile

if i2 > di[i1] then di[i1] = i2 endif

endif

endproc

Drawfigure =

base = x = y = di = array(2)
d = array(2,100)
radius = 100
pi2 = pi * 2
base[1] = 2
base[2] = 6
di[1] = 1
di[2] = 1

while true

for i = 1 to 2
call Dinc(i)
call GetXY(i)
next i

plot (x[1]+x[2]) / 2, (y[1] + y[2]) / 2

endwhile

endproc

call drawfigure

Partitional Pulchritude

by in Arithmetic, Geometry, Integer Sequences, Mathematics and tagged , , , , , , | Leave a comment

If you want a good example of how, in math, something very simple can quickly get very deep, just look at partitions. Here are the partitions of 1 to 5, that is, the ways 1 to 5 can be expressed as a sum of integers smaller than or equal to themselves:

1 = 1

numbpart(1) = 1

2 = 2
1 + 1 = 2

numbpart(2) = 2

3 = 3
1 + 2 = 3
1 + 1 + 1 = 3

numbpart(3) = 3

4 = 4
1 + 3 = 4
2 + 2 = 4
1 + 1 + 2 = 4
1 + 1 + 1 + 1 = 4

numbpart(4) = 5

5 = 5
1 + 4 = 5
2 + 3 = 5
1 + 1 + 3 = 5
1 + 2 + 2 = 5
1 + 1 + 1 + 2 = 5
1 + 1 + 1 + 1 + 1 = 5

numbpart(5) = 7

It’s very easy to understand the concept of partitions, but very difficult to understand how partitions behave. For example, here is numbpart(n), the count of partitions for 1, 2, 3,…

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, … A000041 at the Online Encyclopedia of Integer Sequences, “a(n) is the number of partitions of n (the partition numbers)”

What’s the formula for numbpart(n)? That’s a tricky question. And what’s the formula for the curves produced by counting the various lengths of partitions(n)? That’s another tricky question, but one thing is easy to see. As n gets bigger, the graph of countlen(partitions(n)) acquires a strange, lopsided beauty. Here are the partitions of 8, with the count of how many partitions of a particular length there are:

8 = 8 (1 partition of length 1)
1 + 7 = 8
2 + 6 = 8
3 + 5 = 8
4 + 4 = 8 (4 partitions of length 2)
1 + 1 + 6 = 8
1 + 2 + 5 = 8
1 + 3 + 4 = 8
2 + 2 + 4 = 8
2 + 3 + 3 = 8 (5 of length 3)
1 + 1 + 1 + 5 = 8
1 + 1 + 2 + 4 = 8
1 + 1 + 3 + 3 = 8
1 + 2 + 2 + 3 = 8
2 + 2 + 2 + 2 = 8 (5 of length 4)
1 + 1 + 1 + 1 + 4 = 8
1 + 1 + 1 + 2 + 3 = 8
1 + 1 + 2 + 2 + 2 = 8 (3 of length 5)
1 + 1 + 1 + 1 + 1 + 3 = 8
1 + 1 + 1 + 1 + 2 + 2 = 8 (2 of length 6)
1 + 1 + 1 + 1 + 1 + 1 + 2 = 8 (1 of length 7)
1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 = 8 (1 of length 8)

When counts like that are shown as a graph, the graphs look like this (maximum counts are normalized to the same height):


graph of countlen(partitions(2))


countlen(partitions(3))


countlen(partitions(4))


countlen(partitions(5))


countlen(partitions(6))


countlen(partitions(7))


countlen(partitions(8))


countlen(partitions(9))


countlen(partitions(10))


countlen(partitions(15))


countlen(partitions(20))


countlen(partitions(30))


countlen(partitions(40))


countlen(partitions(50))


countlen(partitions(60))


countlen(partitions(70))


countlen(partitions(80))


countlen(partitions(90))


countlen(partitions(100))


Animated gif of partlen graphs (courtesy EZgif)

The graphs have a long, low right tail because the counts rise to great heights very quick, then fall away again, as you can see with partitions(100):

1 = count(partitions(10),len=1)
50 = count(partitions(10),len=2)
833 = count(partitions(10),len=3)
7153 = count(partitions(10),len=4)
38225 = count(partitions(10),len=5)
143247 = count(partitions(10),len=6)

[…]

10643083 = count(partitions(10),len=16)
11022546 = count(partitions(10),len=17)
11087828 = count(partitions(10),len=18)
10885999 = count(partitions(10),len=19)
10474462 = count(partitions(10),len=20)

[…]

30 = count(partitions(10),len=91)
22 = count(partitions(10),len=92)
15 = count(partitions(10),len=93)
11 = count(partitions(10),len=94)
7 = count(partitions(10),len=95)
5 = count(partitions(10),len=96)
3 = count(partitions(10),len=97)
2 = count(partitions(10),len=98)
1 = count(partitions(10),len=99)
1 = count(partitions(10),len=100)

Sorted for D’s nand Wizz

by in Geometry, Mathematics, Polygonal numbers, Squares, Triangular Numbers and tagged , , , , | Leave a comment

As I’ve pre-previously pointed out, there are an infinite number of points in the plane. And in part of the plane. So you have to pare points to create interesting shapes. One way of paring points is by comparing them. After you’ve compared them, you can sort them. For example, you can compare the distance from (x,y) to the four vertices of a square. Then you can sort the distances from nearest to furthest. Then you can mark (x,y) if the distance to, say, the nearest vertice from (x,y) is evenly divisible by 2 when measured in pixels or some other unit. When you do that, you might get an image like this (depending on the hardware and software you use):

Distance to nearest vertex is evenly divisible by 2, i.e. d mod 2 = 0 for v1 (vertices marked in red)

Or you can mark (x,y) if the distance to the nearest vertex is a triangular number:

is_triangular(d) for v1

Or a square number:

is_square(d) for v1

Or you can test the distance to the second-nearest vertex:

d mod 2 = 0 for v2

And the third-nearest (or second-furthest) vertex:

d mod 2 = 0 for v3

And furthest vertex:

d mod 2 = 0 for v4

Now try expanding or contracting the square:

d mod 2 = 0 for v1 on square * 2

d mod 2 = 0 for v1 on square * 3

d mod 2 = 0 for v1 on square * 0.5

d mod 2 = 0 for v1 on square * 1.5

d mod 2 = 0 for v1 on square * 5

d mod 2 = 0 for v1 on square * 20

d mod 2 = 0 for v1 on square * 100

Finally, here are some more mandala-like images created by using various d mod m on an expanded square (the images should be horizontally and vertically mirror-symmetrical, but my software introduced artefacts):

d mod 2 = 0 for v1 on square * 200
(open in separate window for better detail)

d mod 3 = 0 for v1 on square * 200

d mod 4 = 0 for v1 on square * 200

d mod 5 = 0 for v1 on square * 200

d mod 6 = 0 for v1 on square * 200

d mod 7 = 0 for p1 on square * 200

d mod 8 = 0 for p1 on square * 200

d mod 9 = 0 for p1 on square * 200

d mod 2..9 = 0 for p1 on square * 200 (animated at EZgif)

Post-Performative Post-Scriptum…

The title of this incendiary intervention is a paronomasia on “Sorted for E’s and Wizz”, a song offa of 1995 album Different Class by Sheffield Brit-popsters Pulp rebelliously referencing counter-cultural consumption of psychoactive drugs ecstasy and amphetamine. My program sorted distances, i.e. d’s, but not wizz, therefore it sorted d’s and-not wizz. In Boolean logic, nand means “and-not” (roughly speaking).

Previously Pre-Posted (Please Peruse)…

• Points Pared — an earlier look at points and polygons

I Like Gryke

by in Arithmetic, Fractals, Geometry, Mathematics and tagged , , , , , , , , , , , , , , , , , , , , , | Leave a comment

Sometimes I find fractals. And sometimes fractals find me. Here’s a fractal that found me:

Limestone fractal #1

I call it a limestone fractal or pavement fractal or gryke fractal, because it reminds me of the fissured patterns you see in the limestone pavements of the Yorkshire Dales:

Fissured limestone pavement, Yorkshire Dales (Wikipedia)

The limestone blocks are called clints and the larger fissures between them are called grykes, with kamenitza and karren (from Slavic and German, respectively) for smaller pits and grooves:

Limestone linguistics (Dales Rocks)

Here’s the me-finding fractal again, in a slightly different version:

Limestone fractal #2

How did it find me? Well, I wasn’t looking for fractals, but looking at fractions. Farey fractions and Calkin-Wilf fractions, to be precise. They can both be represented as bifurcating trees, like this:

Calkin-Wilf tree (Wikipedia)

Both trees produce all the irreducible rational fractions — but in a different order. That’s why they create a fractal (rather than a 45° line). By following the same path in both bifurcating trees, I generated parallel sequences of Farey and Calkin-Wilf fractions, then used the Farey fractions to represent x in a 1×1 square and the Calkin-Wilf fractions to represent y (where the Calkin-Wilfs, a/b, were greater than 1, I simply a/b → b/a). When you do that (or use Stern-Brocot fractions instead of the Farey fractions), you get the limestone fractal.

I think it looks better in the second version (which is the one that found me, in fact). For LF #2, I was using standard binary numbers to generate the parallel sequences, so the leftmost digit was always 1 and final step of the tree-search was always in the same direction. Here’s LF #2 as black-on-white rather than white-on-black:

Limestone fractal #2 (black-on-white)

And here is the formation of LF #1 as an animated gif:

Growth of limestone fractal (animated at ezGIF)

And if that’s a me-finding fractal, what about me-found fractals? Here’s one:

The Hourglass Fractal (animated gif optimized at ezGIF)

Hourglass fractal

I can say “I found that fractal” because I was looking for fractals when it appeared on the screen. And re-appeared (and re-re-appeared), because I’ve found it using different methods.

Elsewhere Other-Accessible

• Hour Power — more on the hourglass fractal

The Bellissima Curve

by in Arithmetic, Fibonacci Sequence, Geometry, Mathematics and tagged , , , , , , | Leave a comment

The bell curve is a shape that appears when you make a graph by counting all possible sums of a range of integers like 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. The smallest sum you can get is 1; the largest is 55 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10. But there’s only one sum of 1 and only one sum of 55. Other sums are more common:

• 10 = 1 + 2 + 3 + 4
• 10 = 1 + 2 + 7
• 10 = 1 + 3 + 6
• 10 = 1 + 4 + 5
• 10 = 2 + 3 + 5
• 10 = 2 + 8
• 10 = 3 + 7
• 10 = 4 + 6
• 10 = 10

So there are nine sums of 10. If you graph count-sums with a bigger set of consecutive integers from 1, 2, 3…, you get this shape:

Bell curve from sum-counts with 1, 2, 3, 4, 5, 6, 7, 8, 9, 10…
(open in separate window for full-sized image)

It’s a bell curve. Et c’est une belle curve, a “beautiful curve” in French. But I’ve found what I call bellissime curve — Italian for “most beautiful curves” — by sampling different sets of integers. With the set (1, 3, 5, 7, 9, 11, 13, 15, 17, 19…), you get what you could call a slightly wrinkled bell curve:

Wrinkled bell-curve from sum-counts with 1, 3, 5, 7, 9, 11, 13, 15, 17, 19…
(open in separate window for full-sized image)

After that, as you leave bigger gaps in the sampled sets, the curves start to overlap and add extra beauty:

Overlapping bell curves from sum-counts with 1, 4, 7, 10, 13, 16, 19, 22, 25, 28…

Bellissima curves from sum-counts with 1, 5, 9, 13, 17, 21, 25, 29, 33, 37…

Bellissima curves from sum-counts with 1, 6, 11, 16, 21, 26, 31, 36, 41, 46…

Bellissima curves from sum-counts with 1, 7, 13, 19, 25, 31, 37, 43, 49, 55…

With the set (3, 6, 9, 15, 18, 21…), the bell is back:

Bell curve from sum-counts with 3, 6, 9, 15, 18, 21…

But with (4, 7, 10, 13, 6, 19…), separated by the same distance, you get this:

Bell curve from sum-counts with 4, 7, 10, 13, 6, 19…

When you sample the Fibonacci numbers, (1, 2, 3, 5, 8…), you get this graph:

Caterpillar curve from sum-counts of Fibonacci numbers 1, 2, 3, 5, 8, 13, 21, 34, 55, 89…

When you sample a restricted set of Fibonaccis, (1, 3, 8, 21, 55…), you get this, where each vertical line represents a count of one:

Golden gaps from sum-counts of restricted Fibonacci numbers 1, 3, 8, 21, 55, 144…

That restricted Fibonacci graph is strangely attractive, because it has golden gaps (verb sap!).