# Alternating sums of factorials

Richard Guy’s Strong Law of Small Numbers says

There aren’t enough small numbers to meet the many demands made of them.

In his article by the same name [1] Guy illustrates his law with several examples of patterns that hold for small numbers but eventually fail. One of these examples is

3! − 2! + 1! = 5

4! − 3! + 2! − 1! = 19

5! − 4! + 3! − 2! + 1! = 101

6! − 5! + 4! − 3! + 2! − 1! = 619

7! − 6! + 5! − 4! + 3! − 2! + 1! = 4421

8! − 7! + 6! − 5! + 4! − 3! + 2! − 1! = 35899

If we let f(n) be the alternating factorial sum starting with nf(n) is prime for n = 3, 4, 5, 6, 7, 8, but not for n = 9. So the alternating sums aren’t all prime. Is f(n) usually prime? f(10) is, so maybe 9 is the odd one. Let’s write a code to find out.

```    from sympy import factorial, isprime

def altfact(n):
sign = 1
sum = 0
while n > 0:
sum += sign*factorial(n)
sign *= -1
n -= 1
return sum

numprimes = 0
for i in range(3, 1000):
if isprime( altfact(i) ):
print(i)
numprimes += 1
print(numprimes)
```

You could speed up this code by noticing that

`    altfact(n+1) = factorial(n+1) - altfact(n)`

and tabulating the values of `altfact`. The code above corresponds directly to the math, though it takes a little while to run.

So it turns out the alternating factorial sum is only prime for 15 values less than 1000. In addition to the values of n mentioned above, the other values are 15, 19, 41, 59, 61, 105, 160, and 601.

* * *

[1] The Strong Law of Small Numbers, Richard K. Guy, The American Mathematical Monthly, Vol. 95, No. 8 (Oct., 1988), pp. 697-712.

## 3 thoughts on “Alternating sums of factorials”

1. A different question one could ask and is interesting is whether there are infinitely many alternating factorials which are prime.

Again I wanted to try this in Perl 6.

I noticed that each factorial was only used once, so I figured I would use the iterator API so that it would use a minimal amount of RAM.

my \factorial = ( 1, { ++\$ * \$_ } … * ).iterator;
my \alt-factorial = ( { factorial.pull-one – (\$_//1)} … * ).iterator;
my @alt-primes = (^1000).grep: { alt-factorial.pull-one.is-prime }
say @alt-primes; # (3 4 5 6 7 8 10 15 19 41 59 61 105 160 661)
say +@alt-primes, ‘ primes’; # 15 primes
say now – INIT { now }, ” seconds”; # 127.4444326 seconds

3. Wondering the same question as Kosta, it occurred to me that if any f(n) has a factor <= n+1, the all f(n+k) would also have that as a factor. So the number of prime f(n) would be finite. Some C++ code and an hour of computation revealed n==3612702 as meeting that criteria.

Only then did I check Wikipedia (https://en.wikipedia.org/wiki/Alternating_factorial) and see this fact as part of the article.

BTW, you list n=601 as a prime f(n), but others give n=661 instead.