At one end is the powers of 2 (1,2,4,8,16,32...) and the opposite is the primorials (1,2,6,30,210,2310...) and in-between I put some other series sorted by how much of a "long tail" each had. First I put in the factorial series (1,2,6,24,120,720...) which has the first seven as HCN and five of these as SHCN, but after that does not seem to have any again; they pick up 2's and small primes too quickly to fit the distribution of HCN...

Then I gave a good look at the series of least common multiples of 1 through N. When you figure them by hand you could find the first ten in a few minutes: 1**, 2**, 6**, 12**, 60**, 420, 840*, 2520**, 27720*, 360360*, 720720**... an asterisk indicates a HCN and two indicates a SHCN. So the first members of this series are dense with divisors with some gaps, but how does the pattern develop? The easy to figure out formulation for a LCM number is to multiply every highest power of each prime that is underneath some constant:

LCM(n) = product across all prime p of p^floor(n / log p)

while the HCNs are more unpredictable, they do not occur strictly as multiples of each other and so they do not readily give a formula to produce all of them. However, some websites told me to try:

f(n) = product across all prime p of p^floor(1 / (p^(1/n) - 1) )

and when I used this with a real input less than four I got these thirteen numbers from it:

2, 6, 12, 60, 120, 360, 2520, 5040, 55440, 720720, 1441440, 4324320, 21621600

which are exactly the first thirteen SHCNs. The function inside the exponent increases everywhere along with n, and adds new primes one at a time according to a distribution. I believe that Erdos proved that the SHCNs are all multiples of each other by a prime, so everything here looks good. I then decided to make an assumption about this function:

f(n) = SHCN(n)

then we can learn a lot by applying this to large numbers. With input 6 the number is 780,296,143,507,862,696,557,498,656,000 = 2^8 * 3^4 * 5^3 * 7^2 * 11^2 * 13 through 61. Since it is known that SHCNs add one more prime at a time, and that HCNs occur at least once for every power of 2, the factorization of one of these shows how frequently SHCNs are compared to all HCNs; the proportion will decrease as the larger primes are added to the end more often than twos are.

The question stuck around for me about the long-term behavior for both series, so I evaluated a few of each for high n, and then wrote a python program to continue checking:

Code: Select all

```
shcnlist = []
limit = float(raw_input("exponent to use in equation *not too big!* "))
step = float(raw_input("step size to use while searching *not too small!* "))
e = 1
while e < limit:
ceil = 2**e
# taken from primes.py
n = 2
primes = []
while n < ceil:
factors = []
m = n
for p in primes:
d = float(m)/p
if d == int(d):
factors.append(p)
m = m/p
if len(factors) == 0:
primes.append(n)
factors.append(n)
else:
while m <> 1:
for p in primes:
d = float(m)/p
if d == int(d):
factors.append(p)
m = m/p
n = n+1
shcn = 1
for p in primes:
shcn = shcn * p**int(1/(p**(float(1)/e)-1))
if shcnlist.count(shcn) == 0:
shcnlist.append(shcn)
e = e + step
print "...\n...\n..."
print "limit of the real-valued function"
print limit
print "highest non-zero prime exponent"
print ceil
print "partial list of primes"
print primes
print "identified superior highly composite numbers"
print shcnlist
print "consecutive ratios (should be prime if complete)"
not_complete = 0
for n in range(1,len(shcnlist)):
print shcnlist[n]/shcnlist[n-1],
if primes.count(shcnlist[n]/shcnlist[n-1]) == 0:
not_complete = 1
print "\n"
if not_complete == 1:
print "NOT",
print "COMPLETE"
print "total amount found"
print len(shcnlist)
for n in shcnlist:
factors = []
m = n
for p in primes:
d = float(m)/p
if d == int(d):
factors.append(p)
m = m/p
if len(factors) == 0:
# primes.append(n) *primes have already been found
factors.append(n)
else:
while m <> 1:
for p in primes:
d = float(m)/p
if d == int(d):
factors.append(p)
m = m/p
factors.sort()
print factors
# lcm series
import math
lcmlist = []
n = 1
while n <= primes[-1]:
lcm = 1
for p in primes:
lcm = lcm * p**int(math.log(n)/math.log(p))
lcmlist.append(lcm)
n = n + 1
print "lcm of 1 through n"
print lcmlist
print "lcm's which are also shcn's"
for shcn in shcnlist:
if lcmlist.count(shcn) > 0:
print shcn
```

I wonder what this will do to the notion of some ideal and perfectly divisible huge number...