Encontrando Nmeros Primos

N (N)
10 100 1,000 10,000 100,000 1,000,000 10,000,000 100,000,000 1,000,000,000 10,000,000,000 100,000,000,000 1,000,000,000,000 10,000,000,000,000 100,000,000,000,000 1,000,000,000,000,000 10,000,000,000,000,000 4 25 168 1229 9592 78498 664579 5761455 50847534 455052511 4,118,054,813 37,607,912,018 346,065,536,839 3,204,941,750,802 29,844,570,422,669 279,238,341,033,925

COMPUTO PARALELO Dr. Andrei Tchernykh

Presenta: Gustavo Francisco Mendoza Snchez

Ensenada B. C. a 3 de Diciembre de 2007

Qu son los nmeros primos?

Aquellos numeros naturales que tienen exactamente cuatro divisores. Forman un subconjunto infinito de N
p es primo si sus nicos divisores son p, -p, 1 y -1

Infinidad de los nmeros primos

Demostracin

Euclides, 300 a de C.

Aclaracin

Cuntos nmeros primos hay menores que un nmero dado?

Los 25 nmeros primos menores de 100 son:

2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 59, 61, 67, 71, 73, 79, 83, 89, 97
Los 168 nmeros primos menores de 1000 son:

Entre 1 y 100: Entre 401 y 500: Entre 901 y 1000: Entre 999901 y 1000000:

25 24 14 8

 Existe alguna regla o formula para responder a esta pregunta?

Sea (N) la cantidad de nmeros primos menores que N.

"On the Number of Prime Numbers Less Than a Given Quantity." Bernhard Riemann, 1859
6

"There are some mysteries that the human mind will never penetrate. To convince ourselves we have only to cast a glance at tables of primes and we should perceive that there reigns neither order nor rule Leonhard Euler

Si dividimos N sobre (N)

Como interpretamos esta tabla?

Podemos decir que N/(N) se parece a log(N), y entre ms grande es N mas se aproximan entre si estas dos funciones.
8

THE PRIME NUMBER THEOREM

Carl Friedrich Gauss (1777 to 1855) Adrien-Marie Legendre

THE PRIME NUMBER THEOREM (versin mejorada)

Definimos Li(x) =

10

Version Mejorada

11

Patrn

12

Teorema Fundamental de la Aritmtica

Todo numero natural mayor que uno se puede descomponer como un producto de factores primos de forma nica. Ejemplos:
24 = 2 x 2 x 2 x 3 = 23 x 3 180 = 2 x 2 x 3 x 3 x 5 = 22 x 32 x 5 941 = 941

13

Prueba
Euclides Gauss
Por contradiccin: Suponemos que es falsa la afirmacin del teorema, esto es, existen enteros que no pueden descomponerse como producto de primos, sea n el ms pequeo de estos y analicemos: - n no puede ser primo, su factorizacin estara dada por l mismo y el teorema se cumple. - Si n no es primo tiene una factorizacin en no primos, digamos n = a b, pero a y b son obviamente ms pequeos que n, por lo que tienen una factorizacin en numeros primos, esto implica que n tiene una factorizacin en numeros primos.

14

Ladrillos para construir una teora

Los primos son los ladrillos con los que se construyen los nmeros enteros. Son los tomos de la aritmtica Cada ciencia/materia tiene sus propios ladrillos
Qumica (Tabla peridica) Fsica (Partculas elementales) Biologa (DNA, genes) Msica (Notas) Literatura (Palabras) Pintura (Colores)
15

Como los utilizamos

Conocer la factorizacin prima permite conocer todos los divisores de un nmero.
100 = 22 x 52 2 x 2 = 4 divisores 756 = 22 x 33 x 7 2 x 3 x 1 = 6 divisores

Podemos conocer fcilmente el mximo comn divisor y el mnimo comn mltiplo.

mcm (100, 756) = 22

16

Tipos de nmeros primos

Palindomes:

2 30203 133020331 1713302033171 12171330203317121 151217133020331712151 1815121713302033171215181 16181512171330203317121518161 331618151217133020331712151816133 9333161815121713302033171215181613339 11933316181512171330203317121518161333911

Gaussiano: No tiene factores ni en el campo complejo.

17 = (4 + i)(4 - i) = 16 + 1 (no gaussiano)

Titanic prime: aquel que tiene ms de mil digitos, en 1984 solo se conocian 110 titanic primes. Gigantic: ms de 10,000 digitos. Twin primes: Aquellos que estan separados por 2, ejemplo:
(17,19) (8627,8629) (521,523)
17

Mersenne primes
Son del tipo 2p 1 Marin Mersenne (1588-1648), monje frances que estableci que 2n 1 es un nmero primo para n
n = 2, 3, 5, 7, 13, 17, 19, 31, 67, 127 y 257

Sin embargo deja sin verificar sus resultados, de eso se encargaron unos siglos despues Euler con el 31, Lucas con el 127, Pervouchine el 61, que Mersenne no habia considerado, asi como el 89 y el 107, estos ultimos verificados por Powers, asi, para 1947 la lista para n menor o igual a 256 estaba completa:
n = 2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107 y 127.
18

Los primeros
M521 A las 10:00 P.M. del 30 Enero de 1952, con la M607 U.S. National Bureau of Standards Western Automatic Computer (SWAC) en el Institute M1279 for Numerical Analysis en la University of California, Los Angeles M2203 M2281 M4253 (titanic) M44497 (gigantic) M6972593 (megaprime, mas de 1 millon de digitos)
19

El ms grande
El 4 de septiembre de 2006 el Dr. Curtis Cooper y Dr. Steven Boone's en la CMSU descubren el primo Mersenne #44

32,582,657 2 -1
Este nmero tiene 9,808,358 digitos y es 650,000 digitos ms grande que el previo record encontrado en diciembre de 2005. Sin embargo se quedaron cortos respecto de los 10 millones de digitos que se requieren para recibir el premio de 100,000 dolares otorgado por la Electronic Frontier Fundation. El nuevo primo fue verificado en 6 dias utilizando 16 procesadores Itanium de 21.5 GHz.
20

Electronic Frontier Fundation

2001

$50,000 to the first individual or group who discovers a prime number with at least 1,000,000 decimal digits (awarded Apr. 6, 2000) $100,000 to the first individual or group who discovers a prime number with at least 10,000,000 decimal digits $150,000 to the first individual or group who discovers a prime number with at least 100,000,000 decimal digits $250,000 to the first individual or group who discovers a prime number with at least 1,000,000,000 decimal digits
21

Aplicaciones y hechos curiosos

22

En la naturaleza
Ciclo de vida de la Cigarra

23

PrimeTimeClock
El unico reloj que marca la hora correcta1769 veces al da

Despliega la hora (Horas:Minutos:Segundos) SOLO si es un number primo

Empezando por 00:00:02 Y terminando en 23:59:51

Con un promedio de tres primos por minuto

24

Comunicacin inteligente

25

 Son numeros primos que representan informacin que es prohibido posser o distribuir, ya que interpretada de cierta manera describe algun programa que viola las leyes de derechos de autor. Escrito en hexadecimal, este nmero primo representa un un codigo fuente de C, comprimido, que se usa para desencriptacion de DVD y evitar copias piratas de los mismos.

Primos Ilegales
4856507896573978293098418946942861377074420873513579240196520736 6869851340104723744696879743992611751097377770102744752804905883 1384037549709987909653955227011712157025974666993240226834596619 6060348517424977358468518855674570257125474999648219418465571008 4119086259716947970799152004866709975923596061320725973797993618 8606316914473588300245336972781813914797955513399949394882899846 9178361001825978901031601961835034344895687053845208538045842415 6548248893338047475871128339598968522325446084089711197712769412 0795862440547161321005006459820176961771809478113622002723448272 2493232595472346880029277764979061481298404283457201463489685471 6908235473783566197218622496943162271666393905543024156473292485 5248991225739466548627140482117138124388217717602984125524464744 5055834628144883356319027253195904392838737640739168912579240550 1562088978716337599910788708490815909754801928576845198859630532 3823490558092032999603234471140776019847163531161713078576084862 2363702835701049612595681846785965333100770179916146744725492728 3348691600064758591746278121269007351830924153010630289329566584 3662000800476778967984382090797619859493646309380586336721469695 9750279687712057249966669805614533820741203159337703099491527469 1835659376210222006812679827344576093802030447912277498091795593 8387121000588766689258448700470772552497060444652127130404321182 610103591186476662963858495087448497373476861420880529443
26

Estrella mgica

167

167

167

167

167

167

27

CRIPTOLOGIA
Comuinicacin segura
Cripografia
Tecnicas para encriptar mensajes

Criptoanalisis
Tecnicas para desifrar mensajes encriptados
ENIGMA

28

CRIPTOGRAFIA
Clave privada
Sustitucin monoalfabtica Sustitucin polialfabtica

Clave pblica
RSA (utiliza numeros primos muy grandes)

29

CRIPTOANALISIS
Clave privada
Frecuencias Indice de coincidencias

Clave pblica Factorizacion de numeros primos

30

Encontrando Nmeros Primos

31

Criba de Eratstenes

- Astrnomo, matemtico, poeta, gegrafo y filsofo. -Su mayor reconocimiento se debe a que calcul el dimetro de la Tierra. -Encargado de la biblioteca de Alejandra hasta su muerte.

32

Implementacion
int main() { clock_t ti; NUM = 100000000; ti=clock(); arreglo=(char*)calloc(NUM,sizeof(char)); buscador(); for(i=0;i<NUM;i++) { if(arreglo[i]=='1') contador++; } printf("\nTotal de numeros primos encontrados: %d\n",contador); printf("Tiempo: %f\n", (clock()-ti)/(double)CLOCKS_PER_SEC); return 0; } void buscador() { int i,j; double n=sqrt(NUM); arreglo[0]='0'; arreglo[1]='0'; for(i=2;i<=NUM;i++) arreglo[i]='1'; for(i=2;i<n;i++) { if(arreglo[i]=='1') { for(j=2;j<=floor(NUM/i);j++) arreglo[j*i]='0'; } } }
33

for principal
for( i = 2; i < n; i++) { if( arreglo[ i ] == '1' ) { for( j = 2; j <= floor ( NUM / i ); j++) arreglo[ j * i ] = '0'; } }
0 0 0 1 0 2 1 3 1 4 1 5 1 6 1 7 1 8 1 9 1 10 1 11 1 12 1 13 1 14 1 15 1 16 1 17 1 18 1 19 1 20 1 21 1 22 1 23 1 24 1 25 1

34

for principal
for( i = 2; i < n; i++) { if( arreglo[ i ] == '1' ) { for( j = 2; j <= floor ( NUM / i ); j++) arreglo[ j * i ] = '0'; } }
0 1 0 1 0

2
1

3 1

5 1

7 1

9 1

10

11 1

12

13 1

14

15 1

16

17 1

18

19 1

20

21 1

22

23 1

24

25 1

35

for principal
for( i = 2; i < n; i++) { if( arreglo[ i ] == '1' ) { for( j = 2; j <= floor ( NUM / i ); j++) arreglo[ j * i ] = '0'; } }
0 2 0 1 0

2
1

3
1

4 0

5 1

7 1

8 0

10 0

11 1

12

13 1

14 0

15

16 0

17 1

18

19 1

20 0

21

22 0

23 1

24

25 1

36

for principal
for( i = 2; i < n; i++) { if( arreglo[ i ] == '1' ) { for( j = 2; j <= floor ( NUM / i ); j++) arreglo[ j * i ] = '0'; } }
0 3 0 1 0

2
1

3
1

4 0

5
1

6 0

7 1

8 0

9 0

10

11 1

12 0

13 1

14 0

15

16 0

17 1

18 0

19 1

20

21 0

22 0

23 1

24 0

25

0 37

for principal
for( i = 2; i < n; i++) { if( arreglo[ i ] == '1' ) { for( j = 2; j <= floor ( NUM / i ); j++) arreglo[ j * i ] = '0'; } }
0 0 1 0

2
1

3
1

4 0

5
1

6 0

7
1

8 0

9 0

10 0

11
1

12 0

13
1

14 0

15 0

16 0

17
1

18 0

19
1

20 0

21 0

22 0

23
1

24 0

25 0

38

Notemos
Si queremos encontrar los primos hasta N, basta con calcular los que hay hasta raz de N y eliminar sus mltiplos para obtener todos los primos hasta N.
39

MI Algoritmo
Dado un numero N, calcular todos los nmeros primos menor que N 1. Calcular raz de N [ n sqrt(N) ] 2. Utilizar el algoritmo de Eratstenes para encontrar los nmeros primos hasta n 3. Eliminar los mltiplos de los primos encontrados, desde n+1 hasta N

40

Implementacin secuencial
Inicializacion del arreglo for(i=2;i<NUM;i++) P[i]=1; P[0]=0; P[1]=0; Se encuentran todos los numeros primos hasta raiz del numero original for(i=2;i<n;i++) if(P[i]==1) for(j=2;j<=num/i;j++) P[j*i]=0; Contamos cuantos primos se encontraron hasta raiz de NUM for(i=2;i<num;i++) if(P[i]==1) contador++; Se crea un arreglo que contendra los numeros Primos Encontrados hasta raiz de NUM Ptemp=(int*)calloc(contador,sizeof(int)); j=0; for(i=2;i<num;i++) if(P[i]==1){ { Ptemp[j]=i; j++; } Se marcan los numeros no primos en la parte que resta del arreglo for(j = 0; j < contador; j++){ if((num + 1) % Ptemp[j] == 0) aux = (num + 1) / Ptemp[j]; else aux = ((num + 1) / Ptemp[j]) + 1; for(i = aux; i <= NUM / Ptemp[j]; i++) P[Ptemp[j] * i] = 0; } Se cuentan los primos encontrados y se imprimen los resultados contador = 0; for(i = 0; i < NUM; i++) if(P[i] == 1) { contador++; printf("%d\t",i); ultimo = i } printf("\n%d\n",contador); printf(Primo mas grande %d,ultimo); printf("Tiempo : %f\n",(clock()-ti) / (double) CLOCKS_PER_SEC);
41

MI Algoritmo paralelo (Memoria Distribuida)

1. Cada procesador calcula raz de N [ n sqrt(N) ] 2. Cada procesador utiliza el algoritmo de Eratstenes para encontrar los nmeros primos hasta n 3. El resto del arreglo [n + 1 . . N] se divide entre el numero de procesadores, cada procesador calcula el inicio y fin de la parte del arreglo que le corresponde 4. Cada procesador elimina los mltiplos de los primos encontrados hasta n, del inicio al fin de la parte que le corresponde del arreglo. 5. El primer procesador verifica cuales primos encontr, los cuenta y le pasa el contador al siguiente procesador. 6. El ultimo procesador tiene el numero total de primos encontrados.
42

Funcionamiento
num
0 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 0 0 1

NUM
0 0 0 0

TODOS

PROC 2 PROC 1

PROC 3

PROC 4

PROC 5 PROC 6

PROC 7

PROC 8

-Todos los procesadores calculan los primos hasta num = raz de NUM -El resto del arreglo (NUM - num) se divide entre el numero de procesadores -El primer procesador (id = 0) toma el residuo si es que la divisin del trabajo no es exacta -Cada procesador marca con 0 los multiplos de los primos entre 2 y num -Al terminar de marcar los mltiplos, cada procesador cuenta elementos que quedaron sin marcar (1) y pasa el contador al siguiente procesador. -Por ultimo, el ultimo procesador tiene el total de nmeros primos encontrados.
43

Implementacin
Inicializacin del arreglo con que se va a trabajar for(i=2;i<NUM;i++) P[i]=1; P[0]=0; P[1]=0; Se encuentran todos los nmeros primos hasta raiz de NUM for(i=2;i<n;i++) if(P[i]==1) for(j=2;j<=num/i;j++) P[j*i]=0; Contamos cuantos primos se encontraron hasta raiz de NUM for(i=2;i<num;i++) if(P[i]==1) contador++; Se crea un arreglo que contendr los nmeros primos encontrados hasta raz de el numero original Ptemp=(int*)calloc(contador,sizeof(int)); j=0; for(i=2;i<num;i++) if(P[i]==1) { Ptemp[j]=i; j++; } 44

Se divide el trabajo y cada procesador calcula el inicio y fin de la parte del arreglo que le toca
num
0 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 0 0 1

NUM
0 0 0

TODOS

PROC1 PROC 2 chunk _size PROC 3 PROC 4 PROC 5 PROC 6 PROC 7 PROC 8

new_size
all_start

Cada procesador elimina los multiplos de los numeros primos que encontro hasta raiz de NUM
for(j = 0; j < contador; j++)
{

//for(i = ceil(my_start / Ptemp[j]); i <= floor(my_end / Ptemp[j]); i++)

for(i = aux; i <= my_end / Ptemp[j]; i++)

P[Ptemp[j] * i]=0;
}
45

Cada procesador cuenta los primos que encontr y se imprimen los resultados if(my_id == 0) { Imprime los nmeros primos que encontro, los cuenta y envia el contador al procesador con identificador 1, solo si hay mas de un procesador. MPI_Send(&contador, 1, MPI_INT, 1, tag, MPI_COMM_WORLD); } else { MPI_Recv(&contador, 1, MPI_INT, my_id - 1, tag, MPI_COMM_WORLD, &Stat); Recibe el contador del procesador con identificador uno meor al propio, imprime los numeros primos que encontro, cuenta cuntos fueron y lo suma al contador, enva el contador al procesador con identofocador uno ms que el propio, solo si no es el ltimo procesador. MPI_Send(&contador, 1, MPI_INT, my_id + 1, tag, MPI_COMM_WORLD); } El ultimo procesador imprime la cantidad de primos encontrados y el tiempo de ejecucin
46

RESULTADOS
- Los experimentos se ejecutaron para NUM = 100 millones

- Se encuentran 5,761,455 (50847534)primos

- El primo mas grande encontrado fue: 99,999,989 (999,999,937)
47

Terico
El Prime Number Theorem nos estima (100000000) ~ 100000000 = 5,428,681 log(100000000) Diferencia: 332744

Y la versin mejorada (100000000) ~

100000000

= 5,762,208
Diferencia: 753
48

TIEMPOS PROMEDIO
SEC 1 PROC 2 PROC 3 PROC 4 PROC 5 PROC 6 PROC 7 PROC 8 PROC

74.843

75.046

36.702

27.891

23.614

20.99

18.672

17.974

16.754

Tiempo promedio (20 ejecuciones)

80 70 60 50 40

30
20 10 0 1 2 3 4 5 6 7 8

Procesadores

49

Speed Up
Absoluto: Cuantas veces es mas rpido un programa paralelo respecto del secuencial utilizando p procesadores. Relativo: Cuantas veces es mas rpido un programa paralelo con p procesadores respecto del mismo programa ejecutado con un procesador.

50

Speed Up Absoluto
1 PROC 2 PROC 3 PROC 4 PROC 5 PROC 6 PROC 7 PROC 8 PROC

0.997295 2.039208

2.68341 3.169433

3.56565 4.008301 4.163959 4.467172

Speedup absoluto

5 4.5 4 3.5 3 2.5 2 1.5 1 0.5 0 1 2 3 4 Procesadores 5 6 7 8

51

Speed Up Relativo
2 PROC 3 PROC 4 PROC 5 PROC 6 PROC 7 PROC 8 PROC

2.044739

2.690689

3.17803

3.575322

4.019173

4.175253

4.479289

Speedup Relativo

5 4.5 4 3.5 3 2.5 2 1.5 1 0.5 0 1 2 3 4 Procesadores 5 6 7 8

52

Ley de Amdahl
La fraccin paralela de un programa nunca ser el 100%. pf + sf = 1

Speed up esperado

53

Spped up esperado (3 procs)

54

Speed Up Esperado
2 PROC 3 PROC 4 PROC 5 PROC 6 PROC 7 PROC 8 PROC

1.88859

2.68341

3.398555

4.04543

4.63338

5.17009

5.66198

Speedup esperado

6 5 4

3
2

1
0 1 2 3 4 Procesadores 5 6 7 8

55

Speedups
Speedup's
Esperado Absoluto 6 5 4 3 2 1 0 1 2 3 4 Procesadores 5 6 7 8

Relativo

56

 Speed up por procesador

Eficiencia

Costo
Total de recursos utilizados.

57

Eficiencia
1 PROC 2 PROC 3 PROC 4 PROC 5 PROC 6 PROC 7 PROC 8 PROC

0.997295 1.019604

0.89447 0.792358

0.71313

0.66805 0.594851 0.558397

Eficiencia

1.2

0.8

0.6

0.4

0.2

0 1 2 3 4 Procesadores 5 6 7 8

58

Costo
1 PROC 2 PROC 3 PROC 4 PROC 5 PROC 6 PROC 7 PROC 8 PROC

75.046

73.404

83.673

94.456
Costo

104.95

112.032

125.818

134.032

160 140 120 100 80 60 40 20 0 1 2 3 4 Procesadores 5 6 7 8

59

Gracias por su atencin!

60

Referencias

Prime Obsession, John Derbyshire, 2003, National Academy of Sciences. http://www.mersenne.org/ http://www.wikipedia.com http://everything2.net/ http://primes.utm.edu/mersenne/ http://w2.eff.org/awards/coop.php http://www.primetimeclock.com/ http://primes.utm.edu/howmany.shtml http://mac6.ma.psu.edu/primes/prime_count/pix.html

61