Sei sulla pagina 1di 9

1

Fattorizzazione RSA e congettura di Goldbach


Vincenzo Cerreto, Rosario Turco



Introduzione
La congettura di Goldbach un classico della Teoria dei Numeri
che rientra nei problemi additivi; altrettanto classica la
procedura per fattorizzare un numero composto.

Essi, come problemi classici, hanno un vasto pubblico che li
comprende e che si dedica ad un possibile sviluppo di
dimostrazione.

Nel caso della fattorizzazione, poi, il legame con la crittografia
e lalgoritmo RSA, rende il problema anche di pratica utilit.

Larticolo mette in evidenza come i due problemi siano legati, ed
individua sia un metodo di fattorizzazione di un numero semiprimo
o RSA (N = p * q), sia un metodo grafico di fattorizzazione.


Goldbach e la simmetria
Nella formulazione pi semplice, la congettura di Goldbach afferma
che: Tutti i numeri pari maggiori di 2 possono essere espressi
come somma di due numeri primi p e q, (p + q) = s > 2, dove p pu
anche essere uguale a q.

"Il problema che i numeri primi sono definiti mediante
moltiplicazione, mentre il problema riguarda l'addizione. In
generale difficile stabilire connessioni tra le propriet de1la
moltiplicazione e dell'addizione dei numeri interi." [1]

La domanda da porsi diventa: "Quando che (p * q) = (p + q), dove
p e q sono numeri primi?"

Per far s che l'uguaglianza sia verificata, in qualche modo,
bisogna trovare il "ponte", ovvero la relazione di trasformazione
che unisce il prodotto di due numeri primi con la loro somma.

Lidea nasce usando il concetto di simmetria tra i due numeri primi
p ed q:

2

(1)
2
(2)
2
(3)
2 2
(4)
2 2
(5)
2 2
(6)
2
(7)
(8)
( )
,
2
2* *
2* *
2
2
2* *
4
4 2
2*
4
2
* 2
2
( )
p+q
q p
d p q
p q d p q
q p
p q p q
q p pq
p q p q
pq q p pq
p q
pq q p p q
p q p q
p q

= <
+ = +
| |
+ = +
|
\ .
| | +
+ = +
|
\ .
+ +
= +
+ + = +
+ = +
= +


Partendo dalle (1)(2) si arriva alla (8). Anche partendo dalla (8)
si arriva alla (2) ammettendo la (1). La (2) valida anche se p
= q, in tal caso d=0.

Se N primo, allora uno dei fattori vale 1.

Metodo algebrico di fattorizzazione
La (2) si presta a trovare la fattorizzazione di un numero semiprimo
N = p*q.

Nella (2) il termine noto proprio N=p*q.

Con un algoritmo basta iterativamente aumentare il termine d, di
un valore intero a partire da 0, ed il risultato deve essere
obbligatoriamente un intero pari (per Goldbach).

Il primo valore intero trovato sicuramente la soluzione.

Trovato d, sappiamo che per q > p :

S = p + q
2 d = q - p

Quindi :

p = S/2 d
q = S - p


3

In conclusione sapendo N=p*q e ricavandoci d, troviamo poi p e q.

Il vero problema algoritmico di individuare rapidamente d.

In APPENDICE un semplice algoritmo in PARI/GP, che si basa sulla
(2).

Metodo grafico di fattorizzazione
Il metodo grafico una curiosit che riportiamo, anche perch per
numeri elevati scomodo da usare.

Per la fattorizzazione si utilizza una semplice variazione della
(2), cio:

2
(9)
2
(10)
*
*
p q d d
p q d d
+ +
+


In tal caso si pone:

y = sqrt(pq+x^2) + x
y = sqrt(pq+x^2) - x


Se si eseguono i grafici delle (9)(10) le curve si devono incrociare
obbligatoriamente, per la natura del problema, a delle coordinate
intere, che si possono individuare a colpo docchio sulle singole
curve (vedi il cerchio rosso degli esempi grafici successivi).

Ad esempio per N=33 le curve si incrociano a coordinate(4, 11) e
(4, 3), dove d=4 ed q=11 e p=3 sono i fattori di N=33=3*11.

In questo caso d determinato graficamente.

La non praticit del metodo che i programmi che tracciano i
grafici di funzioni, per numeri abbastanza grandi a causa
dellapprossimazione, danno le coordinate in notazione
scientifica (es: 1,1 E-234) e diventa di difficile
interpretazione.

Un analogo problema risiede nel calcolo numerico e mostreremo un
algoritmo in APPENDICE che cerca di superare tale difficolt.

Nel seguito le immagini della fattorizzazione grafica con Derive
del numero composto N=33.

4



Grafico di y = sqrt(pq+x^2) + x


Grafico di y = sqrt(pq+x^2) - x

Calcolo numerico
Per risolvere il problema in PARI/GP che, per grandi numeri, alcune
funzionalit di libreria operano in notazione scientifica
provocando la perdita di precisione, lalgoritmo implementa la
funzionalit di radice quadrata col metodo di Newton-Raphson, ma
con una precisione decidibile in automatico.

Un esempio duso della procedura :

getFactRSA(33)
getFactRSA(219)
getFactRSA(3064021)


5


La velocit dellalgoritmo dipende, da vari fattori:
- dalla precisione del numero di punti di rilevazione sulla
curva dellalgoritmo di Newton-Raphson (npoint=50);
- dalla precisione per evitare il troncamento delle cifre nella
valutazione della radice quadrata (realprecision);
- dalla velocit con cui si individua il valore di d (cercato
iterativamente).



Se N = N * 1 N numero primo
d=0 d=1 d>1
Quadrato di un numero
primo
Primi gemelli Primi di Polignac


In tabella si riassume che se d=0 vuol dire che si tratta di un
quadrato di un numero primo. Se d=1 abbiamo a che fare con numeri
primi gemelli, per d>1 abbiamo i cosiddetti numeri primi di
Polignac; difatti sempre:

q = p + 2*d

Per la definizione del problema che q > p, non possibile d<0.

Come si pu osservare dal paragrafo delle verifiche, il valore di
d non dipende dalla grandezza del numero da fattorizzare, ma la
semi-distanza tra i numeri primi in gioco; per cui anche un numero
piccolo potrebbe avere un valore di d relativamente grande.

Un possibile miglioramento algoritmico si pu ottenere adottando
il parallelismo su un multi-processore o su pi macchine con una
versione di algoritmo che valuta intervalli di valori di d diversi
o meglio partizionando gli intervalli di scansione di d che si
intendono valutare. Vedi in APPENDICE getPFRSA(n,start,end)
Riferimenti
[1] Cosa la matematica Robbins-Courant ed. Boringhieri


6

APPENDICE


Algoritmo fattorizzazione RSA in PARI/GP

/*
** Prec la precisione che serve, per evitare i troncamenti.
** Prec viene automaticamente calcolata in modo che sia
** superiore di 500 volte il numero di cifre di n.
*/

{getFactRSA(n, npoint=50) = local (S=1.1, d=-1, q=1, p=1);

if( n<4 , error("getFactRSA(n): You must insert an integer
n>3"););

cifre = ceil(log(n)/log(10));
prec = cifre + 500;
default(realprecision, prec);


while( S%2 != 0 & floor(S) != ceil(S),
d = d + 1;
S = 2*mysqrt(1.05,n+d^2,npoint);
if( frac(S) < 10^(-30), S=floor(S););

);
p = S/2 - d;
q = S - p;

default(realprecision, cifre+1);

print("d = ", d);
print("factor q: ",q);
print("factor p: ",p);

}
/*
Radice quadrata col metodo di Newton-Raphson
*/

f(x,N)=local(); {
o=x^2-N;
return(o);
}

f1(x)=local(); {
o=2*x;
7

return(o);
}

mysqrt(x0, N, c=10) = local(i=0); {

x = x0;

if( c > 1,

for(i=2,c,
a = f(x,N)/f1(x);
x = x - a;
);
);
return(x);
}
8


/*
** Su un multi-processore possibile mandare pi sessioni
** in parallelo per diversi valori di d, impostando start ed end
** diversi sulle sessioni
**
** es: getPFRSA(13*11,1,10^6)
**
*/

{getPFRSA(n,start=-1, end=start+10^1000, npoint=50) = local
(S=1.1, d=-1, q=1, p=1);

if( n<4 , error("getPFRSA(n): You must insert an integer n>3"););

cifre = ceil(log(n)/log(10));
prec = cifre + 500;
default(realprecision, prec);

if(start!=-1, d=start-1; );

while( S%2 != 0 & floor(S) != ceil(S) & d <= end,
d = d + 1;
S = 2*mysqrt(1.05,n+d^2,npoint);
if( frac(S) < 10^(-30), S=floor(S););

);
p = S/2 - d;
q = S - p;

default(realprecision, cifre+1);

print("d = ", d);

if( floor(q) == ceil(q) & floor(p) == ceil(p),
print("factor q: ",q);
print("factor p: ",p);
);


if( floor(q) != ceil(q) & floor(p) != ceil(p),
print("d value stopped in the partitioning ... \n");
print("S = ", S);
print("floor S: ",floor(S));
print("ceil S: ",ceil(S));
print("frac S: ",frac(S));
);


}
9

Verifiche numeriche

N d q p Num proc Tempo (ms)
211(*) 105 211 1 1 47
211(*) 105 211 1 4 15
213 34 71 3 1 62
213 34 71 3 4 0
219 35 73 3 1 47
29929(**) 0 173 173 1 0
1052651 5 1031 1021 1 0
11104901 4870 10771 1031 1 3,541
11104901 4870 10771 1031 4 1,731
384837059 12479 35729 10771 1 9,282
(*) 211 un numero primo
(**) 29929 il quadrato di un numero primo