Embed Size (px)
DESCRIPTION
Nuove idee matematiche sui numeri
Citation preview
Fattorizzare i numeri interi
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
cioè deve avere almeno int(n/2) cifre con int(x) la parte la funzione parte
intera di x.
1
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
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{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;}
2
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);}
Primo algoritmo (AL-1) (variante della fattorizzazione alla Fermat)
(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).
3
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>#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: " << i << "\n"; cout << "passi: " << j << "\n"; } } cin >> "-----------------"
return 0;}
4
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
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);
5
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);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);}
6
{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
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.
Cerchiamo di velocizzare la ricerca dei fattori usando l’elemento W precedentemente
descritto.
mi porta a dover risolvere il seguente sistema:
7
mi porta a dover risolvere il seguente sistema:
unito alle soluzioni del sistema
Osservazione
1) equivale alla ben nota relazione
2) se allora (più avanti approfondiremo questo caso)
LISTATO IN C++
#include <stdio.h>#include <math.h>#include <iostream.h>int main(int argc, char *argv[]){ long double p, x, y, s; 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;}
8
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);}
{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);}
9
{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
a numero pari perché differenza di due numeri pari
Ciò porta all’equazione biquaratica
10
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: " <<i << "\n"; cin >> " -----"; 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);}
11
Terzo algoritmo (Al-3)
Dalle Osservazioni precedenti deduciamo che
dove m è intero
allora
,
da cui si può partire direttamente da m per trovare le soluzioni
con ,
(possiamo considerare anche le soluzioni negative di X1, X2 quelle con il segno - ovvero
ma il ragionamento sarebbe identico a quello già fatto)
12
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
porta a risolvere il seguente sistema
unito alle soluzioni di
x = porta a dover risolvere il sistema
allora
LISTATO IN C++
#include <stdio.h>#include <math.h>#include <iostream.h>
13
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: " <<i << "\n"; cin >> " -----";
return 0;}
LISTATO IN PARI/GP
{algo4(p) = local(m, x, y);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);}
14
Quarto algoritmo (Al-4)
ciò porta a
,
, (possiamo considerare anche la soluzione negativa quella con
segno - , però poi occorre calcolare il suo valore assoluto)
Come nei casi precedenti
porta a:
unito alle soluzioni di
porta al sistema di condizioni
Wpbbx 2
allora
15
unito a
ciò porta a:
osservazione: se è un problema RSA allora quindi
con
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;}
16
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;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
17
{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);print(x);print("----");print(p/x); return (1);}
Quinto algoritmo (Al-5)
Se allora sostituendo le variabili ottengo che
quindi
Consideriamo la soluzione positiva come negli altri casi
allora dobbiamo risolvere
unione a
allora il sistema diventa:
18
analogamente si arriva agli stessi risultati nel caso opposto cioè che abbiamo
che .
Quindi
unito a
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
19
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);}
20
Sesto algoritmo (Al-6)
Partiamo da un ben nota relazione algebrica sempre vera:
quindi a > 0 y = p/x
arriviamo a quindi le soluzioni sono 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;}
21
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
quindi
ora da
22
quindi
ma allora
con m = min(a,b)
in modo del tutto analogo da
procedendo come sopra ho che
delle altre disuguaglianze abbiamo già detto di quest'ultima no.
se y = P/x allora
con a > 0 a > p, (a < -3p per a < 0)
23
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++
{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);}
24
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:
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++
#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;
25
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
Questo ci induce a cercare i fattori come
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
26
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"; 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);}
27
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:
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''
28
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''
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
29
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
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
30
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
31
Fattorizzazione per differenza dei fattori
Se allora è ben evidente che: essendo 2 il primo possibile fattore
(ingenerale possiamo considerare anche 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 con
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 con dove possiamo
considerare k crescente (k = 0, 1, 2, …) o decrescente (K = p/2 –2, k =k-1, ……)
Dal fatto che e che troviamo facilmente che .
Anche in questo caso se stiamo trattando un problema RSA poniamo che
porta a
unito a
se ho che
32
nel caso in cui allora
ed infine l’ultimo caso
mi porta a
unito a
33
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 e ponendo y = x+a arriviamo a risolvere una
disequazione di secondo grado le cui soluzioni sono:
con
Nell’ipotesi invece che y = x-a ho che
con
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
Stesso discorso se partiamo da :
per y = x-a ottengo che per y = x+a
34
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:
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 cioè 14124 che è la soluzione
Il caso della somma è ancora più semplice perché
35
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
caso con la virgola:
12,6 +15,4 =
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
36
Ipotesi di Goldbach
La seguente trattazione non è la vera dimostrazione della congettura (la congettura
non è stata ancora dimostrata) ma solo il tentativo di fare alcuni ragionamenti
intorno alla congettura stessa.
LA CONGETTURA: Ogni numero pari maggiore di due è somma al più di due numeri
primi non necessariamente diversi tra loro
Primo tentativo di dimostrazione
Sia data la funzione Phi di eulero che mi dà il numero di primi con q minori di q.
E’ facile provare che
a) è sempre pari qualunque sia q
b) sse q è primo
PRIMO TANTATIVO DI DIMOSTRAZIONE (per induzione)
1) assumiamo che 2a = p+q vera, p, q primi
2) un numero pari è sempre la somma di due numeri pari
37
sse è primo; sse è primo. Allora
3)
4) vera
5) per induzione 2a = p+q per ogni a (ad ogni a cambieranno p, q)
SECONDO TENTATIVO DI DIMOSTRAZIONE (dimostrazione diretta)
Sia n = pq con p, q primi. Possiamo anche considerare n = 2pq perché
è sempre pari e perché MCD(p,q) = 1
pq+1-2k = p+q e dato che pq+1 è pari perché pq è dispri pq+1-2k è pari perché
differenza di numeri pari, quindi pq+1-2k è un generico numero pari che è somma di
due primi p, e q.
ora questo ci indica una strada per costruire numeri primi:
38
risolviamo il sistema
pq+1-2k = m p+q = m
dove m è un generico numero pari e p, q sono le incognite mentre k è un parametro
intero. Svolgendo i calcoli e le opportune sostituzioni abbiamo
a questo punto dovremmo essere in grado di sviluppare un applicativo tale che per
ogni numero pari m mi generi almeno due numeri p, q primi. Ciclando per tutti i pari avremo
tutti i numeri primi . In realtà ci si rende ben presto conto che con questo sistema si ottengono
non solo le coppie di primi ma anche le coppie di dispari la cui somma è m (si veda più in basso
l'impostazione geometrica del problema)
ecco l'applicativo in C++:
#include <stdio.h>#include <iostream.h>#include <math.h>int main(int argc, char *argv[]){long double p, q, m, k;long double v, w;int i, temp;cout << "inserisci un numero pari ";cin >> m;k = int((pow(m,2)-4*m+4)/8);do{
39
q = (m + sqrt(pow(m,2)-4*m+4-8*k))/2;p = (m - sqrt(pow(m,2)-4*m+4-8*k))/2;k = k-1;} while ((q != int(q)) || (p != int(p))) ;v = m-q;w = m-p;cout << "fattore " << p << "\n";cout << "fattore " << q << "\n";cout << "fattore " << v << "\n";cout << "fattore " << w << "\n";cin >> "inserisci numero " >> temp; return 0;}
Si possono costruire altri programmi che sono varianti anche migliori di questa (le coppie dei
numeri trovate non sono necessariamente prime). In alternativa è sempre possibile partire da
un numero pari diciamo 2m e poi sottrarre 1, 2, 5, 7,...tutti i dispari e controllare poi le coppie
così ottenute.
Si potrebbe usare l'equazione di secondo grado
con
quindi possiamo scrivere un programma che accetta S in ingresso come numero pari e in
output ci dà coppie x, y con x+y = s
#include <stdio.h>#include <math.h>#include <iostream.h>int main(int argc, char *argv[]){
40
double x, y, a;long s, p;cout << "inserisci un numero pari ";cin >> s;for(p=int(pow(s,2)/4); p>0; p--){x = (s + sqrt(pow(s,2)-4*p))/2;y = (s - sqrt(pow(s,2)-4*p))/2;p = p-1;if (x == int(x) && y == int(y)){cout <<"------------------------" << "\n";cout << " numero: " << x << "\n";cout << " numero: " << y << "\n";cout <<"------------------------" << "\n";}}
TERZO TENATIVO DI DIMOSTRAZIONE (dimostrazione per assurdo)
consideriamo l'approccio della dimostrazione per assurdo. supponiamo cioè di negare la tesi
ovvero che esiste un numero pari che non può essere somma di due numeri primi. Sia allora 2a
il più piccolo numero pari che non può essere scritto come 2a = p+q con p, q primi. Dunque
2a-2 è pari e può essere scritto come 2a-2 = p+q con p, q primi, allora 2a = 2+p+q
caso 1) 2+p è primo con p primo allora arriviamo all'assurdo 2a = P + q con P= 2+p P, q primi
e il teorema è dimostrato
caso 2) 2+q + primo con q primo allora arriviamo all'assurdo 2a = p + Q con Q = 2 +q con p,
Q primi e il teorema è dimostrato
caso 3) 2+q non è primo né 2+p, allora si potrebbe cambiare la coppia p, q (es 10 = 7+3 =
5+5) e vedere se si verificano i casi 1) 2). Qui il problema è più complesso perché si lega ad
un'altre ben nota congettura che vuole che i numeri primi si distribuiscano più facilmente nella
41
forma p, p+2 con p primo. Nel sottocaso che p=q abbiamo che 2a = 2+2p quindi 2a =
1+(2p+1).
QUARTO TENTATIVO DI DIMOSTRAZIONE (uando il Teorema di Fermat)
allora
da cui possiamo dedurre che 2k = p+q ?
Nota: non dobbiamo provare che la somma di due primi è un pari (questo è banale perché due
primi sono sempre due numeri dispari altrimenti sarebbero divisibili per 2 e la somma di due
dispari è sempre un numero pari), infatti
p+q = 2b sempre (partendo da p e q noti, 2a = 2p' +1 + 2q' +1 per opportuni p', q' interi )
Osservazioni:
- non è vero che ogni numeri pari aumentato di una unità è un numero primo ma è
sempre vero che un numero primo diminuito di una unità è un numero pari, quindi
esistono infiniti numeri pari (non tutti), che aumentati di una unità danno un numero
primo
42
-un numero pari è sempre la somma (o differenza) di due numeri dispari oppure è la
somma di due pari; l'insieme dei numeri dispari comprende l'insieme dei numeri
primi
- l'unico numero primo pari è il 2 (è un primo un po' speciale)
- possiamo considerare 1 un numero primo (è un primo un po' particolare)
Impostazione geometrica del problema
Consideriamo un numeri pari e i un piano cartesiano rappresentiamo tale numero formando
con le ascisse e le ordinate un quadrato. Consideriamo la diagonale del quadrato: nella figura
le x sono nella diagonale le caselle gialle ottenute dall'intersezione tra i numeri primi delle
ascisse (in giallo) e le ordinate (in giallo) minori del numero pari dato. Questo ci suggerisce un
metodo iterativo per costruire la tavola dei numeri primi perché a partire dai primi numeri primi
diagonale dopo diagonale si trovano i primi successivi. Vediamo meglio questo concetto.
6
5 Coppia primi
4 x
3 Coppia primi
2 x
43
1 Coppia primi
1 2 3 4 5 6
a) prendiamo in considerazione tutte le coppie i, j tali che i +j = 2a per un certo
a fissato
b) prendiamo solo in considerazione quelle coppie tali che MCD (i,j) = 1 e la coppia
speciale i=j
c) escludiamo le coppie che contengono l'unità.... le rimanenti coppie sono coppie di
primi ? No in generale ma se procediamo in modo ricorsivo a partire dal primo
numero pari e per ogni pari con questo metodo determiniamo i primi numeri primi
minori di quel numero pari nelle successive diagonali possiamo escludere quei casi
in cui mcd(i,j)= 1 i+j = 2a ma uno dei due (i o j) non è primo (ovvero per ogni
diagonale calcoliamo i primi e ne teniamo in considerazione per le diagonali
successive - un po' come il crivello di Eratostene.)
d) con questo metodo costruttivo iterattivo possiamo dire che nella diagonale c'è
sempre qualche coppia di primi ? In realtà nella diagonale troviamo tutte le possibili coppie
i, j tali che i +j = 2a. Le coppie devono essere o coppie di pari o coppie di dispari. Dobbiamo
provare che tra le coppie di dispari c'è almeno una coppia di primi.
44
10
9 no
8 x
7 Primi
6 x
5 Primi
4 x
3 Primi
2 x
1 no
1 2 3 4 5 6 7 8 9 10
la diagonale è sempre simmetrica e questo ci permette di procedere più veloci
visualizzazione multipla (si possono intravedere interessanti geometrie ?)
10
9 no
8 x
7 primi Primi
6 x x
5 Primi primi Primi
4 x x x
3 Primi primi primi Primi
2 Primi x x x
1 Primi primi primi Primi no
1 2 3 4 5 6 7 8 9 10
45
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
Giocare in borsa con la matematica
Molti matematici ritengono che l'analisi tecnica (tanto cara agli economisti e alle banche) non
sia un valido strumento di previsione. Forse hanno ragione, forse no.
L'idea è allora quella di proporre (algoritmi un po' strani e fantasiosi) che però potrebbero
essere efficaci in molte situazioni
Supponiamo di considerare che X sia una variabile casuale. X rappresenta il valore di una certa
azione al variare del tempo. Consideriamo i valori di X per circa 30 sedute di borsa
consecutive (un mese e mezzo di contrattazioni).
46
Calcoliamo la media e lo scarto quadratico medio di X cioè . Questa può in effetti essere
una forzatura ma possiamo accettare l'ipotesi valida. Per giustificarla potremmo dire
che in un determinato periodo temporale (periodo che comprende anche le
previsioni a breve ovvero periodo totale = periodo dati + periodo previsione) la
variabile casuale X assumerà dei valori x1.....xN, con probabilità p1........pN tale che
la somma delle probabilità pi sia pari a 1.
Utilizziamo il teorema di Chebicev che dice che data una qualunque variabile casuale X vale la
seguente relazione:
cioè
k >0
Ove P è la probabilità che la variabile casuale X assuma certi valori in un intervallo di dati.
47
Impostiamo il livello di affidabilità al 95% cioè e troviamo K (possiamo fare altre
scelte dl tipo 90% o 98%, troveremo valori di k differenti). Più aumentiamo il livello di
affidabilità più aumenta anche il range cioè l'intervallo in cui il valore della nostra azione può
oscillare per il prossimo mese di contrattazioni. Diminuendo la percentuale si rischia di fare
previsioni poco attendibili.
Con queste considerazioni stimiamo che il valore della nostra azione oscillerà nel prossimo
mese di contrattazioni in un determinato intervallo a < X < b con una certa probabilità.
Ovvio che la previsione del valore del titolo deve essere limitata nel tempo in quanto i
parametri della variabile casuale andrebbero ricalcolati alla fine di ogni giornata borsistica. Ma
tanto per semplificare supponiamo di fare una previsione per un periodo temporale di circa un
mese
se si potesse stimare la probabilità p che un titolo scenda o salga in un ben determinato
periodo (o q la probabilità opposta p+q =1) non sarebbe una idea malvagia considerare la
distribuzione di Bernulli e dire che la probabilità che in n sedute di contrattazioni ci siano k
rialzi del titolo è:
48
ove p+q = 1, e dove la variabile casuale ha media = np e varianza = npq. Se riusciamo a
ben stimare p e q riapplicando il teorema di Chebicev possiamo avere delle informazioni in più
sul possibile andamento del nostro titolo. Possiamo calcolare p e q supponendo di studiare il
titolo per 30 sedute di borsa consecutive p = numero di sedute positive /30, q = numero di
sedute negative / 30, la media è facilmente calcolabile
Posso considerare un portafoglio finanziario formato da n titoli, impostare un valore C da
investire e cercare le quantità che devo acquistare di ogni singolo titolo in modo da
massimizzare il mio investimento (problema di ricerca operativa)
I piani di accumulo del capitale
Molte strategie di investimento si basa sui piani di accumulo del capitale. L'idea che voglio
proporre è quella di usare la serie geometrica per progettare un piano di accumulo. Di solito i
tradizionali piani prevedono un investimento costante, usando la serie aritmetica o quella
geometrica possiamo considerare interessanti varianti
49
S = somma da investire
n = numero delle sedute di borsa da considerare = periodo di investimento
a = valore iniziale da investire
(termine ennesimo)
ad ogni seduta investirà il termine:
a cui impongo dei limiti fissati
Se penso che la tendenza si al rialzo una strategia prudente è 0<q<1 (se ci fossero delle
chiusure in "negativo" la perdita sarebbe limitata)
Se penso che la tendenza sia al ribasso una strategia prudente è q>1 (al primo "rimbalzo
tecnico" si recuperano tutte le perdite)
Nel caso delle progressioni aritmetiche:
50
il vero problema è come scegliere i parametri in modo da ottimizzare i guadagni e ridurre la
perdite supponendo di sapere la "tendenza del mercato". L'argomento merita un
approfondimento. Non tutti sono concordi con queste teorie ed esistono comunque pareri
discordi.
Il Lotto e la matematica
Non esistono teoria sicure sul gioco del lotto. Qui vogliamo presentare un semplice programma
in Visual Basic .Net per la generazione di numeri casuali per giocare al Lotto e tentare la
fortuna. Chi vende i numeri "fortunati" spesso altro non fa che usare sistemi come questo
(sistemi che non garantiscono in nessun caso vincite)- Il listato si può modificare per adattarlo
anche ad altri linguaggi di programmazione come il C/C++.
LISTATO IN VISUAL BASIC .NET
Module Module1 Sub Main() Dim generator As New Random Dim arr(30) As Integer Dim randomValue As Integer Dim ruota As String Dim i As Integer Console.WriteLine("inserisci la ruota") ruota = Console.ReadLine() Console.WriteLine(ruota) For i = 0 To 4 randomValue = generator.Next(1, 90) arr(i) = randomValue Console.Write(arr(i)) Console.Write("-") Next Console.ReadLine()
51
End SubEnd Module
52
Sommario
Fattorizzare i numeri interi...............................................................................................................................1
Considerazione preliminare (algoritmo 0)....................................................................................................1
Primo algoritmo (AL-1) (variante della fattorizzazione alla Fermat).............................................................3
Secondo algoritmo (Al-2)..............................................................................................................................7
Terzo algoritmo (Al-3).................................................................................................................................12
Quarto algoritmo (Al-4)..............................................................................................................................15
Quinto algoritmo (Al-5)..............................................................................................................................18
Sesto algoritmo (Al-6).................................................................................................................................21
Fattorizzazione con le disequazioni............................................................................................................22
Fattorizzazione con il teorema di Bezout....................................................................................................25
Fattorizzazione con i logaritmi....................................................................................................................26
Fattorizzazione con il metodo della bisezione............................................................................................28
L'approccio combinatorio - economico del problema................................................................................29
Fattorizzazione e ricerca operativa.............................................................................................................30
Fattorizzazione per differenza dei fattori...................................................................................................32
Fattorizzazione per individuazione dell’intervallo migliore.......................................................................34
Teoria dei grandi numeri................................................................................................................................35
Ipotesi di Goldbach.........................................................................................................................................37
Impostazione geometrica del problema.....................................................................................................43
Giocare in borsa con la matematica................................................................................................................46
I piani di accumulo del capitale......................................................................................................................49
Il Lotto e la matematica..................................................................................................................................51
Sommario.......................................................................................................................................................52
53
