lunedì 31 agosto 2015

Alcune Terne di Beal

Ecco alcune terne molto particolari di beal che integriamo rispetto agli articoli già pubblicato sull'argomento
(da un'osservazione di Morfeo Chiesa):
da 1+a^n = b^m

moltiplicando entrambi i membri per a^m ho che
a^m+a^(m+n) = (ab)^m

che è nella forma x^M + y^N = z^Q

con
x = a, y=a, z = ab
M = m, N = m+n, Q = m

esempio: 
1+2^3 = 3^2
2^2+2^(3+2) = (2*3)^2
2^2+2^5 = 6^2
MCD(2, 2, 6) = 2

esempio:
1+7 = 2^3
7^3 + 7^3*7 = 7^3*2^3
7^3+7^4 = 14^6
MCD(7, 7, 14) = 7

E' vero in generale che
a^n-1 = b
a^n b^n = b^(n+1) +b^n
(ab)^n = b^(n+1) +b^n

ma anche:
1+Q^L-1 = Q^L
se Q^L-1 = M^k
allora M^L+M^(L+k) = (MQ)^L


Su suggerimento di Morfeo Chiesa ecco altre soluzioni molto interessanti:
a^x+b^y = c^z

y = L+1
x = z = L
a=b=q^L - 1
c = q(q^L-1)

MCD(a, b, c) = q^L-1

attezione:
1+8 = 9
1^5+2^3 = 3^2

sabato 29 agosto 2015

Valutazione delle tariffe telefoniche per i cellulari

Valutazione delle tariffe per la telefonia mobile

costo totale = [numero medio di chiamate al mese o a settimana]*(scatto alla risposta + [costo al minuto]*[durata media in minuti delle chiamate]) + eventuale canone fisso

costo complessivo = costo totale per chiamate verso stesso operatore + costo totale per chimate verso altro operatore

giovedì 27 agosto 2015

Teoria combinatoria delle equazioni diofantine

Per trovare tutte le possibili soluzioni di una equazione difoantina (equazione a più variabili intere positive) possiamo procedere in questo modo:

Supponiamo che vogliamo trovare un controesempio dell'ultimo teorema di fermat, vogliamo controllare tutte le possibili soluzioni dell'equazione x^n+y^n = z^n.

Possiamo pensare alle soluzioni come una quaterna (x, y, z, n)  di interi  dove 1 < x, y, z, n, < A con A numero intero fissato. Al variare di A avremo tutti possibili candidati. A=1, 2, 3, 4, ....

Quindi dobbiamo considerare le disposizioni con ripetizione di A elementi su 4 posti ovvero
D(A, k) = A^k 
nel nostro caso
D(A, 4) = A^4 al variare di A
Dato che esiste un algoritmo efficiente ( procedura)  per elencare tutte le possibili disposizioni di A elementi su k posti abbiamo determinato una procedura per verificare le soluzioni dell'ultima teorema di Fermat e più in generale di qualunque equazione diofantina.

Per verificare le soluzioni della equazione di Beal x^n + y^n = z^p basterà prendere in esame
D(A, 6) = A^6  al variare di A casi possibili

Al variare di A però, il numero di elementi da considerare si incrementa in modo più che esponenziale e questo ci dà una idea della complessità computazionale.
Su queste basi un calcolatore quantistico ci può dare una mano.

In casi specifici è comunque possibile stabilire delle proprietà per limitare l'insieme dei candidati ammissibili

sabato 15 agosto 2015

Infinite soluzioni per RSA

Algoritmo ispirato da un lavoro di A. Lepore (http://howtodecodersa.altervista.org)

N =xy (problema RSA)

Vale sempre x^2+knx-N=0 con n =(y-x)/k
Ora poniamo n = 1, 2, 3 ...  per ogni n fissato abbiamo una corrispondente equazione algebrica di II grado x^2+knx-N=0 .

n = 1 , x^2+kx-N=0, da risolvere k = 0, 1, 2, 3, ... fino a trovare sol intere
n = 2, x^2+2kx-N=0, da risolvere k = 0, 1, 2, 3, ... fino a trovare sol intere
n = 3, x^2+3kx-N=0, da risolvere k = 0, 1, 2, 3, ... fino a trovare sol intere

Per un determinato valore di k intero questa equazione ammetterà soluzioni intere  che altro non sono che i fattori di N. 

Tutto questo ci suggerisce un attacco in parallelo in cui ogni ad PC assegniamo un valore di n

il codice in python sarà

import math;
def facto(N, n):
k = 0;
x = (-n*k+math.sqrt(n*n*k*k+4*N))/2;
while (x != math.floor(x)):
k = k+1;
x = (-n*k+math.sqrt(n*n*k*k+4*N))/2;
print(x);
print(N/x);


Un analogo procedimento possiamo applicarlo alle relazioni analoghe alla precedente:
x(x+k) +6nx=N, n = (y-x-k)/6

x(x+k)+Mnx=N, y =(y-x-k)/M



giovedì 13 agosto 2015

Crittografia simmetrica classica

Nella crittografia simmetrica classica:
0 <= x < N
x = numero a cui corrisponde un carattere nell'alfabeto a N caratteri (i caratteri sono identificati con un numero progressivo a 0 a N-1)
C(x) = ax+b mod(N) funzione cifrante (serve per cifrare)
D(x) = a'x+b' mod(N) funzione decifrante (serve per decifrare)
a' = inverso(a) mod(N)
b' = -a'b
MCD(a,n) = 1

E' possibile aumentare la sicurezza scegliendo una diversa funzione cifrante per ogni carattere

---------------------------------------------------
CODICE IN PYTHON:
import math;
def modulo(e, n):
return( e-n*math.floor(e/n) );
def inv(a,n):
i = 0;
c = a*i;
while( (((a*i-1)/n != math.floor( (a*i-1)/ n) ) and i < n)):
i = i+1;
c = a*i;
return(i);
def C(x):
a = 15;
b = 48;
n = 26;
return(modulo(a*x+b, n));
def D(x):
        a = 15;
        b = 48;
        n = 26;
        A = inv(a, n);
        B = -A*b;
        return( modulo(A*x+B, n));
---------------------------------------------------
CODICE IN PARI/GP

{C(x) = local(a, b, n);
a = 15;
b = 48;
n = 26;
g = lift(Mod(a*x+b,n));
return (g);
}

{D(Y) = local(a, b, n);
a = 15;
b = 48;
n = 26;
A= lift(Mod(a, n)^(-1));
B = -A*b;
h = lift(Mod(A*Y+B,n));
return (h);
}
---------------------------------------------------

lunedì 10 agosto 2015

Ancora equazioni diofantine

n = pq con p, q primi
p^k = n-f
p^k+f = n = ((p+q)/2)^2-((p-q)/2)^2
p^k +((p-q)/2)^2 -((p+q)/2)^2 = n-f
n-f = V quindi risolve l'equazione A^k+B^2-C^2 = V
f = n-p^k
V = n-f
f = n-V

oppure:
p^k = n+f
p^k+f = n = ((p+q)/2)^2-((p-q)/2)^2
quindi risolve A^k+B^2-C^2 = V
V=n+f
f= V-n


sabato 8 agosto 2015

Crittografia simmetrica e generatore di password

Ecco un generatore di password e anche un sistema per comunicare con password sempre diverse ogni giorno
l’ applicazione in Excel che serve a generare password di qualunque lunghezza in modo casuale  e a realizzare un insieme di parole chiave per  cifrare con la crittografia simmetrica documenti.Ogni giorno i file scambiati (inviati e ricevuti) vengono cifrati con una password diversa

mercoledì 5 agosto 2015

Osservazioni importanti sulla congettura di Goldbach

2a = p+q

per il piccolo teorema di fermat ho:

u^(2a) = u^(p+q) = (u^p) (u^q) = u^2 mod(pq) = u^2 mod(n)


u^(2a) = u^2 mod (n)

lunedì 3 agosto 2015

Generazione numeri casuali

p = NextPrime(Random(10^30))
q = NextPrime(Random(10^30))

N = PQ

p = randomprime(10^20)
p = randomprime(10^20)

La matematica della valutazione