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 *n*, *f*(*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.

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

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.