Primes
and FLT

This is a
few more suggestions for the people who are planning to find a counterexample
of the Fermat's last theorem. There are many kinds of prime numbers like
Fermat numbers, Mersenne numbers, Lucas numbers, etc... Those primes can
be very huge. But those methods do not calculate all the possible primes
and each number calculated may have to be tested and the testing process
may take hours of computer time. For the purpose of searching for a solution
to the FLT (or set some lower limit), we may only need to find ALL the
primes smaller than n, say like all primes less than 1 trillion. Below
is a method, invented by who know (I think this method was invented some
thousands years ago, when people discovered prime numbers), and it guarantees
to find all the primes. And it is not too slow either. Here is the FORTRAN
program I just wrote to test the method. It took 160 seconds of my slugish
VAX station to find all 78498 primes p < 1 million. To find all the
primes below 1 trillion, I estimate it would take less than 160s * sqrt(1
trillion / 1 million) = 160000s = 44 hours on my very slow machine and
I don't think that is too bad. If you want to try it then you need to modify
the program to do it step by step and put the results from each step into
a file. e.g., search from range 1-1million, 1million-2million, ... because
I don't think any machine can have enough memory to contain all 1 trillion
numbers in its memory.

c--------------

integer n(500000),p(100000)

nn=1000000

imax=(nn-1)/2

do i=1,imax

n(i)=i*2+1

enddo p(1)=2

k=1

10 k=k+1

p(k)=n(1)

ip=n(1)

j=0

do 20 i=2,imax

if(jmod(n(i),ip).eq.0)goto
20

j=j+1 n(j)=n(i)

20 continue
imax=j

if(n(1)**2.gt.n(imax))goto
40

if(imax.gt.1)goto
10

40 do 50 i=1,imax

p(k+i)=n(i)

50 continue

do 30 i=1,k+imax,10

write(6,900)(p(j),j=i,i+9)

30 continue

write(6,*)'
Total primes = ',k+imax

stop 900 format(x,10i7)

end

--------------------

Now after
the prime number problem is solved, you can start on the FLT. The problem
of calculating a^n+b^n=c^n can be a problem when n is large. However, we
don't have to calculate a^n, b^n, and c^n directly. You may still need
a way to handle very large numbers a, b, and c, but not a^n, b^n, and c^n.
The way to do it is:

We now know
for large n and assume b>=c, then b < c <= b(1+.693/n). Or c=b(1+x)
where x <= 0.693/n = very small number for large n. This type of form
gives us some advantages.

1/ We don't
have to start from b=2 or 3... We can start from b>=n/.693

2/ Don't need
to vary c from c=2 up. We can have c in the range b < c <= b+0.693b/n

3/ From a^n+b^n=c^n
then we have a^n=c^n-b^n=b^n[(1+x)^n-1]

Using Taylor
expansion (You may use other kinds of expansions if you like) we then have
a^n=b^n [xn + x^2 n(n-1)/2 + x^3 n(n-1)(n-2)/6 + ...] or a = b [xn + x^2
n(n-1)/2 + x^3 n(n-1)(n-2)/6 + ...]^(1/n) = b y^(1/n) You only need to
calculate few terms inside the square bracket to get a highly accurate
value, which is now denoted by y.

The term y^(1/n)
will converge to unity quickly and you may lose some significant digits.
You may consider to calculate that term by expansion method instead of
direct calculating. The calculations of the expansion above using real
number. After it is done, you can compare it with the exact integer. If
it within the machine's uncertainty (i.e., correct to 19 digits if you
work with 20 digit numbers) then it may be right candidate.