diszkrét matematika 12. eloadásmgyongyi/diszkretmat/12... · 2020. 12. 15. · diszkrét...

Diszkrét matematika12. el®adás

MÁRTON Gyöngyvé[email protected]

Sapientia Egyetem,Matematika-Informatika TanszékMarosvásárhely, Románia

2020, ®szi félév

MÁRTON Gyöngyvér 2020, Diszkrét matematika

Mir®l volt szó az elmúlt el®adáson?

a diszkrét logaritmus, algoritmusok

a brute-force algoritmusBaby-step Giant-step, Shanks algoritmusa

a számelmélet alaptétele

összetett számok faktorizációja:

a Fermat féle faktorizációa Pollard ρ féle faktorizáció


Mir®l lesz szó?

a kínai maradéktétel

az RSA és a kínai maradéktétel

diofantoszi egyenletek

ál-véletlenszám generátorok (pseudo-random number generators):

a lineáris kongruencián alapuló generátora Python véletlenszám generátoraa közép-négyzet módszer (middle-square)a Blum-Blum-Shub generátor


A kínai maradéktétel

Feladat: Ha egy tojásokkal teli kosárból kivesszük a tojásokat 2, 3, 4, 5, majd 6-osával, akkor rendre 1, 2, 3, 4, 5 tojás marad mindig a kosárban. Ha 7-esévelvesszük ki nem marad egy tojás sem. Hány tojás van a kosárban?

A feladat az alábbi kongruencia-rendszerrel modellezhet®:

x ≡ 1 (mod 2)x ≡ 2 (mod 3)x ≡ 3 (mod 4)x ≡ 4 (mod 5)x ≡ 5 (mod 6)x ≡ 0 (mod 7)

Mi a fenti rendszer megoldása?



1. tétel

Legyenek m1,m2, ...,mr pozitív, páronként relatív prímek. Ekkor az

x ≡ a1 (mod m1)x ≡ a2 (mod m2)...x ≡ ar (mod mr )

kongruencia-rendszernek M = m1 ·m2 · ... ·mr modulus szerint egy megoldásavan.

A megoldás meghatározásának menete:

meghatározzuk: Mk = M/mk = m1 ·m2 · ... ·mk−1 ·mk+1 · ... ·mr ,

meghatározzuk az Mk értékek inverzét (mod mk) szerint, jelöljük ezeketMk -val,

x = a1 ·M1 · M1 + a2 ·M2 · M2 + ...+ ar ·Mr · Mr lesz a rendszermegoldása.



A tojásos feladat az alábbi kongruencia-rendszerre vezethet® vissza:

x ≡ 4 (mod 5)x ≡ 11 (mod 12)x ≡ 0 (mod 7)

mert

az x ≡ 3 (mod 4) egyenlet megoldásai kielégítik az x ≡ 1 (mod 2)egyenlet megoldásait,

az x ≡ 5 (mod 6) egyenlet megoldásai kielégítik az x ≡ 2 (mod 3)egyenlet megoldásait,

az x ≡ 11 (mod 12) egyenlet megoldásai kielégítik az x ≡ 3 (mod 4) ésx ≡ 5 (mod 6) egyenletek megoldásait.



A megoldás menete:

a1 = 4, a2 = 11, a3 = 0,

m1 = 5,m2 = 12,m3 = 7,

M = 420,M1 = 84,M2 = 35,M3 = 60,

M1 = 4, M2 = 11, M3 = 2,

vegyük észre, hogy fennáll:

M1 · M1 = 1 (mod m1)

M2 · M2 = 1 (mod m2)

M3 · M3 = 1 (mod m3)

84 · 4 = 1 (mod 5)35 · 11 = 1 (mod 12)60 · 2 = 1 (mod 7)

x = 4 · 84 · 4+ 11 · 35 · 11+ 0 · 60 · 2 = 119 (mod 420).


A kínai maradéktétel, ha 2 egyenlet van

Oldjuk meg a következ® egyenletrendszert:

x ≡ 6 (mod 10)x ≡ 8 (mod 13)

A megoldás menete:

M = 130,M1 = 13,M2 = 10,

M1 = 7, M2 = 4,

vegyük észre, hogy fennáll:

M1 · M1 = 1 (mod m1) : 13 · 7 = 1 (mod 10)

M2 · M2 = 1 (mod m2) : 10 · 4 = 1 (mod 13)

x = 13 · 7 · 6+ 10 · 4 · 8 = 86 (mod 130).


RSA, a kínai maradéktétel

a kínai maradéktétel alkalmazható az RSA-nál, a visszafejtési folyamatgyorsítható vele, ekkor 2 egyenletet kell megoldani

az n nagyságrendjével megegyez® d hatványkitev® helyett elvégzünk kétkisebb hatványkitev®vel való hatványozást

fennáll a következ® két összefüggés:

p prímszám, d ≡ dp (mod p − 1) ⇔ cd ≡ cdp (mod p)q prímszám, d ≡ dq (mod q − 1) ⇔ cd ≡ cdq (mod q)

a következ® egyenletrendszert kell megoldanunk a kínai maradéktételsegítségével:

x ≡ cdp (mod p)x ≡ cdq (mod q)


RSA, a kínai maradéktétel

meghatározzuk dp, dq,Mq,Mp értékeket a következ® módon:

dp = d mod(p-1)dq = d mod(q-1)Mq = inverz(q, p)Mp = inverz(p, q)

a cd (mod n) értéket megadja az x értéke, ahol

x = (Mq · q · xp +Mp · p · xq) (mod n)xp = cdp (mod p)xq = cdq (mod q).


Az RSA, a kínai maradéktétel

1. feladat

Az alábbi Python függvény a korábban megadott RSA_fel függvényben, a visszafejt®RSA_decrypt függvény helyett a RSA_decrypt_ függvényt hívja meg, paraméterkéntmeg kell neki adni a p, q értékeket.

def RSA_fel():

k = int(input('bit meret: '))

e, d, n, p, q = RSA_key_gen(k)

print ('nyilvanos kulcs: ', e, n)

print ('titkos kulcs: ', d, n)

print ('titkos adatok: ', p, q)

print('kerek egy szamot, kisebb legyen, mint ', n)

K = int(input())

cK = RSA_crypt(K, e, n)

print ('titkositott ertek: ', cK)

K = RSA_decrypt_(cK, d, n, p, q)

print ('visszafejtett ertek: ', K)


Az RSA, a kínai maradéktétel

2. feladat

A visszafejt® RSA_decrypt_ függvény

def RSA_decrypt_(cK, d, n, p, q):

dp = d % (p-1)

dq = d % (q-1)

Mq = inverz(q, p)

Mp = inverz(p, q)

cKp = pow(cK, dp, p)

cKq = pow(cK, dq, q)

K = (Mq * q * cKp + Mp * p * cKq) % n

return K

A RSA_key_gen és RSA_crypt függvényeket, a 10. el®adásban írtuk meg.


Diofantoszi egyenletek

egész együtthatós többismeretlenes algebrai egyenletek, amelyeknekmegoldásai egész számok (ritkán természetes vagy racionális számok),

elnevezése Diophantosz (3. század), görög matematikus után,

csak els®fokú, kétismeretlenes diofantoszi egyenletekkel fogunkfoglalkozni: a · x +m · y = b

2. tétel

Legyenek a,m egész számok, úgy hogy d = lnko(a,m). Az a · x +m · y = begyenletnek nincs megoldása az egész számok körében, ha d nem osztja b-t.Ha d | b, akkor az egyenletnek végtelen sok megoldása van:

x = x0 + (m/d) · n, y = y0 − (a/d) · n,

ahol n egész szám és x0, y0 az egyenlet egy partikuláris megoldása



a partikuláris megoldás meghatározásához, kiterjesztett Eukleidészialgoritmussal meghatározzuk a x , y , d-t, azaz fennáll: a · x +m · y = d ,

ekkor: x0 = x · (b/d), y0 = y · (b/d),a pozitív megoldások meghatározásához a következ®képpen járunk el:

x0 +m

d· n ≥ 0 ⇒ n ≥ −x0

md

y0 −a

d· n ≥ 0 ⇒ n ≤ y0

ad


Diofantoszi egyenletek, példa

Egy elárusító 1676 ron értékben rendelt almát és körtét. Minden láda alma 36ronba, és minden láda körte 50 ronba kerül. Hány láda almát és hány ládakörtét rendelhetett?

1. megoldás: 16 láda almát és 22 láda körtét rendelt,16 · 36+ 22 · 50 = 1676.

2. megoldás: 41 láda almát és 4 láda körtét rendelt,41 · 36+ 4 · 50 = 1676.

A megoldás menete:

az 36 · x + 50 · y = 1676 diofantoszi egyenlet pozitív megoldásait keressük.

meghatározzuk a = 36, m = 50 legnagyobb közös osztóját: d = 2.

megvizsgáljuk, hogy d = 2 osztja-e 1676-ot.

a kiterjesztett eukleidészi algoritmussal meghatározzuk: x = 7, y = −5értékeket, azaz fennáll 7 · 36+ (−5) · 50 = 2.

megszorozzuk x , illetve y -tb

d=

1676

2= 838-cal.

egy partikuláris megoldás x0 = 5866, y0 = −4190, ekkor fennáll:5866 · 36− 4190 · 50 = 1676



Keressük a pozitív megoldásokat, fenn kell álljon:

5866+50

d· n = 5866+ 25 · n ≥ 0 ⇒ n ≥ −234.64

−4190− 36

d· n = −4190− 18 · n ≥ 0 ⇒ n ≤ −232.7

⇒ n = −234x1 = 5866+ 25 · (−234) = 16y1 = −4190− 18 · (−234) = 22

⇒ n = −233x2 = 5866+ 25 · (−233) = 41y2 = −4190− 18 · (−233) = 4


Diofantoszi egyenletek, példa

Egy elárusító 549 ron értékben rendelt almát és körtét. Minden láda alma 18ronba, és minden láda körte 33 ronba kerül. Mennyi az a minimális ládaszámamit az elárusító rendelhetett?

Megoldások:25 láda alma és 3 láda körte, összesen 28 láda14 láda alma és 9 láda körte, összesen 23 láda3 láda alma és 15 láda körte, összesen 18 láda

Az elárusító 18 láda gyümölcsöt rendelt.



A megoldás menete:

Meghatározzuk 18 és 33 legnagyobb közös osztóját: d = 3.

Megvizsgáljuk, hogy d = 3 osztja-e 549-et.

A kiterjesztett eukleidészi algoritmussal meghatározzuk: x = 2, y = −1értékeket: 2 · 18+ (−1) · 33 = 3.

Megszorozzuk x , illetve y ,549

d= 183-mal.

Egy partikuláris megoldás x0 = 366, y0 = −183.Keressük a pozitív megoldásokat, fenn kell álljon:

366+33

d· n = 366+ 11 · n ≥ 0 ⇒ n ≥ −33.2

−183− 18

d· n = −183− 6 · n ≥ 0 ⇒ n ≤ −30.5



⇒ n = −33x1 = 366+ 11 · (−33) = 3y1 = −183− 6 · (−33) = 15

⇒ n = −32x2 = 366+ 11 · (−32) = 14y2 = −183− 6 · (−32) = 9

⇒ n = −31x3 = 366+ 11 · (−31) = 25y3 = −183− 6 · (−31) = 3

A minimumot az x1 = 3, y1 = 15 megoldás adja, ami összesen 18 ládát jelent.



3. feladat

Határozzuk meg egy egy kétismeretlenes diofantikus egyenlet pozitívmegoldásait.

def diofant (a, m, b): >>> diofant(36, 50, 1676)

(d, xk, yk) = extEuclid (a, m) ...

if b % d != 0:

print ('nincs megoldas')

return

x0 = xk * b//d

y0 = yk * b//d

bd = m//d

ad = a//d

n1 = int (ceil(-x0 / bd))

n2 = int (floor(y0 / ad))

if n1 <= n2:

print('megoldasok:')

for i in range(n1, n2 + 1):

print (x0 + bd * i, y0 - ad * i)

else: print('nincs pozitiv megoldas')


Ál-véletlenszám generátorok (pseudo-random numbergenerators)

a lineáris kongruencián alapuló generátor

a Python véletlenszám generátora

a közép-négyzet módszer (middle-square)

a Blum-Blum-Shub generátor


A lineáris kongruencián alapuló generátor

álvéletlen számokat generál, nagyon gyors, kis memória igény¶,

jó statisztikai viselkedés jellemzi ⇒ olyankor alkalmazzák, amikor nemkövetelmény a rendszerek biztonsága

az alkalmazott matematikai összefüggés:

zi+1 = (a · zi + b) (mod m), ahol 1 ≤ a, b ≤ m − 1, és m ≥ 2, ahol

az m -modulus, az a -szorzó, a b -növekedési-érték, és z0 -kezdeti érték(seed) konstans értékek, kiválasztásuk a generátor használhatóságát ismeghatározza.

Példa, legyen a = 1, b = 7,m = 10, z0 = 3, ekkor

az alkalmazott képlet: zi+1 = (zi + 7) (mod 10), z0 = 3a generált számsorozat: 0 7 4 1 8 5 2 9 6 3 0 7 4 1...



4. feladat

Határozzuk meg z0 = 3,m = 10, a = 1, b = 7 bemenetek esetén, a lineáriskongruencián alapuló generátor által generált els® 15 értéket.

from time import time

def pLinGen(z0):

m, a, b = 10, 1, 7

if z0 != None:

z1 = z0

else: z1 = int(time())

z1 = (z1 * a + b ) % m

return z1

def main(seed = None):

for i in range(15):

seed = pLinGen(seed)

print(seed, end = ' ')

>>> main(3)

0 7 4 1 8 5 2 9 6 3 0 7 4 1 8



a generátor periódusa akkor és csakis akkor lesz maximális, ha:

a és b relatív prímek,a− 1 osztható m minden prímosztójával,a− 1 és m is 4 valamely többszöröse.

tipikus értékek:

m a b

ANSI C 231 1103515245 12345C/C++ 231 214013 2531011Java 248 25214903917 11



5. feladat

Határozzuk meg az AnsiC-nél használt bemeneti paraméterek esetében a generátoráltal generált els® értéket, különböz® kezdeti z0 értékekre.

def randAnsiC(z0 = None):

m = (1 << 31)

a = 1103515245

b = 12345

return pLinGen(m, a, b, z0)

>>> randAnsiC()

1796272615

>>> randAnsiC()

2140508564

>>> randAnsiC(1796272615)

2140508564


A Python véletlenszám generátora

Mersenne Twister-nek (megbízhatatlan Mersenne) hívják. A periódusa219937 − 1 és 53-bites valós számot állít el®. A háttérben lev®matematika: lineáris algebra, véges testek, bináris testek elmélete

a Mersenne Twister algoritmust 1997-ben publikálta, Takuji Nishimura,Makoto Matsumoto két japán kutató

a generátor periódusa egy Mersenne prím

Mersenne prímek: a 2n − 1 alakú prímszámok, pl.:

3 = 22 − 1, 7 = 23 − 1, 31 = 25 − 1, 127 = 27 − 1

csak prím n esetében lesz 2n − 1 prímszám,ha n összetett, akkor 2n − 1 is összetett,ha n prímszám, akkor 2n − 1 lehet összetett is, és prímszám is,

Mersenne számok: 2n − 1 alakú számok, ahol n prím, és 2n − 1 lehetprím, vagy összetett, pl.:2047 = 211 − 1 = 23 · 89; 8388607 = 223 − 1 = 47 · 178481a Python kód elérhet® a wikipédián: link


https://en.wikipedia.org/wiki/Mersenne_Twister

A közép-négyzet módszer (middle-square)

Neumann János módszere:

a kezdeti seed egy n számjegy¶ szám

ezt a számot négyzetre emeljük, szükség esetén kiegészítjük balrólnullásokkal

a véletlenszer¶en generált szám a középs® számjegyekb®l képezett nszámjegy¶ szám lesz

Legyen a seed = 9809802 = 0960400 6046042 = 0364816 6486482 = 0419904 1991992 = 39601 9609602 = 0921600 216⇒ 216


A közép-négyzet módszer (middle-square)

6. feladat

Megadott r kezd®érték esetén határozzuk meg a közép-négyet módszer általgenerált n-ik értéket. Vizsgáljuk a módszer periódusát is.

def midSqr(r, n):

k = len(str(r))

for i in range(n):

x = str( r * r)

y = (len(x) - k) // 2

r = int( x [y: y + k])

print(r, end = ' ')

def midSqrP(r):

k = len(str(r))

L = []

while len(L) == len(set(L)):

x = str( r * r)

y = (len(x) - k) // 2

r = int (x [y: y + k])

L += [r]

return L

>>> midSqrP(8193)

[1252, 5675, 2056, 2271, 1574, 4774, 7910, 5681, 2737, 4911, 1179,

3900, 2100, 4100, 8100, 6100, 2100]


A Blum-Blum-Shub generátor

alkalmas kriptográ�ai rendszerekben, biztonságát a faktorizációs éskvadratikus maradék feltételezés adja

nagy számításigény¶, ezért csak nagy biztonságot követel® rendszereknélalkalmazzák

a moduláris négyzetreemelés az alkalmazott függvény, ahol akövetkez®képpen hozza létre a (b1, b2, . . . bn) bitsorozatot az algoritmus:

bi = ui (mod 2) és ui = u2i−1 (mod N), ahol

u0 a generátor egy kezdeti értéke, amelyet a következ®képpen

választunk ki: u0 = r2 (mod N), ahol rR←− {2, 3, . . . ,N − 1} és

lnko(r ,N) = 1N = P ·Q és P, Q prímek, úgy hogy P = 2 · p + 1, Q = 2 · q + 1 ésp, q is prímek

a generált P,Q értékek tehát biztonságos prímek (safe prime)

a generált prímekre fennáll: P ≡ Q ≡ 3 (mod 4), ezeket még Blumegészeknek is hívják.



Példa

legyen P = 23,Q = 59 két biztonságos prím, N = 1357

legyen u0 = 9

ui = u2i−1 (mod N), bi = ui%2

i ui bi1 81 12 1133 13 1324 04 1089 15 1260 06 1267 17 1315 18 407 1

A generált bitsorozat: 1, 1, 0, 1, 0, 1, 1, 1



7. feladat

Generáljunk l darab bitet a Blum-Blum-Shub generátorral, ahol az alkalmazott Nlegyen egy k bites szám.

def bbs(k, l):

P = safePrime (k//2)

Q = safePrime (k//2)

N = P * Q

r = randint(2, N)

u = (r*r) % N

for i in range(0, l):

u = (u * u) % N

print (u % 2, end = ' ')

>>> bbs(64, 16)

0 1 1 0 1 0 0 1 1 1 0 1 1 1 0 1

def safePrime(k):q = getrandbits(k)if not (q & 1): q += 1while True:

p = 2 * q + 1if miller_rabinT(q, 10) and miller_rabinT(p, 10):

return pq = getrandbits(k)if not (q & 1): q += 1



A BBS generátor biztonsága, akkor megfelel®, ha N legalább 1024 bites. Ahatékonyság növelése érdekében, ha N = 1024, akkor egyszerre 8 bitet, azaz 1bájtot is lekérhetünk, a u % 256 vagy u & 255 m¶veletet alkalmazva.

8. feladat

Írjunk egy Python programot, amely menüpontokból, a következ®ket teszilehet®vé:

a BBS generátorhoz szükséges P,Q prímszámok generálása, illetvebase64-es alakjuknak, állományba való, mentése

a BBS generátorhoz szükséges P,Q prímszámok állományból valókiolvasása

tetsz®leges hosszúságú számsorozat generálása, BBS módszerrel



def bbs256(P, Q, l):

N = P * Q

r = randint(2, N)

u = (r*r) % N

for i in range(0, l):

u = (u * u) % N

print (u & 255, end = ' ')

def myDecode(mStr):

nr = 0

for elem in mStr:

nr = (nr << 8) + elem

return nr

def myEncode(nr):

bL = []

while nr > 0:

bL = [nr & 255] + bL

nr = nr >> 8

return bL



def primeRead(nev):

f = open(nev, 'rt')

temp = f.read()

f.close()

b64P, b64Q = temp.split('\n')

P = myDecode(b64decode(b64P.encode()))

Q = myDecode(b64decode(b64Q.encode()))

return P, Q

def primeWrite(k, nev):

P = safePrime (k//2)

Q = safePrime (k//2)

b64P = b64encode(bytes(myEncode(P)))

b64Q = b64encode(bytes(myEncode(Q)))

f = open(nev, 'wb')

f.write(b64P + b'\n' + b64Q)

f.close()

print('P: ', P, '\nQ: ', Q)

return P, Q



from base64 import b64decode, b64encodedef main():

P, Q = None, Nonewhile True:

x = input('''0- Kilépés1- prímszám generálás/fileba írás2- prímszám beolvasás3- BBS generátor''')

if x == '0': breakif x == '1':

nev = input('az állomány neve: ')k = int(input('a primek bitmérete: '))P, Q = primeWrite(k, nev)

if x == '2':nev = input ('az állomány neve: ')P, Q = primeRead(nev)

if x == '3':if P == None or Q == None:

print('nincs prim')continue

print('P: ', P, '\nQ: ', Q)l = int(input('a számsorozat hossza: '))print('a veletlen számsorozat: ')bbs256(P, Q, l)


diszkrét matematika 12. eloadásmgyongyi/diszkretmat/12... · 2020. 12. 15. · diszkrét...

Documents