Kapitel 2: Zahlentheoretische Algorithmen Gliederung 1 - fbi.h

Kapitel 2: Zahlentheoretische Algorithmen
Gliederung
1.
2.
3.
4.
5.
6.
7.
8.
9.
2/3, Folie 1
Grundlagen
Zahlentheoretische Algorithmen
Sortierverfahren
Ausgewählte Datenstrukturen
Dynamisches Programmieren
Graphalgorithmen
String-Matching
Kombinatorische Algorithmen
Lineare Programmierung
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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 2
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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 3
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
Einfache algorithmische Fragestellungen
 Bestimmung des Produkts von a und b
7641 * 8512
61128000
3820500
76410
15282
... wir wissen bereits, daß die Multiplikation von
a und b nach der Schulmethode im „worst
case“ die Komplexität O(n2) hat, wobei n das
Maximum der Länge von a und b ist
61128000
3820500
91692
61128000
3912192
65040192
2/3, Folie 4
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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 */)
17915 : 43
... die Division von a durch b nach der Schulmethode hat dieselbe Komplexität wie die
Multiplikation nach der Schulmethode
17
0
179
172
... das Bestimmen des Rests von a bei Teilung
durch b gemäß Schulmethode hat im „worst
case“ die Komplexität O(n2) hat, wobei n das
Maximum der Länge von a und b ist
71
43
285
258
27 (/* = 17915 mod 43 */)
2/3, Folie 5
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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 /)
3820
1910
955
477
238
119
59
29
14
7
3
1
2/3, Folie 6
... 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(n2),
wobei n die Länge von a ist
bin(a) = 1110111011001
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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 ≡ m2 mod pq bestimmen, was einfach ist */)
 Entschlüsselung (/* Schritt 1 */)
•
2/3, Folie 7
Charly B. bestimmt zunächst natürliche Zahlen mp < p und mq < q mit
mp ≡ k(p+1)/4 mod p und mq ≡ k(q+1)/4 mod q
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
Bestimmung modularer Potenzen
 Aufgabenstellung
•
•
es seien x, y und z natürliche Zahlen
bestimme r = xy 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 8
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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‘ = 1977326743 */)
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
10n-1 viele Multiplikationen um r‘ zu bestimmen
... die naive Herangehensweise hat im „worst case“ die Komplexität
Ω(10n) und ist offenbar hoffnungslos langsam
2/3, Folie 9
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
Bestimmung modularer Potenzen
 Andere Herangehensweise (/* Beispiel */)
•
es seien x = 7, y = 11 und z = 23
•
berechne bin(y) = 1011
•
•
•
•
berechne r0 = 7 mod 23 (/* = 71 mod 23; also r0 = 7 */)
berechne r1 = r0*r0 mod 23 (/* = 72 mod 23; also r1 = 3 */)
berechne r2 = r1*r1 mod 23 (/* = 74 mod 23; also r2 = 9 */)
berechne r3 = r2*r2 mod 23 (/* = 78 mod 23; also r3 = 12 */)
•
•
setze r‘0 = r0, r‘1 = r1, r‘2 = 1 und r‘3 = r3
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 10
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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*20+1*21+ 0*22 + 1*23 = 1 + 2 + 0 + 8
•
also gilt:
711 = 7(1+2+8) = 71*72*70*78
•
also gilt:
711 ≡ 71*72*70*78 mod 23 ≡ (((71*72)* 70)*78) mod 23
... alle diese Multiplikationen werden gleich modulo 23 ausgeführt, da
somit die Zwischenergebnisse nicht „zu groß“ werden
2/3, Folie 11
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
Bestimmung modularer Potenzen
 Andere Herangehensweise (/* allgemeine Vorgehensweise */)
•
•
2/3, Folie 12
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) = xk,...,x1,x0
2.
berechne
•
r0 = a mod z
•
r1 = r0*r0 mod z
...
•
rk = rk-1* rk-1 mod z
(/* = a1 mod z */)
(/* = a2 mod z */)
(/* = a2k mod z */)
3.
für i = 0, ...,k setze r‘i = ri, falls xi = 1, und r‘i = 1, sonst
4.
berechne r = r‘0*r‘1*...*r‘k mod z (/* schrittweise */)
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Methode des
fortgesetzten
Quadrierens
Kapitel 2: Zahlentheoretische Algorithmen
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(n2)
... Schritt 2 hat im „worst case“ die Komplexität O(n3) (/* 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(n3)
... unter Verwendung der Methode des fortgesetzten Quadrierens
erhält man Verfahren zum Bestimmen der modularen Potenzen,
die im „worst case“ die Komplexität O(n3) hat
2/3, Folie 13
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
Einordnung
 Entschlüsselung (/* Schritt 2 */)
•
•
Charly B. bestimmt ganze Zahlen zp und zq mit zpp + zqq = 1
Charly B. bestimmt die natürlichen Zahlen s1,t1 < pq mit
s1 ≡ (zpp*mq + zqq*mp) mod pq und t1 ≡ (zpp*mq - zqq*mp) mod pq
sowie die Zahlen s2 = pq - s1 und t2 = pq - t1
... die Bestimmung der Zahlen zp und zq müssen wir uns
genauer ansehen
... s1, t1, s2 und t2 zu bestimmen, ist wiederum einfach
2/3, Folie 14
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
Einordnung
 Eine einfache Beobachtung
•
•
es seien p und q Primzahlen
es sei zp und zq ganze Zahlen mit zpp + zqq = 1
es gilt offenbar:
zpp ≡ 1 mod q und zqq ≡ 1 mod p
... zp ist die multiplikative Inverse von p modulo q
... zq 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 15
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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:
•
•
2/3, Folie 16
ggT(a,b) = ggT(b,a) = ggT(a,|b|)
ggT(a,0) = ggT(a,n*a) = |a|
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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
2/3, Folie 17
© 2013 Prof. Steffen Lange
-
HDa/FbI
xt = cyt + r und damit r = (x - cy)*t
a = cxt + yt und damit a = (cx + y)*t
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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
2/3, Folie 18
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Euklid(27,33) = Euklid(33,27)
= Euklid(27,6)
= Euklid(6,3)
= Euklid(3,0)
=3
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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(n2)
Offene Frage: Wie oft wird die Prozedur Euklid(.,.) aufgerufen?
•
es seien (a0,b0),(a1,b1), (a2,b2) die Parameter, die bei den ersten drei
Aufrufen der Procedure Euklid(.,.) übergeben werden
•
offenbar gilt:
•
•
•
a = a0 > b = b0 = a1 > b1 = a2 > b2
a0 = c0b0 + b1 mit c0 ≥ 1 und a1 = c1b1 + b2 mit c1 ≥ 1
also gilt: b0 = a1 = c1b1 + b2 mit c1 ≥ 1
also gilt b0 ≥ b1 + b2 > 2b2
2/3, Folie 19
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
Vorüberlegung
 Der Euklidsche Algorithmus (/* Analyse, cont */)
•
es seien (a0,b0),(a1,b1), ..., (ak,bk) die Parameter, die bei den Aufrufen der
Prozedur Euklid(.,.) übergeben werden
•
analog (/* zu ersten drei Aufrufen */) kann man ganz allgemein zeigen, daß
gilt:
b2 > 2b4 und b4 > 2b6 und und b6 > 2b8 ...
•
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(n3)
2/3, Folie 20
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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 21
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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 22
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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 23
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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 24
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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(n3)
•
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 25
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
Vorüberlegung
 Illustration (/* Korrektheit */)
Berlekamp(27,33) = ( 3,5,-4 )
3 = 5*27 + (-4)*33
Berlekamp(33,27) = ( 3,-4,5 )
3 = (-4)*33 + 5*27
Berlekamp(27,6) = ( 3,1,-4 )
3 = 1*27 + (-4)*6
Berlekamp(6,3) = ( 3,0,1 )
Berlekamp(3,0) = ( 3,1,0 )
2/3, Folie 26
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
3 = 0*6 + 1*3
3 = 1*3 + 0*0
Kapitel 2: Zahlentheoretische Algorithmen
Vorüberlegung
 Der Berlekampsche Algorithmus (/* Korrektheit */)
•
es seien (a0,b0),(a1,b1), ..., (ak,bk) die Parameter, die bei den Aufrufen der
Prozedur Berlekamp(.,.) übergeben werden
•
da bk = 0 und Berlekamp(ak,bk) = (ak,1,0) gilt, folgt ak = 1*ak + 0*bk
•
•
es sei Berlekamp(ai+1,bi+1) = (ak,x‘,y‘) und ak = x‘*ai+1 + y‘*bi+1 (/* IV */)
außerdem gilt ai+1 = bi und bi+1 = r mit r = ai mod bi
•
•
es sei Berlekamp(ai,bi) = (ak,x,y) mit x = y‘ und y = x‘ - (ai div bi)*y‘
es ist zu zeigen, daß x*ai + y*bi = ak gilt (/* IB */)
x*ai + y*bi =
=
=
=
=
2/3, Folie 27
© 2013 Prof. Steffen Lange
-
HDa/FbI
y‘*ai + (x‘ - (ai div bi)*y‘)*bi
y‘*ai + x‘*bi - (ai div bi)*y‘)*bi
x‘*bi + y‘*(ai - (ai div bi)*bi)
x‘*bi + y‘*r
x‘*ai+1 + y‘*bi+1 = ak
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
Bestimmung multiplikativer Inverser
 Einordnung
•
•
es seien p und q Primzahlen
es sei zp und zq ganze Zahlen mit zpp + zqq = 1
•
um zp und zq (/* 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 zp = x und zq = y
•
•
•
2/3, Folie 28
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen
Kapitel 2: Zahlentheoretische Algorithmen
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(n3)
alle anderen Schritte haben im „worst case“ die Komplexität O(n2)
... also kann Charly B. die verschlüsselte Nachricht in moderater
Zeit, d.h. im „worst case“ in Zeit O(n3) entschlüsseln
2/3, Folie 29
© 2013 Prof. Steffen Lange
-
HDa/FbI
-
Effiziente Algorithmen