Follow the above link or click the graphic below to visit the Homepage. |

Divisibility ofCullen Numbers James Cullen |

My introduction to Cullen Numbers came during searches on genealogical material for the site and I came across a mention of a Rev James Cullen after whom the Cullen Numbers are named. He was interested in the divisibility properties of the numbers. A little research turned up a biography, some definitions, and websites related to the search for Prime Cullens. Seeing that we share the same name and that Number Theory is one of my side-interests, I've looked into the Cullen Numbers at some depth and am presenting that material here. Also, I normally sign pages I've authored with 'Jim Cullen' but I've made an understandable exception for this page! The calculations were done almost exclusively on a Texas Instruments Voyage 200 PLT, a programmable graphing calculator with a built-in CAS (Computer Algebra System). For the functions to work as expected, the MODE setting should be in AUTO. Some programs were run on the TI-89 Titanium to free up the V200 for further work. Some tinkering was done on the HP49G+ but nothing fruitful since the keyboard and user RPL programming can be troublesome, to put it nicely.

In the format I'm using, I will at times explain some of the mathematical concepts but at other times I may not. I'm assuming that anyone who finds this page will be initiated on most of the concepts or at least have a running start and an idea of where to search for further information. Program code is provided, where applicable, and is written in TI-Basic. Again, since the code springs directly from the mathematical concepts, I am assuming at least the basic knowledge from the reader and so explanations of program code will be brief. If you're well acquainted with TI-Basic and the mathematical concepts, please feel free to contact me if you feel there are any notable errors or omissions.

Rev. James Cullen was born April 19,1867 at Drogheda, Co Meath, in Ireland. He studied pure and applied mathematics at Trinity College in Dublin but thereafter sought to become a priest and attended various schools and colleges in England. He was ordained priest at St Beuno's College in North Wales on July 31'st 1901 and continued teaching mathematics to younger Jesuits there and in Derbyshire. In 1905 at St Mary's College in Derbyshire, Rev Cullen originated the study of what we now know as the "Cullen Numbers". He was particularly interested in the divisibilty of the numbers as none of them were found to be prime except the first. In fact, it was not until 1957 that the study of the Cullen Numbers was taken up again and it was discovered and then proven that the the 141'st Cullen Number was also prime. Rev Cullen continued his duties in the priesthood but also contributed mathematical articles for publication in journals such as "Nature" and "The Mathematical Gazette". Rev James Cullen passed away on December 7, 1933.

Cullen Numbers are positive integers of the form **C _{n} = n^{ . }2^{n} + 1**, where

Calculation of Cullen Numbers is relatively simple but, since the integer value increases so quickly with **n**, there is a limit as to how high an exact integer value for a Cullen Number may be calculated. Since the maximum size of an integer on the TI V200 is 614 decimal digits, the maximum Cullen Number that may be exactly represented is **C _{2029}**. If we allow for exponential notation, the calculator will continue to return values up to

N'th Cullen Number |

:cullen(n):Func :If n>2029:return "overflow" :n*2^n+1 :EndFunc |

Cullen Numbers can also be expressed as a recurrent series and so share some properties with other series. The expression for the Cullen Numbers in this form is:

To see how this works, calculate **C _{n} = C_{3}**, given that

Then find that

**1a) Number of Digits in a Cullen Number C _{n}**

More as a matter of curiosity than anything, the number of digits in a Cullen Number

and I've disregarded the trailing "+1" for simplicity's sake. Take for example the above list of Prime Cullens. The number of digits in **C _{141} = 45**. The number of digits in

Decimal Digits of N'th Cullen Number |

:cdgts(n):Func :ceiling(log(n)+n*log(2)) :EndFunc |

The final digits of Cullen Numbers repeat in a predictable manner. For example, the pattern of the last digits of consecutive Cullen Numbers repeats in cycles of twenty. The pattern is:

I've split up the cycle of twenty into four cycles of five for a reason. The Cullen Numbers are rich with patterns and here we can see them directly. Cullen Numbers congruent to **0 mod 5** end with a **one**. Two consecutive Cullen Numbers congruent to **3 and 4 mod 5** repectively, share the same last digit. Of course all Cullen numbers are odd and so end in **1, 3, 5, 7, or 9**, and it is equally probable that a given random Cullen Number will end in any particular odd digit.

The cyclic patterns extend beyond just the final digit. Any number of final digits, which we will here refer to as **D**, results in a pattern with a predictable cycle length we will call **L _{D}**.

There is one catch to this pattern of final digits; the pattern does not extend all the way down to **C _{0}** unless you are considering just one final digit. If you wish to consider two or three final digits, their pattern only extends down to

Here are given several straight forward summations involving the Cullen Numbers. The derivations themselves are equally direct and so only the results are given. The first is a simple sum of all Cullen numbers from **1** to **k**:

k | |

C_{n} = 2 ^{.} ( k - 1 ) ^{.} 2^{k} + k + 2 | |

n = 1 |

and you would of course add one to the above result if you wanted the summation to begin at **C _{0}=1**. Applying a modulus to the above formula for the summation yields a few interesting results such as the fact that the sum of any six consecutive Cullen Numbers results in an integer that is itself divisible by six. In this case, the sum divided by six is found to be equal to

The following summations are for the even and odd indexed Cullen Numbers respectively:

k | |

C_{(2n)} = [ ( 24k - 8 ) ^{.} 4^{k} + 9k + 17 ] / 9 | |

n = 0 |

k | |

C_{(2n+1)} = [ ( 48k + 8 ) ^{.} 4^{k} + 9k + 19 ] / 9 | |

n = 0 |

As large as Cullen numbers can be, it's actually a quick and easy task to calculate any Cullen Number to a prime ( or any other ) modulus. Primarily, I'll be concerned with a prime modulus. The standard rules of modular arithmetic apply and we need to calculate:

Numerically, we can use the modpwr(2,n,p), modular exponentiation function, to obtain an intermediate result and then take the rest of the expression to mod p:

and remember that, since p is prime and so coprime to 2, we may reduce the exponent mod phi(p), where phi(p) is Euler's Totient function. Since p is prime, phi(p) = p-1. If n is less than p already, don't bother. Any trick though, to reduce the exponent for the sake of speed, is fair game. Here I use only the standard modular exponentiation function. In the end result, if **cmod(n,p) = 0**, then **C _{n}** is divisible by

C_{n} mod p | Mod Exp: a^{b} mod m |

:cmod(n,p):Func :mod(n*modpwr(2,n,p)+1,p) :EndFunc | :modpwr(a,b,m):Func:Local z :1 -> z:If b=0:return z :Loop :If mod(b,2)=1:mod(a*z,m) -> z :int(b/2) -> b :If b=0:Return z :mod(a^2,m) -> a :EndLoop :EndFunc |

In the case that you'd like to try your hand at a simple prime sieve for Cullen Numbers, it's really not much different than trial-factoring regular integers. Here's a few tips. Instead of testing divisibility of Cullen Numbers one prime number at a time using slow TI-Basic looping statements, use the very fast built-in Greatest Common Divisor function on the product of a whole group of primes. If the greatest common divisor of a Cullen Number and a product of primes is greater than one then the Cullen Number cannot be prime since it shares factors ( and therefore HAS factors ) with a product of primes. I have taken the product of all the primes less than a thousand and broken the product up into four pieces which I have stored in integer variables called **pp1, pp2, pp3, and pp4**. The details are as follows:

pp2: Primes from 53 through 199 whose product is 65 decimal digits.

pp3: Primes from 211 through 499 whose product is 125 decimal digits.

pp4: Primes 503 through 997 whose product is 210 decimal digits.

Note that **2** is included in the **pp1** prime product even though no Cullen Number can be divisible by two. The reason is that these variables serve other purposes besides the calculations meant for Cullen Numbers. Notice also that **pp1** is an integer of only 18 digits ( the actual value is **614889782588491410** ). This is because the smaller primes have a much greater chance of being factors of Cullen Numbers. In fact, one-third of all Cullen Numbers are divisible by three; one-fifth of all Cullen Numbers are divisible by five; one seventh of all Cullen Numbers are divisible by seven; and so on. The majority of composite Cullen Numbers are detected by the quick modular calculation using an integer that's only 18 decimal digits long. If compositeness is not detected, then we can take more time for a careful inspection and steadily increase the prime product ( **pp2, pp3, pp4** ) used in the GCD calculation. This is another advantage of using four separate prime products - you have the option of choosing when to quit trial factoring!

I will mention here one point involving the actual calculation. Since you can't use the GCD calculation on the expression defining the Cullen Numbers since the size of the integers would overflow the calculator, make use of the following:

**Then GCD( a , b ) = GCD( a mod b , b )**

What this amounts to in the coding is simply applying **cmod(n,pp1)** first and then taking the **GCD** of the result with **pp1**. The code below provides the full Cullen Number trial-factoring routine and a simple program to fill the contents of **pp1, pp2, pp3,** and **pp4** using TI's built-in **isPrime(x)** function, which returns 'true' if **x** is prime and 'false' if **x** is not a prime. Likewise, **culltst(n)** returns 'true' if **C _{n}** is a prime candidate due to the trial factoring results. The test returns 'false' if

Fill Prime Variables | Cullen Trial Factoring Function |

:fillpp():Prgm:Local p :7 -> p:210 -> pp1:1 -> pp2:1 -> pp3:1 -> pp4 :Loop:If p>46:Exit:p+2 -> p :While not isPrime(p):p+2 -> p:EndWhile :pp1*p -> pp1:EndLoop :Loop:If p>198:Exit:p+2 -> p :While not isPrime(p):p+2 -> p:EndWhile :pp2*p -> pp2:EndLoop :Loop:If p>498:Exit:p+2 -> p :While not isPrime(p):p+2 -> p:EndWhile :pp3*p -> pp3:EndLoop :Loop:If p>996:Exit:p+2 -> p :While not isPrime(p):p+2 -> p:EndWhile :pp4*p -> pp4:EndLoop:Disp "Done" :EndPrgm |
:culltst(n):Func :If gcd(pp1,cmod(n,pp1)) > 1:Return false :If gcd(pp2,cmod(n,pp2)) > 1:Return false :If gcd(pp3,cmod(n,pp3)) > 1:Return false :If gcd(pp4,cmod(n,pp4)) > 1:Return false :Return true :EndFunc |

Given that Cullen Numbers grow so rapidly with **n** and that factorization itself is a difficult task, it's a wonder that we have as much done as we do in Cullen Number factorization. There are known divisibility properties that help. Here are two divisibility properties, derived from Fermat's Little Theorem, that will come in handy:

and it's companion property (which proves to be slightly less useful):

One of the most basic and useful divisibility properties is this:

where "odd prime" means any prime number greater than two. A simple proof of this can be found by setting **n=p-1** or **n=p-2** in the expression **n ^{.} 2^{n} + 1** for Cullen Numbers and then solving the congruency. We get, if

We can use this definition of **B _{p}** immediately to determine the locations of two consecutive Cullen Numbers divisible by a given prime

**If p is any odd prime and k is an integer greater than or equal to zero:**

As an example, suppose **p = 11**, which is congruent to 3 (mod 8). This means that **B _{p} = p^{ . }( p-1 ) = 11 ^{.} 10 = 110**. If k is set to zero in the above equation then we have our basic divisibility property which states that

This rule holds for all values of **k** and locates ALL such pairs of Cullens divisible by **p** as the value of **k** goes to infinity. There are other Cullen Numbers divisible by **p** besides those pairs identified above. There are also other divisibility properties and some very powerful algebraic factorizations not discussed here that cover some of them. One I will mention, since it proves useful later on, is the following general divisibility property:

When I first started plugging values of **k** into this equation, I found that it missed all the pairs mentioned above. The values for **m(k)** grew so large so quickly that it skipped over tens then hundreds then thousands of Cullens. In fact, it also seemingly randomly skipped huge numbers of known Cullens divisible by a given **p** ... or did it?
**5) Divisibility of Cullen Numbers using Index mod B _{p}**

Since we find that two consecutive Cullen Numbers divisible by a given prime **p** can be easily located using the definition of **B _{p}**, it's only logical to look at ALL Cullen Numbers divisible by a given prime

What we find is that ALL Cullen Numbers divisible by a given prime **p**, when their indexes are taken **mod B _{p}**, repeat in a predictable pattern. The examples given here are for the first eight odd prime numbers, namely;

p | B_{p} | List of all ( n mod B_{p} ) where C_{n} is divisible by prime p | #Terms (T_{p}) |
---|---|---|---|

3 | 6 | { 1, 2 } | 2 |

5 | 20 | { 3, 4, 6, 17 } | 4 |

7 | 21 | { 5, 6, 10 } | 3 |

11 | 110 | { 6, 9, 10, 18, 24, 45, 47, 52, 71, 103 } | 10 |

13 | 156 | { 4, 7, 11, 12, 22, 41, 57, 66, 97, 99, 140, 146 } | 12 |

17 | 136 | { 15, 16, 19, 25, 30, 52, 77, 106 } | 8 |

19 | 342 | {10,12,17,18,34,61,87,116,119,128,139,149,153,184,199,212,273,312} | 18 |

23 | 253 | { 5, 7, 21, 22, 34, 42, 83, 107, 125, 135, 178} | 11 |

A few observations on these results. The number of items in each list is just **B/p**, which we will from here on refer to as **T _{p}**. In other words; if

I'll provide an example before we continue. What I've found is that there is an entire set of new divisibility properties similiar to the ones we already have. They were derived by substituting in values for **k** and restating the results as a new divisibility property: Some examples are, for **k = 0, 1, 2, 3, and 4** respectively:

The general statement can be made that:

**If N is prime, then C _{n} is divisible by N.**

These results are entirely useful and interesting and I have not seen them stated anywhere else. I'm really surprised that these haven't been found independently before. Once the results are charted into the tables above, the pattern becomes very clear. Note that when **k = 0** and when **k = 1**, we have our basic divisibility property that states; **if p is prime, then p divides C _{p-1} and C_{p-2}**. Later we will make use of these divisibility properties to improve the sieve for Cullen Primes. Note also however, that as

With some precalculation using the general divisibility property, we now have a method of determining divisibility using the lists from the above table. For example, suppose we want to determine whether or not **C _{2201}** is divisible by

There are a couple options for the precalculation. One is two calculate **cmod(n,p)** for all Cullen Numbers from **C _{1}** through

We begin with a modification of the general divisibility property given in the previous section. All we've really done is to take the values **mod B _{p}** as follows:

The result is that **m(k) mod B _{p}**, as

Compare this to the results from the above table, which are in numerically ascending order:

The obvious workaround is to reorder the list, which is easy enough to accomplish, but of course requires some time for the calculator to do, especially for larger values of **p**. It isn't strictly necessary to sort the list for a simple lookup table but the **mklist(p)** program does so for your benefit should you like to inspect the list of numbers. The programs below will allow you to experiment with this method of testing divisibility of Cullen Numbers by primes. Be aware that trying to test divisibility by large prime numbers can result in excessively long execution times! I've prevented primes larger than **500** from being used in the test (which I suppose you may disable if you really want to). Execution time for primes near **500** is just under 30 seconds. The **mklist(p)** program, if developed more, could be a bit faster if I were to use the **modpwr(a,b,m)** function. Since this is just a demonstration program and is actually faster as is with small primes, I left that calculation as a simple exponential. The first program, **mklist(p)**, performs the precalculation by creating a string variable called **clist** in the **Main** folder of the calculator. Variable **clist** contains a string representation of all **n mod B _{p}** for which

Create blist & clist for p | Test C_{n} Divisible by p |

:mklist(p):Prgm :ClrIO:Local t,k :If p>500 Then:Disp "Argument is TOO big!":Pause:ClrIO:Stop:EndIf :If not isPrime(p) Then:Disp "Argument must be a prime number!":Pause:ClrIO:Stop:EndIf :(p-1) -> t :If abs(4-mod(p,8))=3:t/2 -> t :t*p -> blist :seq(mod((2^k-k)*(p-1)-k,blist),k,1,t) -> clist :SortA clist :string(clist) -> clist :","&mid(clist,2,dim(clist)-2)&"," -> clist :Disp "Finished":Pause:ClrIO :EndPrgm | :testdiv(n):Func :If inString(clist,","&string(mod(n,blist))&",")=0:Return false :Return true :EndFunc |

As an example of how fast this method can work, I performed the precalculation for **p = 491**, which took about twenty seconds. I then ran **testdiv(n)** to find out if **C _{29702468866000}** ( a Cullen Number with almost 9 trillion decimal digits ) was divisible by

It becomes clear that there is a bottleneck when it comes to determining divisibility of Cullen Numbers by larger and larger primes using a list-type lookup table described in the last section. The precalculation required can quickly grow to an unreasonable size. Consider a potential prime factor **p = 134625781**, which is really not as unreasonable as you may think - sieving programs typically sieve, or perform trial-division, into the billions during the process of searching for prime Cullen Numbers. Note that **134625781 is congruent to 5 mod 8** so that we need to precalculate, store, and perform searches on, a list of **( p-1 ) = 134625780** items. This is not very desirable, and not just because of the memory and cpu requirements to handle the list. Sieving ranges are typically only in the tens of thousands of prime candidates at a time and one quickly approaches the point where there is no time savings at all using a lookup table for determining divisibility of Cullen Numbers.

Can the divisibility test be performed without the precalculation? Yes but, the complexity of doing so is just about the same complexity of performing the **cmod(n,p) = 0** test. It's not likely that any algebraic manipulation of the numbers would magically give you the required information without having to perform at least one modular exponentiation, the same as required by the **cmod(n,p) = 0** divisibility test. If this were not so, then prime numbers would not be the mystery that they are. An example illustrates this.

In Section 4 there was given a general divisibility property:

and it's modification in order to calculate the list of **n mod B _{p}** such that

We have the ability to, in effect, work this property in reverse. That is, determine the value of **k** required to be added to **n** in order that the result is divisible by **( p-1 )**, then divide by **( p-1 )** and add the value of **k** again. Take this result to **mod p**. Then check whether two raised to this particular value of **k**, taken to **mod p**, results in an equal value:

Then if [ ( n mod B_{p} + k ) / ( p - 1 ) + k ] mod p = 2^{k} mod p

**Then C _{n} is divisible by p.**

which is clearly a convoluted method of determining the divisibility of a Cullen Number **C _{n}** by a given prime

The goal of the Cullen Prime Sieve is to eliminate prime candidates by showing that a given Cullen Number has factors. So far we've implemented only a basic prime sieve by checking Cullen Numbers for divisibility by prime numbers less than **1000**. If you inspect the factorizations of Cullen Numbers however, you'll find that very large factors are very common. It is not practical to check for divisibility by primes of this size so we need another way to show a Cullen Number has factors without actually testing for divisibility directly.

One way to do this is to try working the divisibility properties in reverse. As an example, I'll demonstrate this concept using the simplest and most useful property:

Suppose we want to determine whether or not **C _{40}** can be eliminated as a prime candidate by showing it has factors. If we note that

The **isPrime(x)** function on the TI V200/92+/89 line of calculators is a fast and reliable method of implementing this concept and so the following line of code may be added to our Cullen Trial Factoring Function **culltst(n)**:

Since this is basically a conditional sieve with primes that are just as large as the index of the Cullen Numbers we are checking, this is an excellent method to add on to our sieving function - especially for large Cullen Number indexes. We just need to make note of the fact that the density of primes tapers off at high values of **n** and so we can expect to see some drop in effectiveness in our sieving function.

While we're at it we may also want to make use of the two divisibility properties given in Section 4:

For example, consider the first divisibility property. We need to check not only that **2 ^{.}n-1** is a prime number, but also that this prime is

(2*n+1)/3 -> t:If isPrime(t) and abs(4-mod(t,8))=3:Return false

which turns out to work very well with the only concern is the unavoidable tapering off of effectiveness for large values of **n** due to the nature of the density of primes. I will demonstrate shortly what I mean by "effectiveness" and how it impacts the programming of these tests.

What we'd like to do first though is to expand on the idea of actually targeting primes as potential factors instead of sieving with primes at random. Since we have quite a few tests to try on Cullen Numbers now, I've tried to implement some ideas into programming code which will cover more than one test at a time. Recall the general divisibility from Section 4:

By taking advantage of this property we can not only eliminate one of our other tests, but we can also speed up the test in the process. In addition, we are able to uncover factors not obtainable otherwise besides with brute force and inordinate amounts of time. As an example, I implemented all the tests we've put together at this point ( plus one test not covered in this article ) and ran the test from **C _{1354800}** to

**{ 1354860, 1354878, 1354889, 1354893, and 1354896 }**

Using the above general divisibility property, I was able to quickly demonstrate that two of these Cullen Numbers are composite by providing a factor:

**C _{1354878} is divisible by 677441**

which can be confirmed by noting that **cmod(1354827,270967)=0** and **cmod(1354878,677441)=0**.

To make the general divisibility property work for us, we first assume that there is a prime number **p** which divides **C _{n}** and satisfies the divisibility property for some value of

If ( n + k ) mod r is congruent to zero then test:

If (( n + k ) / r ) + 1 is a prime number p,

**Then C _{n} is divisible by p**

Although the algorithm may be a bit convoluted, it is the direct result of working the general divisibility property in reverse. Since there are no modular exponentiations and the integer divisions are small, the algorithm is very very fast for what it does. When **k = 0 and k = 1** in the equations, we are actually performing the check for the divisibility property that states:

since, when **k = 0**, we are checking that **n + 1 = p**; and, when **k = 1**, we are checking that **n + 2 = p**. Another nice thing about this is that the loop terminates after just one **isPrime(x)** function execution if a prime factor is found where the old method automatically requires that we perform **isPrime(x)** twice.
**8) Extended Divisibility Properties of Cullen Numbers**

It is possible to immediately extend some of the known divisibility properties of Cullen Numbers by recognizing the fact that **n**, for all Cullen Numbers **C _{n}** divisible by a given prime

In the examples in the previous section, we made use of the general divisibility property by solving the equation for **m _{k}** for prime

**If p is any odd prime and k is an integer greater than or equal to zero:**

Not only can we perform the basic check on whether **n+1** or **n+2** is a prime number **p**, but we can also check to see if maybe **n+1** or **n+2** is a multiple of **B _{p}** added to a prime number

We will expand the above equations for the case of **n+1** being a possible multiple of **B _{p}** added to

Case: p = +/- 1 mod 8 | Case: p = +/- 3 mod 8 |
---|---|

n+1 = p + k ^{.} p ^{.} ( p-1 ) ^{.} 1/2 | n+1 = p + k ^{.} p ^{.} ( p-1 ) |

n+2 = p + k ^{.} p ^{.} ( p-1 ) ^{.} 1/2 | n+2 = p + k ^{.} p ^{.} ( p-1 ) |

which we then rearrange to solve for **p**, taking only the positive solution of the quadratic:

Case: p = +/- 1 mod 8 | Case: p = +/- 3 mod 8 |
---|---|

p= [ sqrt(8^{.}k^{.}n + (k+2)^{2}) + k-2 ] / (2^{.}k) | p= [ sqrt(4^{.}k^{.}n + (k+1)^{2}) + k-1 ] / (2^{.}k) |

p= [ sqrt(8^{.}k^{.}n + k^{.}(k+12)+4) + k-2 ] / (2^{.}k) | p= [ sqrt(4^{.}k^{.}n + k^{.}(k+6)+1) + k-1 ] / (2^{.}k) |

As expected, when **k=0** in any case, we find that, if either **n+1** or **n+2** is a prime number **p**,then **C _{n}** is divisible by

Then C

This is easily confirmed and, when you look again at the equations this result was derived from, not entirely surprising. In fact, it can be shown that if **n** is any perfect power of any prime **p**, then both **C _{n-1}** and

If we only consider the cases where **k<3** then there is one other divisibility property that may be of some use in discovering prime factors of **C _{n}**:

If p = [ sqrt( r ) + 1 ] / 4 is a prime congruent to 3 or 5 mod 8

or If p = [ sqrt( r ) - 1 ] / 2 is a prime congruent to 1 or 7 mod 8

Then C

For example, by the above, we could show that **C _{1126}** or

Divisibility of Cullen Numbers according to the prime factors of the index of Cullen Numbers seems to be a reasonable approach. Consider the case where two consecutive Cullen Numbers are divisible by the same prime divisor. These comprise about **80-90%** of all Cullen Numbers in the range of indexes of **10 ^{2} - 10^{3}** and about

We begin with the simple case where an index **n** of a Cullen Number cannot be factored at all. In this case we will say that **n = p**. It is a simple matter to show that the congruencies **C _{n-1} mod p** and

We go one step further and suppose that **n = p ^{.}p** so that n has two factors, both equal and both prime. We again substitute and solve the congruencies for

Using the examples above as a guide, we suppose that **n = p _{1} ^{.} p_{2}** so that

**FermatSearch: Biography of Rev James Cullen.****Cullen Top Twenty: Chris Caldwell's Top Twenty Cullen Primes Page at UTM.****Prime Glossary: Definition and some properties of the Cullen Numbers.****Paul Leyland: Factorizations Page for Cullen and Woodall Numbers.****Prothsearch: Internet coordinated search for record breaking Prime Cullen Numbers.****Cullen Status: Prothsearch's Cullen Prime search status page.****Primzahlenarchiv: Generalized Cullen Prime Search****Mathworld: Mathworld's article on the Cullen Numbers.**

© Oct, Nov 2005 - James Cullen - all rights reserved.