Let *s*(*n*) be the sum of the proper divisors of *n*, the divisors less than *n* itself. A number *n* is called excessive, deficient, or perfect depending on whether *s*(*n*) − *n* is positive, negative, or 0 respectively, as I wrote about a few days ago.

The number *s*(*n*) is called the aliquot sum of *n*. The iterated aliquot problem asks whether repeated iterations of *s* always converge to a perfect number or to 0. This problem has something of the flavor of the Collatz conjecture, a.k.a. the hailstone problem.

As mentioned here, about 1/4 of all integers are excessive and about 3/4 are deficient. That is, *s*(*n*) is smaller than *n* for about 3 out of 4 integers. Based on just this, it seems plausible that iterated aliquots would often converge. (See the next post for a visualization of *how much* the function *s* increases or decreases its argument.)

We can investigate the iterated aliquot problem with the following Python code.

from sympy import divisors def s(n): if n == 0: return 0 return sum(divisors(n)) - n def perfect(n): return n == s(n) def iterate(n): i = 0 while True: if perfect(n) or n == 0: return i n = s(n) i += 1

The function `iterate`

counts how many iterations it takes for repeated applications of *s* to converge.

For *n* = 1 through 24, the sequence of iterates converges to 0, the only exception being the perfect number 6.

When *n* = 25 the sequence converges, but it converges to 6 rather than 0. That is, 25 is the smallest number which is not perfect but for which the sequence terminates in a perfect number.

When *n* = 138, the sequence converges, but it takes 178 iterations to do so. For smaller *n* the sequence converges much sooner.

When *n* = 220, we see something new. *s*(220) = 284, and *s*(284) = 220. That is, our code is stuck in an infinite loop.

So we need to go back and refine our question: does the sequence of iterations always converge to 0, converge to a perfect number, or enter a loop?

We have to modify the Python code above to look for loops;

def iterate(n): i = 0 seen = set() while True: if perfect(n) or n == 0 or n in seen: return i seen.add(n) n = s(n) i += 1

At least for *n* < 276 the sequence converges.

When I tried 276, the iterations got much larger and slower. I let it run for 400 iterations and the last iteration was

165895515315097460916365008018720.

This took 150 seconds. I switched over to Mathematica and it calculated the same result in 0.6 seconds.

Then I asked Mathematica to run 600 iterations and that took 64 seconds. I went up to 700 iterations and that took 6133 seconds. So it seems that each set of 100 iterations takes about 10 times longer than the previous one.

The last result I got was

19672082490505732759807289983767208175341724164433534581895943000246457396.

Maybe the iterations turn around eventually, but so far it looks like they’ve reached escape velocity. The growth isn’t monotonic. It goes up and down, but more often goes up.

The problem of whether the sequence always converges is unsolved. I don’t know whether it’s known whether the particular sequence starting at 276 converges.

**Update**: See the first comment. It’s an open problem whether the sequence starting at 276 converges.

It is not known whether 276 converges, it’s been taken to 213 digits ( http://factordb.com/sequences.php?se=1&aq=276&action=last20&fr=0&to=100 ) which would be 50 to 100 thread-years to factorise with current tools

Thanks!

Hi John, small correction, should the sentence “A number n is called excessive, deficient, or perfect depending on whether s(n) is positive, negative, or 0 respectively” not be “… on whether s(n)-n is positive, negative, or 0…”?

Thanks.