Kapitel 2: Zahlentheoretische Algorithmen Gliederung

Transkript

1 Gliederung 1. Grundlagen 2. Zahlentheoretische Algorithmen 3. Sortierverfahren 4. Ausgewählte Datenstrukturen 5. Dynamisches Programmieren 6. Graphalgorithmen 7. String-Matching 8. Kombinatorische Algorithmen 9. Lineare Programmierung 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

2 Gliederung des Abschnitts Algorithmische Fragestellungen Fahrplan einfache algorithmische Fragestellung Berechnung von modularen Potenzen der größte gemeinsame Teiler und die Berechnung von modularen Inversen... das ist das aus Sicht der Vorlesung wichtige Unterkapitel... wir diskutieren nur solche algorithmische Fragestellungen die im Zusammenhang mit dem Kryptosystem von Rabin eine wichtige Rolle spielen 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

3 Einfache algorithmische Fragestellungen Aufgabenstellungen es seien a und b ganze Zahlen bestimme das Produkt von a und b bestimme den Rest von a bei Teilung durch b bestimme die Binärdarstellung der Zahl b... uns interessieren Algorithmen zur Lösung dieser Aufgaben und deren Komplexität (/* Anzahl der Elementaroperationen in Abhängigkeit von der Länge der Dezimaldarstellung der gegebenen Zahlen */) 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

4 Einfache algorithmische Fragestellungen Bestimmung des Produkts von a und b 7641 * wir wissen bereits, daß die Multiplikation von a und b nach der Schulmethode im worst case die Komplexität O(n 2 ) hat, wobei n das Maximum der Länge von a und b ist /3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

5 Einfache algorithmische Fragestellungen Bestimmung des Restes bei Teilung von a durch b... es wird a gemäß der Schulmethode durch b geteilt (/* den zu zu bestimmenden Rest erhält man quasi nebenbei */) : (/* = mod 43 */)... die Division von a durch b nach der Schulmethode hat dieselbe Komplexität wie die Multiplikation nach der Schulmethode... das Bestimmen des Rests von a bei Teilung durch b gemäß Schulmethode hat im worst case die Komplexität O(n 2 ) hat, wobei n das Maximum der Länge von a und b ist 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

6 Einfache algorithmische Fragestellungen Bestimmung der Binärdarstellung einer Zahl a... es wird a wird sukzessive halbiert, wobei die Stellen nach dem Komma abgeschnitten werden (/* die zu bestimmende Binärdarstellung von a erhält man quasi nebenbei */) 7641 (/* = a /) bin(a) = man benötigt im worst case nicht mehr als 4*n Divisionen durch 2, wobei n die Länge von a ist... das Bestimmen der Binärdarstellung von a hat im worst case die Komplexität O(n 2 ), wobei n die Länge von a ist 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

7 Einordnung Zur Erinnerung bei der Verwendung des Kryptosystems von Rabin hat offenbar der Empfänger der verschlüsselten Nachricht (/* Charly B. */) die mit Abstand komplexeren Berechnungen durchzuführen (/* Lucie muß nur die Zahl k mit k m 2 mod pq bestimmen, was einfach ist */) Entschlüsselung (/* Schritt 1 */) Charly B. bestimmt zunächst natürliche Zahlen m p < p und m q < q mit m p k (p+1)/4 mod p und m q k (q+1)/4 mod q 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

8 Bestimmung modularer Potenzen Aufgabenstellung es seien x, y und z natürliche Zahlen bestimme r = x y mod z es sei n das Maximum der Länge von x, y und z... wir wollen r bestimmen und interessieren uns für die worst case Komplexität des verwendeten Algorithmus in Abhängigkeit von n 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

9 Bestimmung modularer Potenzen Naive Herangehensweise (/* Beispiel + ganz grobe Analyse */) es seien x = 7, y = 11 und z = 23 berechne r = 7*7*7*7*7*7*7*7*7*7*7 (/* r = */) berechne r mit r = r mod 23 (/* r = 22 */)... zur Berechnung von r benötigt man 10 Multiplikationen... Allgemein: wenn y die Länge n hat, dann benötigt man mindestens 10 n-1 viele Multiplikationen um r zu bestimmen... die naive Herangehensweise hat im worst case die Komplexität Ω(10 n ) und ist offenbar hoffnungslos langsam 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

10 Bestimmung modularer Potenzen Andere Herangehensweise (/* Beispiel */) es seien x = 7, y = 11 und z = 23 berechne bin(y) = 1011 berechne r 0 = 7 mod 23 (/* = 7 1 mod 23; also r 0 = 7 */) berechne r 1 = r 0 *r 0 mod 23 (/* = 7 2 mod 23; also r 1 = 3 */) berechne r 2 = r 1 *r 1 mod 23 (/* = 7 4 mod 23; also r 2 = 9 */) berechne r 3 = r 2 *r 2 mod 23 (/* = 7 8 mod 23; also r 3 = 12 */) setze r 0 = r 0, r 1 = r 1, r 2 = 1 und r 3 = r 3 berechne r = r 0 *r 1 *r 2 *r 3 mod 23 (/* r = 2*/)... zur Berechnung von r benötigt man 6 Multiplikationen sowie 7 Berechnungen von Resten bei Teilung durch 23 (/* man berechnet r 1 = r 0 *r 1 mod 23, dann r 2 = r 1 *r 2 mod 23 und am Ende r = r 3 *r 4 mod 23 */) 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

11 Bestimmung modularer Potenzen Andere Herangehensweise (/* Beispiel, Begründung */) es seien x = 7, y = 11 und z = 23 da bin(y) = 1011 ist, gilt y = 1*2 0 +1* * *2 3 = also gilt: 7 11 = 7 (1+2+8) = 7 1 *7 2 *7 0 *7 8 also gilt: *7 2 *7 0 *7 8 mod 23 (((7 1 *7 2 )* 7 0 )*7 8 ) mod alle diese Multiplikationen werden gleich modulo 23 ausgeführt, da somit die Zwischenergebnisse nicht zu groß werden 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

12 Bestimmung modularer Potenzen Andere Herangehensweise (/* allgemeine Vorgehensweise */) es seien x, y, z natürliche Zahlen es sei n das Maximum der Länge von x, y und z 1. berechne bin(y) = x k,...,x 1,x 0 2. berechne r 0 = a mod z (/* = a 1 mod z */) r 1 = r 0 *r 0 mod z (/* = a 2 mod z */)... r k = r k-1 * r k-1 mod z (/* = a 2k mod z */) Methode des fortgesetzten Quadrierens 3. für i = 0,...,k setze r i = r i, falls x i = 1, und r i = 1, sonst 4. berechne r = r 0 *r 1 *...*r k mod z (/* schrittweise */) 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

13 Bestimmung modularer Potenzen Andere Herangehensweise (/* Analyse */) es seien x, y, z natürliche Zahlen es sei n das Maximum der Länge von x, y und z... Schritt 1 hat im worst case die Komplexität O(n 2 )... Schritt 2 hat im worst case die Komplexität O(n 3 ) (/* die Länge der Binärdarstellung von y hat höchstens die Länge 4n */)... Schritt 3 hat worst case die Komplexität O(n)... Schritt 4 hat worst case die Komplexität O(n 3 )... unter Verwendung der Methode des fortgesetzten Quadrierens erhält man Verfahren zum Bestimmen der modularen Potenzen, die im worst case die Komplexität O(n 3 ) hat 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

14 Einordnung Entschlüsselung (/* Schritt 2 */) Charly B. bestimmt ganze Zahlen z p und z q mit z p p + z q q = 1 Charly B. bestimmt die natürlichen Zahlen s 1,t 1 < pq mit s 1 (z p p*m q + z q q*m p ) mod pq und t 1 (z p p*m q - z q q*m p ) mod pq sowie die Zahlen s 2 = pq - s 1 und t 2 = pq - t 1... die Bestimmung der Zahlen z p und z q müssen wir uns genauer ansehen... s 1, t 1, s 2 und t 2 zu bestimmen, ist wiederum einfach 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

15 Einordnung Eine einfache Beobachtung es seien p und q Primzahlen es sei z p und z q ganze Zahlen mit z p p + z q q = 1 es gilt offenbar: z p p 1 mod q und z q q 1 mod p... z p ist die multiplikative Inverse von p modulo q... z q ist die multiplikative Inverse von q modulo p... mit Hilfe einer Erweiterung des Euklidschen Algorithmus zum Bestimmen des größten gemeinsamen Teilers zweier Zahlen p und q kann man die gesuchten multiplikativen Inversen schnell bestimmen 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

16 Vorüberlegung Zentraler Begriff: Größter gemeinsamer Teiler es seien a, b und c ganze Zahlen c ist ein gemeinsamer Teiler von a und b, falls c sowohl a als auch b teilt c ist der größte gemeinsame Teiler von a und b, wenn es kein c > c gibt, welches ebenfalls gemeinsamer Teiler von a und b ist... wir bezeichnen ggt(a,b) den größten gemeinsamen Teiler von a und b Einige einfache Eigenschaften für alle a, b und n gilt: ggt(a,b) = ggt(b,a) = ggt(a, b ) ggt(a,0) = ggt(a,n*a) = a 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

17 Vorüberlegung Eine wichtige Eigenschaft es seien a und b ganze Zahlen Dann gilt: ggt(a,b) = ggt(b,r) mit r = a mod b... zum Beweis dieser Eigenschaft genügt es zu zeigen, daß für jede Zahl t gilt: t ist gemeinsamer Teiler von a und b ist gdw. t ist gemeinsamer Teiler von b und r Begründung: a = xt, b = yt und r = a mod b b = xt und r = yt xt = cyt + r und damit r = (x - cy)*t a = cxt + yt und damit a = (cx + y)*t 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

18 Vorüberlegung Der Euklidsche Algorithmus es seien a und b ganze Zahlen Prozedur Euklid ( a,b ) { if ( b == 0 ) return(a); else { r = a mod b; return(euklid(b,r)); } } Beispiel: a = 27, b = 33 Euklid(27,33) = Euklid(33,27) = Euklid(27,6) = Euklid(6,3) = Euklid(3,0) = 3 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

19 Vorüberlegung Der Euklidsche Algorithmus (/* Analyse */) es seien a und b ganze Zahlen mit a > b und n das Maximum der Länge der Zahlen a und b offenbar hat jede Ausführung des else-zweigs die Komplexität O(n 2 ) Offene Frage: Wie oft wird die Prozedur Euklid(.,.) aufgerufen? es seien (a 0,b 0 ),(a 1,b 1 ), (a 2,b 2 ) die Parameter, die bei den ersten drei Aufrufen der Procedure Euklid(.,.) übergeben werden offenbar gilt: a = a 0 > b = b 0 = a 1 > b 1 = a 2 > b 2 a 0 = c 0 b 0 + b 1 mit c 0 1 und a 1 = c 1 b 1 + b 2 mit c 1 1 also gilt: b 0 = a 1 = c 1 b 1 + b 2 mit c 1 1 also gilt b 0 b 1 + b 2 > 2b 2 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

20 Vorüberlegung Der Euklidsche Algorithmus (/* Analyse, cont */) es seien (a 0,b 0 ),(a 1,b 1 ),..., (a k,b k ) die Parameter, die bei den Aufrufen der Prozedur Euklid(.,.) übergeben werden analog (/* zu ersten drei Aufrufen */) kann man ganz allgemein zeigen, daß gilt: b 2 > 2b 4 und b 4 > 2b 6 und und b 6 > 2b 8... folglich halbiert sich bei jedem zweiten Aufruf der Prozedur Euklid(.,.) der Wert des zweiten Übergabeparameters da die Prozedur Euklid(.,.) nur aufgerufen wird, wenn der zweite Übergabeparameter ungleich 0 ist, gibt es höchstens O(log(b)) viele Prozeduraufrufe... folglich gibt es nur O(n) viele Prozeduraufrufe (/* es gilt log(b) 4n */) und demzufolge hat die Prozedur Euklid(.,.) im worst case die Komplexität O(n 3 ) 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

21 Vorüberlegung Ein anderer Blick auf den größten gemeinsamen Teiler es seien a und b ganze Zahlen und es sei n = ggt(a,b) Dann gilt: ggt(a,b) = min ( { s 1 s L } ) mit L = { xa+yb x,y Z }... also läßt sich n als Linearkombination von a und b darstellen es seien s 1 das minimal Element in L und x und y so gewählt, daß s = ax + yb gilt Teil 1: man kann zeigen, daß ggt(a,b) auch ein Teiler von s ist... also gilt ggt(a,b) s Teil 2: man kann zeigen, daß s sowohl ein Teiler von a als auch von b ist... also gilt s ggt(a,b) 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

22 Vorüberlegung Der Berlekampsche Algorithmus es seien a und b ganze Zahlen Prozedur Berlekamp ( a,b ) { if ( b == 0 ) return(a,1,0); else { r = a mod b; (d,x,y ) := Berlekamp(b,r); x = y ; y = x - (a Div b)*y ; return((d,x,y)) } }... offenbar gilt d = ggt(a,b) 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

23 Vorüberlegung Der Berlekampsche Algorithmus (/* Beispiel */) a = 27, b = 33 Berlekamp(27,33) = (,, ) Berlekamp(33,27) = (,, ) Berlekamp(27,6) = (,, ) Berlekamp(6,3) = (,, ) Berlekamp(3,0) = ( 3,1,0 ) 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

24 Vorüberlegung Der Berlekampsche Algorithmus (/* Beispiel, cont */) a = 27, b = 33 Berlekamp(27,33) = ( 3,5,-4 ) Berlekamp(33,27) = ( 3,-4,5 ) Berlekamp(27,6) = ( 3,1,-4 ) Berlekamp(6,3) = ( 3,0,1 ) Berlekamp(3,0) = ( 3,1,0 ) 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

25 Vorüberlegung Der Berlekampsche Algorithmus (/* Analyse */) es seien a und b ganze Zahlen mit a > b und n das Maximum der Länge der Zahlen a und b... die Prozedur Berlekamp(.,.) hat offenbar im worst case dieselbe Komplexität wie die Prozedur Euklid(.,.); also ebenfalls O(n 3 ) die Korrektheit beweist man induktiv... wenn Berlekamp(a,b) = (d,x,y) gilt, so soll sowohl d = ggt(a,b) als auch x*a + y*b = ggt(a,b) gelten... das d = ggt(a,b) gilt ist uns schon klar 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

26 Vorüberlegung Illustration (/* Korrektheit */) Berlekamp(27,33) = ( 3,5,-4 ) Berlekamp(33,27) = ( 3,-4,5 ) 3 = 5*27 + (-4)*33 3 = (-4)*33 + 5*27 Berlekamp(27,6) = ( 3,1,-4 ) 3 = 1*27 + (-4)*6 Berlekamp(6,3) = ( 3,0,1 ) 3 = 0*6 + 1*3 Berlekamp(3,0) = ( 3,1,0 ) 3 = 1*3 + 0*0 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

27 Vorüberlegung Der Berlekampsche Algorithmus (/* Korrektheit */) es seien (a 0,b 0 ),(a 1,b 1 ),..., (a k,b k ) die Parameter, die bei den Aufrufen der Prozedur Berlekamp(.,.) übergeben werden da b k = 0 und Berlekamp(a k,b k ) = (a k,1,0) gilt, folgt a k = 1*a k + 0*b k es sei Berlekamp(a i+1,b i+1 ) = (a k,x,y ) und a k = x *a i+1 + y *b i+1 (/* IV */) außerdem gilt a i+1 = b i und b i+1 = r mit r = a i mod b i es sei Berlekamp(a i,b i ) = (a k,x,y) mit x = y und y = x - (a i div b i )*y es ist zu zeigen, daß x*a i + y*b i = a k gilt (/* IB */) x*a i + y*b i = y *a i + (x - (a i div b i )*y )*b i = y *a i + x *b i - (a i div b i )*y )*b i = x *b i + y *(a i - (a i div b i )*b i ) = x *b i + y *r = x *a i+1 + y *b i+1 = a k 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

28 Bestimmung multiplikativer Inverser Einordnung es seien p und q Primzahlen es sei z p und z q ganze Zahlen mit z p p + z q q = 1 um z p und z q (/* die gesuchten multiplikativen Inversen */) zu bestimmen, genügt es die Prozedur Berlekamp(.,.) mit den Parametern a = p und b = q aufzurufen als Ergebnis erhält man ganze Zahlen x und y, so daß xa + by = ggt(a,b) gilt da p und q Primzahlen sind gilt ggt(a,b) = 1 demnach gilt z p = x und z q = y 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

29 Fazit Komplexität der Entschlüsselung beim Kryptosystem von Rabin die zentralen Schritte (/* Schritt 1 und Schritt 2 */) haben jeweils im worst case die Komplexität O(n 3 ) alle anderen Schritte haben im worst case die Komplexität O(n 2 )... also kann Charly B. die verschlüsselte Nachricht in moderater Zeit, d.h. im worst case in Zeit O(n 3 ) entschlüsseln 2/3, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen