The search for a Beal

Conjecture Counterexample

**Theory From Wikipedia **

**Beal's conjecture** is a conjecture in number theory proposed by the Texas billionaire and amateur mathematician Andrew Beal.

While investigating generalizations of Fermat's last theorem in 1993, Beal formulated the following conjecture:

If

where *A*, *B*, *C*, *x*, *y*, and *z* are positive integers with *x*, *y*, *z* > 2 then *A*, *B*, and *C* must have a common prime factor.

**The Search **

My computer search is currently state of the art and is the fastest program currently mentioned on the internet (2nd is this). Because the program is super-optimized, it uses a lot of memory, about 1 gig, as well as 64-bit arithmetic so you need a 64 bit OS! Download my program and reserve a range! After it completes zip and send my the results file.

Run the program like "bealconjecture.exe 4 10000 20000" to search w/ 4 threads from 10k-20k. We need to go up to 1 million for this run to finish. If you exit the program it will auto resume if you rerun it with the same parameters.**What do the equations output mean?**

The equations a^x + b^y have coprime bases a & b (which means gcd of a & b is 1), are equal to a power (c^z) mod four large prime numbers (two just under 2^28 and two under 2^32). The c^z is not necessarily the same for each modular solution, which it would have to be for it be a real solution, but the exponent's z are equal modulo 7.

What all that meant is that the vast majority of numbers are quickly eliminated at each stage of testing, and the program outputs those that have passed all its tests to be brute force checked. There is still a very small probablity that each one of these solutions is a counterexample (an actual solution). The output file is actually a script I run using pari that performs this brute force work.

**More Math or Where does the program spend most of the work?**

Most of my time is spent doing hash lookups to see if (a^x + b^y) mod n is in the hashtable of c^z. I'm using the c# default hashtable with the primes ~2^32, but I do a "presieve" with primes ~2^28 using a "primitive perfect" hash table. I have an array 1 - ~2^28 with a 0 or not 0 in each byte (not 0 represents where the hit is, because 2 hits must be in the same section), and I can just lookup up by index which is faster than a hash lookup.

Probably the second most significant time usage is the modular exponentation. I use the theory and code from wikipedia - modular exp.**Latest Version!**

http://jjoshua2.googlepages.com/bealconjecture1.2.zip

Archive

http://jjoshua2.googlepages.com/bealconjecture1.1.zip

http://jjoshua2.googlepages.com/BealConjecture.exe

**Source Code!!**

http://jjoshua2.googlepages.com/Program.cs

Sorry its messy I never really cleaned it up.

**The Status**

**Searching 3 <= exponent <= 10 & 1 <= bases <= 1,000,000 - COMPLETE!**

1-100k jjoshua2 - complete

100k-**150k videogames101** - complete

150-250k phillipart - complete

250k-750jjoshua2 - complete

750-1000 jjoshua2 complete

Program does not recognize k use full like 990000 1000000.

The search gets faster and faster as the search range numbers get larger.

It is possible we may expand with a second run.