Mötley Vüe

Here’s the Fibonacci sequence, where each term (after the first two) is created by adding the two previous numbers:


1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765...

In “Fib and Let Tri”, I described how my eye was caught by 55, which is a palindrome, reading the same backwards and forwards. “Were there any other Fibonacci palindromes?” I wondered. So I looked to see. Now my eye has been caught by 55 again, but for another reason. It should be easy to spot another interesting aspect to 55 when the Fibonacci numbers are set out like this:


fib(1) = 1
fib(2) = 1
fib(3) = 2
fib(4) = 3
fib(5) = 5
fib(6) = 8
fib(7) = 13
fib(8) = 21
fib(9) = 34
fib(10) = 55
fib(11) = 89
fib(12) = 144
fib(13) = 233
fib(14) = 377
fib(15) = 610
fib(16) = 987
fib(17) = 1597
fib(18) = 2584
fib(19) = 4181
fib(20) = 6765
[...]

55 is fib(10), the 10th Fibonacci number, and 5+5 = 10. That is, digsum(fib(10)) = 10. What other Fibonacci numbers work like that? I soon found some and confirmed my answer at the Online Encyclopedia of Integer Sequences:


1, 5, 10, 31, 35, 62, 72, 175, 180, 216, 251, 252, 360, 494, 504, 540, 946, 1188, 2222 — A020995 at OEIS

And that seems to be the lot, according to the OEIS. In base 10, at least, but why stop at base 10? When I looked at base 11, the numbers of digsum(fib(k)) = k didn’t stop coming, because I couldn’t take the Fibonacci numbers very high on my computer. But the OEIS gives a much longer list, starting like this:


1, 5, 13, 41, 53, 55, 60, 61, 90, 97, 169, 185, 193, 215, 265, 269, 353, 355, 385, 397, 437, 481, 493, 617, 629, 630, 653, 713, 750, 769, 780, 889, 905, 960, 1013, 1025, 1045, 1205, 1320, 1405, 1435, 1501, 1620, 1650, 1657, 1705, 1735, 1769, 1793, 1913, 1981, 2125, 2153, 2280, 2297, 2389, 2413, 2460, 2465, 2509, 2533, 2549, 2609, 2610, 2633, 2730, 2749, 2845, 2893, 2915, 3041, 3055, 3155, 3209, 3360, 3475, 3485, 3521, 3641, 3721, 3749, 3757, 3761, 3840, 3865, 3929, 3941, 4075, 4273, 4301, 4650, 4937, 5195, 5209, 5435, 5489, 5490, 5700, 5917, 6169, 6253, 6335, 6361, 6373, 6401, 6581, 6593, 6701, 6750, 6941, 7021, 7349, 7577, 7595, 7693, 7740, 7805, 7873, 8009, 8017, 8215, 8341, 8495, 8737, 8861, 8970, 8995, 9120, 9133, 9181, 9269, 9277, 9535, 9541, 9737, 9935, 9953, 10297, 10609, 10789, 10855, 11317, 11809, 12029, 12175... — A020995 at OEIS

The list ends with 1636597 = A18666[b11] and the OEIS says that 1636597 almost certainly completes the list. According to David C. Terr’s paper “On the Sums of Fibonacci Numbers” (pdf), published in the Fibonacci Quarterly in 1996, the estimated digit-sum for the k-th Fibonacci number in base b is given by the formula (b-1)/2 * k * log(b,φ), where log(b,φ) is the logarithm in base b of the golden ratio, 1·61803398874… Terr then notes that the simplified formula (b-1)/2 * log(b,φ) gives the estimated average ratio digsum(fib(k)) / k in base b. Here are the estimates for bases 2 to 20:


b02 = 0.3471209568153086...
b03 = 0.4380178794859424...
b04 = 0.5206814352229629...
b05 = 0.5979874356654401...
b06 = 0.6714235829697111...
b07 = 0.7418818776805580...
b08 = 0.8099488992357201...
b09 = 0.8760357589718848...
b10 = 0.9404443811249043...
b11 = 1.0034045909311624...
b12 = 1.0650963641043091...
b13 = 1.1256639207937723...
b14 = 1.1852250528196852...
b15 = 1.2438775226715552...
b16 = 1.3017035880574074...
b17 = 1.3587732842474014...
b18 = 1.4151468584732730...
b19 = 1.4708766105122322...
b20 = 1.5260083080264088...

In base 2, you can expect digsum(fib(k)) to be much smaller than k; in base 20, you can expect digsum(fib(k)) to be much larger. But as you can see, the estimate for base 11, 1.0034045909311624…, is very nearly 1. That’s why base 11 produces so many results for digsum(fib(k)) = k, because only a slight deviation from the estimate might create a perfect ratio of 1 for digsum(fib(k)) / k, i.e. digsum(fib(k)) = k. But in the end the results run out in base 11 too, because as k gets higher and fib(k) gets bigger, the estimate becomes more and more accurate and digsum(fib(k)) > k. With lower k, digsum(fib(k)) can easily fall below k or match k. That happens in other bases, but because their estimates are further from 1, results for digsum(fib(k)) = k run out much more quickly.

To see this base behavior represented visually, I’ve created Ulam-like spirals for k using three colors: blue for digsum(fib(k)) < k, yellow for digsum(fib(k)) > k, and red for digsum(fib(k)) = k (with the green square at the center representing fib(1) = 1). As you can see below, the spiral for base 11 immediately stands out. It’s motley, not dominated by blue or yellow like the other spirals:

Spiral for digsum(fib(k)) in base 9
(blue for digsum(fib(k)) < k, yellow for digsum(fib(k)) > k, red for digsum(fib(k)) = k, green for fib(1))


Spiral for digsum(fib(k)) in base 10


Spiral for digsum(fib(k)) in base 11 — a motley view of blue, yellow and red


Spiral for digsum(fib(k)) in base 12


Spiral for digsum(fib(k)) in base 13


Finally, here are spirals at higher and higher resolution for digsum(fib(k)) = k in base 11:

digsum(fib(k)) = k in base 11 (low resolution)
(green square is fib(1))


digsum(fib(k)) = k in base 11 (x2 resolution)


digsum(fib(k)) = k in base 11 (x4)


digsum(fib(k)) = k in base 11 (x8)


digsum(fib(k)) = k in base 11 (x16)


digsum(fib(k)) = k in base 11 (x32)


digsum(fib(k)) = k in base 11 (x64)


digsum(fib(k)) = k in base 11 (x128)


digsum(fib(k)) = k in base 11 (animated)

Triangular Squares

The numbers that are both square and triangular are beautifully related to the best approximations to √2:

Number

Square Root

Factors of root

1 1 1
36 6 2 * 3
1225 35 5 * 7
41616 204 12 * 17

and so on.

In each case the factors of the root are the numerator and denominator of the next approximation to √2. — David Wells, The Penguin Dictionary of Curious and Interesting Mathematics (1986), entry for “36”.


Elsewhere other-accessible

A001110 — Square triangular numbers: numbers that are both triangular and square

The Trivial Troot

Here is the square root of 2:

√2 = 1·414213562373095048801688724209698078569671875376948073176679738...

Here is the square root of 20:

√20 = 4·472135954999579392818347337462552470881236719223051448541794491...

And here are the first few triangular numbers:

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66, 78, 91, 105, 120, 136, 153, 171, 190, 210, 231, 253, 276, 300, 325, 351, 378, 406, 435, 465, 496, 528, 561, 595, 630, 666, 703, 741, 780, 820, 861, 903, 946, 990, 1035...

What links √2 and √20 strongly with the triangular numbers? At first glance, nothing does. The square roots of 2 and 20 are very different from the triangular numbers. Square roots like those are irrational, that is, they can’t be represented as a fraction or ratio of integers. This means that their digits go on for ever, never falling into a regular pattern. So the digits are hard to calculate. The sequence of triangular numbers also goes on for ever, but it’s very easy to calculate. The triangular numbers get their name from the way they can be arranged into simple triangles, like this:

* = 1


*
** = 3


*
**
*** = 6


*
**
***
**** = 10


*
**
***
****
***** = 15

The 1st triangular number is 1, the 2nd is 3 = 1+2, the 3rd is 6 = 1+2+3, the 4th is 10 = 1+2+3+4, and so on. The n-th triangular number = 1+2+3…+n, so the formula for the n-th triangular number is n*(n+1)/2 = (n^2+n)/2. So what’s the 123456789th triangular number? Easy: it’s 7620789436823655 (see A077694 at the OEIS). But what’s the 123456789th digit of √2 or √20? That’s not easy to answer. But here’s something else that is easy to answer. If tri(n) is the n-th triangular number, what are the values of n when tri(n) is one digit longer than tri(n-1)? That is, what are the values of n when tri(n) increases in length by one digit? If you look at the beginning of the sequence, you can see the first three answers:

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66, 78, 91, 105...

1 is one digit longer than nothing, as it were, and 1 = tri(1); 10 is one digit longer than 6 and 10 = tri(4); 105 is one digit longer than 91 and 105 = tri(14). Here are some more answers, giving triangular numbers on the left, as they increase in length by one digit, and the n of tri(n) on the right:

1 ← 1
10 ← 4
105 ← 14
1035 ← 45
10011 ← 141
100128 ← 447
1000405 ← 1414
10001628 ← 4472
100005153 ← 14142
1000006281 ← 44721
10000020331 ← 141421
100000404505 ← 447214
1000001326005 ← 1414214
10000002437316 ← 4472136
100000012392316 ← 14142136
1000000042485480 ← 44721360
10000000037150046 ← 141421356
100000000000018810 ← 447213595
1000000000179470703 ← 1414213562
10000000002237948990 ← 4472135955
100000000010876002500 ← 14142135624
1000000000022548781025 ← 44721359550
10000000000026940078203 ← 141421356237
100000000000242416922750 ← 447213595500
1000000000000572687476751 ← 1414213562373
10000000000004117080477500 ← 4472135955000
100000000000007771272992046 ← 14142135623731
1000000000000031576491575006 ← 44721359549996
10000000000000140731196136705 ← 141421356237310
100000000000000250760786750861 ← 447213595499958
1000000000000000638090771126060 ← 1414213562373095
10000000000000000479330922588410 ← 4472135954999579
100000000000000000169466805816725 ← 14142135623730950
1000000000000000025572412483843115 ← 44721359549995794
10000000000000000087657358700327265 ← 141421356237309505
100000000000000000097566473134542830 ← 447213595499957939
1000000000000000000987561276980703725 ← 1414213562373095049
10000000000000000003048443380954913921 ← 4472135954999579393
100000000000000000006832246143819194316 ← 14142135623730950488
1000000000000000000014155501020518731556 ← 44721359549995793928

Can you spot the patterns? When tri(n) has an odd number of digits, n approximates the digits of √2; when tri(n) has an even number of digits, n approximates the digits of √20. And what can you call the approximations? Well, in a way they’re triangular roots so I’m calling them troots. Here are the troots for tri(n) with an odd number of digits:

1 → 1
14 → 105
141 → 10011
1414 → 1000405
14142 → 100005153
141421 → 10000020331
1414214 → 1000001326005
14142136 → 100000012392316
141421356 → 10000000037150046
1414213562 → 1000000000179470703
14142135624 → 100000000010876002500
141421356237 → 10000000000026940078203
1414213562373 → 1000000000000572687476751
14142135623731 → 100000000000007771272992046
141421356237310 → 10000000000000140731196136705
1414213562373095 → 1000000000000000638090771126060
14142135623730950 → 100000000000000000169466805816725
141421356237309505 → 10000000000000000087657358700327265
1414213562373095049 → 1000000000000000000987561276980703725
14142135623730950488 → 100000000000000000006832246143819194316
14142135623730950488... = √2 (without the decimal point)

When I first found these patterns, I thought I might have discovered something mathematically profound. I hadn’t. Troots are trivial. I think troots are beautiful too, but a little thought soon showed me how easily and obviously they arise. Remember that the formula for tri(n), the n-th triangular number, is tri(n) = (n^2+n)/2. As you can see above, when tri(n) is increasing in length by one digit, it rises above the next power of 10, which always begins with 1 followed by only 0s. Therefore n^2+n will begin with the digit 2 followed by some 0s, which then becomes 1 followed by some 0s as (n^2+n) is divided by 2. So n for tri(n) increasing-by-one-digit will be the first integer, n, where n^2+n yields a number with 2 as the leading digit followed by more and more 0s.

And that’s why n approximates the digits of √2·0000… and √20·0000…, for tri(n) with an odd and even number of digits, respectively. Similar trootful patterns exist in other bases and for other polygonal numbers, like the square numbers, the pentagonal numbers and so on. The troots are beautiful to see but trivial to explain. All the same, there is a sense in which you can say the mindless sequence of triangular numbers is “calculating” the digits of √2 and √20. It even rounds up the final digits when necessary:

1414214 → 1000001326005
14142136 → 100000012392316
141421356 → 10000000037150046
141421356... = √2
[...]
14142135624 → 100000000010876002500
141421356237 → 10000000000026940078203
141421356237... = √2
[...]
14142135623731 → 100000000000007771272992046
141421356237310 → 10000000000000140731196136705
1414213562373095 → 1000000000000000638090771126060
1414213562373095... = √2
[...]
1414213562373095049 → 1000000000000000000987561276980703725
14142135623730950488 → 100000000000000000006832246143819194316
14142135623730950488... = √2

Fib and Let Tri

It’s a simple sequence with hidden depths:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155... — A000045 at OEIS

That’s the Fibonacci sequence, probably the most famous of all integer sequences after the integers themselves (1, 2, 3, 4, 5…) and the primes (2, 3, 5, 7, 11…). It has a very simple definition: if fib(fi) is the fi-th number in the Fibonacci sequence, then fib(fi) = fib(fi-1) + fib(fi-2). By definition, fib(1) = fib(2) = 1. After that, it’s easy to generate new numbers:

2 = fib(3) = fib(1) + fib(2) = 1 + 1
3 = fib(4) = fib(2) + fib(3) = 1 + 2
5 = fib(5) = fib(3) + fib(4) = 2 + 3
8 = fib(6) = fib(4) + fib(5) = 3 + 5
13 = fib(7) = fib(5) + fib(6) = 5 + 8
21 = fib(8) = fib(6) + fib(7) = 8 + 13
34 = fib(9) = fib(7) + fib(8) = 13 + 21
55 = fib(10) = fib(8) + fib(9) = 21 + 34
89 = fib(11) = fib(9) + fib(10) = 34 + 55
144 = fib(12) = fib(10) + fib(11) = 55 + 89
233 = fib(13) = fib(11) + fib(12) = 89 + 144
377 = fib(14) = fib(12) + fib(13) = 144 + 233
610 = fib(15) = fib(13) + fib(14) = 233 + 377
987 = fib(16) = fib(14) + fib(15) = 377 + 610
[...]

How to create the Fibonacci sequence is obvious. But it’s not obvious that fib(fi) / fib(fi-1) gives you ever-better approximations to a fascinating constant called φ, the golden ratio, which is 1.618033988749894…:

1/1 = 1
2/1 = 2
3/2 = 1.5
5/3 = 1.66666...
8/5 = 1.6
13/8 = 1.625
21/13 = 1.615384...
34/21 = 1.619047...
55/34 = 1.6176470588235294117647058823...
89/55 = 1.618181818...
144/89 = 1.617977528089887640...
233/144 = 1.6180555555...
377/233 = 1.618025751072961...
610/377 = 1.618037135278514...
987/610 = 1.618032786885245...
[...]

And that’s just the start of the hidden depths in the Fibonacci sequence. I stumbled across another interesting pattern for myself a few days ago. I was looking at the sequence and one of the numbers caught my eye:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597...

55 is a palindrome, reading the same forward and backwards. I wondered whether there were any other palindromes in the sequence (apart from the trivial single-digit palindromes 1, 1, 2, 3…). I couldn’t find any more. Nor can anyone else, apparently. But that’s in base 10. Other bases are more productive. For example, in bases 2, 3 and 4, you get this:

11 in b2 = 3
101 in b2 = 5
10101 in b2 = 21


22 in b3 = 8
111 in b3 = 13
22122 in b3 = 233


11 in b4 = 5
111 in b4 = 21
202 in b4 = 34
313 in b4 = 55


I decided to concentrate on tripals, or palindromes with three digits. I started looking at bases that set records for the greatest number of tripals. And there are some interesting patterns in the digits of the tripals in these bases (when a digit > 9, the digit is represented inside square brackets — see base-29 and higher). See how quickly you can spot the patterns:

Palindromic Fibonacci numbers in base-4

111 in b4 (fib=21, fi=8)
202 in b4 (fib=34, fi=9)
313 in b4 (fib=55, fi=10)

4 = 2^2 (pal=3)


Palindromic Fibonacci numbers in base-11

121 in b11 (fib=144, fi=12)
313 in b11 (fib=377, fi=14)
505 in b11 (fib=610, fi=15)
818 in b11 (fib=987, fi=16)

11 is prime (pal=4)


Palindromic Fibonacci numbers in base-29

151 in b29 (fib=987, fi=16)
323 in b29 (fib=2584, fi=18)
818 in b29 (fib=6765, fi=20)
[13]0[13] in b29 (fib=10946, fi=21)
[21]1[21] in b29 (fib=17711, fi=22)

29 is prime (pal=5)


Palindromic Fibonacci numbers in base-76

1[13]1 in b76 (fib=6765, fi=20)
353 in b76 (fib=17711, fi=22)
828 in b76 (fib=46368, fi=24)
[21]1[21] in b76 (fib=121393, fi=26)
[34]0[34] in b76 (fib=196418, fi=27)
[55]1[55] in b76 (fib=317811, fi=28)

76 = 2^2 * 19 (pal=6)


Palindromic Fibonacci numbers in base-199

1[34]1 in b199 (fib=46368, fi=24)
3[13]3 in b199 (fib=121393, fi=26)
858 in b199 (fib=317811, fi=28)
[21]2[21] in b199 (fib=832040, fi=30)
[55]1[55] in b199 (fib=2178309, fi=32)
[89]0[89] in b199 (fib=3524578, fi=33)
[144]1[144] in b199 (fib=5702887, fi=34)

199 is prime (pal=7)


Palindromic Fibonacci numbers in base-521

1[89]1 in b521 (fib=317811, fi=28)
3[34]3 in b521 (fib=832040, fi=30)
8[13]8 in b521 (fib=2178309, fi=32)
[21]5[21] in b521 (fib=5702887, fi=34)
[55]2[55] in b521 (fib=14930352, fi=36)
[144]1[144] in b521 (fib=39088169, fi=38)
[233]0[233] in b521 (fib=63245986, fi=39)
[377]1[377] in b521 (fib=102334155, fi=40)

521 is prime (pal=8)


Palindromic Fibonacci numbers in base-1364

1[233]1 in b1364 (fib=2178309, fi=32)
3[89]3 in b1364 (fib=5702887, fi=34)
8[34]8 in b1364 (fib=14930352, fi=36)
[21][13][21] in b1364 (fib=39088169, fi=38)
[55]5[55] in b1364 (fib=102334155, fi=40)
[144]2[144] in b1364 (fib=267914296, fi=42)
[377]1[377] in b1364 (fib=701408733, fi=44)
[610]0[610] in b1364 (fib=1134903170, fi=45)
[987]1[987] in b1364 (fib=1836311903, fi=46)

1364 = 2^2 * 11 * 31 (pal=9)


Two patterns are quickly obvious. Every digit in the tripals is a Fibonacci number. And the middle digit of one Fibonacci tripal, fib(fi), becomes fib(fi-2) in the next tripal, while fib(fi), the first and last digits (which are identical), becomes fib(fi+2) in the next tripal.

But what about the bases? If you’re an expert in the Fibonacci sequence, you’ll spot the pattern at work straight away. I’m not an expert, but I spotted it in the end. Here are the first few bases setting records for the numbers of Fibonacci tripals:

4, 11, 29, 76, 199, 521, 1364, 3571, 9349, 24476, 64079, 167761, 439204, 1149851, 3010349, 7881196...

These numbers come from the Lucas sequence, which is closely related to the Fibonacci sequence. But where fib(1) = fib(2) = 1, luc(1) = 1 and luc(2) = 3. After that, luc(li) = luc(li-2) + luc(li-1):

1, 3, 4, 7, 11, 18, 29, 47, 76, 123, 199, 322, 521, 843, 1364, 2207, 3571, 5778, 9349, 15127, 24476, 39603, 64079, 103682, 167761, 271443, 439204, 710647, 1149851, 1860498, 3010349, 4870847, 7881196... — A000204 at OEIS

It seems that every second number from 4 in the Lucas sequence supplies a base in which 1) the number of Fibonacci tripals sets a new record; 2) every digit of the Fibonacci tripals is itself a Fibonacci number.

But can I prove that this is always true? No. And do I understand why these patterns exist? No. My simple search for palindromes in the Fibonacci sequence soon took me far out of my mathematical depth. But it’s been fun to find huge bases like this in which every digit of every Fibonacci tripal is itself a Fibonacci number:

Palindromic Fibonacci numbers in base-817138163596

1[139583862445]1 in b817138163596 (fib=781774079430987230203437, fi=116)
3[53316291173]3 in b817138163596 (fib=2046711111473984623691759, fi=118)
8[20365011074]8 in b817138163596 (fib=5358359254990966640871840, fi=120)
[21][7778742049][21] in b817138163596 (fib=14028366653498915298923761, fi=122)
[55][2971215073][55] in b817138163596 (fib=36726740705505779255899443, fi=124)
[144][1134903170][144] in b817138163596 (fib=96151855463018422468774568, fi=126)
[377][433494437][377] in b817138163596 (fib=251728825683549488150424261, fi=128)
[987][165580141][987] in b817138163596 (fib=659034621587630041982498215, fi=130)
[2584][63245986][2584] in b817138163596 (fib=1725375039079340637797070384, fi=132)
[6765][24157817][6765] in b817138163596 (fib=4517090495650391871408712937, fi=134)
[17711][9227465][17711] in b817138163596 (fib=11825896447871834976429068427, fi=136)
[46368][3524578][46368] in b817138163596 (fib=30960598847965113057878492344, fi=138)
[121393][1346269][121393] in b817138163596 (fib=81055900096023504197206408605, fi=140)
[317811][514229][317811] in b817138163596 (fib=212207101440105399533740733471, fi=142)
[832040][196418][832040] in b817138163596 (fib=555565404224292694404015791808, fi=144)
[2178309][75025][2178309] in b817138163596 (fib=1454489111232772683678306641953, fi=146)
[5702887][28657][5702887] in b817138163596 (fib=3807901929474025356630904134051, fi=148)
[14930352][10946][14930352] in b817138163596 (fib=9969216677189303386214405760200, fi=150)
[39088169][4181][39088169] in b817138163596 (fib=26099748102093884802012313146549, fi=152)
[102334155][1597][102334155] in b817138163596 (fib=68330027629092351019822533679447, fi=154)
[267914296][610][267914296] in b817138163596 (fib=178890334785183168257455287891792, fi=156)
[701408733][233][701408733] in b817138163596 (fib=468340976726457153752543329995929, fi=158)
[1836311903][89][1836311903] in b817138163596 (fib=1226132595394188293000174702095995, fi=160)
[4807526976][34][4807526976] in b817138163596 (fib=3210056809456107725247980776292056, fi=162)
[12586269025][13][12586269025] in b817138163596 (fib=8404037832974134882743767626780173, fi=164)
[32951280099]5[32951280099] in b817138163596 (fib=22002056689466296922983322104048463, fi=166)
[86267571272]2[86267571272] in b817138163596 (fib=57602132235424755886206198685365216, fi=168)
[225851433717]1[225851433717] in b817138163596 (fib=150804340016807970735635273952047185, fi=170)
[365435296162]0[365435296162] in b817138163596 (fib=244006547798191185585064349218729154, fi=171)
[591286729879]1[591286729879] in b817138163596 (fib=394810887814999156320699623170776339, fi=172)

817138163596 = 2^2 * 229 * 9349 * 95419 (pal=30)

Power Trap

Back in 2015, in an article called “Power Trip”, I looked at an unfamiliar sequence created by deleting zeroes from a familiar sequence. And I made a serious but fortunately-not-fatal error in my reasoning. The familiar sequence was powers of 2:

• 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576…

This is what happens when you delete the zeroes from the powers of 2 (and carry on multiplying by two):

2 * 2 = 4
4 * 2 = 8
8 * 2 = 16
16 * 2 = 32
32 * 2 = 64
64 * 2 = 128
128 * 2 = 256
256 * 2 = 512
512 * 2 = 1024 → 124
124 * 2 = 248
248 * 2 = 496
496 * 2 = 992
992 * 2 = 1984
1984 * 2 = 3968
3968 * 2 = 7936
7936 * 2 = 15872
15872 * 2 = 31744
31744 * 2 = 63488
63488 * 2 = 126976
126976 * 2 = 253952
253952 * 2 = 507904 → 5794
5794 * 2 = 11588
11588 * 2 = 23176
23176 * 2 = 46352
46352 * 2 = 92704 → 9274…


I pointed out that this new sequence has to repeat, because deleting zeroes prevents n growing beyond a certain size. Eventually, then, a number will repeat and the sequence will fall into a loop: “This happens at step 526 with 366784, which matches 366784 at step 490.”

But that’s deleting every zero. What happens if you delete every second zero? That is, you start with a zero-count, zc, of 0. When you meet the first zero in the sequence, zc = zc + 1 = 1. When you meet the second zero in the sequence, zc = zc + 1 = 2. So you delete that second zero and reset zc to 0. The first zero occurs when 1024 = 2 * 512, so 1024 is left as it is. The second zero occurs when 2 * 1024 = 2048, so 2048 becomes 248. The sequence for zc=2 looks like this:

1 * 2 = 2
2 * 2 = 4
4 * 2 = 8
8 * 2 = 16
16 * 2 = 32
32 * 2 = 64
64 * 2 = 128
128 * 2 = 256
256 * 2 = 512
512 * 2 = 1024 → 1024
1024 * 2 = 2048 → 248
248 * 2 = 496
496 * 2 = 992
992 * 2 = 1984
1984 * 2 = 3968
3968 * 2 = 7936
7936 * 2 = 15872
15872 * 2 = 31744
31744 * 2 = 63488
63488 * 2 = 126976
126976 * 2 = 253952
253952 * 2 = 507904 → 50794
50794 * 2 = 101588 → 101588
101588 * 2 = 203176 → 23176
23176 * 2 = 46352
46352 * 2 = 92704 → 92704
92704 * 2 = 185408 → 18548

Again, the sequence has to repeat and I claimed that it did so “at step 9134 with 5458864, which matches 5458864 at step 4166”. I also said that I hadn’t found the loop for the delete-every-third-zero sequence, where zc=3. Coming back to this type of sequence in 2021, I wrote a much faster machine-code program to see if I could find the answer for zc=3. And I thought that I had. My program said that the sequence for zc=3 repeats at step 166369 with 6138486272, which matches 6138486272 at step 25429.

Or does it repeat? Does it match? In 2021 I suddenly realized that I had neglected to consider something vital back in 2015: whether the zero-count was the same when the sequence appeared to repeat. Take the zc=2 sequence. If zc=0 at at step 4166 and zc=1 at 9134 (or vice versa), the sequence isn’t in a loop, because it will be deleting a different set of zeroes after step 4166 than it is after step 9134.

I checked whether the zero-count for that sequence is the same when the sequence appears to repeat. Fortunately, it is the same and the zero-delete sequence for zc=2 does indeed begin looping “at step 9134 with 5458864, which matches 5458864 at step 4166”.

So my error wasn’t fatal for the zc=2 sequence. But what about the zc=3 sequence? Alas, the zero-count is different for 6138486272 at step 166369 than for 6138486272 at step 25429. The sequence doesn’t behave the same after those steps and hasn’t looped. I needed to find the n1 = n2 for steps s1 and s2 where zc1 = zc2. And even with the much faster machine-code program it took some time. But I can now say that 958718377984 at step 379046, with zc=0, matches 958718377984 at step 200906, with zc=0.

Spiral Artefact

What’s the next number in this sequence of integers?


5, 14, 19, 23, 28, 32, 37, 41, 46, 50, 55... (A227793 at the OEIS)

It shouldn’t be hard to work out that it’s 64 — the sum-of-digits of n is divisible by 5, i.e., digsum(n) mod 5 = 0. Now try summing the numbers in that sequence:


5 + 14 = 19
19 + 19 = 38
38 + 23 = 61
61 + 28 = 89
89 + 32 = 121
121 + 37 = 158
158 + 41 = 199
199 + 46 = 245
[...]

Here are the cumulative sums as another sequence:


5, 19, 38, 61, 89, 121, 158, 199, 245, 295, 350, 414, 483, 556, 634, 716, 803, 894, 990, 1094, 1203, 1316, 1434, 1556, 1683, 1814, 1950, 2090, 2235, 2389, 2548, 2711, 2879, 3051, 3228, 3409, 3595, 3785, 3980, 4183, 4391, 4603, 4820, 5041, 5267, 5497, 5732, 5976, 6225...

And there’s that cumulative-sum sequence represented as a spiral:

Spiral for cumulative sum of n where digsum(n) mod 5 = 0


You can see how the spiral is created by following 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E… from the center:


ZYXWVU
GFEDCT
H432BS
I501AR
J6789Q
KLMNOP

What about other values for the cumulative sums of digsum(n) mod m = 0? Here’s m = 2,3,4,5,6,7:

Spiral for cumulative sum of n where digsum(n) mod 2 = 0
s1 = 2, 4, 6, 8, 11, 13, 15, 17, 19, 20, 22…
s2 = 2, 6, 12, 20, 31, 44, 59, 76, 95, 115… (cumulative sum of s1)


sum of digsum(n) mod 3 = 0
s1 = 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33…
s2 = 3, 9, 18, 30, 45, 63, 84, 108, 135, 165…


sum of digsum(n) mod 4 = 0
s1 = 4, 8, 13, 17, 22, 26, 31, 35, 39, 40, 44…
s2 = 4, 12, 25, 42, 64, 90, 121, 156, 195, 235…


sum of digsum(n) mod 5 = 0
s1 = 5, 14, 19, 23, 28, 32, 37, 41, 46, 50, 55…
s2 = 5, 19, 38, 61, 89, 121, 158, 199, 245, 295…


sum of digsum(n) mod 6 = 0
s1 = 6, 15, 24, 33, 39, 42, 48, 51, 57, 60, 66…
s2 = 6, 21, 45, 78, 117, 159, 207, 258, 315, 375…


sum of digsum(n) mod 7 = 0
s1 = 7, 16, 25, 34, 43, 52, 59, 61, 68, 70, 77…
s2 = 7, 23, 48, 82, 125, 177, 236, 297, 365, 435…


The spiral for m = 2 is strange, but the spirals are similar after that. Until m = 8, when something strange happens again:

sum of digsum(n) mod 8 = 0
s1 = 8, 17, 26, 35, 44, 53, 62, 71, 79, 80, 88…
s2 = 8, 25, 51, 86, 130, 183, 245, 316, 395, 475…


Then the spirals return to normal for m = 9, 10:

sum of digsum(n) mod 9 = 0
s1 = 9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99…
s2 = 9, 27, 54, 90, 135, 189, 252, 324, 405, 495…


sum of digsum(n) mod 10 = 0
s1 = 19, 28, 37, 46, 55, 64, 73, 82, 91, 109, 118…
s2 = 19, 47, 84, 130, 185, 249, 322, 404, 495, 604…


Here’s an animated gif of m = 8 at higher and higher resolution:

sum of digsum(n) mod 8 = 0 (animated gif)


You might think this strange behavior is dependant on the base in which the dig-sum is calculated. It isn’t. Here’s an animated gif for other bases in which the mod-8 spiral behaves strangely:

sum of digsum(n) mod 8 = 0 in base b = 5, 6, 7, 9, 11, 12, 13 (animated gif)


But the mod-8 spiral stops behaving strangely when the spiral is like this, as a diamond:


   W
  XIV
 YJ8HU
ZK927GT
LA3016FS
 MB45ER
  NCDQ
   OP

Now the mod-8 spiral looks like this:

sum of digsum(n) mod 8 = 0 (diamond spiral)


But the mod-4 and mod-9 spirals look like this:

sum of digsum(n) mod 4 = 0 (diamond spiral)


sum of digsum(n) mod 9 = 0 (diamond spiral)


You can also construct the spirals as a triangle, like this:


     U
    VCT
   WD2CS
  XE301AR
 YF456789Q
ZGHIJKLMNOP

Here’s the beginning of the mod-5 triangular spiral:

sum of digsum(n) mod 5 = 0 (triangular spiral) (open in new window for full size)


And the beginning of the mod-8 triangular spiral:

sum of digsum(n) mod 8 = 0 (triangular spiral) (open in new window for full size)


The mod-8 spiral is behaving strangely again. So the strangeness is partly an artefact of the way the spirals are constructed.


Post-Performative Post-Scriptum

“Spiral Artefact”, the title of this incendiary intervention, is of course a tip-of-the-hat to core Black-Sabbath track “Spiral Architect”, off core Black-Sabbath album Sabbath Bloody Sabbath, issued in core Black-Sabbath success-period of 1973.

RevNumSum

If you take an integer, n, and reverse its digits to get the integer r, there are three possibilities:


n > r (e.g. 85236 > 63258)
n < r (e.g. 17783 < 38771)
n = r (e.g. 45154 = 45154)

If n = r, n is a palindrome. If n > r, I call n a major number. If n < r, I call n a minor number. And here are the minor and major numbers represented as white squares on an Ulam-like spiral (the negative of a minor spiral is a major spiral, and vice versa — sometimes one looks better than the other):

b=2 (minor numbers)


b=3


b=4


b=5


b=6


b=7 (major numbers)


b=8 (minor numbers)


b=9 (mjn)


b=10 (mjn)


b=11 (mjn)


b=12 (mjn)


b=13 (mjn)


b=14 (mjn)


b=15 (mjn)


b=16 (mjn)


b=17 (mjn)


b=18 (mjn)


b=19 (mjn)


b=20 (mjn)


Minor numbers, b=2..20 (animated)


Now let’s look at a sequence formed by summing the reversed numbers, minor ones, major ones and palindromes. Here are the standard integers:


1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17...

If you sum the integers, you get what are called the triangular numbers:


1 = 1
3 = 1 + 2
6 = 1 + 2 + 3
10 = 1 + 2 + 3 + 4
15 = 1 + 2 + 3 + 4 + 5
21 = 1 + 2 + 3 + 4 + 5 + 6
28 = 1 + 2 + 3 + 4 + 5 + 6 + 7
36 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8
45 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
55 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
66 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11
78 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12
91 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13
105 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14
120 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15
136 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16
153 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17
171 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18
190 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19
210 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20

But what happens if you reverse the integers before summing them? Here side-by-side are the triangular numbers and the underlined revnumsums (as they might be called):


45 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
45 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
55 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
46 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1
66 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11
57 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 11
78 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12
78 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 11 + 21
91 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13
109 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 11 + 21 + 31
105 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14
150 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 11 + 21 + 31 + 41
120 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15
201 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 11 + 21 + 31 + 41 + 51
136 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16
262 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 11 + 21 + 31 + 41 + 51 + 61
153 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17
333 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 11 + 21 + 31 + 41 + 51 + 61 + 71
171 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18
414 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 11 + 21 + 31 + 41 + 51 + 61 + 71 + 81
190 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19
505 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 11 + 21 + 31 + 41 + 51 + 61 + 71 + 81 + 91
210 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20
507 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 11 + 21 + 31 + 41 + 51 + 61 + 71 + 81 + 91
+ 2

Unlike triangular numbers, revnumsums are dependent on the base they’re calculated in. In base 2, the revnumsum is always smaller than the triangular number, except at step 1. In base 3, the revnumsum is equal to the triangular number at steps 1, 2 and 15 (= 120 in base 3). Otherwise it’s smaller than the triangular number.

And in higher bases? In bases > 3, the revnumsum rises and falls above the equivalent triangular number. When it’s higher, it tends towards a maximum height of (base+1)/4 * triangular number.

Palindrought

The alchemists dreamed of turning dross into gold. In mathematics, you can actually do that, metaphorically speaking. If palindromes are gold and non-palindromes are dross, here is dross turning into gold:


22 = 10 + 12
222 = 10 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 23 + 24
484 = 10 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 34
555 = 10 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 34 + 35 + 36
2002 = nonpalsum(10,67)
36863 = nonpalsum(10,286)
45954 = nonpalsum(10,319)
80908 = nonpalsum(10,423)
113311 = nonpalsum(10,501)
161161 = nonpalsum(10,598)
949949 = nonpalsum(10,1417)
8422248 = nonpalsum(10,4136)
13022031 = nonpalsum(10,5138)
14166141 = nonpalsum(10,5358)
16644661 = nonpalsum(10,5806)
49900994 = nonpalsum(10,10045)
464939464 = nonpalsum(10,30649)
523434325 = nonpalsum(10,32519)
576656675 = nonpalsum(10,34132)
602959206 = nonpalsum(10,34902)
[...]

The palindromes don’t seem to stop arriving. But something unexpected happens when you try to turn gold into gold. If you sum palindromes to get palindromes, you’re soon hit by what you might call a palindrought, where no palindromes appear:


1 = 1
3 = 1 + 2
6 = 1 + 2 + 3
111 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 11 + 22 + 33
353 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 11 + 22 + 33 + 44 + 55 + 66 + 77
7557 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 11 + 22 + 33 + 44 + 55 + 66 + 77 + 88 + 99 + 101 + 111 + 121 + 131 + 141 + 151 + 161 + 171 + 181 + 191 + 202 + 212 + 222 + 232 + 242 + 252 + 262 + 272 + 282 + 292 + 303 + 313 + 323 + 333 + 343 + 353 + 363 + 373 + 383
2376732 = palsum(1,21512)

That’s sequence A046488 at the OEIS. And I suspect that the sequence is complete and that the palindrought never ends. For some evidence of that, here’s an interesting pattern that emerges if you look at palsums of 1 to repdigits 9[…]9:


50045040 = palsum(1,99999)
50045045040 = palsum(1,9999999)
50045045045040 = palsum(1,999999999)
50045045045045040 = palsum(1,99999999999)
50045045045045045040 = palsum(1,9999999999999)
50045045045045045045040 = palsum(1,999999999999999)
50045045045045045045045040 = palsum(1,99999999999999999)
50045045045045045045045045040 = palsum(1,9999999999999999999)
50045045045045045045045045045040 = palsum(1,999999999999999999999)

As the sums get bigger, the carries will stop sweeping long enough and the sums may fall into semi-regular patterns of non-palindromic numbers like 50045040. If you try higher bases like base 909, you get more palindromes by summing palindromes, but a palindrought arrives in the end there too:


1 = palsum(1)
3 = palsum(1,2)
6 = palsum(1,3)
A = palsum(1,4)
[...]
66 = palsum(1,[104]) (palindromes = 43)
LL = palsum(1,[195]) (44)
[37][37] = palsum(1,[259]) (45)
[73][73] = palsum(1,[364]) (46)
[114][114] = palsum(1,[455]) (47)
[172][172] = palsum(1,[559]) (48)
[369][369] = palsum(1,[819]) (49)
6[466]6 = palsum(1,[104][104]) (50)
L[496]L = palsum(1,[195][195]) (51)
[37][528][37] = palsum(1,[259][259]) (52)
[73][600][73] = palsum(1,[364][364]) (53)
[114][682][114] = palsum(1,[455][455]) (54)
[172][798][172] = palsum(1,[559][559]) (55)
[291][126][291] = palsum(1,[726][726]) (56)
[334][212][334] = palsum(1,[778][778]) (57)
[201][774][830][774][201] = palsum(1,[605][707][605]) (58)
[206][708][568][708][206] = palsum(1,[613][115][613]) (59)
[456][456][569][569][456][456] = palsum(1,11[455]11) (60)
22[456][454][456]22 = palsum(1,21012) (61)

Note the palindrome for palsum(1,21012). All odd bases higher than 3 seem to produce a palindrome for 1 to 21012 in that base (21012 in base 5 = 1382 in base 10, 2012 in base 7 = 5154 in base 10, and so on):


2242422 = palsum(1,21012) (base=5)
2253522 = palsum(1,21012) (b=7)
2275722 = palsum(1,21012) (b=11)
2286822 = palsum(1,21012) (b=13)
2297922 = palsum(1,21012) (b=15)
22A8A22 = palsum(1,21012) (b=17)
22B9B22 = palsum(1,21012) (b=19)
22CAC22 = palsum(1,21012) (b=21)
22DBD22 = palsum(1,21012) (b=23)

And here’s another interesting pattern created by summing squares in base 9 (where 17 = 16 in base 10, 40 = 36 in base 10, and so on):


1 = squaresum(1)
5 = squaresum(1,4)
33 = squaresum(1,17)
111 = squaresum(1,40)
122221 = squaresum(1,4840)
123333321 = squaresum(1,503840)
123444444321 = squaresum(1,50483840)
123455555554321 = squaresum(1,5050383840)
123456666666654321 = squaresum(1,505048383840)
123456777777777654321 = squaresum(1,50505038383840)
123456788888888887654321 = squaresum(1,5050504838383840)

Then a palindrought strikes again. But you don’t get a palindrought in the triangular numbers, or numbers created by summing the integers, palindromic and non-palindromic alike:


1 = 1
3 = 1 + 2
6 = 1 + 2 + 3
55 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
66 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11
171 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18
595 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34
666 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36
3003 = palsum(1,77)
5995 = palsum(1,109)
8778 = palsum(1,132)
15051 = palsum(1,173)
66066 = palsum(1,363)
617716 = palsum(1,1111)
828828 = palsum(1,1287)
1269621 = palsum(1,1593)
1680861 = palsum(1,1833)
3544453 = palsum(1,2662)
5073705 = palsum(1,3185)
5676765 = palsum(1,3369)
6295926 = palsum(1,3548)
35133153 = palsum(1,8382)
61477416 = palsum(1,11088)
178727871 = palsum(1,18906)
1264114621 = palsum(1,50281)
1634004361 = palsum(1,57166)
5289009825 = palsum(1,102849)
6172882716 = palsum(1,111111)
13953435931 = palsum(1,167053)
16048884061 = palsum(1,179158)
30416261403 = palsum(1,246642)
57003930075 = palsum(1,337650)
58574547585 = palsum(1,342270)
66771917766 = palsum(1,365436)
87350505378 = palsum(1,417972)
[...]

If 617716 = palsum(1,1111) and 6172882716 = palsum(1,111111), what is palsum(1,11111111)? Try it for yourself — there’s an easy formula for the triangular numbers.

Rollercoaster Rules

n += digsum(n). It’s one of my favorite integer sequences — a rollercoaster to infinity. It works like this: you take a number, sum its digits, add the sum to the original number, and repeat:


1 → 2 → 4 → 8 → 16 → 23 → 28 → 38 → 49 → 62 → 70 → 77 → 91 → 101 → 103 → 107 → 115 → 122 → 127 → 137 → 148 → 161 → 169 → 185 → 199 → 218 → 229 → 242 → 250 → 257 → 271 → 281 → 292 → 305 → 313 → 320 → 325 → 335 → 346 → 359 → 376 → 392 → 406 → 416 → 427 → 440 → 448 → 464 → 478 → 497 → 517 → 530 → 538 → 554 → 568 → 587 → 607 → 620 → 628 → 644 → 658 → 677 → 697 → 719 → 736 → 752 → 766 → 785 → 805 → 818 → 835 → 851 → 865 → 884 → 904 → 917 → 934 → 950 → 964 → 983 → 1003 → 1007 → 1015 → 1022 → 1027 → 1037 → 1048 → 1061 → 1069 → 1085 → 1099 → 1118 → 1129 → 1142 → 1150 → 1157 → 1171 → 1181 → 1192 → 1205 → ...

I call it a rollercoaster to infinity because the digit-sum constantly rises and falls as n gets bigger and bigger. The most dramatic falls are when n gets one digit longer (except on the first occasion):


... → 8 (digit-sum=8) → 16 (digit-sum=7) → ...
... → 91 (ds=10) → 101 (ds=2) → ...
... → 983 (ds=20) → 1003 (ds=4) → ...
... → 9968 (ds=32) → 10000 (ds=1) → ...
... → 99973 (ds=37) → 100010 (ds=2) → ...
... → 999959 (ds=50) → 1000009 (ds=10) → ...
... → 9999953 (ds=53) → 10000006 (ds=7) → ...
... → 99999976 (ds=67) → 100000043 (ds=8) → ...
... → 999999980 (ds=71) → 1000000051 (ds=7) → ...
... → 9999999962 (ds=80) → 10000000042 (ds=7) → ...
... → 99999999968 (ds=95) → 100000000063 (ds=10) → ...
... → 999999999992 (ds=101) → 1000000000093 (ds=13) → ...

Look at 9968 → 10000, when the digit-sum goes from 32 to 1. That’s only the second time that digsum(n) = 1 in the sequence. Does it happen again? I don’t know.

And here’s something else I don’t know. Suppose you introduce a rule for the rollercoaster of n += digsum(n). You buy a ticket with a number on it: 1, 2, 3, 4, 5… Then you get on the rollercoaster powered by with that number. Now here’s the rule: Your ride on the rollercoaster ends when n += digsum(n) yields a rep-digit, i.e., a number whose digits are all the same. Here are the first few rides on the rollercoaster:


1 → 2 → 4 → 8 → 16 → 23 → 28 → 38 → 49 → 62 → 70 → 77
2 → 4 → 8 → 16 → 23 → 28 → 38 → 49 → 62 → 70 → 77
3 → 6 → 12 → 15 → 21 → 24 → 30 → 33
4 → 8 → 16 → 23 → 28 → 38 → 49 → 62 → 70 → 77
5 → 10 → 11
6 → 12 → 15 → 21 → 24 → 30 → 33
7 → 14 → 19 → 29 → 40 → 44
8 → 16 → 23 → 28 → 38 → 49 → 62 → 70 → 77
9 → 18 → 27 → 36 → 45 → 54 → 63 → 72 → 81 → 90 → 99
10 → 11
11 → 13 → 17 → 25 → 32 → 37 → 47 → 58 → 71 → 79 → 95 → 109 → 119 → 130 → 134 → 142 → 149 → 163 → 173 → 184 → 197 → 214 → 221 → 226 → 236 → 247 → 260 → 268 → 284 → 298 → 317 → 328 → 341 → 349 → 365 → 379 → 398 → 418 → 431 → 439 → 455 → 469 → 488 → 508 → 521 → 529 → 545 → 559 → 578 → 598 → 620 → 628 → 644 → 658 → 677 → 697 → 719 → 736 → 752 → 766 → 785 → 805 → 818 → 835 → 851 → 865 → 884 → 904 → 917 → 934 → 950 → 964 → 983 → 1003 → 1007 → 1015 → 1022 → 1027 → 1037 → 1048 → 1061 → 1069 → 1085 → 1099 → 1118 → 1129 → 1142 → 1150 → 1157 → 1171 → 1181 → 1192 → 1205 → 1213 → 1220 → 1225 → 1235 → 1246 → 1259 → 1276 → 1292 → 1306 → 1316 → 1327 → 1340 → 1348 → 1364 → 1378 → 1397 → 1417 → 1430 → 1438 → 1454 → 1468 → 1487 → 1507 → 1520 → 1528 → 1544 → 1558 → 1577 → 1597 → 1619 → 1636 → 1652 → 1666 → 1685 → 1705 → 1718 → 1735 → 1751 → 1765 → 1784 → 1804 → 1817 → 1834 → 1850 → 1864 → 1883 → 1903 → 1916 → 1933 → 1949 → 1972 → 1991 → 2011 → 2015 → 2023 → 2030 → 2035 → 2045 → 2056 → 2069 → 2086 → 2102 → 2107 → 2117 → 2128 → 2141 → 2149 → 2165 → 2179 → 2198 → 2218 → 2231 → 2239 → 2255 → 2269 → 2288 → 2308 → 2321 → 2329 → 2345 → 2359 → 2378 → 2398 → 2420 → 2428 → 2444 → 2458 → 2477 → 2497 → 2519 → 2536 → 2552 → 2566 → 2585 → 2605 → 2618 → 2635 → 2651 → 2665 → 2684 → 2704 → 2717 → 2734 → 2750 → 2764 → 2783 → 2803 → 2816 → 2833 → 2849 → 2872 → 2891 → 2911 → 2924 → 2941 → 2957 → 2980 → 2999 → 3028 → 3041 → 3049 → 3065 → 3079 → 3098 → 3118 → 3131 → 3139 → 3155 → 3169 → 3188 → 3208 → 3221 → 3229 → 3245 → 3259 → 3278 → 3298 → 3320 → 3328 → 3344 → 3358 → 3377 → 3397 → 3419 → 3436 → 3452 → 3466 → 3485 → 3505 → 3518 → 3535 → 3551 → 3565 → 3584 → 3604 → 3617 → 3634 → 3650 → 3664 → 3683 → 3703 → 3716 → 3733 → 3749 → 3772 → 3791 → 3811 → 3824 → 3841 → 3857 → 3880 → 3899 → 3928 → 3950 → 3967 → 3992 → 4015 → 4025 → 4036 → 4049 → 4066 → 4082 → 4096 → 4115 → 4126 → 4139 → 4156 → 4172 → 4186 → 4205 → 4216 → 4229 → 4246 → 4262 → 4276 → 4295 → 4315 → 4328 → 4345 → 4361 → 4375 → 4394 → 4414 → 4427 → 4444

The 11-ticket is much better value than the tickets for 1..10. Bigger numbers behave like this:


1252 → 4444
1253 → 4444
1254 → 888888
1255 → 4444
1256 → 4444
1257 → 888888
1258 → 4444
1259 → 4444
1260 → 9999
1261 → 4444
1262 → 4444
1263 → 888888
1264 → 4444
1265 → 4444
1266 → 888888
1267 → 4444
1268 → 4444
1269 → 9999
1270 → 4444
1271 → 4444
1272 → 888888
1273 → 4444
1274 → 4444

Then all at once, a number-ticket turns golden and the rollercoaster-ride doesn’t end. So far, at least. I’ve tried, but I haven’t been able to find a rep-digit for 3515 and 3529 = 3515+digsum(3515) and so on:


3509 → 4444
3510 → 9999
3511 → 4444
3512 → 4444
3513 → 888888
3514 → 4444
3515 → ?
3516 → 888888
3517 → 4444
3518 → 4444
3519 → 9999
3520 → 4444
3521 → 4444
3522 → 888888
3523 → 4444
3524 → 4444
3525 → 888888
3526 → 4444
3527 → 4444
3528 → 9999
3529 → ?
3530 → 4444
3531 → 888888
3532 → 4444

Does 3515 ever yield a rep-digit for n += digsum(n)? It’s hard to believe it doesn’t, but I’ve no idea how to prove that it does. Except by simply riding the rollercoaster. And if the ride with the 3515-ticket never reaches a rep-digit, the rollercoaster will never let you know. How could it?

But here’s an example in base 23 of how a ticket for n+1 can give you a dramatically longer ride than a ticket for n and n+2:


MI → EEE (524 → 7742)
MJ → EEE (525 → 7742)
MK → 444 (526 → 2212)
ML → 444 (527 → 2212)
MM → MMMMMM (528 → 148035888)
100 → 444 (529 → 2212)
101 → 444 (530 → 2212)
102 → EEE (531 → 7742)
103 → 444 (532 → 2212)
104 → 444 (533 → 2212)
105 → EEE (534 → 7742)
106 → EEE (535 → 7742)
107 → 444 (536 → 2212)
108 → EEE (537 → 7742)
109 → 444 (538 → 2212)
10A → MMMMMM (539 → 148035888)
10B → EEE (540 → 7742)
10C → EEE (541 → 7742)
10D → EEE (542 → 7742)
10E → EEE (543 → 7742)
10F → 444 (544 → 2212)
10G → EEE (545 → 7742)
10H → EEE (546 → 7742)
10I → EEE (547 → 7742)
10J → 444 (548 → 2212)
10K → 444 (549 → 2212)
10L → MMMMMM (550 → 148035888)
10M → EEE (551 → 7742)
110 → EEE (552 → 7742)

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)