Fattorizzazione primalità

Fattorizzare i numeri interi

(di Cristiano Armellini, [email protected])

Ci sono molti algoritmi efficienti per fattorizzare numeri interi e molti sono i testi dove è

possibile trovare una completa trattazione sull'argomento, Qui vogliamo proporre dei sistemi

(in parte abbastanza originali e forse relativamente veloci ma senza nessuna pretesa da parte

nostra) per cercare di trovare i fattori di un numero intero con metodi algebrici e facilmente

implementabili in un moderno calcolatore. L'idea è comunque quella di trovare dei limiti entro

cui cercare con maggiori probabilità le soluzioni. Nella ricerca delle soluzioni prendiamo

principalmente in esame solo valori interi positivi benché in linea di principio potremmo

considerare anche i negativi dal momento che 9 = 3*3 = (-3)*(-3). Facendo girare tutti gli

algoritmi in parallelo aumenta la probabilità di trovare soluzioni in tempi rapidi. Ogni algoritmo

sarà implementato con una applicazione scritta in C/C++ o in PARI/Gp per la gestione dei

grandi numeri

Considerazione preliminare (algoritmo 0)

Dato un numero p da fattorizzare di n cifre è facile provare che almeno un fattore deve essere

dell'ordine di

1

W =10int (n

2 )−1

cioè deve avere almeno int(n/2) cifre con int(x) la parte la funzione parte

intera di x. Questa considerazione parte dal fatto che se un fattore in un problema tipo RSA

fosse troppo piccolo sarebbe fin troppo facile individuarlo con metodi banali di ricerca per

tentativi.

Se p = ab con a, b numeri primi allora entrambi i fattori sono entrambi maggiori di W cioè tali

per cui

a > W, b > W cioè S= a+b > W. In questo particolare caso possiamo porre anche

W =10int (n

2 )

Considerare W ci è particolarmente utile quando trattiamo di grandi dimensioni

perché come vedremo meglio con gli altri algoritmi ci può aiutare a trovare dei limiti per i

fattori da ricercare.

LISTATO IN C++

#include <stdio.h>#include <math.h>#include <iostream.h>

int main(int argc, char *argv[]){long double x, p;long i = 0;int cifre;cout << "inserisci il numero di cifre del numero intero";cin >> cifre;cout <<" inserisci il numero da fattorizzare";cin >> p;x = pow(10, int(cifre/2)-1 );do{

2

x = x + 1;i = i + 1;} while(int(p/x) != (p/x));cout << "un fattore e' " << x;cout <<" passi di elaborazione: " << i;cin >> "---------";return 0;}

LISTATO IN PARI/GP

{ algo2(cifre) = local(x, p);

p = nextprime(10^10)*nextprime(10^12);

x = 10^(floor(cifre/2)-1);

while(floor(p/x) != (p/x), x=x+1);

print(x);

print("-----");

print(p/x);

return (1);}

3

Primo algoritmo (AL-1) (variante della fattorizzazione alla Fermat)p=x1 x2

(in generale non è detto che ci siano solo due fattori come nell'RSA ma il

procedimento di fattorizzazione può essere ripetuto per ognuno dei due fattori trovati finché

non si arriva a fattori che hanno decomposizione banale cioè che sono primi).

x1>√ p ,x1<p2

x2<√ px1,2>0

x1ORx2>W

dove OR sta ad indicare che la relazione vale per una radice o per entrambe

tutti i numeri interi positivi (ove la ricerca può essere fatta in modo sequenziale

oppure random)

Attenzione: per P molto grande A(p) cioè il numero dei primi minori di P è

approssimativamente p/log(p)

LISTATI IN C++ E IN VISUAL BASIC .NET

Nei codici sorgenti in C++ che seguono ho usato l'espressione 'int(p/x)' per

semplicità tuttavia sarebbe meglio sostituirla con la più esatta sintatticamente

floor(fabs(p/x)).

#include <stdio.h>#include <iostream.h>

4

#include <math.h>

int main(int argc, char *argv[]){ long double x, p; long i, j; j = 0; cout << "inserisci il numero da fattorizzare "; cin >> p; for( i = int(sqrt(p)); i <= int(p/2); i++) { j = j +1; if(int(p/i) == (p/i)) { cout << "fattore: " <> "-----------------"

return 0;}

lo stesso algoritmo può essere implementato in Visual Basic .Net usando per la ricerca

dei fattori un generatore di numeri casuali: la ricerca si rileva molto più veloce:

Module Module1

Sub Main() Dim p As Decimal Dim generator As New Random Dim a As Decimal Dim i As Integer i = 0 Console.WriteLine("inserisci il numero da fattorizzare") p = Console.ReadLine() Do a = generator.Next(2, Int(Math.Sqrt(p))) i = i + 1 Loop While ((p / a) <> Int(p / a)) Console.Write("fattore: ") Console.Write(a) Console.Write("passi: ") Console.Write(i) Console.ReadLine() End Sub

End Module

5

LISTATI IN PARI/GP

{fermat(p) = local(x);x = floor(sqrt(p));while (floor(p/x) != (p/x), x--);print(x); print("----"); print(p/x);return (1);}

{fermat2(p) = local(a, x, y);a = floor(sqrt(p));x = random(a);y = precprime(x);while (floor(p/y) != (p/y), x = random(a);y = precprime(x)); print(y); print("----"); print(p/y);return (1);}

{fermat3(p) = local(a, x, y);a = floor(sqrt(p));x = random(a);while (floor(p/x) != (p/x), x = random(a)); print(x); print("----");print(p/x);return (1);}

{fattore2(p) =local(s, x);s = truncate(sqrt(p));x = precprime(s);while (truncate(p/x) != (p/x),s--;x = precprime(s));print(x);return (1);}

{fattore3(p)= local(s, x);

6

s=0;x = nextprime(s);while (truncate(p/x) != (p/x),s++;x = nextprime(s));print(x);return (1);}

{fattore4(p)= local(s, x);s=truncate(p/2);x = precprime(s);while (truncate(p/x) != (p/x),s--;x = precprime(s));print(x);return (1);}

{fattore5(p)= local(s, x);s=truncate(p/2);x = nextprime(s);while (truncate(p/x) != (p/x),s++;x = nextprime(s));print(x);return (1);}

Secondo algoritmo (Al-2)

Dalla nota relazione

x2−sx+ p=0

s= x1+ x2

p=x1 x2

7

x1,2=s±√s2−4 p

2

s>2√ p , s<−2√ p

Supponiamo di stare a considerare un tipico problema RSA quindi p ha solo due fattori ed s è

sicuramente un numero pari essendo la somma di due primi quindi di due numeri dispari.

Questo algoritmo è particolarmente veloce quando x1 , x2 10n/2 dove p 10n ma è comunque

molto oneroso quando le radici differiscono per almeno 3-4 cifre e perché comunque fa uso

delle radici quadrate che sono complesse da calcolare per valori elevati.

Cerchiamo di velocizzare la ricerca dei fattori usando l’elemento W precedentemente

descritto.

x1=s−√s2−4 p

2>W

mi porta a dover risolvere il seguente sistema:

s>2√ p oppure s<−2√ p

s<W 2+ pW

,s−2W >0

x2=s+√s2−4 p

2>W

mi porta a dover risolvere il seguente sistema:

8

2W−s<0s2−4 p>0

unito alle soluzioni del sistema

s2−4 p>02W−s>0

s>W 2+ pW

Osservazione

1)

s2−4 p>0

equivale alla ben nota relazione

( x+ y2 )

2

>xy

2) se

d= s2

allora

x1,2=d±√d2−p

(più avanti approfondiremo questo caso)

3)

x+ y< xyk

, xy=p

porta a

x2 k+ pk−pxxk

<0

ovvero

k< px

x2+ p

dove pi può supporre

k≈10int( n

2)

con n il numero delle cifre di P. Trovare

k=int ( px

x2+ p)

ci aiuta a calcolare una

stima superiore per s = x+y per aumentare anche grazie al punto 1) la ricerca delle soluzioni.

LISTATO IN C++

#include <stdio.h>#include <math.h>#include <iostream.h>int main(int argc, char *argv[]){ long double p, x, y, s;

9

long i; cout << "inserisci il numero da fattorizzare "; cin >> p; s = 2* int(sqrt(p)); i = 0; do { x = (s + sqrt(pow(s,2)-4*p))/2; y = (s - sqrt(pow(s,2)-4*p))/2; s = s+1; i = i+1; }while((int(p/x) != (p/x)) || (int(p/y) != (p/y))) ; // si può mettere && (and) al posto di || (OR) ma una delle due cout << "un fattore e' " << x << "\n"; //soluzioni trovate potrebbe non essere intera cout << "un fattore e' " << y << "\n"; cout << "passi: " << i; cin >> "--------------------"; return 0;}

LISTATI IN PARI/GP

{fatto(p) =local(s, x);s = 2 * truncate(sqrt(p));x = (s - sqrt(abs(s^2-4*p)))/2;while (truncate(p/x) != (p/x), s++);print(x);return (1);}

{algo1(p) = local( s, d, x, y);s = 2 * floor(sqrt(p));d = sqrt(abs(s^2-4*p));x = (s + d)/2;y = (s - d)/2;while (floor(p/x) != (p/x) && floor(p/y) != (p/y),s++;d = sqrt(abs(s^2-4*p));x = (s + d)/2;y = (s - d)/2);print(x);print("----");print(y);return (1);}

10

{algo1(p) = local(s, d, x, y);s = floor(sqrt(p));d = sqrt(abs(s^2-p));x = (s + d);y = (s - d);while (floor(p/x) != (p/x) && floor(p/y) != (p/y),s = s+1;d = sqrt(abs(s^2-p));x = (s + d);y = (s - d));print(x);print("----");print(y);return (1);}

{algo2b(p) = local(b, d, x, y);b = floor(sqrt(p));d = sqrt(abs(b^2-p));x = b + d;y = b - d;while (floor(p/x) != (p/x) && floor(p/y) != (p/y),b++ ;d = sqrt(abs(b^2-p));x = b + d;y = b - d);print(x);print("----");print(y); return (1);}

VARIANTE

s2>4 p s2=4 p+a ,a>0 , p=xy a numero pari perché differenza di due numeri pari

Ciò porta all’equazione biquaratica

x4−x2 (a+2 p )+ p2=0

11

x1,2=√ a+2 p±√a2+4ap2

12

LISTATO IN C++

#include <stdio.h>#include <math.h>#include <iostream.h>int main(int argc, char *argv[]){ float a, x, y, p; long double i; cout << "inserisci il numero da fattorizzare "; cin >> p; a = 0; i = 0; do{ x = sqrt( (a+2*p+sqrt(pow(a,2)+4*a*p))/2); y = sqrt( (a+2*p-sqrt(pow(a,2)+4*a*p))/2); a = a+1; i = i+1; } while ((int(p/x) != (p/x)) || (int(p/y) != (p/y))) ; // si può mettere && (and) al posto di || (OR) ma una

cout << "fattore: " << x << "\n"; // delle due soluzioni trovate potrebbe non essere intera cout << "fattore: " << y << "\n"; cout << "passi: " <> " -----"; return 0;}

LISTATO IN PARI/GP

{algo3(p) = local(a, x, y, d);a = 0;d = sqrt(abs(a^2+4*a*p));x = sqrt(abs((a+2*p+d)/2));y = sqrt(abs((a+2*p-d)/2));while (floor(p/x) != (p/x) && floor(p/y) != (p/y),a++;d = sqrt(abs(a^2+4*a*p));x = sqrt(abs((a+2*p+d)/2));y = sqrt(abs((a+2*p-d)/2)));print(x);print("----");print(y); return (1);}

13

Terzo algoritmo (Al-3)

Dalle Osservazioni precedenti deduciamo che

( s2 )

2

−(m2 )

2

=p

dove m è intero

x2=s2−m

2

x1=s2+ m

2

allora

x12−mx1−p=0

,

x22+mx2−p=0

da cui si può partire direttamente da m per trovare le soluzioni

x1=m+√m2+4 p

2

x2=−m+√m2+4 p

2

con

m=±√s2−4 p,

s>m ,s>2√ p

(possiamo considerare anche le soluzioni negative di X1, X2 quelle con il segno - ovvero

14

x1=m−√m2+4 p

2

x2=−m−√m2+4 p

2

ma il ragionamento sarebbe identico a quello già

fatto)

Sempre nell’ipotesi di considerare un problema di fattorizzazione RSA usiamo il fattore W per

accelerare la ricerca delle soluzioni. Consideriamo per semplicità le soluzioni positive ma lo

stesso discorso vale per quelle negative

x=m+√m2+4 p

2>W

porta a risolvere il seguente sistema

m2+4 p>02W−m<0

unito alle soluzioni di

m−2W >0

m>W 2−pW

x =

−m+√m2+4 p2

>W

porta a dover risolvere il sistema

m2+4 p>02W +m>0

m< p−W 2

W

15

x=−m−√m2+4 p

2>W

allora

m<−2Wm2+4 p>0

m<W 2−pW

LISTATO IN C++

#include <stdio.h>#include <math.h>#include <iostream.h>int main(int argc, char *argv[]){ long double m, x, y, p; long i; cout << "inserisci il numero da fattorizzare "; cin >> p; m = 0; i = 0; do{ x = (m + sqrt(pow(m, 2) + 4*p))/2; y = (-m + sqrt(pow(m, 2) + 4*p))/2; m = m+1; i = i+1; } while ( (int(p/x) != (p/x)) || (int(p/y) != (p/y))); // si può mettere && (and) al posto di || (OR) ma una

cout << "fattore: " << x << "\n"; // delle due soluzioni trovate potrebbe non essere intera cout << "fattore: " << y << "\n"; cout << "passi: " <> " -----";

return 0;}

LISTATO IN PARI/GP

{algo4(p) = local(m, x, y);16

m= 0;d = sqrt(m^2+4*p);x = (m+d)/2;y = (-m+d)/2;while (floor(p/x) != (p/x) && floor(p/y) != (p/y),m++ ;d = sqrt(m^2+4*p);x = (m+d)/2;y = (-m+d)/2);print(x);print("----");print(y);return (1);}

Quarto algoritmo (Al-4)p=x1 x2=a2−b2=(a−b )(a+b )

x1=a−b , x2=a+b

x1−x2=−2b

x1+x2=2a

ciò porta a

x12+2bx1−p=0

,

x12−2ax1+ p=0

x1=a±√a2−p

,

x1=−b±√b2+ p

(possiamo considerare anche la soluzione negativa quella

con segno - , però poi occorre calcolare il suo valore assoluto)

17

Come nei casi precedenti

x=a+√a2−p>W porta a:

a2−p>0W −a<0 unito alle soluzioni di

a>√ p ,a<−√ pa−W <0

a>W 2+ pW

x=a−√a2−p>W porta al sistema di condizioni

a>√ p ,a<−√ pa>W

a<W 2+ pW

allora

b2+ p>0W +b<0 unito a

b2+ p>0W +b>0

b< p−W 2

2W

x=−b−√b2+ p>W ciò porta a:

b<−Wb2+ p>0

b> p−W 2

2W

Wpbbx 2

18

osservazione: se

p=x1 x2

è un problema RSA allora

x1+x2=2a

x1=2a−x2

quindi

x22−2ax2+ p=0

x2=a±√a2−p

con

a2> p

LISTATO IN C++

#include <stdio.h>#include <math.h>#include <iostream.h>int main(int argc, char *argv[]){long double x, y, p;long a;long i = 0;cout<< "inserisci il numero da fattorizzare ";cin >> p;a = int(sqrt(p));a = a+1;do {x = a + sqrt(pow(a,2) -p);y = a - sqrt(pow(a,2) - p);a = a+1;i = i+1;} while( (int(p/x)!=(p/x)) ||(int(p/y) != p/y)) ; // si può mettere && (and) al posto di || (OR) ma una delle duecout << "fattore: " << x << "\n"; // soluzioni trovate potrebbe non essere interacout << "fattore: " << y << "\n";cout << "passaggi: " << i;cin >> "-------------"; return 0;}

LISTATO IN PARI/GP

{algo5(p) = local(a, d, x, y);a = floor(sqrt(p));d = sqrt(abs(a^2-p));x = a+d;y = a-d;

19

while (floor(p/x) != (p/x) && floor(p/y) != (p/y),a = a+1 ;d = sqrt(abs(a^2-p));x = a+d;y = a-d);print(x);print(y); return (1);}

LISTATO IN C++

#include <stdio.h>#include <math.h>#include <iostream.h>int main(int argc, char *argv[]){long double x, p;long b;long i = 0;cout<< "inserisci il numero da fattorizzare ";cin >> p;b = int(sqrt(p));b = b+1;do {x = - b + sqrt(pow(b,2) + p);b = b+1;i = i+1;} while((int(p/x)!=(p/x)));cout << "fattore: " << x << "\n";cout << "fattore: " << y << "\n";cout << "passaggi: " << i;cin >> "-------------";return 0; }

LISTATO IN PARI/GP

{algo6(p) = local(s, x);b = floor(sqrt(p));x = -b + sqrt(abs(b^2 +p));while (floor(p/x) != (p/x),b++;x = (s + sqrt(abs(s^2-4*p)))/2);

20

print(x);print("----");print(p/x); return (1);}

Quinto algoritmo (Al-5)

Se

p=x1 x2 , x2=x1+a

allora sostituendo le variabili ottengo che

x12+x1a−p=0

quindi

x1=−a±√a2+4 p

2

Consideriamo la soluzione positiva come negli altri casi

x=−a+√a2+4 p

2>W

allora dobbiamo risolvere

a<−2Wa2+4 p>0

unione a

a>−2W

a< p−W 2

W

x=a+√a2+4 p

2>W

allora il sistema diventa:

21

2W−a>0a2+4 p>0

a>W 2−pW

analogamente si arriva agli stessi risultati nel caso opposto cioè che

x2=x1−a

abbiamo

che

x=a±√a2+4 p

2

.

Quindi

a2+4 p>02W−a<0

unito a

a2+4 p>02W−a<0

a>W 2−pW

Come negli altri casi si sarebbe potuto considerare per X1 e X2 anche le soluzioni negative ,

quello con segno - poi si sarebbe dovuto calcolare il loro valore assoluto

22

LISTATO IN C++

#include <stdio.h>#include <math.h>#include <iostream.h>int main(int argc, char *argv[]){long double x, y, p;long a;long i = 0;cout<< "inserisci il numero da fattorizzare ";cin >> p;a = 0;a = a+1;do {x = (-a+sqrt(pow(a,2)+4*p))/2;y = (a+sqrt(pow(a,2)+4*p))/2;a = a+1;i = i+1;} while( (int(p/x)!=(p/x)) ||(int(p/y) != p/y)) ; // si può mettere && (and) al posto di || (OR) ma una delle duecout << "fattore: " << x << "\n"; // soluzioni trovate potrebbe non essere interacout << "fattore: " << y << "\n";cout << "passaggi: " << i;cin >> "-------------";return 0;}

LISTATO IN PARI/GP

{algo7(p) = local(a, d, x, y);a = 0;d = sqrt(a^2+4*p);x = (-a + d)/2;y = (a + d)/2;while (floor(p/x) != (p/x) && floor(p/y) != (p/y),a = a+1;d = sqrt(a^2+4*p);x = (-a + d)/2;y = (a + d)/2);print(x);print("----");print(y);return (1);}

23

Sesto algoritmo (Al-6)

Partiamo da un ben nota relazione algebrica sempre vera:

x2+ y2

2>xy

quindi

x2+ y2=2 xy+2a

a > 0 y = p/x

arriviamo a

x4−2 x2( p+a )+ p2=0

quindi le soluzioni sono

x1,2=√ p+a±√a2+2 pa

dove

però per evitare errori di calcolo sostituiamo ad a a/2 per effetto della disuguaglianza di

partenza

LISTATO C++

#include <stdio.h>#include <math.h>#include <iostream.h>

int main(int argc, char *argv[]){long double x, y, p;long int i, a, c;a = 0;i = 0;cout << "inserisci numero ";cin >> p;do{ x = sqrt(p+a+sqrt(pow(a,2)+2*p*a)); y = sqrt(p+a-sqrt(pow(a,2)+2*p*a)); a = a+1; // qui è meglio mettere a = a+ 1/2 se non è un problema RSA; i = i +1;}while( (int(p/y) != (p/y)) || (int(p/x) != (p/x)) ) ; // si può mettere && (and) al posto di || (OR) macout << "fattore: " << x << "\n"; // una delle due soluzioni trovate potrebbe non essere intera cout << "fattore: " << y << "\n";cout << "passi: " << i;}

24

LISTATO IN PARI/GP

{algo8(p) = local(a, d, x, y);a = 0;d = sqrt(a^2+2*p*a);x = sqrt(abs(p+a+d));y = sqrt(abs(p+a-d));while (floor(p/x) != (p/x) && floor(p/y) != (p/y),a = a+0.5;d = sqrt(abs(a^2+2*p*a));x = sqrt(abs(p+a+d));y = sqrt(abs(p+a-d)));print(x);print("----");print(y);return (1);}

Fattorizzazione con le disequazioni

Nel campo della fattorizzazione dei numeri possono essere impiegate le disuguaglianze

notevoli

(a−b )2=a2+b2−2ab

ab=a2+b2

2−

( a−b )2

2

quindi

ab< a2+b2

2

ora da

25

(a+b)2=a2+b2+2ab

ab=(a+b)2

2−a2+b2

2

quindi

ab<(a+b )2

2

ma allora

m2<ab< a2+b2

2<(a+b )2

2

con m = min(a,b)

in modo del tutto analogo da

(a+b)3=a3+3a2b+3ab2+b3

procedendo come sopra ho che

ab<(a+b )2

3

delle altre disuguaglianze abbiamo già detto di quest'ultima no.

s2>3 p , s2=3 p+a ,a>0

se y = P/x allora

26

x=√ p+a±√−3 p2+2 pa+a2

2

con a > 0 a > p, (a < -3p per a < 0)

LISTATO IN C++

#include <cstdlib>#include <iostream>#include <math.h>using namespace std;int main(int argc, char *argv[]){ double x, p, a, start; cout << "inserisci il numero da fattorizzare "; cin >> p; a = p; do { x = sqrt( (p+a+sqrt(-3*pow(p,2)+2*p*a + pow(a,2)) )/2); a = a+1; } while(int(p/x) != (p/x)); cout << "fattore " << x; system("PAUSE"); return EXIT_SUCCESS;}

LISTATO IN C++

27

{algo10(p) = local(a, d, x, y);a = p;d = sqrt(abs(-3*p^2 + 2*p*a+a^2));x = sqrt(abs((p+a+d)/2));y = sqrt(abs((p+a-d)/2));while (floor(p/x) != (p/x) && floor(p/y) != (p/y),a = a+1;d = sqrt(abs(-3*p^2 + 2*p*a+a^2));x = sqrt(abs((p+a+d)/2));y = sqrt(abs((p+a-d)/2)));print(x);print("----"); print(y); return (1);}

Fattorizzazione con il teorema di Bezout

Il famoso teorema di Bezout ci può aiutare a trovare i fattori di un problema RSA. Sia p = ap

dal teorema di Bezout sappiamo che se d=MCD(a,b) esistono u, v interi tali che d = ua +

bv. Ora dato che d=MCD(a,b) = 1 abbiamo che 1= au + bv. Da queste considerazioni

esplicitando a e sapendo che p = ab troviamo:

b2v−b+up=0

b=1±√1−4uvp2v

ove uv = k < 0 mentre v può essere v > 0, v < 0. in pratica il programma prima trova i possibili

valori di k poi cerca i valori di v:

LISTATO C++

28

#include <stdio.h>#include <iostream.h>#include <stdio.h>#include <math.h>int main(int argc, char *argv[]){double x, y, p, k, v;double a, b;int j, i;k = 0;v = 0;cout << "inserisci un numero da fattorizzare ";cin >> p;do{k = k-1;i = i+1;a = 1-sqrt(1-4*k*p);b = 1+sqrt(1-4*k*p);} while (((a) != int(a)) && ((b) != int(b))) ;do{v = v-1;i = i+1;x = a/(2* v);y = b/(2* v);} while (((p/x) != int(p/x)) && ((p/y) != int(p/y)));if ((p/x) == int(p/x)){cout << "fattore "<< x << "\n";}else if ((p/y) == int(p/y)){cout << "fattore "<< y << "\n";}cout << "passi " << i;cin >> j; return 0;}

Fattorizzazione con i logaritmi

Sia n = ab. Per le note proprietà dei logaritmi sappiamo che Log(n) = Log(ab) = Log(a) +

Log(b). Supponiamo che Log(a) = Log(b) quindi Log(n) = 2Log(a), cioè Log(a) =

Log(n)/2

29

a=10Log(n )

2

Questo ci induce a cercare i fattori come

x1>10Log (n )

2 , x2<10Log(n)

2

possiamo utilizzare il parametro a al posto del già citato W o della

radice quadrata di n negli algoritmi precedenti per avere un migliore intervallo dove cercare le

soluzioni

LISTATO C++

#include <cstdlib>#include <iostream>#include <math.h>

using namespace std;

int main(int argc, char *argv[])

{ long double m, x, y, p; long i; cout << "inserisci il numero da fattorizzare "; cin >> p; x = int(pow(10, log10(p)/2))+1; y = int(pow(10, log10(p)/2))+1; do{ x = x-1; y = y+1; i = i+1; } while ( (int(p/x) != (p/x)) && (int(p/y) != (p/y)) );

cout << "fattore: " << x << "\n"; cout << "fattore: " << y << "\n";

30

cout << "passi: " <<i << "\n";

system("PAUSE"); return EXIT_SUCCESS;}

LISTATO PARI/GP

{algo9(p) = local(p, d, x, y);d = log(p)/log(10);x = floor(10^d);y = floor(10^d);while (floor(p/x) != (p/x) && floor(p/y) != (p/y),y = y+1;x =x-1);print(x);print("----");print(y);return (1);}

Fattorizzazione con il metodo della bisezione

Sia p = ab il numero da fattorizzare con a, b numeri primi (nel caso si voglia trattare un

problema RSA).

supponiamo di considerare p', p'', p' =a'b', p'' = a''b''

p' < p < p'' con a' < a < a'', b' < b < b''

ove a', a'', b', b'' non sono necessariamente numeri primi ma sono certamente dispari oppure

tutti numeri pari.

l'algoritmo procede come segue:

31

1) x = (a'' + a') / 2, y = (b'' + b') / 2

2) xy = p oppure (p è divisibile per x o per y) ?

2.1) se si abbiamo trovato la soluzione a = x, b = y (oppure x o y) Fine

2.2) altrimenti xp < p

2.2.1) se si poniamo a' := x, b' := y e torniamo al punto 1)

2.2.2) se no poniamo a'':= x, b'' := y e torniamo al punto 2)

la velocità dell'algoritmo dipende da come scegliamo p', p'' che ovviamente dovrebbero essere

abbastanza vicini a p, per questo motivo possiamo utilizzare come fattori di p', p''

la cosa più semplice è considerare p' = p-1, p'' = p+1, nel caso in cui p non sia un numero pari.

Esempio:

p = 91 = 13*7

p' = 91 +1 = 92 = 23 * 4

p'' = 91 -1 = 90 = 9 * 10

ora (23+9)/2 = 16 (non è la soluzione 16 = 13*2), (4+10)/2 = 7 (è la soluzione)

variante: a' = b', a'' = b''

32

L'approccio combinatorio - economico del problema

Guardiamo la cosa da un altro punto di vista. Supponiamo di poter disporre di molti calcolatori

in rete e di poter distribuire l'enorme carico di elaborazione dati tra questi computer per

trovare velocemente la soluzione al problema della fattorizzazione di grandi numeri (RSA). E'

possibile ? Di quanti pc avrò bisogno ? E' conveniente dal punto di vista economico ? Sia n il

numero da fattorizzare. Ci basa trovare un fattore. Per Fermat sappiamo che una soluzione

deve essere minore della radice quadrata di n. Sia allora W il numero di cifre della radice

quadrata di n.

P = il numero di calcolatori in rete

C = numero di combinazioni (possibili soluzioni intere al problema, cioè possibili

divisori di n) che ogni calcolatore può valutare ogni secondo (o ogni unità di tempo)

T = secondi o (altra unità di tempo)

Q = numeri di cifre della radice quadrata di n

n = ab numero da fattorizzare

vale la relazione P*C*T = 10^Q

10^Q è il numero delle disposizioni con ripetizione di 10 numeri su k posti

33

a questo punto si sia j il costo medio unitario di ogni PC occorre valutare che il costo

totale dei PC in rete non superi una certa ben definita quota oltre la quale non

converrebbe implementare il sistema (sum(jC) < M). Infine il fattore tempo. T <

Tmax perché occorre fissare un limite massimo ragionevole oltre il quale non ha

senso andare. Considerando tutte queste condizioni possiamo progettare un sistema

di calcolo distribuito

Fattorizzazione e ricerca operativa

Possiamo vedere le cose anche da un altro punto di vista, dal punto di vista della ricerca

operativa (programmazione non lineare). Il nostro problema diventa un problema di

programmazione non lineare a variabili intere:

funzione obiettivo P = X1 X2

variabili: X1, X2

vincoli: X1, X2 >0 e interi

e applicare i metodi della ricerca operativa e/o i software già predisposti per questo tipo di

problemi

34

35

Fattorizzazione per differenza dei fattori

Se

p=xy

allora è ben evidente che:

0<x− y< p2−2

essendo 2 il primo possibile fattore

(ingenerale possiamo considerare anche

pq−q

ove q è tale che non esiste nessun fattore di p

minore o uguale a q . Ora x = p/y e x-y = k troviamo che

y2+ yk−p=0

con

y=−k±√k2+4 p

2

dove possiamo considerare k crescente (k = 0, 1, 2, …) o decrescente (K

= p/2 –2, k =k-1, ……)

Se invece vogliamo trovare x y = p/x, quindi

x2−xk−p=0

con

x=k±√k2+4 p

2

dove

possiamo considerare k crescente (k = 0, 1, 2, …) o decrescente (K = p/2 –2, k =k-1, ……)

36

Dal fatto che 0<x− yW

che porta a

k 2+4 p>02W−k<0 unito a

k 2+4 p>(2W−k )2

k 2+4 p>02W−k>0

se x=

k−√k2+4 p2

>W ho che

k−2W >0(k−2W )2>k2+4 p

nel caso in cui x=

−k−√k2+4 p2

>W allora

−k−2W >0(−k−2W )2>k2+4 p

ed infine l’ultimo caso

x=−k+√k 2+4 p

2>W

mi porta a

k 2+4 p>02W +k<0 unito a

k 2+4 p>02W +k>0k 2+4 p>(2W +k )2

37

LISTATO IN PARI/Gp

{diff1(p) =local(k, y, x);k = 0;y = (-k + sqrt(k^2+4*p))/2;x = (-k - sqrt(k^2+4*p))/2;while (truncate(p/y) != (p/y) && truncate(p/x) != (p/x) ,k=k+1;y = (-k + sqrt(k^2+4*p))/2;x = (-k - sqrt(k^2+4*p))/2);print(y);print(x);return(1);}

Fattorizzazione per individuazione dell’intervallo migliore

Partendo dalla già nota relazione

x2+ y2

2>xy

e ponendo y = x+a arriviamo a risolvere una disequazione di secondo grado le cui soluzioni sono:

x>−a+√4 p−a2

2 x<

−a−√4 p−a2

2 con 4 p−a2>0

Nell’ipotesi invece che y = x-a ho che

x>a+√4 p−a2

2 x<

a−√4 p−a2

2 con 4 p−a2>0

Il problema è capire quale valore di a assegnare. Nei problemi RSA le radici non sono né troppo

vicine tra loro né troppo lontane quindi un buon valore per a potrebbe essere a=±√ p

Stesso discorso se partiamo da ( x+ y )2>4 p :

per y = x-a ottengo che x> a+2√ p

2, x< a−2√ p

2 per y = x+a x>−a+2√ p

2, x<−a−2√ p

2

38

Teoria dei grandi numeri

Come è possibile gestire in un normale calcolatore numeri molto grandi, diciamo

numeri interi a 200 cifre ? Vediamo l'algoritmo con un esempio e poi generalizziamo con il

formalismo matematico

Supponiamo di voler calcolare 321*44 = 14124

sappiamo che ogni numero intero lo possiamo scrivere nella sua notazione polinomiale:

(3 x2+2 x+1 )(4 x+4 )

con X = 10

svolgiamo la moltiplicazione tra i polinomi e consideriamo che 12 mod 2 = 2 e che

12-(12 mod 10) = 10 (per i coefficienti del polinomio prodotto usiamo l'aritmetica

modulo 10 ovvero se abbiamo coefficienti maggiori o uguali a 10 cioè ad esempio 12

= 10 +2 scriviamo 12 = X+2 per poi continuare a semplificare e a ridurre modulo 10

finché tutti i coefficienti del polinomio sono in base 10)

tralasciano i passaggi abbiamo che

1 x4+4 x3+1 x2+2 x+4

cioè 14124 che è la soluzione

Il caso della somma è ancora più semplice perché39

3 x2+2 x+1+4 x+4=3 x2+6 x+5

cioè 321 + 44 = 365 (anche per la somma se ce ne fosse

stato bisogno avremmo dovuto ridurre i coefficienti del polinomio in base l'aritmetica modulo

10)

Idem è il caso della differenza tra numeri

Questo ci permetterà di programmare un calcolatore per fargli compiere operazioni molto

complesse che un normale PC non riuscirebbe a fare. Infatti dall'algebra elementare esistono

formule che generalizzano la somma, la differenza la moltiplicazioni e la divisione tra polinomi

di qualunque grado

∑i=0

h

(ri xi)+∑

i=0

k

(ui xi )= ∑

i=0

max(h , k )

(ri+ui ) xi

∑i=0

h

ri xi∑i=0

k

ui xi=∑

j=0

h+k

( ∑i+ p= j

ri up ) x j

caso con la virgola:

12,6 +15,4 =

x+2+ 3x+x+5+ 4

x=2 x+7+1=2 x+8

40

Il caso della divisione è un po',più complesso anche se in realtà una divisione non è altro che

una serie di sottrazioni come una moltiplicazione non è che una serie di somme

Il Crivello di Eratostene

crivello di Eratostene (formulazione grafica: le x sono i primi perché non hanno intersezioni

con "gialli")

14

13 Primo

12

11 Primo

10

9

8

7 Primo

6

5 Primo

4

3

2 Primo

1

1 2 3 4 5 6 7

41

Analisi della complessità computazionale di alcuni algoritmi di

fattorizzazione

In precedenti occasioni ci siamo occupati di studiare nuovi algoritmi di fattorizzazione in parte varianti della

fattorizzazione alla Fermat e del metodo delle divisioni banali. In generale gli algoritmi descritti risultano

essere efficienti solo nel caso in cui il numero da fattorizzare p si compone di fattori anche molto grandi ma

dello stesso ordine di grandezza o che comunque hanno un numero di cifre simile ovvero che non

differiscano di più di 3-4 cifre.

Vediamo per alcuni casi semplici come si può affrontare una stima della complessità computazionale.

Sia p=x1 x2 , s=x1+x2 da x2−sx+ p=0 abbiamo che

x1,2=s ±√ s2−4 p

2

Che impone la condizione per l’esistenza del radicale s≥ 2√ p, s intero e pari perché somma di due primi

Quindi se cerchiamo s con s < n e s≥ 2√ p, e pari al massimo arriveremo alla soluzione in un numero di

passi pari a: p2−√ p che in ogni caso è enorme rispetto alle dimensioni di p

42

D’altra parte un po’ meglio va se valutiamo di considerare le soluzioni tra i numeri dispari compresi tra 2 e

√ p (in questo intervallo ci deve essere sempre la soluzione più piccola) perché in questo caso otterrei la

soluzione in al massimo √ p2

−1 passi.

Nelle considerazioni precedenti abbiamo supposto di cercare le soluzioni tra i numeri dispari ipotizzando di

non avere una tavola di primi già a disposizione.

Considerazioni identiche valgono per altri metodi già esposti come per

φ ( p )=( x1−1 ) ( x2−1 )=4a≤ p=¿a≤p4

, p=x1 x2

Dove ovviamente va aggiunta la condizione di a per l’esistenza del radicale.

43

Stima della complessità computazionale della fattorizzazione con il

metodo dell’attacco casuale (rapporti tra statistica e numeri primi)

Supponiamo che p sia un numero da fattorizzare molto grande (es RSA). Sappiamo che il fattore più piccolo

deve necessariamente trovarsi tra 2 e la radice quadrata di p. Supponiamo di avere un calcolatore che

generi numeri casuali e che ogni numero casuale generato sia un numero primo tra 2 e la radice quadrata

di p. Per ogni numero casuale estratto si verifica se è o no un divisore di p e , in caso negativo, si passa al

successivo numero. Ipotizziamo che il nostro programma tenga “memoria” dei numeri estratti in modo che

l generatore di “primi casuali” non possa ripetere mai lo stesso numero.

Al primo tentativo la probabilità di aver trovato la soluzione sarà

P1=1x

logx

= logxx

Ove è stato usato il ben noto teorema dei numeri primi e x=∫(√ p) e log(x) è il logaritmo naturale di x. In

luogo di x/log(x) avremmo potuto anche usare una stima di ∫2

xdy

log ( y)

Al secondo tentativo

P2=1

xlogx

−1

… al k-esimo tentativo

44

Pk=1

xlogx

−k+1

Questa formula ci dà una stima della probabilità che al k-esimo tentativo (k intero) abbiamo di “indovinare”

la soluzione. Come si vede man mano che aumentano i tentativi aumenta la probabilità di “vittoria”,

probabilità che è comunque condizionata dalla grandezza di p numero da fattorizzare. Come si può ben

vedere all’aumentare delle dimensioni di p la probabilità diminuisce in modo esponenziale

Primi e probabilità

Sia datato ora un intervallo [a, b]

Prendiamo a caso un qualunque numero dispari in questo intervallo la probabilità che sia primo è

P=( (b−a)/2b/ log (b)−a/ log (a ) )

Oppure

P=(b−a)/2

∫a

bdy

log( y )

Con log(x) il logaritmo naturale di x e il simbolo = sta per “circa, valore approssimato”

45

Dove abbiamo usato il teorema dei numeri primi, se consideriamo intervalli che contengono numeri primi

molto grandi

46

Codice in C++ per generare una tabella di primi (per applicazioni reali è consigliabile usare una libreria specifica o un programma per la gestione dei grandi numeri come PARI/GP o Python

#include <cstdlib>#include <iostream>#include <math.h>

long mcd(long a, long b) {long t; while(b !=0){ t = b; b = a%b; a = t; } return a; }

using namespace std;

int main(int argc, char *argv[])

{ long k, p; int j; k = 3; p = 2; for(j= 1; j <= 20; j++) { if (mcd(p, k) ==1) { cout << k << "\n"; p = k*p; } k = k+2; } system("PAUSE"); return EXIT_SUCCESS;}

47

Complessità computazionale degli algoritmi di fattorizzazione

In questo articolo valuteremo la complessità computazionale del migliore algoritmi di fattorizzazione

possibile (escludendo quelli di tipo quantistico).

Il teorema di numeri primi afferma che

limx→+∞

π (x )x

ln (x)

=1

ovvero

π ( x ) xln (x )

Dove π ( x ) è il numero dei primi minori o uguali a x. (per x opportunamente grande).

Un formulazione più evoluta dello stesso teorema mostra che

π ( x ) Li ( x )=∫0

xdy

ln ( y)

Ove Li(x) è il logaritmo integrale

Ora prendiamo in esame il problema della fattorizzazione p = ab con a, b primi e supponiamo a < b.

Sappiamo che a deve essere compreso tra 2 e la radice quadrata di p. Il nostro obiettivo è trovare a

perché così b è facilmente calcolabile con b = p/a (problemi di tipo RSA). Per fattorizzare un qualunque

numero intero di procederà ricorsivamente come per p=ab con a, b primi.

Il numero dei numeri primi compresi tra 2 la radice quadrata di p (per p grande) è approssimativamente:

π (√ p )− 2ln (2)

√ pln (√ p)

− 2ln (2)

48

(anche se l’ultimo termine possiamo trascurarlo)

π (√ p ) √ pln(√ p)

Oppure:

π (√ p ) ∫2

√ pdy

ln ( y)

Grazie all’aiuto del software Mathematica stimiamo i passi necessari (nel caso peggiore) per trovare il

fattore più piccolo del numero p = ab con a, b primi molto grandi e a < b. Ci poniamo cioè nella condizione

di disporre di un algoritmo che ci fornisce tutti i numeri primi da 2 alla radice quadrata di p (anzi

supponiamo di averli già calcolati) e che altro non ci rimane da fare che verificare quali di questi numeri

divide p. Ci poniamo nel caso migliore possibile (algoritmo ideale).

Con il Mathematica:

p:=10^12

Sqrt[p]/Log[Sqrt[p]]

N[%]

NIntegrate[1/Log[x], {x, 2, Sqrt[p]}]

Facendo variare p (numero da fattorizzare) costruiamo la seguente tabella:

dimensione (dim) P (numero da fattorizzare = ab Steps (caso peggiore) stimati con

il teorema dei numeri primi

20 10^20 k*10^8

25 10^25 k*10^11

30 10^30 k*10^13

49

35 10^35 k*10^15

40 10^40 k*10^18

Ove k < 10, k > 1, k diverso per ogni P.

È facile provare che gli steps (passi nel caso peggiore del migliore algoritmo possibile) seguono la legge:

Steps k10∫(dim

2 )−2

Questa formula ci dà una stima per confrontare tutti gli algoritmi conosciuti e quelli nuovi per capire quanto

ancora è possibile migliorare. Nel nostro ragionamento ci siamo posti nel “caso peggiore” perché

ovviamente la soluzione potrebbe essere trovata anche in un solo passo o perché p è un quadrata perfetto

o magari perché un suo divisore è un numero relativamente piccolo che qualunque calcolatore può

facilmente trovare in pochi secondi.

Deduciamo che gli steps seguono una legge di tipo esponenziale rispetto alla dimensione del numero da

fattorizzare e questo nel peggiore del migliore algoritmo di fattorizzazione possibile di tipo non quantistico

m algebrico.

Deduciamo che P != NP.

50

Funzioni che generano molti numeri primi e i software che generano

numeri primi al computer

f ( x )=x2+x+q ,q=2,3,5,11,17,41 ;0≤ x≤q−2

f ( x )=x2−x+41 , x=1 ,2 ,3 ,…. ,40

f ( x )=x2−79 x+1601 , x=1,2 ,3 ,…. ,79

f ( x )=2x2+p ; p=2 ,3 ,5 ,11 ,29; 0≤ x≤ p−1

Sono tutte funzioni che generano numeri primi sotto le condizioni restrittive indicate nelle formule. Da

verifiche di tipo statistico fatte al computer risulta che in ogni caso queste funzioni continuano a generare

una gran quantità di numeri primi (non solo numeri primi) anche al di fuori dei limiti descritti, quindi

potrebbero essere usate per tentare di trovare i fattori di numeri primi molto grandi. A queste possiamo

aggiungere i numeri primi di Mersenne e di Fermat ovvero:

f ( x )=22x

+1, f ( x )=2x−1

51

Per realizzare delle tabelle di numeri primi al computer possiamo usare specifici software come il PARI/GP

e il Mathematica

In PARI/GP:

{primi1() = local(i);

i = 2;

while(i<=100,i++;write("primi1.txt", print(prime(i))));

return(1);}

{primi2() = local(i);

i = 3;

while(i<=100,i = i+2; if(isprime(i), write("primi2.txt",i)));

return(1);}

Mentre in Mathematica abbiamo la funzione

Table[Prime[n], {n, 1, 100}]

Oppure per verificare se un numero è primo o no PrimeQ[numero]

52

Per fattorizzare numeri interi anche molto grandi possiamo ancora usare il Mathematica :

scomposizione = FactorInteger[numero]

In PARI/GP invece per fattorizzare un numero si usa il comando

factor(numero)

e la funzione isprime(numero) per verificare se un numero è primo o no (test di primalità);

nextprime(numero) e precprime(numero) indicano invece rispettivamente il successivo e il precedente

numero primo di un numero dato. Per finire prime(i) indica semplicemente l’i-esimo numero primo.

53

Numeri primi in Java

Per generare numeri primi in JAVA (potentissimo linguaggio di programmazione che consente di gestire

grandi numeri grazie alle librerie java.math.biginteger e java.math.bigdecimal) possiamo usare il seguente

codice:

package primi2;import java.math.BigDecimal;import java.math.BigInteger;import java.math.*;

public class Main { public static void main(String[] args) { long j =1; BigInteger inizio = new BigInteger("3"); BigInteger passo = new BigInteger("2"); inizio = inizio.add(passo); System.out.println(inizio); while(j < 100000){ if( inizio.isProbablePrime(100000000)) System.out.println(inizio); inizio = inizio.add(passo); j = j+1; } j = j+1; inizio = inizio.add(passo); } }

Il programma altro non fa che considerare tutti i numeri dispari e poi verifica se sono dei numeri primi. In

caso affermativo li stampa a video altrimenti passa al numero primo successivo

54

Fattorizzare grandi numeri con JAVA

Con questo codice realizziamo un potente programma di fattorizzazione in JAVA che però richiede di sapere

in anticipo l’ordine di grandezza dei fattori in bit (es : 512- nel nostro caso abbiamo messo 40 per

semplificare e 187 il numero da fattorizzare). Quando viene stampato il resto zero abbiamo trovato un

fattore. Il programma altro non fa che generare numeri casuali primi di una certa grandezza e quindi

verifica se sono fattori del numero p:

package fattore;import java.math.BigDecimal;import java.math.BigInteger;import java.math.*;import java.security.*;

public class Main {

/** * @param args the command line arguments */ public static void main(String[] args) { BigInteger p = new BigInteger("187"); long i = 2; BigInteger fatt = BigInteger.probablePrime(40 ,new SecureRandom()); while( i < 100 ){

fatt = BigInteger.probablePrime(40 , new SecureRandom());

System.out.println("fattore" + fatt);

System.out.println("resto" + p.mod(fatt)); }

}

}

55

Un algoritmo per fattorizzare numeri RSA

Supponiamo di trovarci nella seguente condizione n = pq dove p, q sono numeri primi anche molto grandi.

φ (n )=φ ( pq )=φ ( p ) φ (q )=( p−1 ) (q−1 )=4a

Dove ho usato il fatto che MCD(p, q)= 1, essendo p, q primi e le note proprietà della funzione phi di Eulero.

Svolgendo i calcoli (q = p/ n) si arriva facilmente a:

p2−p (n+1−4 a )+n=0

Le cui soluzioni sono

p=n+1−4 a±√(n+1−4a)2−4n

2

E operando sull’esistenza del radicale ho le condizioni (si cerca a tra gli interi) :

a> n+1+2√n4

∪a< n+1−2√n4

Quindi una possibile implementazione in C++ è:

caso 1) in C++

#include <cstdlib>#include <iostream>#include <math.h>using namespace std;int main(int argc, char *argv[]){ double p, q, n; long i; i = 0; double a; cout << "inserisci il numero da fattorizzare "; cin >> n; a = floor((n+1-2*sqrt(n))/4); do{ p = ((n+1-4*a)- sqrt(pow(n+1-4*a, 2)-4*n))/2; a = a-1; i = i+1; }while(floor(p) != p);cout << "fattore " << p << "\n";cout << "fattore " << n/p << "\n";;

56

cout << "passaggi " <#include <iostream>#include <math.h>using namespace std;int main(int argc, char *argv[]){ double p, q, n; long i; i = 0; double a; cout << "inserisci il numero da fattorizzare "; cin >> n; a = floor((n+1-2*sqrt(n))/4); do{ p = ((n+1-4*a)+sqrt(pow(n+1-4*a, 2)-4*n))/2; a = a-1; i = i+1; }while(floor(p) != p);cout << "fattore " <#include <iostream>#include <math.h>using namespace std;int main(int argc, char *argv[]){ double p, q, n; long i; i = 0; double a; cout << "inserisci il numero da fattorizzare "; cin >> n; a = floor((n+1+2*sqrt(n))/4); do{ p = ((n+1-4*a)+ sqrt(pow(n+1-4*a, 2)-4*n))/2; a = a+1;

57

i = i+1; }while(floor(p) != p);cout << "fattore " <#include <iostream>#include <math.h>using namespace std;int main(int argc, char *argv[]){ double p, q, n; long i; i = 0; double a; cout << "inserisci il numero da fattorizzare "; cin >> n; a = floor((n+1+2*sqrt(n))/4); do{ p = ((n+1-4*a)- sqrt(pow(n+1-4*a, 2)-4*n))/2; a = a+1; i = i+1; }while(floor(p) != p);cout << "fattore " << p << "\n";cout << "fattore " << n/p << "\n";;cout << "passaggi " << i << "\n"; system("PAUSE"); return EXIT_SUCCESS;}

Per I grandi numero si consiglia l’uso del PARI/GP con I codici che riporto di seguito

Caso 1) in PARI/GP

{fatto(n) =local(p, q, a);a = truncate((n+1-2*sqrt(n))/4);p = ((n+1-4*a)-sqrt((n+1-4*a)^2-4*n))/2;while ((truncate(n/p) != (n/p)),p = ((n+1-4*a)-sqrt((n+1-4*a)^2-4*n))/2;a=a-1;); print(p); print(n/p);return (1);}

58

Caso 2) in PARI/GP

{fatto(n) =local(p, q, a);a = truncate((n+1-2*sqrt(n))/4);p = ((n+1-4*a)-sqrt((n+1-4*a)^2-4*n))/2;while ((truncate(n/p) != (n/p)),p = ((n+1-4*a)+sqrt((n+1-4*a)^2-4*n))/2;a=a-1;); print(p); print(n/p);return (1);}

Caso 3) in PARI/GP

{fatto(n) =local(p, q, a);a = truncate((n+1+2*sqrt(n))/4);p = ((n+1-4*a)+sqrt((n+1-4*a)^2-4*n))/2;while ((truncate(n/p) != (n/p)),p = ((n+1-4*a)+sqrt((n+1-4*a)^2-4*n))/2;a=a+1;); print(p); print(n/p);return (1);}

Caso 4) in PARI/GP

{fatto(n) =local(p, q, a);a = truncate((n+1+2*sqrt(n))/4);p = ((n+1-4*a)+sqrt((n+1-4*a)^2-4*n))/2;while ((truncate(n/p) != (n/p)),p = ((n+1-4*a)-sqrt((n+1-4*a)^2-4*n))/2;a=a+1;); print(p); print(n/p);return (1);}

Questi algoritmi sono parte integrante di altri sistemi già descritti nell’articolo “teoria dei numeri” e pubblicati in questo sito.

Ora vediamo le cosa da una prospettiva leggermente diversa. Sia

P = xy , x = p-a, y = p-b con a > 0, b > 0

59

p= ( p−a ) ( p−b )=p2−pb−pa+ab

a= p2−p−pbp−b

>0

Allora possiamo scegliere b < p-1 e decrementare b fino a trovare un a intero che soddisfi le condizioni iniziali per poi calcolare x, y ma questo procedimento ci porterebbe al metodo delle divisioni banali che è utile solo quando un fattore è molto più piccolo rispetto all’altro quindi non nel caso di un problema RSA.

Codice C++ ( variante a divisioni banali)

#include <cstdlib>#include <iostream>#include <math.h>using namespace std;int main(int argc, char *argv[]){double a, b, p, i;i =0;cout << "Inserisci il numero da fattorizzare ";cin >> p;b = p-1;do{ a = (pow(p,2)-p-p*b)/(p-b); b--; i++; } while (floor(a) != a);cout << p-a << "\n";cout << p/(p-a) << "\n";cout << "passaggi" << i << "\n";; system("PAUSE"); return EXIT_SUCCESS;}

Facciamo un ulteriore passo avanti cercando di migliorare il modo per trovare le soluzioni intere:

60

Possiamo però ipotizzare che a = b ( a è circa b). Questo ci porta a all’equazione:

b2−2 pb+ p2−p=0

b=p±√ p

Consideriamo per semplicità la radice più piccola di b quella con il segno – e incrementiamo o decrementiamo b di una unità alla volta, allora il codice del nostro programma diventa:

using namespace std;int main(int argc, char *argv[]){double a, b, p, i;i =0;cout << "Inserisci il numero da fattorizzare ";cin >> p;b = floor(p-sqrt(p));do{ a = (pow(p,2)-p-p*b)/(p-b); b++; // va bene anche b--; i++; } while (floor(a) != a);

cout << p-a << "\n";cout << p/(p-a) << "\n";cout << "passaggi" << i << "\n";; system("PAUSE"); return EXIT_SUCCESS;}

Variante

Possiamo considerare P = xy, con x, y numeri primi diversi da 2 e y = x-a con a numero intero ovviamente pari essendo la differenza di numeri primi quindi di numeri dispari. Facendo le sostituzioni otteniamo che:

x2−xa−p=0

Analogamente se x = y-b ho che

y2− yb−p=0

Ove

x=a±√a2+4 p2

Quindi lì applicazione in C++ che ne deriva sarà:

61

#include <cstdlib>#include <iostream>#include <math.h>using namespace std;int main(int argc, char *argv[]){double a, p, i, x;i =0;cout << "Inserisci il numero da fattorizzare ";cin >> p;a =0;do{ x = (a+sqrt(pow(a,2)+4*p))/2; a = a-2;; i++; } while (floor(x) != x);cout << x << "\n";cout << p/x << "\n";cout << "passaggi" << i << "\n";; system("PAUSE"); return EXIT_SUCCESS;}

Un crivello per generare numeri primi (poco efficiente)

NUMERO DISPARI MASSIMO COMUN DIVISORE

LISTA DEI PRIMI PRODOTTO DEI PRIMI

35 MCD(3,5)=1 =< 3, 5

primi3, 5 3*5 = 15

7 MCD(15,7)=1 => 7 primo 3, 5, 7 15*7 = 1059 MCD(105, 9) != 1 => 9

non è primo11 MCD(105, 11) =1 => 11

primo3, 5, 7, 11 105*7 =1155

13 MCD(1155, 13)=1 => 13 è primo

3, 5, 7, 11, 13 1155*13 =15015

15 MCD(15015, 15) != 1 => 15 non è primo

17 MCD(15015, 17) = 1 => 17 è primo

3, 5, 7, 11, 13, 17 15015*17= 255255

19 MCD(255255, 19)=1 => 19 è primo

3, 5, 7, 11, 13, 17, 19 255255*19= 4849845

21 MCD(4849845, 21) != 1 => 21 non è primo

23 MCD(4849845, 23) = 1 => 23 è primo

3, 5, 7, 11, 13, 17, 19, 23 4849845*23= 111546435

62

25 MCD(111546435, 25) != 1 => 25 non è primo

27 MCD(111546435, 27) !=1 => non è primo

ecc ecc ecc ecc… … … …

IL MCD va calcolato con il metodo di Euclide

Vantaggi del metodo:

Il metodo è facilmente programmabile con qualunque linguaggio (PARI/GP, C/C++, ecc)

Il sistema genera effettivamente tutti e soli numeri primi ovvero la lista dei primi

Svantaggi del metodo:

Il metodo richiede un enorme capacità di calcolo ( ad ogni passo si calcola il prodotto di n primi

consecutivi) tuttavia grazie ai moderni PC in grado di moltiplicare numeri a centinaia di cifre questo

problema è solo in parte risolto (vedi es PARI/GP, Python, Mathematica).

Applicazione: a primo MCD (a, prodotto dei primi < int(Radq(a))=1

La formula per i numeri primi

Se p = ab e p dispari , con a < b a, b primi allora MCD(p, floor(sqrt(p)!!))= a oppure a p ove il simbolo !! sta ad indicare il semifattoriale cioè il prodotto di tutti i dispari minori della radice quadrata di p (sqrt(p)). In tutti i casi la potenza di calcolo necessaria è davvero impressionante.

Più in generale Se p = ab, allora MCD(p, floor(sqrt(p)!))= a oppure a p ove ! è il fattoriale di p.

In codice PARI/GP

{fattore31(p) = local(w);w = gcd(p,floor(sqrt(p))!);print(w);print(p/w);return(1);}

Se invece vogliamo semplicemente trovare una lista di primi, basterà

{tabella2() = local(p, i, k);

63

k = 3;k = k+2;p = 3;for(i=1, 30, if(gcd(p, k) == 1, print(k), p = p*k);k = k+2);return(1);}

{tabella() = local(p, i);p = 3;p = p+2;for(i=1, 30, if(gcd(p, floor(sqrt(p))!) == 1, print(p));p = p+2);return(1);}

SISTEMI “BRUTE FORCE” PER LA FATTORIZZAZIONE DI GRANDI NUMERI

USANDO IL CALCOLO PARALLELO

Supponiamo di dover fattorizzare un numero molto grande (ad esempio un classico problema RSA).

Ovviamente ci poniamo nell’ipotesi che non abbia divisori pari (2, 4, 6, ecc) e che non sia un primo di

Mersenne o di Fermat perché in questi casi la soluzione sarebbe molto facile da trovare.

Un tipico algoritmo “brute force” (forza bruta) è:

VERSIONE IN PYTHONimport mathdef fattore(s): i = 3

while (i*int(s/i) != s) and( i <= math.sqrt(s)):

i = i+2

print(i) print(s/i)

return ('fine')

64

VERSIONE IN PARI/GP{fattore(s) = local(i);i = 3;while(i*floor(s/i) != s && i <= sqrt(s), i = i+2);print(i);print(s/i);return(1);}

Dove ho specificato sia la versione in Python che in PARI/GP (due ottime soluzioni software per la gestione

di numeri di grandi dimensioni). In questo caso la verifica viene fatta su semplicemente tutti i possibili

numeri dispari (che ovviamente comprendono anche i primi) da 3 alla radice quadrata del numero da

fattorizzare in quanto dalla teoria dei numeri sappiamo che in questo intervallo deve esserci il fattore più

piccolo

Usando un solo computer ci potrebbero volere molti anni per trovare la soluzione cioè per trovare i fattori

di p = ab con a, b numeri primi molto grandi

Una soluzione consiste nel far “girare” il programma di fattorizzazione in diversi computer assegnando ad

ogni PC un intervallo diverso.

Un possibile schema potrebbe essere

PC1: da 3 a 10^10-1

PC2: da 10^10-1 a 10^20-1

PC3 da 10^20-1 a 10^30-1

Ecc.

Il limite superiore no potrà essere superiore alla radice quadrata di p (numero da fattorizzare)

Quindi nel generico PC del nostro laboratorio avremo

VERSIONE IN PARI/GP{fattore(s, lim_inf, lim_sup) = local(i, lim_inf, lim_sup);

65

i = lim_inf;while(i*floor(s/i) != s && i <= lim_sup, i = i+2);print(i);print(s/i);return(1);}

Analogamente possiamo scrivere il codice in altri linguaggi ad es il Python o il C++

A questo punto bisogna stabilire oltre gli intervalli opportuni anche il numero di calcolatori necessari per

ottenere la soluzione in tempi ragionevoli.

Per abbattere i costi si potrebbe stabilire gli intervalli e assegnare ogni intervallo a un PC differente

tramite una specie di ” concorso” via internet: coloro che vogliono partecipare installeranno il PARI/GP

nel loro PC e poi faranno girare il programma prendendo l’intervallo che verrà loro assegnato per e-mail

nel momento dell’iscrizione al concorso. Il vincitore avrà un premio in denaro.

La classica versione (in Java) di un programma che fattorizza un qualunque numero con i meccanismi della

forza bruta è:

package fattore2;

public class Main {

public static void main(String[] args) {

double p, i;

p = 1234567891273.0;

i = 3;

while ( p%i != 0.0 ){

i = i+2.0;

}

System.out.println(i);

System.out.println(p/i);

66

}

}

Fattorizzare con il massimo comun divisoreUn possibile algoritmo di fattorizzazione che usa il massimo comun divisore MCD è:

sia d un valore di partenza e p il numero da fattorizzare (d=2, d=p, , d = p/2, d=int(sqrt(p))

c = MCD(p, d)

c = 1 ? se no ovvero se c <> 1 abbiamo finito un fattore di p è c

altrimenti c = c+1 (oppure c = c-1) e si ritorna al punto precedente

Abbiamo sviluppato degli esempi in Python variando il valore d iniziale:

import mathdef mcd(a,b):

if b == 0:return a

else:return mcd(b, a%b)

def fatt(p):d = p+1;k = mcd(p, d);while k == 1:

d = d+1;k = mcd(p, d);

print (k);print (p/k);return (1);

def fatt2(p):d = p-1;k = mcd(p, d);while k == 1 and d > 1:

d = d-1;k = mcd(p, d);


def fatt3(p):d = math.floor(math.sqrt(p));k = mcd(p, d);

67

while k == 1 and d > 1:d = d-1;k = mcd(p, d);


def fatt4(p):d = math.floor(math.sqrt(p));k = mcd(p, d);while k == 1:

d = d+1;k = mcd(p, d);


def fatt5(p):d = 2;k = mcd(p, d);while k == 1:

d = d+1;k = mcd(p, d);


def fatt6(p):d = math.floor(p/2);k = mcd(p, d);while k == 1:

d = d+1;k = mcd(p, d);


def fatt7(p):d = math.floor(p/2);k = mcd(p, d);while k == 1:

d = d-1;k = mcd(p, d);


La velocità e l'efficacia di questo algoritmo dipendono da come sono distribuiti i fattori di n=pq e

dal valore iniziale d

68

Infatti non sempre è più veloce di altri sistemi già precedentemente descritti come quello che,

partendo dalle relazioni p-q = 2a e n = pq arriva a q^2 +2aq-n=0 ovvero , sempre in Python

import mathdef potenza(a,b):

if b == 0:return 1

else:return a*potenza(a,b-1)

def fatto(p):n = 0.0;x = -n+math.sqrt(p+potenza(n,2));while p/x != math.floor(p/x):

n = n+1;x = -n +math.sqrt(p+potenza(n,2));

print(x);print(p/x);return (1);

Un metodo per fattorizzare grandi numeriSupponiamo ancora una volta di dover trovare i fattori di un numero p = ab dove p ha almeno 21

cifre ovvero è dell'ordine dei 10^(21-1).

Il primo passo sarà quello di trovare tutti gli x, y interi tali che x+y = 21 a partire (se esiste) dalla

combinazione in cui x, y sono uguali(stiamo supponendo che i due fattori non abbiano dimensioni

troppo diverse)

Nel nostro caso p = 10^(21-1) ovvero p di 21 cifre

Cifre del fattore a

Cifre del fattore b

Dimensioni di a

Intervallo di ricerca per a

Costo computazionale per a

Dimensioni di b

Intervallo di ricerca per b

Costo computazionale per b

10 11 10^(10-1) 10^9 - 10^10

(10^10-10^9)/2

10^(11-1) 10^10 – 10^11

(10^11-10^10)/2

9 12 10^(9-1) 10^8-10^9 (10^9-10^8)/2

10^(12-1) 10^11-10^12

(10^12-10^11)/2

… … …. … … … … ….

Ovviamente ma mano la dimensioni di a diminuiscono quelle di b aumentano quindi nella ricerca ci

69

conviene concentrarci sul fattore più piccolo ovvero su a e considerare nell'intervallo della ricerca

solo i numeri dispari (se p fosse divisibile per un numero pari l'ultima cifra dovrebbe terminate per

0, 2, 4, 6, 8 quindi sarebbe facilmente individuabile)

Purtroppo questo sistema ha dei costi ancora esponenziali ovvero dell'ordine di (10^n-10^n-1)/2

tuttavia per riga della tabella possiamo pensare di impegnare differenti calcolatore per accelerare i

tempi di elaborazione. Nei problemi RSA l'esperienza mostra che anche nel caso di centinaia di

cifre i fattori di p differivano al massimo di 3-4 cifre.

La fattorizzazione Geometrica

La fattorizzazione geometrica consente (almeno teoricamente) di trovare i fattori di un numero usando

solo considerazioni di tipo geometrico e non algebrico. Dato che tutti i numeri interi e non si possono

rappresentare in una retta reale questo procedimento consentirebbe, almeno in linea teorica, di

fattorizzare in modo molto veloce (quasi istantaneo) qualunque tipo di numero. Il problema è che è

impossibile rappresentare numeri di grandi dimensioni in una retta reale e quindi il metodo per questo

motivo è di scarsa praticità. Di seguito proponiamo alcuni schemi che usano il teorema di Euclide e la

similitudine per spiegare in dettaglio come avviene il procedimento.

70

71

72

Generare una lista di primi usando il teorema di Wilson e la primalità con Fermat

Il teorema di Wilson afferma che:

Sia N un intero > 2. allora N è primo sse (N-1)! = -1 (mod N)

il simbolo = sta per congruente

Questo criterio di primalità non è molto efficiente perché comunque richiede una certa potenza di

calcolo. Per questo motivo proponiamo un programma scritto con il potente linguaggio di

programmazione Python che permette di gestire numeri interi molto grandi :

tramite la funzione Wilson() di generare una lista di primi

tramite la funzione testwilson(p) di effettuare un test di primalità

tramite la funzione fattore(p) vengono generati numeri pseudocasuali tra 2 la radice

quadrata del numero da fattorizzare fino a trovare una soluzione.

Tramite la funzione testprimo(p) si fa un test di primalità e nel caso il numero non sia

primo viene fornito un fattore

Nel codice sono presenti anche altre funzioni utili alla teoria dei numeri, alla fattorizzazione degli

interi e alla ricerca dei numeri primi

Ecco il codice in Python

import mathdef mcd(a,b):

if b == 0:return a

else:return mcd(b, a%b)

def fattoriale(x):if x < 2:

return 1else:

return x*fattoriale(x-1)

73

Per il fattoriale c'è anche la funzione math.factorial(x) e per la potenza math.pow(x,y) oppure a**n

def divisore(num,den): if den ==1: return num else: return float(num)/den

def potenza(a,b):if b == 0:

return 1else:

return a*potenza(a,b-1)def wilson():

n = 3;while(n < 100):

if fattoriale(n-1)%n == -1%n:print(n);

n = n+1;return 1;

def testwilson(n):if fattoriale(n-1)%n == -1%n:

print('è primo');else:

print('non è primo');return 1;

def fattore(p): import random; import math; x = math.floor(random.random()*math.sqrt(p)); while(p/x != math.floor(p/x)): x = math.floor(random.random()*math.sqrt(p)); print (x); print (p/x); return 1;

def testprimo(p):i = 2;while i < p:

if mcd(i,p) != 1:print('non è primo');print(mcd(i,p));return 0;

i = i+1;return 1;

Per rimanere nel tema della primalità, possiamo costruire un programma in Python che sfrutti il

74

piccolo teorema di Fermat ovvero se N è primo, per ogni intero a primo con N ho che

a^(N-1)= 1 mod N. Questo dal punto di vista logico equivale a dire che se esiste un a tale che

MCD(a,N) = 1 e a^(N-1) != 1 allora N non è primo. Quindi possiamo scrivere il seguente test di

primalità:

def test2primo(N):j = 2;while j < N-1:

if mcd(j, N) == 1:if (j** (N-1))%N != 1%N :

return 'non è primo';j = j+1;

return 'è primo';

Ove ** è la funzione potenza che potevamo sostituire con potenza(a,b).

Nota:

Per generare numeri interi casuali che possono essere fattori di un numero intero p possiamo usare

anche il PARI/Gp secondo il codice

{fattor(p) = local(w);w = 1+random(floor(sqrt(p)));while( p/w != floor(p/w), w = 1+random(floor(sqrt(p))));print(w);print(p/w);return(1);}

Algoritmi di primalità

Un noto problema matematico è quello di determinate se un numero p è primo o no. E’ ben evidente che

se MCD(p, (p-1)!) = 1 p non potrebbe avere divisori banali quindi deduciamo che p deve essere primo

75

mentre se MCD(p, (p-1)!) <> 1 ovviamente dovremmo dedurre che p deve essere composto. Quindi

arriviamo alla conclusione che

P primo MCD(p, (p-1)!) = 1

Il fattoriale di un numero n ! = n(n-1)(n-2)…….3*2*1 ma si può anche calcolare usando la formula ricorsiva:

n! = n(n-1)! Ove 0! = 1! = 1. Il MCD(p, (p-1)!) si può calcolare agevolmente con il famoso algoritmo di

Euclide. Con numeri abbastanza grandi il fattoriale potrebbe costituire un problema perché occorrerebbe

disporre di calcolatori molto potenti capaci di gestire numeri interi a miglia di cifre. Un aiuto ci potrebbe

venire da software specifici come il PARI/gp o il Mathematica ma ovviamente entro un certo limite.

Possiamo diminuire la complessità computazione sostituendo a (p-1)! Il termine (int(√p))! applicando il

principio della fattorizzazione alla Fermat. Quindi P primo MCD(p, int((√p)!) = 1.

Test di primalità probabilistici

Il piccolo teorema di Fermat afferma che

Se a è in intero e p è un numero primo ap=a modulo p

Applicando la legge logica che afferma essere equivalenti p => q e non q => non p abbiamo

Se esiste un intero a 1 < a (x+y)p=xp+yp (mod p)

76

La dimostrazione di questo teorema molto semplice si basa sul teorema del binomio (sviluppo)

Quindi in modo analogo:

Se esiste una coppia di interi x, y | (x+y)p != xp+yp (mod. p) allora p non è primo . Possiamo allora tentare di

unire i due teoremi per formulare un interessante algoritmo probabilistico che ci dirà in modo veloce se un

numero è un primo o è composto.

ALGORITMO:

Sia dato un p intero dispari e non un quadrato perfetto

Tramite un generatore di numeri casuali formiamo delle coppie (un certo numero, più è alto più è

alta la probabilità di non fallire) di interi casuali x, y con 1 < x < p, 1 < y < p

Se troviamo per tutte le coppie x, y (x+y)p = xp+yp (mod. p) e (xp=x mod p, yp=y mod p) allora p è

probabilmente primo.

Altrimenti se esistono x, y | (x+y)p = xp+yp (mod. p) e (xp != x mod p oppure yp != y mod p) allora p

non è primo.

Nota:

(x+y)p=xp+yp=x+y=(x+y) mod p ovvero zp=z mod p , con z= x+y

Un nuovo test di primalitàIl piccolo teorema di Fermat afferma che:

se p è un numero primo allora per ogni intero a con MCD(a, p)=1 (p non divide a) , allora

a^(p-1) = 1 mod p (qui l'= sta per congruo)

Il teorema sui residui quadratici afferma che

77

per ogni numero primo p > 2 e per ogni numero a non divisibile per p (MCD(a, p)=1) si

verifica uno dei seguenti fatti:

a^((p-1)/2) = 1 oppure a^((p-1)/2)=-1 mod p (qui l'= sta per congruo)

Da questi due importantissimi teoremi applicando l'equivalenza logica che

p=>q equivale a non q => non p

e che un numero intero è primo o non è primo

formuliamo il seguente test di primalità ove assumiamo che N sia un numero dispari e non un

quadrato perfetto (in questi casi sarebbe immediato verificarne la primalità anche per numeri con

moltissime cifre):

N dispari e non un quadrato perfetto (altrimenti N non è primo)

Se esiste un a intero 2 < a < N tale che

MCD(a,N)= 1 e

a^(N-1) != 1 mod N e

a^((N-1)/2) !=1 mod N AND a^((N-1)/2) !=-1

■ allora N non è primo

altrimenti è primo

Osserviamo che a causa dei pseudo primi di Carmichael i test di primalità proposti se indicano che

un numero non è primo certamente non è un numero primo, mentre se indicano che è primo è da

intendersi come “probabilmente primo”

Il codice seguente è scritto in Pyton ed è di semplice lettura

def mcd(a,b):if b == 0:

return aelse:

return mcd(b, a%b)

78

def test2primo(N):j = 2;while j < N:

if mcd(j, N) == 1:if (j**(N-1)%N != 1%N) and ((j** ((N-1)/2))%N != 1%N) and ((j** ((N-

1)/2))%N != -1%N):return 'non è primo';

j = j+1;

return 'è primo';

79

Education

Fattorizzazione primalità