In 2004 mysterious billboard was erected on Highway 101 in Silicon Valley. The billboard had no company listed and simply said “{first 10-digit prime found in consecutive digits of e}.com”.

Clearly, this was a challenge to the nerds of Silicon Valley. The solution is known and the challenge has been over for nearly a decade, but it still represents an interesting problem to solve.

Prime Numbers

Perhaps the most difficult portion of solving the billboard challenge comes in understanding what makes a number prime.

A prime number is a number that is only divisible by itself and one. The most common primality test for a number $\ n$ is to check if the number is divisible by any number from 1 to $\ sqrt n$. This is called trial division and the code to implement this is relatively straightforward.

import math

def basicPrime(n):
if n <= 2:
raise ValueError
if not type(n) == int:
raise TypeError
prime = True
for iter in range(2, math.floor(math.ceil(math.sqrt(n))) + 1):
if n % iter == 0:
prime = False
break
if prime:
print('%s is the first 10 digit prime in e.' % n)
return prime

The output generated from the code does return the correct answer:

7427466391

This method works but it is just brute-forcing the problem. There is a more fun way to solve the problem using a more advanced algorithm.

Fermat’s Little Theorem

Fermat’s Little Theorem (stated originally in 1640) is an interesting way of checking if a number is prime.

The theorem states that if $\ p$ is some prime number then:

$a^p \equiv a (mod p)$

In layman’s terms, this means that for some prime number $\ p$ and an integer $\ a$ less than $\ p$, $\ a^p – a$ is always divisible by $\ p$.

For example: let’s choose a prime number $\ p$ to be 23 and $\ a$ to be 3.

$3^{23} – 3 = 94143178827 – 3 = 94143178824 = 23 * 4093181688$

so $\ p$ is prime.

Now, let $\ p$ equal 24 (not prime) and let’s see what happens:

$3^{24} – 3 = 282429536481 – 3 = 282429536478 = 24 * 11767897353.3$

so $\ p$ is not prime.

Liar and Witness numbers

Unfortunately, Fermat’s Little Theorem is foolproof and can generate false positives. These are known as liar’s numbers.

For example, let $\ p$ equal 15 and let $\ a$ equal 4 and let’s check if 15 is prime (it isn’t):

$4^{15} – 4 = 1073741824 -4 = 1073741820 = 15 * 71582788$

so $\ p$ is prime (false positive).

False positives like this exist but using a different $\ a$ value usually reveals a liar’s number to be composite (These are called witness numbers).

This begs the question: is there any number $\ n$ such that every $\ a$ from $\ 0 < a < n -1$ a false positive is returned?

Carmichael Numbers

The answer is yes! In fact, there are infinitely many numbers that will always return a false positive. These numbers are known as Carmichael numbers. I encourage you to prove this to yourself (probably via code since the numbers can be exceptionally difficult to keep manage).

Does this mean that Fermat’s Little Theorem is incorrect or useless? It certainly isn’t perfect, but per Wikipedia, there are 2183 Carmichael numbers between 0 and 25,000,000,000.

It follows that the chance of $\ n$ being a Carmichael number is:

$\frac{2183}{250000000000} = 0.00000008732$ or .000008732%

That’s accurate enough for the purpose of solving this challenge. So let’s implement it in code.

import math
import random
from fractions import gcd

def fermatPrime(n):
tests = [random.randint(2,10) for i in range(5)]
prime = True

for a in tests:
print(a,n)
x = gcd(a,n) == 1 # why
y = (a**n - 1) % n == 1
print('n: %s A: %s GCD: %s Fermat: %s' % (n, a, x, y))
if not x or not y:
prime = False
break.

if prime:
print('%s is the first 10 digit prime in e.' % n)

return prime


This code also returns the correct answer of

7427466391 

but it only conducts 6 iterations rather than $\ sqrt(n)$ iterations. In reality, it takes a long time to run because the exponentials that need to be calculated when $\ n$ is a 10 digit number are huge. Nevertheless, it’s a more interesting solution to the problem than simply using trial division.

That’s all there is to the Google Billboard Challenge. I’m going to write some tests using Python’s unittest module to provide a quick way to check if the functions are still working.

import unittest
from basicPrime import basicPrime

def test_basicPrimesWithComposities(self):
firstComposites = [4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 26, 27, 28, 30, 32, 33, 34, 35, 36]
for composite in firstComposites:
self.assertFalse(basicPrime(composite))

def test_basicPrimesWithNegativeZeroOne(self):
with self.assertRaises(ValueError):
basicPrime(-1)
with self.assertRaises(ValueError):
basicPrime(0)
with self.assertRaises(ValueError):
basicPrime(2)

def test_basicPrimeWithPrimes(self):
firstPrimes = [3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
for prime in firstPrimes:
self.assertTrue(basicPrime(prime))

## Repeated for fermatPrime - omitted from blog for brevity

if __name__ == '__main__':
unittest.main()


That’s all I have for now. Thanks for reading. If you’re interested in the full source all my projects are available on my GitHub under an MIT license.