Algoritmo para calcular números primos muy grandes

Ayer estaba leyendo un documento que hablaba sobre los números primos y en él aparecia Euclides que dice que hay infinitos números primos (P1* P2* P3*.. *PN)+1, pero después dice que el número resultante puede ser primo o no.

Mi teoría es que si se va multiplicando una sucesión de números primos (sin repetir ninguno) que empieza desde el primer número primo y acaba en cualquier otro número primo y se le suma o resta 1 habremos conseguido un número primo; la razón es que el número que hemos conseguido al multiplicar la sucesión de números es divisible por todos los números por los cuales se ha multiplicado, pero al sumarle o restarle 1 ese número deja de ser divisible y se convierte en un número primo...

He hecho un algoritmo con java para calcular un número primo muy grande, en mi opinión es bastante eficiente pero tiene un problema, la capacidad de la mayor variable que utilizo (double) es demasiado pequeña para lo que quiero hacer, el mayor número que puedo meter es: 1.7 *10 E 308 y como quiero un numero de 10 millones de cifras para superar el record actual con eso no hago nada, he pensado en un array de double pero necesitaria espacio para 32500 numeros de unas 308 cifras cada uno y aunque luego metiese los resultados de las multiplicaciones de esos números en un archivo y hiciese las operaciones cuando mi ordenador ,que solo tiene 512 MB de RAM, se pusiese a multiplicar un número de 3 millones de cifras por uno de 308 cifras (la capacidad de un double) se me quemaria la RAM, porque ademas no es una sola operacion son operaciones muy intensas sin parar.

He estado mirando páginas web en las que bajándote un programa puedes ayudar a calcular una operacion matematica pero como estan en inglés (y yo de inglés no se mucho) no les he enviado un email para ver si me podían ayudar.

¿Por qué cambiar de algoritmo para calcular los números primos?

Pues porque el que hay ahora 2 E NP -1 (2 elevado a un numero primo, al resultado se le resta 1) el resultado que da no se sabe si es primo y hay que comprobarlo, con mi algoritmo no hay que preocuparse de si es o no primo porque (al menos teoricamente) ya he probado que siempre da números primos y os dejo esta lista con los diez primos números primos para que lo comprobéis:

La lista tendrá este formato:

multiplicación = resultado(r) solucion1(r-1) y solucion2(r+1)
2 = 2                                                                      1                  y 3 
2*3 = 6                                                                  5                  y 7
2*3*5 = 30                                                           29                 y 31
2*3*5*7  = 210                                                    209               y 211
2*3*5*7*11 = 2310                                             2309             y 2311
2*3*5*7*11*13 = 30030                                     30029           y 30031
2*3*5*7*11*13*17 = 510510                             510509         y 510511
2*3*5*7*11*13*17*19 = 9699690                     9699689       y 9699691
2*3*5*7*11*13*17*19*23 = 223092870           223092869   y 223092871
2*3*5*7*11*13*17*19*23*29 = 6469693230   6469693229 y 6469693231

El código fuente para aplicar esta idea es el siguente:

class Primo_mas_grande {
  public static void main(String Args[]) {
    int contador_primos;
    double i,j,numero_primo, otro_contador=0;
    double primos[] = new double[500];
    primos[0]=3;
    for(i=7, numero_primo=30/* 2*3*5*/, contador_primos=3/*ya he puesto 3 primos*/, j=1;i<=700;i+=2
   /*solo cuentan los números impares*/) {
      if(otro_contador==4 ) {
        i+=2; /*si el número acaba en 5 se le suma 2*/
        otro_contador=0;
      }
      otro_contador++;	
      for(int b=0;;b++) {     	  
     	if(i%primos[b]==0) break;
      	if(i%primos[b] !=0 && primos[b]>(i/3)) { /*si el numero es menos del triple que otro 
        el numero es primo*/     	  
      	  contador_primos++;
      	    primos[(int)j] = i; /*si es primo se mete en el array*/
      	    j++;      	  
      	  numero_primo*=i;/*se multiplica el primo por el resultado de la multiplicaciçon de los 
          primos anteriores*/      	    
      	  break;
        }
      }         
    }
    numero_primo += 1;
    System.out.println("El numero primo obtenido es: "+numero_primo+ " y se ha utilizado un total de
   "+contador_primos+" sin contar el 1");
  }
}
/*Solo calculo los números hasta 700 porque si meto mas primos no caben en la variable numero_primo*/

Los problemas que tiene ya los he comentado, no tengo ni suficiente RAM, ni variables con capacidad suficiente ni un supercomputador para poder hacer el cálculo en un tiempo razonable.

No sabia muy bien donde poner esto, ni si es adecuado ponerlo en kriptopolis, o es algun consejo o que me digais si conoceis alguna web en castellano parecida a http://www.mersenne.org/ (su página en castellano no va) para poder pedir ayuda para calcular el algoritmo, si veis algun error en la explicación, teoria o código también os agradecería que me lo dijeseis.

Puede que publicando esto aqui alguien que puede calcular el algoritmo me lo robe, 100.000 dólares de premio son muy tentadores.