Randomisierte Algorithmen

Randomisierte Algorithmen
Vorwort
Diese Mitschrift wurde in der Vorlesung „randomisierte Algorithmen“ bei Univ-Prof. Herrn
Dietzfelbinger von Martin Aumüller angefertigt. Diese Vorlesung wurde im Wintersemester
2007/2008 an der TU Ilmenau gehalten. Diese Mitschrift gewährt keine Garantie für Korrektheit, für Verbesserungen oder Kritik stehe ich gern unter [email protected]
zur Verfügung.
3
Inhaltsverzeichnis
Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1 Einführung und Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1 Beispiel: Identität von Polynomprodukten
1.2 Beispiel: Min-Cut-Algorithmus . . . . . . .
1.2.1 Analyse des Min-Cut-Algorithmus . .
1.3 Verifikation von Matrixprodukten . . . . .
1.4 Randomisiertes Quicksort . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . 7
. . 9
. . 9
. 11
. 12
. .. .. ... .. .. .. .. .. .. ...
17
.. .. .. .. .. .. ... .. .. .. .. .. .. .. ... .. .. .. .. .. .. ...
17
3 Modellierung und Transformation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
3.1 Modell, Grundbegriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Typen von randomisierten Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
24
.. .. .. ... .. .. .. .. .. .. .. ... .. .. .. .. .. .. ...
25
2 Grundlagen der Wahrscheinlichkeitsrechnung
2.1 Grundbegriffe
4 Randomisierte Suche
4.1 Suche mit wenigen Zufallsbits . . . . .
4.1.1 Zweifach unabhängige Suche . .
4.2 Suche in angeordneten linearen Listen
4.3 Mediansuche bzw. „k-Selection“ . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
25
25
28
29
.. .. .. ...
33
.
.
.
.
.
.
.
.
.
.
33
33
36
36
38
6 Algebraische Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
6.1
6.2
6.3
6.4
41
41
42
43
5 Randomisierte Algorithmen für Probleme aus der Zahlentheorie
5.1 Fakten aus der Zahlentheorie . . . . . . . . .
5.2 Quadratwurzel mod p, Quadratwurzelziehen
5.3 Der Miller-Rabin-Primzahltest . . . . . . . .
5.3.1 Der Fermat-Test . . . . . . . . . . . . . .
5.3.2 Nichttriviale Quadratwurzeln der 1 . .
Der Satz von Schwartz-Zippel . .
Identität von Polynomen . . . . .
Polynomdeterminanten . . . . . .
Perfekte Matchings auf bipartiten
..
.
..
..
..
.
.
.
.
.
... .. .. .. .
... .. .. .. .
... .. .. .. .
Graphen . . .
5
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Kapitel 1
Einführung und Beispiele
Essentiell für randomisierte Algorithmen sind Zufallszahlengeneratoren. Dabei liefert der Aufruf
von RAND-NUM(k) eine Zufallszahl im Intervall {0, 1, , k − 1}. Wichtig dabei ist, dass es sich
nur um Pseudo-Zufallszahlen handelt. Dabei wird ein zufälliger Startwert(„seed “) genutzt und
dann deterministisch die „Zufallszahl“ bestimmt. Dies soll aber nicht Thema dieser Vorlesung
sein.
Definition 1.1. (Randomisierter Algorithmus)
Idealisierend kann man sagen: Ein Algorithmus/Programm führt echte Zufallsexperimente
durch (z.B. das Werfen einer Münze mit dem Resultat 0/1 bzw. Werfen eines k-seitigen Würfels). Eine Eingabe x bestimmt den Rechenweg und/oder das Ergebnis resA(x) (entspricht einer
Struktur) nicht mehr eindeutig. Die Rechenzeit (bzw. Schrittzahl) ist eine Zufallsvariable
tA(x), dabei kann man den Erwartungswert E(tA(x)) bestimmen.
Wozu benötigt man randomisierte Algorithmen, wenn die Ergebnisse schwanken und nicht
eindeutig festgelegt werden können?
An vielen Beispielen sieht man, dass viele Probleme z.Z. nicht mit deterministischen Algorithmen effizient gelöst werden können. Man erhofft sich von randomisierten Algorithmen einen
Effizienzgewinn in Bezug auf Zeit, Platz und z.B. Approximationsgüte. Weiterhin spielt es
eine wichtige Rolle, um worst-case-Inputs zu vermeiden.
Beispiel 1.2. (randomisiertes Quicksort)
Für alle Inputs x ist E(tA(x)) = O(n log n). Dies steht im Kontrast zu „normalem“ Quicksort,
bei dem es Inputs gibt mit Laufzeit Ω(n2) verursachen.
1.1 Beispiel: Identität von Polynomprodukten
Frage: Ist (x4 + 4 x3 + 6 x2 + 4 x + 1)(x4 − 4 x3 + 6 x2 − 4 x + 1) = (x2 − 1)4?
Allgemein:
•
•
Input: f1(x), , fs(x), g1(x), , gt(x)
Frage: Ist f1(x) · · fs(x) = g1(x) · · gt(x)
Der naive Ansatz ist logischerweise beiden Seiten auszumultiplizieren und danach zu vergleichen.
Dafür ist jedoch der Aufwand von Interesse. Wir definieren:
deg(a0 + a1 x + + an xn) = n für an 0
Wenn wir f1(x) · f2(x) berechnen wollen mit Graden d1 bzw. d2 erreichen wir einen Aufwand
von O(d1 · d2). Wenn wir nun
d f 4 d(f1(x) + + d(fs(x)))
betrachten, sind die Kosten für das Ausmultiplizieren nun O(d2f ) bzw. O(d2g) für die Polynome
g1(x), , gt(x). Wie können wir diesen quadratischen Aufwand verbessern?
Wir definieren:
h(x) 4 f (x) − g(x)
7
8
Einführung und Beispiele
Klar ist, dass
f (x) ≡ g(x) ⇔ h(x) ≡ 0 (Nullpolynom)
Außerdem gilt:
h(x) ≡ 0 ⇒ h(a) = 0 ⇒ f (a) = g(a)∀a ∈ R oder a ∈ N
und
deg(h(x)) ≤ max {d g , d f } = : dh
Wenn wir es nicht mit dem Nullpolynom zu tun haben, d.h. h(x) 0, dann ist
|{a ∈ R|h(a) = 0}| ≤ deg(h(x)) ≤ dh
was äquivalent zu
|{a ∈ R|f (a) = g(a)}| = |{a ∈ R|f (a) = g(a)}|
ist.
Algorithmus 1.1.1
Input: f1(x), , fs(x), g1(x), , gt(x)
P
P
1. Berechne d f = 1≤i≤s d(fi(x)) und d g = 1≤i ≤t d(gi(x)) und dh = max {d f , d g }
•
2. Wähle zufällig eine Zahl a ∈ {0, 1, , 2 · dh − 1}.
3. Berechne f (a) = f1(a) · . · fs(a) und g(a) = g1(a) · · gt(a). Der Aufwand dafür ist O(dh)
Multiplikationen.
4. Ausgabe:
Resultat:
•
0 falls f (a) = g(a)
1 falls f (a) g(a)
nur einfache Berechnungen werden ausgeführt
•
schnelle Laufzeit: O(dh)
•
falls f (x) ≡ g(x), dann ist unsere Ausgabe immer 0 (a ist egal).
Wie verhält sich unser Algorithmus:
•
falls f (x) g(x), d.h. h(x) 0:
|{a ∈ R|a < 2 · dh , h(a) = 0}|
2 · dh
dh
≤
2 · dh
1
=
2
P („Ausgabe 0“) =
Dies ist nicht zufriedenstellend.
Ein Ausweg daraus ist, den Bereich größer zu wählen, z.B. {0, , z · dh − 1}. Das führt zu einer
1
Fehlerschranke von ≤ z . Besser ist dieser Ansatz:
1. for l = 1 to c do
a. b 4 Algo1.1.1(f1, , fs , g1, , gt)
b. if b = 1 then Ausgabe „nicht identisch“
2. Ausgabe „identisch“
Analyse:
•
•
Zeit: O(c · dh)
f (x) ≡ g(x) ⇒ Ausgabe „identisch“
9
1.2 Beispiel: Min-Cut-Algorithmus
•
f (x) g(x) ⇒
P (Ausgabe „identisch“) = c · P (b = 0)
1
1
· ·
=
2
2
c
1
= c
2
Wenn wir z.B. c = 100 wählen, besitzen wir schon eine Wahrscheinlichkeit für das richtige
Ergebnis von
1
1
< 30
100
2
10
Wenn wir nun den Aufwand der naiven Implementierung mit unserem randomisierten Algorithmes für dh = 10000 vergleichen, erhalten wir naiv etwa 108 Multiplikationen gegebenüber
100 · 104 = 106 Multiplikationen bei unserem randomisierten Algorithmus. Dies entspricht auf
einem PC idealisiert den Unterschied zwischen „in ein paar Sekunden berechnet“ zu „benötigt ein
paar Minuten“.
1.2 Beispiel: Min-Cut-Algorithmus
Gegeben sei ein ungerichteter Graph G = (V , E). O.B.d.A sei dieser zusammenhängend, sonst
müssten wir unsere Betrachtungen auf den Zusammenhangskomponenten durchführen. Ein
Schnitt in G sind C ⊆ E mit S ⊆ V und (x, y) ∈ C ⇒ x ∈ S , y S. Also ist (V , E − C) unzusammenhängend. Wir suchen einen Schnitt mit |C | = min {|C ′||C ′ ist Schnitt in G}, also ein Schnitt
mit der geringsten Anzahl von Kanten. Für den Algorithmus ist es von Bedeutung, dass wir
Schlingen (d.h. Kanten der Form e ∈ E und |e| = 1). Parallele Kanten bleiben im folgenden
bestehen.
Algorithmus 1.2.1
1. Wähle Kante e = (i, j) zufällig.
2. Verschmelze i, j zu einem Superknoten (d.h. wir führen eine Kontraktion der beiden
Knoten zu einem Knoten i ′ durch, der die Kanten zu anderen Knoten behält).
Dies wiederholen wir genau (n − 2)-mal. Danach sind nur noch 2 Superknoten vorhanden und
wir haben einen Schnitt gefunden, der V in S und V − S teilt. Die Ausgabe ist C = E ∩ (S ×
(V − S)).
Es lässt sich leicht feststellen, dass die gelieferten Ergebnisse nicht optimal sind, d.h. es
wird nicht garantiert der minimale Schnitt gefunden. Können wir aber abschätzen, wie nah
unsere gefundenen Schnitten an dem tatsächlichen minimalem Schnitt liegen?
1.2.1 Analyse des Min-Cut-Algorithmus
Definition 1.3.
mc(G): = min {|C ||C Schnitt in G} = : k
Sei c0 Schnitt in G mit |c0| = k, d.h. c0 ist ein gesuchter minimaler Schnitt. Folgende Fakten
sind leicht einzusehen:
•
•
(V ,E − c0) hat genau zwei Zusammenhangskomponenten. Gäbe es mehr als zwei Zusammenhangskomponenten, dann könnte man eine Kante aus c0 entfernen und die Zahl der
Komponenten sinkt um 1, ist aber immer noch > 2 ⇒ |c0| ist nicht minimal.
Falls G Mehrfachkanten besitzt. kann zwischen 2 über mehrere Kanten verbundene
Zusammenhangskomponenten nicht eine Kante im Schnitt liegen, weil man diese aus dem
Schnitt entfernen könnte und so |c0| minimieren könnte.
10
Einführung und Beispiele
Für einen optimalen Schnitt gilt als, dass durch den Schnitt in G zwei Zusammenhangskomponenten übrig bleiben und alle Kanten zwischen diesen beiden Komponenten sind im Schnitt.
Unser Wunsch für den Algorithmus wäre es, wenn er den Schnitt c0 finden würde. Dies ist äquivalent damit, dass unser Algorithmus nie zufällig eine Kante aus c0 wählt.
Wir definieren dafür ein Ereignis Ei = {in Runde i wird keine Kante aus c0 gewählt}. Dann
gilt:
Pr(Algorithmus gibt c0 aus) = Pr(E1 ∩ E2 ∩ ∩ En−2)
= Pr(E1) · Pr(E2|E1) · · Pr(En−2|E1 ∩ E2 ∩ ∩ En−3)
=Pr(E1 ∩E2)
Angenommen, es ist E1 ∩ E2 ∩ ∩ Ei−1 eingetreten, d.h. in Runde 1, , i − 1 wurde keine Kante
aus c0 gewählt. Können wir eine Abschätzung für
Pr(Ei |E1 ∩ E2 ∩ ∩ Ei−1) ≤ ?
finden, d.h. wie wahrscheinlich ist es, dass in Runde i eine Kante aus c0 gewählt wird.
Wir wissen, dass |c0| = k gilt, wieviele Kanten sind noch da? Dabei hilft uns eine wichtige
Beobachtung: Jeder Schnitt c in Gi−1 zerlegt auch G. Daraus können wir schlussfolgern,
dass folgendes gilt:
mc(Gi−1) ≥ k
und daraus folgt, dass deg(T ) ≥ k für jeden (Super-)Knoten T in Gi−1. Damit folgt, dass Gi−1
mindestens
k · (n − i + 1)
2
Kanten besitzt, denn Gi−1 hat n − (i − 1) Knoten. Nun können wir unsere Abschätzung vornehmen:
|c0|
Pr(Ei |E1 ∩ E2 ∩ ∩ Ei−1) ≤
k(n − i + 1)/2
k
=
k(n − i + 1)/2
2
=
(n − i + 1)
Damit können wir nun leicht bestimmen, wie groß die Wahrscheinlichkeit ist, dass in Runde i
eine Kante e gewählt wurde, die nicht in c0 liegt.
2
n−i+1
n−i−1
=
n−i+1
Pr(Ei |E1 ∩ E2 ∩ ∩ Ei−1) = 1 −
Damit gilt:
P (E1 ∩ E2 ∩ ∩ En−2) ≥
n−2 n−3 n−4 n−5
3 2 1
·
·
·
· · · ·
n
n−1 n−2 n−3
5 4 3
Wir sehen leicht, dass sich viele Terme untereinander kürzen lassen und wir die Abschätzung
vereinfachen können zu
2
P (E1 ∩ E2 ∩ ∩ En−2) =
n(n − 1)
2
> 2
n
Lemma 1.4.
Pr(Algorithmus gibt c0 aus) ≥
2
n2
Diese Wahrscheinlichkeit ist natürlich sehr gering. Können wir sie weiter verbessern?
11
1.3 Verifikation von Matrixprodukten
Algorithmus 1.2.2
Wiederhole Algorithmus 1.2.1 z-mal mit den Resultaten C1, , Cz. Wähle aus allen
Schnitten denjenigen mit der geringsten Kardinalität C ∗ aus. Gib C ∗ aus.
Auch diesen Algorithmus wollen wir noch kurz analysieren. Es gilt:
Pr(|C ∗| > mc(G)) ≤ Pr((C1 C0) ∧ (C2 C0) ∧ ∧ (Cz C0))
= Pr(C1 C0) · Pr(C2 C0) · · Pr(Cz C0))
z
2
≤ 1− 2
n
Mit z =
n2
2
erhalten wir die Wahrscheinlichkeit für die falsche Ausgabe durch:
Pr(|C ∗| > k) ≤
2
1− 2
n
≤ e−1
1
=
e
n2
2
und damit ist die Wahrscheinlichkeit
schon relativ hoch.
Bekanntermaßen gilt:
Pr(C ∗ ist minimaler Schnitt) ≥ 1 −
∀x ∈ R: 1 + x ≤ ex
und damit für y > 0:
Mit t = c ·
n2
2
1
≈ 0.632
e
(1 + x) y ≤ exy
· ln n und einer Konstante c können wir nun noch eine Abschätzung tätigen:
2
Pr(|C | > k) ≤ 1 − 2
n
∗
c· n2 ·ln n
2
< e−c·ln n =
1
nc
Wir können also durch die Wahl der Konstanten c die Wahrscheinlichkeit einer falschen Ausgabe
des Algorithmus verringern. Es bleibt zu sagen, dass es schnelle deterministische Algorithmen
für dieses Problem existieren, die auf Algorithmen bzgl. maximaler Flüsse basieren. Aber durch
„Tuning“ sind randomisierte Algorithmen (wie der 1.2.2) die schnellsten bekannten Min-CutAlgorithmen.
1.3 Verifikation von Matrixprodukten
Wir rechnen hierfür im Z p = {0, , p − 1}, mit p prim. Dieser stellt bekanntlich einer endlichen
Körper dar. Besonders gibt es also hinsichtlich der Multiplikation ein Inverses. Gegeben sind im
folgenden 3 (n, n)-Matrizen A, B, C über Z p. Wir fragen uns, ob A · B = C gilt. Die naive
Lösung wäre, A · B zu berechnen und das Ergebnis mit C zu vergleichen. Dafür ist der Aufwand
grob mit O(n3) Multiplikationen im Z p abzuschätzen. Geht es auch einfacher? Klar ist, dass für
D=A·B −C
gilt, dass
und genauso für v = (v1, , vn)T ∈ Znp :
A·B =C ⇔D=0
(A · B) v = C v ⇔ D v = 0
Damit können wir folgenden Algorithmus formulieren:
12
Einführung und Beispiele
Algorithmus 1.3.1
1. Wähle v1, , vn ∈ Z p zufällig
2. Berechne u = A · (B · v) und w = C · v (Rechenzeit ist Θ(n2))
3. Ausgabe:
0 falls u = w
1 falls u w
Das Verhalten ist im Falle A · B = C klar, dann ist die Ausgabe 0. Sei nun A · B C, also D 0.
Dann gibt es i, j0 mit di, j0 0. Für v1, , v j0 −1, v j0 +1, , vn beliebig gibt es v j0 ∈ Z p mit
di,1 · v1 + + di,j0 −1 v j0 −1 + di,j0 · v j0 + + di,nv n = 0
und daraus folgt für v zufällig:
Pr(D v = 0) ≤
also
1
p
p(Ausgabe 0) ≤
1
p
1.4 Randomisiertes Quicksort
Gegeben sei ein Feld A[1 n]. Dies enthält Zahlen b1, ., , bn.
Zur Vereinfachung sei b1, , bn verschieden und die Aufgabe ist es, die Zahlen so zu sortieren dass eine sortierte Folge (a1, , an)
ausgegeben wird mit a1 < a2 < < an und (a1, , an) stellt eine Permutation von {b1, , bn } dar.
Ein paar wiederholende Worte zu Quicksort:
•
•
Prozedur qs(l,r): Array A[l r] sortieren mit 1 ≤ l ≤ r ≤ n. Dazu wird ein Pivotelement t
zufällig aus A[l r] gewählt.
qs(l,r) nutzt die Prozedur partition, diese arrangiert A[l r] so um, dass
◦
Pivotelement in A[p] steht mit l ≤ p ≤ r
◦
in A[l p − 1] Einträge < als Pivotelement, wenn p − 1 > l, dann muss qs(l, p − 1)
noch ausgeführt werden
◦
in A[p + 1 r] Einträge > als Pivotelement, wenn p + 1 < r, dann muss qs(p + 1,r)
ausgeführt werden
Der Gesamtaufruf von Quicksort lautet qs(1,n). Klar ist, dass pro Aufruf von Partition das
Pivotelement mit r − l anderen Elementen verglichen wird. Es ergibt sich also ein Zeitaufwand
von O(r − l).
Wenn wir uns den Ablauf des Partitionsvorgangs genauer ansehen, erzeugt der Quicksortaufruf einen (gedachten) Binärbaum, wobei jeweils das Pivotelement Wurzel ist und linker
Teilbaum der Aufruf qs(l,p − 1) wird und rechter qs(p + 1,r). Jeder Schlüssel ai kommt also entweder als Wurzel (Pivotelement) vor oder ist ein Blatt des Aufrufbaums.
Abbildung 1.1. Ablauf eines Quicksort-Aufrufs
13
1.4 Randomisiertes Quicksort
Es bleibt zu erwähnen, dass es maximal (n + 1) viele leere Blätter gibt.
Wie können wir die Laufzeit nun genau abschätzen?
Laufzeit =
O(n)
organisatorischer Aufwand für n QS-Aufrufe
+ O(Anzahl der Vergleiche in Partition)
Partition in qs(l,r) kostet Zeit O(r-l)
Die Anzahl der Vergleiche in allen Partitionsaufrufen wollen wir im folgenden mit C bezeichnen,
C stellt eine Zufallsvariable dar. Wie können wir E(C) (den Erwartungswert der Zufallsvariable
C) bestimmen?
X
C =
#Knoten im Unterbaum mit Wurzel ai
=
1≤i≤n
X
X
1≤i≤n 1≤ j ≤n, j i
Xi,j
mit
Xi, j =
1 falls Knoten a j echter Nachfolger von ai ist
0 sonst
Intuitiv betrachtet, ist ai genau dann ein Vorgänger von aj wenn ai Pivotelement wurde und aj
dabei in A[l r] lag.
X
Xi, j
C =
1≤i, j ≤n,i j
!
X
E(C) = E
Xi,j
1≤i, j ≤n,i j
X
=
E(Xi,j )
1≤i, j ≤n,i j
Dies ist durch die Linearität des Erwartungswertes möglich. Nun gilt:
E(Xi,j ) = Pr(Xi,j = 1)
= Pr(a j echter Nachfahr von ai)
Betrachten wir nun den Fall, dass die Zahlen sortiert die Form a1, a2, , ai , , aj , , an
annehmen (Fall i < j). Anfangs seien {ai , , a j } im selben Teilarray. Dabei erzeugen qs-Aufrufe, bei denen das Pivotelement-Element nicht in {ai , , aj } liegt, ein Teilarray bei denen alle
Elemente von {ai , , aj } im gleichen Teilarray liegen. Irgendwann wird nun ein Pivot-Element
in {ai , , a j } gewählt. Wir unterscheiden dabei 3 Fälle:
1. ak wird als Pivotelement gewählt mit i ≤ k ≤ j. Dann liegt ai in einem anderen Teilbaum
als aj und ai ist nicht Vorfahr von aj .
2. a j wird Pivotelement. Dann ist ai intuitiverweise nicht Vorfahr von a j .
3. ai wird Pivotlement. Dann ist ai echter Vorfahre von a j .
Die Wahrscheinlichkeit, dass ai Pivotelement wird, ist gegeben durch
Für den Fall, dass j > i gilt, ist
1
j −i+1
E(Xi, j ) = Pr(ai Vorfahr von a j )
1
=
j −i+1
Für den zweiten Fall, dass i < j gilt, ist analog
E(Xi,j ) =
1
i−j +1
14
Einführung und Beispiele
Damit können wir nun endlich den Erwartungswert unserer Zufallsvariable C abschätzen:
E(C) =
X
1≤i,j ≤n,i j

1 1 1
0 2 3 4

 1 0 1 1
 2
 1 1 2 13

0 2
= 
 3 2
0




=
2
Sym m etrie
·
1
|j − i| + 1

1
n
1
2
1
2
0





(Die Summe der Einträge dieser Matrix)





1
1
1
1
1
·2+ ·1
(n − 1) + (n − 2) + (n − 3) + +
4
n−1
n
2
3
= 2 · (n (Hn − 1) − (n − 1) + (Hn − 1))
= 2 · ((n + 1)(Hn − 1) − (n − 1))
Folgerung 1.5. Die erwartete Anzahl von Vergleichen von randomisiertem Quicksort auf n
Inputs beläuft sich auf
2((n + 1)(Hn − 1) − (n − 1))
Dies lässt sich mit
2 · O(n log n)
abschätzen.
Um diese Abschätzung zu erläutern, nutzen wir eine leichte Abschätzung:
Abbildung 1.2.
15
1.4 Randomisiertes Quicksort
Es gilt:
Z
n
1
dx
x 1
1
1 1 1
1
1
1
≤
1+
+ +
+
+
+
2
2
2 2 3
2 n−1 n
ln(n) =
1
1. Trap ez
1
1 1
+ + +
n
2 3
1
1
= Hn −
+
2 2n
1
+
=
2
−
1
2·n
Man kann auch noch zeigen, dass
lim Hn − ln n ≈ 0.577 = γ
n→∞
Wobei γ die Eulersche Konstante darstellt. Zusammenfassend gilt für große n:
E(C) =
≈
=
=
2((n + 1)(Hn − 1) − (n − 1))
2 · n(ln n + γ − 1) − 2 · n + O(log n)
2 · n · ln n − (4 − 2 · γ) · n + O(log n)
(n · log n) ·
(2 · ln n)
− 2.86 · n + O(log n)
≈1.38 (Quicksortkonstante)
Satz 1.6. Die erwartete Anzahl von Vergleichen bei Quicksort auf n Inputs kann durch
(2 · ln 2) · n · log n − 2.86 · n + O(log n)
für große n abgeschätzt werden.
Kapitel 2
Grundlagen der Wahrscheinlichkeitsrechnung
Als Grundlage dient folgendes PDF:
plate/startIA/ktea/Lehre/ra/ws07/elemw.pdf
http://www.tu-ilmenau.de/fakia/fileadmin/tem-
2.1 Grundbegriffe
Definition 2.1. Ein Wahrscheinlichkeitsraum ist ein Paar
P (Ω, p) wobei Ω eine endliche
oder abzählbar unendliche Menge ist und p: Ω → [0, 1] mit
w∈Ω p(w) = 1. p bezeichnen wir
auch als Verteilung.
Bemerkung 2.2. Für jedes A ⊆ Ω ist die Reihe
eindeutigen Wert.
P
w ∈A
pw absolut und konvergiert gegen einen
Beispiel 2.3.
1. Werfen eines Würfels: Ω = {1, , 6}, p(1) = = p(6) = 6 . Münzwurf: Ω = {0, 1} mit p(0) =
1
p(1) = 2 .
1
2. Werfen zweier Würfel und die Summe der Augenzahlen ist das Resultat. Diesmal gibt es
gewisse Äquivalenzen, z.B. ist der Wurf einer 6 und einer darauffolgenden 1 gleich dem
Wurf von 5 und 2. Nun gilt:
•
p(2) = 36 , p(3) = 36 , p(4) = 36 , , p(7) = 36 , , p(12) = 36
1
2
3
6
1
3. Die uniforme Verteilung ist definiert auf endlichen Ω. Dann gilt:
p(w) =
1
,w∈Q
|Ω|
Die Sprechweise „wähle w aus Ω zufällig“ weißt immer auf eine uniforme Verteilung
hin.
4. Würfeln, bis die erste 6 kommt. Ω1 = {(a1, , ak , 6)|k ≥ 0, a1, , ak 6} und p1((a1, , ak ,
k+1
1
.
6)) = 6
Weitere Beispiele sind im PDF nachzulesen.
Weiter ist für eine Zufallsvariable X: „die Verteilung von X“ ist ein neuer Wahrscheinlichkeitsraum:
•
•
ΩX = {X(w)|w ∈ Ω}
pX (α) = Pr(X = α) oder auch Pr(X −1({α})).
Wesentliche Ungleichungen
•
Markov:
Pr(Z ≥ t) ≤
E(Z)
(Z ≥ 0)
t
17
18
Grundlagen der Wahrscheinlichkeitsrechnung
•
verallgemeinerte Markov-Ungleichung: Wenn X Zufallsvariable und wenn X ⊆
Def(f ) und f (x) ≥ 0 monoton stets, E(f (x)) ist definiert
Pr(X ≥ t) ≤
laut Wikipedia:
E(f (X))
f (t)
Pr(f (X) ≥ t) ≤
•
E(f (X))
t
Jensensche Ungleichung:
Sei f eine konvexe Funktion. Bei konvexen Funktionen existiert zu einem Punkt (x0,
f (x0)) ein α mit f (x0) + α(x − x0) ≤ f (x). D.h. die Tangente an einem Punkt liegt immer
unterhalb des Funktionsgraphen. Sei X eine Zufallsvariable mit X ⊆ D, D Intervall und
f : D → R. Es gilt:
f (E(X)) ≤ E(f (X))
Beweis.
Sei x0 4 E(X). x0 liegt auch in dem Intervall D. Weil f konvex ist, existiert α mit
f (x0) + α(x − x0) ≤ f (x), x ∈ D
Daraus folgt nun:
f (x0) + α(X − x0) ≤ f (X)
Durch die Monotonie des Erwartungswertes gilt:
E(f (x0) + α(X − x0) ≤ E(f (x))
f (x0) + α · E(X) − α · x0 ≤ E(f (x))
f (x0)=f (E(X))
•
Cauchy-Schwarzsche-Ungleichung:
Dies ist äquivalent zu:
|E(X · Y )| ≤
p
E(X 2) · E(Y 2)
E(X · Y )2 ≤ E(X 2) · E(Y 2)
Beweis.
Für λ ∈ R definiere f (λ) = E((X + λY )2). Es gilt:
E((X + λY )2) = E(X 2) + 2 · λ · E(X · Y ) + λ2 · E(Y 2)
Dies stellt nun ein quadratisches Polynom in λ dar.
1. Fall: E(Y 2) = 0 ⇒ Y = 0 (d.h. Y (ω) = 0 für alle ω mit pω > 0). Daraus folgt aber
nun E(X · Y ) = 0.
2. Fall: E(Y 2) > 0. Dann ist f (λ) wirklich eine quadratische Funktion. Dies bedeutet
wiederum, dass f (λ) eine Parabel ist und da E(Y 2) > 0 hat diese Parabel in
Minimum. Wir differenzieren f (λ):
f ′(λ) = 2 · E(X · Y ) + 2 · λ0 · E(Y 2)
Dies setzen wir 0 und sehen:
λ0 = −
und es gilt:
f (λ0) = E(X 2) + 2 ·
−
E(X · Y )
E(Y 2)
E(X · Y )
E(Y 2)
· E(X · Y ) +
E(X · Y )2
· E(Y 2) ≥ 0
E(Y 2)2
19
2.1 Grundbegriffe
Daraus folgt nun:
E(X 2) · E(Y 2) − E(X · Y )2 ≥ 0
•
Beispiel 2.4. (Markov-Ungleichung)
1. f (x) = eax ⇒
2. f (x) = xk für k ≥ 0, X ≥ 0.
Spezialfall: k gerade, k ∈ N
E(ea·X )
et
E(X k
Pr(X ≥ t) ≤
tk
Pr(ea·X ≥ et) ≤
Pr((X − E(X))k ≥ tk) ≤
denn:
auf
E((X − E(X))k)
tk
Z 4 (X − E(X))2, Z ≥ 0
z
z
k
2
also:
Pr(|X − E(X)| ≥ t) ≤
E((X − E(X))k)
tk
für k = 2 ist dies die Chebychev-Ungleichung, für k ≥ 4 die verallgemeinerte Chebychev-Ungleichung.
Weiter ging es auf dem Wiederholungsblatt mit bedingten Wahrscheinlichkeiten und Unabhängigkeit.
Kapitel 3
Modellierung und Transformation
In diesem Kapitel werden keine konkreten Algorithmen vorgestellt, sondern es geht um die theoretischen Grundlagen der Modellierung von randomisierten Algorithmen. Dafür werden wir die
aus der Vorlesung „Algorithmentheorie“ bekannte Registermaschine.
3.1 Modell, Grundbegriffe
Ein paar kurze Fakten zur Registermaschine:
•
•
•
•
es existiert ein Programm mit Zeilen B0, , Bl−1
der Befehlszeiger steht am Anfang auf 0
den Speicher stellen die Register R0, R1, dar
der Befehlssatz besteht aus arithmetischen Befehlen, Speicherbefehlen und Sprungbefehlen
Definition 3.1. (Konfiguration einer Registermaschine)
Aus dem Befehlszählerstand und dem Speicherinhalt können wir eindeutig den Zustand der
Registermaschine wiederherstellen. Die Konguration einer Registermaschine ist ein Tupel
κ = (Z , α)
mit α: N → N und α(i) ist der Inhalt von Register Ri. Nur endliche viele α(i) sind dabei nicht 0.
Die Menge von Kongurationen ist definiert durch
κM = {κ|κ ist Konfiguration von M }
Bemerkung 3.2. κM ist abzählbar unendlich.
Definition 3.3. (Nachfolgekonfiguration)
κ ⊢M k ′ ⇔ in κ gestartet, geht M in einem Schritt in Konfiguration k ′ über.
Wir führen zusätzlich, um den Anforderungen der Vorlesungsalgorithmen gerecht zu werden, den
Befehl RANDOM ein. Die Semantik von „Random“ ist einfach beschrieben:
Nach dem Schritt steht in R0 einer der Zahlen ∈ {0, , < R0 > − 1}. Jede mit Wahrschein1
lichkeit < R > . Wenn < R0 > = 0 gilt, dann gibt es keine Änderung und wenn < R0 > = 1, dann
0
ist < R0 > danach den Wert 0. Der Befehlszähler wird um eins erhöht.
Die Relation ⊢M wird erweitert auf RRAM (Registermaschine mit Befehl „Random“).
Definition 3.4. (Nachfolgekonfiguration bei RRAM)
κ ⊢M κ ′ , auch wenn der in κ aktuelle Befehl „Random“ ist und κ ′ eine der α(0) möglichen
Nachfolgekonfigurationen ist.
Definition 3.5. (Übergangswahrscheinlichkeiten)
21
22
Modellierung und Transformation
Die Übergangswahrscheinlichkeit von der Konfiguration κ in einem Schritt zur Konfiguration
κ ′ zu gelangen ist definiert durch

′

 undefiniert , es gilt nicht κ ⊢ κ
1
, falls κ = (Z , α), aktueller Befehl in κ ist Random , α(0) ≥ 1, κ ⊢M κ ′
Pκ,κ ′ =
α(0)


1
, sonst
Für eine Registermaschine M und einen Input x gibt es eine Startkonfiguration
κ0 4 init(x)
Wir können alle Berechnungen, die sich daraus ergeben, in einem Berechnungsbaum darstellen. Dabei gibt es bei den jeweiligen Random-Befehlen Verzweigungen mit α(0) Kindern.
Alle anderen Befehle für zu einer eindeutigen Nachfolgekonfiguration. Jede Berechnung ist dabei
ein Weg im Baum.
Definition 3.6. Eine Konfigurationenfolge κ0, κ1, , κt heißt legale Teilberechnung, falls
κ0 ⊢ κ1 ⊢ ⊢ κt. Sie heißt eine legale Berechnung falls zudem κt eine Haltekonfiguration ist,
d.h. der Befehlszähler ist ≥ l. Wir bezeichnen legale Teilberechnung mit ϕ. Es gilt:
P ϕ = Pκ0,κ1 · Pκ1,κ2 · · Pκt−1,κt
Wenn in ϕ genau u Random-Befehle vorkommen, mit r1, , ru jeweils Alternativen, dann ist
Y 1
Pϕ =
ri
1≤i≤u
Definition 3.7. (Bestandteile eines randomisierten Algorithmus)
Ein Algorithmus A besteht aus:
•
M, eine randomisierte Registermaschine
•
O, eine Menge von Outputs
•
Out: κM → O, transformiert eine Haltekonfiguration zu einem Output
•
I, eine Menge von Inputs
•
In: I → κM, transformiert einen Input x in eine Startkonfiguration
Definition 3.8. Für einen Algorithmus A = (M , I , O, In, Out) und einen legalen Input x ∈ I sei:
ΩA,x 4 {ϕ|ϕ ist legale und vollständige Berechnung von M, ϕ = (κ0, , κt), κ0 = In(x)}
Wichtig ist, dass ΩA,x von x abhängt. Jeder Input hat also seinen eigenen Wahrscheinlichkeitsraum.
Bemerkung 3.9. ΩA,x ist abzählbar, da die Menge der Konfigurationen abzählbar ist und
ΩA,x ist eine Teilmenge aller Sequenzen von κM . κM war abzählbar.
Lemma 3.10.
X
ϕ∈ΩA,x
Beweis. (Idee)
Betrachte
Pϕ ≤ 1
ΩA,x,t = {ϕ|ϕ partielle legale Berechnung, ϕ = (κ0, , κs), s ≤ t, k0 = In(x)}
Man kann zeigen (formal mit Induktion über t):
X
ϕ∈ΩA,x,t
Pϕ = 1
23
3.1 Modell, Grundbegriffe
Sei
Ω∗A,x,t = {ϕ|ϕ ist legale Berechnung von M auf x mit Länge ≤ t} ⊆ ΩA,x,t
Daraus folgt dann, dass
X
ϕ∈Ω∗
A,x,t
P ϕ ≤ 1 ⇒t→∞
X
ϕ∈ΩA,x
Pϕ ≤ 1
P
Bemerkung 3.11. Es gilt
ϕ∈ΩA,x < 1, wenn (eine Teilmenge von) Berechnungen nicht
halten. Wir legen betrachten nur Algorithmen A mit
X
Pϕ = 1
ϕ∈ΩA,x
Beispiel 3.12. Ein randomisiertes Programm:
1. R0 ← 2
2. RANDOM
3. IF R0 = 0 goto 0
Der Berechnungsbaum dafür ist leicht aufzustellen. Wir sehen, dass der „linkeste“ Weg nie
stoppt → erzeugt einen unendlichen Berechnungsweg. Müssen wir diesen Algorithmus ausschließen? Es gilt:
X
1 1 1
+ + +
Pϕ =
2 4 8
ϕ∈ΩA,x
= 1
Es gibt also Algorithmen, die in unserem Berechungsmodell liegen, obwohl sie unendliche
Berechnungswege besitzen.
Definition 3.13. (Wahrscheinlichkeitsraum für die Analyse randomisierter Algorithmen)
Unser Wahrscheinlichkeitsraum ist
ΩA,x , (P ϕ) ϕ∈ΩA,x)
Definition 3.14.
Wenn A = (M , I , O, In, Out) ein randomisierter Algorithmus ist, dann definieren wir die
Rechenzeit:
tA,x((κ0, , κt)
4
t
∈ΩA ,x
Wir schreiben auch:
tA(x)
Dabei sollte man vorsichtig sein, denn es handelt sich um eine Zufallsvariable wobei das Argument ϕ unterdrückt wird. Analog kann man auch den Speicherplatz SA(x) definieren. Dies
wird an gegebener Stelle nachgereicht.
Definition 3.15. Erwartete Rechenzeit von A auf x:
tA,x = EA,x(tA,x)
Definition 3.16. (Worst-Case-Rechenzeit)
tˆA(x) 4 sup {tA,x(ϕ)|ϕ ∈ ΩA,x }
Man sollte dabei nicht Maximum schreiben, da es unendliche Berechnungen geben könnte und
die mit dem Maximum nicht „erwischt“ werden.
24
Modellierung und Transformation
Wie üblich ist die Inputmenge in Größenklassen eingeteilt.
Definition 3.17. Für n ∈ N definiere
T̂A(n)
4
TA(n) = sup {t¯A(x)|x ∈ I , size(x) = n}
sup {tA,x(ϕ)|size(x) = n, ϕ ∈ ΩA,x } = sup {tˆA(x)|x ∈ I , size(x) = n}
Definition 3.18. Sei A = (M , I , O, In, Out) ein randomisierter Algorithmus. Das
A auf x ist die folgende Zufallsgröße:
Resultat von
resA,x((κ0, , κt)) 4 Out(κt)
für eine Haltekonfiguration κt. Wir schreiben dafür meistens
A(x) für resA,x
mit
A(x): ΩA,x → O
3.2 Typen von randomisierten Algorithmen
Sei f : I → O eine Funktion und A = (M , I , O, In, Out) ein randomisierter Algorithmus.
Definition 3.19. (Fehlerwahrscheinlichkeit)
errA,f (x) = PrA,x(f (x) ∈[0,1]
heißt die
fest
A(x)
Z ufal lsgröße
Fehlerwahrscheinlichkeit von A bzgl. f auf x.
)
Kapitel 4
Randomisierte Suche
In diesem Kapitel beschäftigen uns Themen wie „Suche mit wenigen Zufallsbits“, „Suchen in
Listen“ und „Median einer Folge“.
4.1 Suche mit wenigen Zufallsbits
Sei A eine beliebige Grundmenge. Wir betrachten eine Menge B ∅ mit B ⊆ A. Unser Ziel ist
es nun ein x ∈ B zu finden. Als Grundlage dafür haben wir den Test „ist ein x in B?“ gegeben.
Eine naive Taktik ist nun x1, x2, in A zufällig zu wählen und zu testen, ob xi ∈ B, bis ein Element von B gefunden wurde. Ein geeignetes Kostenmaß ist dabei die Anzahl der Runden T . Sei
|B |
nun ρ = |A| (die Dichte von B in A). Da diesem Experiment eine geometrische Verteilung
zugrunde liegt ist die erwartete Rundenanzahl
E(T ) =
1
ρ
Wir führen noch ein zusätzliches Kostenmaß ein, die Anzahl von Zufallsbits. Für einen Versuch ist dies etwa ⌈log |A|⌉ Zufallsbits. Die erwartete Anzahl von Zufallsbits ist nun etwa
E(T ) · ⌈log |A|⌉ =
⌈log |A|⌉
ρ
Dies kann sehr groß werden, wenn ρ klein ist. Ein Ziel dieses Abschnitts ist es zu zeigen, dass
O(log |A|) Zufallsbits reichen. Der Trick dafür heißt zweifach unabhängige Suche.
4.1.1 Zweifach unabhängige Suche
Annahme: A hat algebraische Struktur. Dafür betrachten wir A = {0, 1, , |A| − 1}. Sei nun p ≥
|A| eine Primzahl, wobei ein Satz aus der Zahlentheorie sagt, dass ein solches p existiert mit p <
2 · |A|. Sei nun A ′ 4 Z p und B ⊆ A ′. Nun gilt
ρ′ =
|B | ρ
≥
|A ′| 2
Wähle nun r, s aus A zufällig. Die Kosten dafür in „Zufallsbits“ sind 2 · ⌈log |A|⌉ Bits. Teste nun
∈ A. Teste nun, ob diese in B sind. Eine kleine Komplix1, x2, wobei xi 4
r·i+s
Körp erarithm etik in A
kation dabei ist, wenn r = 0 gewählt wird, denn dann gilt xi = s. Im Fall r = 0 setzen wir nun als
Reperatur r = 1.
Algorithmus Paarweise unabh. Suche
1. Wähle r, s ∈ A zufällig
2. falls r = 0 dann setze r = 1
3. i:= − 1
4. repeat
i = i + 1;
5. until x ∈ B
25
26
Randomisierte Suche
6. return x
Analyse der Korrektheit
Weil r 0, gilt {r · 0 + s, r · 1 + s, r · 2 + s, , r · (p − 1) + s} = Z p.Das bedeutet, dass irgendwann ein Element von B gefunden wird (wir hatten als Voraussetzung, dass B ∅).
Analyse der Laufzeit
Für betrachten dabei die Korrektur im Fall r = 0 nicht. Sei nun
1 , falls Xi ∈ B
Yi 4
,0≤i< p
0 , falls Xi B
Für i j ist Xi und Xj unabhängig und daher sind Yi , Y j unabhängig.
Beweis. Um zu zeigen, dass Xi und X j unabhängig sind, muss folgendes gelten:
Pr(Xi = x ∧ Xj = y)
|{(r,s)|r·i+s=x∧r· j +s= y }|
1
= 2
p2
p
= Pr(Xi = x) ·
1
p
Pr(X j = y)
|{(r,s)|r·i+s= y})
p
1
= 2=p
|A|2
p
denn auf der rechten Seite finden wir ein Gleichungssystem, das genau eine Lösung hat.
Für 1 ≤ k ≤ p sei Zk: = Y0 + + Yk−1. Was bedeutet Zk = 0? Es gilt
Zk = 0 ⇔ die ersten k Tests sind erfolglos.
Unser Ziel ist nun Pr(Zk = 0) nach oben abzuschätzen.
Lemma 4.1.
E(Zk) = k · ρ
Var(Zk) = k · ρ(1 − ρ)
Beweis. Es gilt:
E(Zk) =
=
=
=
X
0≤i<k
X
0≤i<k
X
0≤i<k
X
E(Yi)
Pr(Yi = 1)
Pr(Xi ∈ B)
ρ
0≤i<k
Var(Zk) =
=
=
=
=
=
X
= k·ρ
|B |
= k·
|A|
Var(Yi) (wegen paarweiser Unabhängigkeit)
0≤i<k
X
E((Yi − E(Yi))2)
0≤i<k
X
ρ · (1 − ρ)2 + (1 − ρ) · (0 − ρ)2
0≤i<k
X
0≤i<k
X
0≤i<k
X
0≤i<k
E((Yi − ρ)2)
ρ(1 − ρ)((1 − ρ) + ρ)
ρ(1 − ρ)
= k · ρ · (1 − ρ)
27
4.1 Suche mit wenigen Zufallsbits
Nun können wir mit der Chebychew-Ungleichung folgendes schlussfolgern:
Pr(Zk = 0) ≤ Pr(|Z − E(Zk)| ≥ E(Zk))
Var(Zk)
≤
t2
k · ρ(1 − ρ)
=
(k · ρ)2
1−ρ
=
k·ρ
Die Wahrscheinlichkeit, dass die ersten k Runden erfolglos sind, ist also kleiner bzw. gleich
1−ρ
k·ρ
1
Für k ≥ ρ ist der Nenner ≥ 1, also erhält man eine echte Schranke. Wie sieht es nun mit der
erwarteten Rundenzahl aus?
X
Pr(Rundenzahl ≥ k)
E(#Rundenzahl) =
k ≥1
≤ 1+
= 1+
= 1+
X
k ≥2
p
X
1−ρ
(k − 1) · ρ
1−ρ
(weil p = |A|)
(k − 1) · ρ
k=2
p
1−ρ X 1
ρ
k−1
k=2
1−ρ
= 1+
H p−1
ρ
1−ρ
= 1+
ln p
ρ
log |A|
= O
ρ
Unschön dabei ist der log |A|-Faktor. Eine Verbesserung erreichen wir aber, in dem wir den
Algorithmus modifizieren. Wir nutzen 2 Suchen, zweifach unabhängig, die quasiparallel
ablaufen.
Algorithmus modifizierte zweifach unabhängiges Suchen
1. Wähle r1, r2, s1, s2 ∈ A = Z p zufällig (4 · log⌈log |A|⌉ Zufallsbits)
2. Falls r1 = 0, setze r1 = 1. Falls r2 = 0, setze r2 = 1
3. repeat
i=i+1
x1 = r1 · i + s1
if x1 ∈ B, return x1
x2 = r2 · i + s2
if x2 ∈ B,return x2
4. until false (Endlosschleife)
Die Korrektheit ist klar.
Analyse Laufzeit
Sei Xi(1) 4 r1 · i + s1 und Xi(2) = r2 · i + s2 und äquivalent dazu
(
(l)
1 falls Xi(l) ∈ B
Yi 4
0 sonst
(l)
Zk
4
Y0(l) + + Yk−1
(l)
28
Randomisierte Suche
mit l ∈ {1, 2}. Nun gilt:
Pr(Runden 1, , k erfolglos) = Pr(Zk = 0 ∧ Zk = 0)
(2)
(1)
Dies ist unabhängig, also gilt:
(2)
(1)
Pr(Zk = 0) · Pr(Zk = 0) ≤
1− ρ
k·ρ
2
Für die erwartete Rundenzahl gilt nun:
X
Pr(es gibt mehr als k Runden)
E(Rundenzahl) =
k ≥1
k−1 Runden erfolglos
(
2 )
1−ρ
min
≤ 1+
,1
(k − 1) · ρ
k ≥2
2
X X
1
1+
≤ 1+
(k − 1)ρ
1
1
X
2≤k ≤⌊ ρ ⌋+2
1
1
≤ 2+ + 2
ρ ρ
≤ 2+
1
1
+
ρ ρ2
k ≥⌊ ρ ⌋+3
X
1
k ≥⌊ ρ ⌋+3
X
1
k ≥⌊ ρ ⌋+3
Z ∞
1
(k − 1)2
Z k −1
dt
2
k −2 t
dt
1
1
+ ·
ρ ρ2 ⌊ 1 ⌋+1 t2
ρ ∞
1
1
1
1
1
1
= 2+ + 2 · −
= 2+ + 2 · 1
ρ ρ
t ⌊ 1 ⌋+1
ρ ρ ⌊ ⌋+1
≤ 2+
ρ
ρ
1
1
≤ 2+ + 2 · ρ
ρ
ρ
1
= 2 1+
ρ
1
= O
ρ
1
1
Die erwartete Anzahl von Tests ist dann ≤ 4 1 + ρ = O ρ .
In den Notizen findet man noch eine schärfere Abschätzung über die Chebychev-CantelliUngleichung.
4.2 Suche in angeordneten linearen Listen
Für einen Suchschlüssel x, soll der Zeigeger auf das Listenelement xi ≥ x, i minimal sein. OBdA
sei der letzte Schlüssel xn in der Liste ein Wächterelement, d.h. xn = ∞. Wir wissen, dass bei
einer deterministischen Suche die Anzahl der Vergleiche im schlechtesten Fall n ist. Im Durchn
schnitt müssen wir 2 Vergleiche durchführen. Wir wollen diese Vergleichsanzahl durch einen
randomisierten Algorithmus verringern. Eine technische Voraussetzung dabei ist, dass wir auf
zufällige Listenelemente zugreifen können, also direkt auf den Zeiger.
Idee. Wähle ein Listenelement x zufällig. Wir führen eine Fallunterscheidung durch:
1. x = x j
2. Wenn x > x j : Starte Suche bei x j
3. Wenn x < x j : Suche von Anfang
Idee. Wähle zufällig Einträge xi1, xi2, , xil. Wir werden dabei l später festlegen. Finde unter
xi1, , xil das größte Element, das kleiner als x ist und starte Suche dort.
29
4.3 Mediansuche bzw. „k-Selection“
Die Korrektheit des Algorithmus ist intuitiv klar. Von Interesse ist der Zeitbedarf bzw. die
Anzahl der Vergleiche.
Beweis. Sei Y1 = #Vergleiche in 1. Phase ≤ 1 + 2 · L (2 Vergleiche pro xi j ). Wir definieren nun
Y2 4 #Vergleiche in Phase 2 außer den letzten Vergleich
Für uns von Interesse ist der Erwartungswert E(Y ).
Pr(Y2 ≥ j) = Pr(die j Elemente vor Ziel xk wurden in Phase 1 nicht gewählt)
l
n−j
=
n
l
j
= 1−
n
< e
− j ·L
n
Daraus erhalten wir nun
X
E(Y2) =
j ≥1
X
<
Pr(Y2 ≥ j)
e
−j ·l
n
j ≥1
−l/n
e
1 − e−l/n
1
= l/n
e −1
l
1
es gilt: (el/n > 1 + ) <
n
1 + l/n − 1
n
=
l
=
n
Wir haben insgesamt im erwarteten Fall 1 + 2l + 1 + l . Wann wird 2 · l +
n
l
minimal?
n
0 = 2− 2
l
q n
l =
2
Die Anzahl der Vergleiche im erwarteten Fall ergibt sich zu
√
4+2· 2·n
√
in O( n ). Dies ist natürlich besser als O(n) im deterministischen Fall.
4.3 Mediansuche bzw. „k-Selection“
Gegeben sei eine Menge von Elementen S = {a1, , an }.
Definition 4.2. a ∈ S hat Rang k, falls |{i|ai ≤ a}| = k. Der
n
⌈ 2 ⌉.
Die deterministische Situation für diese Probleme:
•
•
Sortieren O(n log n)
geht in O(n) Vergleichen.
Randomisiertes Quickselect
Median ist das Element von Rang
30
Randomisierte Suche
Die Zahlen a1, , an in Array A[1 n]. Wähle t ∈ {1, , n} zufällig (das Pivotelement). Sei
x 4 A[t]. Partitioniere, so dass A[1 p − 1] < x und A[p + 1 n] > x. Wie finden wir damit das kt kleinste Element.
1. Fall: p = k, dann ist x das Element mit Rang k
2. Fall: p > k: Rekursion mit k und A[1 p − 1]
3. Fall: p < k: Rekursion mit k − p und A[p + 1 n]
Die erwartete Anzahl von Vergleichen ist grob: n + 2 + 4 + 8 + < 2 · n. Die exakte Analyse ist
etwas komplizierter. Wir wollen uns primär einen anderen Algorithmus betrachten.
Wir kümmern uns ab hier nur noch um die Mediansuche. Die gezeigten Techniken sind aber
auch für k-Selection benutzbar.
Idee. Finde a ∈ S, a ≤ Median, und b ∈ S, b ≥ Median. Doppelte Partitionierung nun und wir
sortieren den Zielbereich zwischen a und b. Wirbrauchen dafür folgendes: Rang(b)-Rang(a)
n
sollte dafür nicht zu groß sein (unbedingt: o log n ). Die Kosten für das Partitionieren beläuft
n
n
n
sich auf O(n) (später interessiert uns auch die Konstante). Es gilt: A[u] = a und A[v]=b. Wie
finden wir geeignete a und b? Wir nutzen dafür Random Sampling, eine Grundtechnik in den
randomisierten Algorithmen. Wähle L 4 n3/4. Aus Einfachheitsgründen soll n1/4 ∈ N. Wähle L
Elemente aus A zufällig: B = {b1, , bl }. Dies kann auch eine Multimenge sein. Wir sortieren
√
n3/4
n3/4
n3/4
diese Menge in O(n3/4 · log n) = o(n). Wähle in S Elemente vom Rang 2 − 1/4 = 2 − n
n
√
n3/4
a
bzw. 2 + n . Der vollständige Algorithmus ist hier zu finden.
b
Laufzeitanalyse.
•
•
•
B sortieren benötigt O(n3/4log n) = o(n)
A[u + 1 v − 1] sortieren: O(n3/4 · log n) = o(n)
Partitionierung: Wir vergleichen zuerst mit a (n Vergleiche), nur falls > a mit b verglei1
3
chen ( ≤ 2 · n + O(n3/4) Vergleiche). Insgesamt: 2 n + O(n3/4) Vergleiche. Die Konstante
1.5 ist die beste bekannte konstante für Selection.
Zur Analyse benötigen wir einiges mathematisches Werkzeug. Sei Pr(Fall 1) = Pr(A1 ∪ A2)
n
n
wobei A1 = {u > 2 } und A2 = {v < 2 }. Die genaue Darstellung von Fall 1 bzw. Fall 2 kann im
Algorithmus 4.1 nachgelesen werden. Nun sei
Pr(A1) = Pr(bL/2− √n liegt oberhalb des Medians)
Wir nehmen nun an, dass A aufsteigend sortiert wäre, d.h. a1a2 a n a n +1 an. Damit können
2
2
wir die Wahrscheinlichkeit des Ereignisses A1 weiter abschätzen.
√
Pr(A1) = Pr(Folge b1, , bL trifft erste Hälfte {a1, , a n } weniger als L/2 − n − mal)
2
Wir definieren nun neue Zufallsvariable Xi.
(
1 falls A[ji] ∈ {a1, , a n }
2
Xi =
0 sonst
Sei nun X = X1 + + XL. Nun berechnen wir den Erwartungswert:
m 4 E(X) =
Wir wollen nun eine Abschätzung für
Pr(X ≤
L
2
L √
− n) ≤ ?
2
gewinnen. Dafür fehlt uns noch etwas „Handwerkszeug“.
Einschub. Grundlagen der Wahrscheinlichkeitstheorie, Chernoff-Hoeffding-Schranke.
31
4.3 Mediansuche bzw. „k-Selection“
Sei X1, , Xn 0-1-wertig, unabhängig und pi = Pr(Xi = 1). Sei X = X1 + + Xn und m 4
E(X). Wir wollen nun eine Abschätzung für Pr(X ≥ m · (1 + δ)) ≤ ? finden.
Pr(X ≥ (1 + δ) · m) = Pr(et·X ≥ et(1+δ)·m)
E(et·X )
≤ t(1+δ)·m
e
!
Y
t·X
t·X
i
E(e ) = E
e
(4.1)
1≤i≤n
=
=
=
Y
E(et·Xi)
1≤i≤n
Y
1≤i≤n
Y
1≤i≤n
(Einschub: 1 + x ≤ ex) ≤
Y
(pi · et + (1 − pi) e0)
(1 + pi(et − 1))
e pi(e
t
−1)
1≤i≤n
(p1 + + pn)(et −1)
= e
t
= eE(X)(e −1)
t
= em(e −1)
Also:
t
E(et·X ) ≤ em(e −1)
(4.2)
Kombiniere nun (4.1) und (4.2):
t
em(e −1)
et(1+δ)·m
Dies gilt für jedes beliebige t > 0. Wähle t so, dass die rechte Seite möglichst klein wird. Minimiere et − 1 − (1 + δ)t. Daraus können wir schlussfolgern, dass
Pr(X ≥ (1 + δ)m) ≤
t = ln(1 + δ)
den Ausdruck minimiert.
Pr(X ≥ (1 + δ)m) ≤
eδ
(1 + δ)1+δ
m
Das ist die erste Form der Chernoff-Hoeffding-Gleichung. Es gilt:
Pr(X ≥ (1 + δ) · m) ≤ e−δ
2
·m/3
, 0 ≤ δ ≤ 1.8
ist die zweite Form der Chernoff-Hoeffding-Schranke. Ohne Beweis, sei auch der zweite Teil der
Chernoff-Hoeffding-Schranke erwähnt:
m m
e−δ
−δ 2/2
Pr(X ≤ (1 + δ) · m) ≤
≤
e
(1 − δ)1−δ
für alle δ zwischen 0 und 1. Kommen wir nun zu unserer Analyse des Algorithmus zurück.
n3/4/2
2
L √
Pr X ≤ − n ≤ e−δ /2
2
wobei
n3/4 √
L √
− n =
− n
2
2
!
√
n
= m 1 − 3/4
n /2


2
= m · 1 − 1/4 
n
δ
32
Randomisierte Suche
Weiter gilt:
e
−δ 2/2
n3/4/2
=
e
2
n
−√
1/4
= e−·n
Dies ist für gorße n winzig klein. Pr(A2) ≤ e−n
schlussfolgern, dann
1/4
lässt sich analog einsehen. Wir können also
Pr(Fall 1) ≤ 2 · e−n
Wir wollen nun Fall 2 betrachten.
n3/4/2
1/4
Pr(Fall 2 ∧ nicht Fall 1) ≤ ?
Wir führen 2 Ereignisse B1 und B2 ein.
n
B1: v − > D · n3/4
2
n
B2: − n > D · n3/4
2
Ein Ereignis davon muss eintreten.
Pr(Fall 2 ∧ nicht Fall1) ≤ Pr(B1) + Pr(B2)
n
Wir betrachten wieder nur B1 und B2 ergibt sich dann analog.Falls v > 2 + D · n3/4 gilt, dann ist
√
der Rang n3/4 + n in b1, , bL {a1, a2, , a n +D·n3/4}. Sunten ist der Bereich des Arrays
2
n
A[1 2 + D · n3/4]
Pr(B1) = Pr(A[j1], , A[jl] trifft Sunten weniger als n/2 + D · n3/4 − mal)
Wir führen wieder Zufallsvariablen ein:
Xi =
1 falls A[ji] ∈ Sunten
0 sonst
n
=
mit X = X1 + + XL und m 4 E(X) = L · 2 n


m
2
L √
Pr X ≤ + n  ≤ e−δ /2
2
+ D · n3/4
L
2
+D·
√
n.
m(1−δ)
Ein Wert für D von
5
2
((D −1)(
√
n ))2
·m
= e
−
= e
−(D −1)2 ·n/2·(
2·m2
√
n3/4
+D n )
2
→große n 0
ist z.B. gut.
Bemerkung 4.3. Sortieren mit Random Sampling?
Gegeben sei Array A[1 n]. Wähle L Samples, sortiere: b1 ≤ b2 ≤ ≤ bL. Für jedes x in A:
•
•
finde i mit bi ≤ x ≤ bi+1
alle diese x bilden ein Fach Bi.
Der Aufwand ist hier höher als im Medianfall: n · log(L) Vergleiche (mit binärer Suche). Sortiere
dann jedes Fach separat (z.B. mittels Mergesort). Mit Hoeffding
kann man zeigen, dass alle Bi
√
etwa gleich groß sind (bei vernünftiger Wahl von L, z.B. n ). Für einen Prozessor erhält man
dafür kaum Vorteile (normales Quicksort ist schneller). Wenn man L Prozessoren besitzt, kann
jeder Block auf einem Prozessor
gerechnet werden und damit L Blöcke gleichzeitig sortiert
n log n
werden in Gesamtzeit O
.
L
Kapitel 5
Randomisierte Algorithmen für Probleme
aus der Zahlentheorie
Begleitend dazu, sei auf das Skript zu diesem Kapitel unter http://www.tuilmenau.de/fakia/fileadmin/template/startIA/ktea/Lehre/ra/ws07/zahlentheorie-fakten.pdf verwiesen. Beginnen werden wir mit den Themen randomisiertes „Quadratwurzelnziehen modulo p“
und „Primzahltest bzw. Primzahlerzeugung“.
5.1 Fakten aus der Zahlentheorie
Als bekannt vorausgesetzt wird die Division mit Rest: x = q · m + r mit Rest r, wobei r =
x mod m. Zusätzlich sei Z∗m = {0, , m − 1} gegeben. Für beliebiges m ist dies ein Ring, für eine
Primzahl m ein endlicher Körper.
Lemma 5.1. (Bezout)
1. n, m teilerfremd ⇒ ∃x, y: x · m + y · n = 1
2. ∃x, y: x · m + y · n = ggT(n, m)
Beweis und Beispiel dazu im Skript.
Lemma 5.2.
ggT(a, m) = 1 ⇔ ∃b: a · b mod m = 1
Beweis. Folgt fast direkt aus der zweiten Aussage von Bezout.
∗
Für uns ist nun Z∗m = {a|1 ≤ a < m, ggT(a, m) = 1}. Als Beispiel sei Z21
= {1, 2, 4, 5, 8, 10, 11,
13, 16, 17, 19, 20}. Diese Zahlen haben modulo 21 immer ein Inverses.
Satz 5.3. (kleiner Satz von Fermat)
Sei m eine Primzahl, a ∈ Z∗m. Dann gilt:
am−1mod m = 1
Hierbei sei noch die schnelle Exponatiation genannt. Der Kern dabei ist die folgende Vorgehensweise:

 (ak/2 mod m)2 mod m
k gerade



(k −1)/2
2
mod m) · a) mod m k ungerade
ak mod m = ((a

a
k=1


1
k=0
Die Rekursionstiefe ist dabei die Bitanzahl des Exponenten. Für gerade k benötigen wir eine
Mulitplikation. Für ungerade k müssen wir zusätzlich noch mit a multiplizieren.
5.2 Quadratwurzel mod p, Quadratwurzelziehen
Betrachten wir das Beispiel p = 13.
33
34
Randomisierte Algorithmen für Probleme aus der Zahlentheorie
a
1 2 3 4 5 6 7 8 9 10 11 12
a mod 13 1 4 9 3 12 10 10 12 3 9 4 1
2
Tabelle 5.1.
Leicht zu sehen ist, dass jede Quadratzahl 2-mal vorkommt. Dies ist jedoch nicht überrap−1
schend, da a2 mod p = p2 − 2p a + a2 mod p = (p − a)2 mod p ist. Es gibt genau 2 viele Quadratzahlen, da für jedes b maximal zwei Werte a mit a2 mod p = b existieren können. (Die Gleichung X 2 = b hat in einem Körper Z p maximal zwei Lösungen).
Definition 5.4. QR p 4 {a2 mod p|1 ≤ a < p} ist der
quadratische Rest.
Es stellen sich nun mehrere Fragen:
1. Wie erkennt man Quadratwurzeln modulo p? (leicht)
2. Quadratwurzelziehen: Zu b ∈ QR p, finde a mit a2 mod p = b. (randomisiert)
Behauptung. p ungerade Primzahl, a ∈ Z p∗, dann:
1. a(p−1)/2 mod p ∈ {1, p − 1}, dabei spielt p − 1 die Rolle der − 1 in Z p
2. a ∈ QR p ⇔ a(p−1)/2mod p = 1.
Aus 2. ergibt sich dabei sofort der Test: „Ist a ∈ QR p?“.
Beweis.
1. Nach dem kleinen Satz von Fermat gilt für c 4 a(p−1)/2mod p:
c2 mod p = a p−1mod p = 1
Es gibt nur zwei Zahlen in Zp∗ mit d2 mod p = 1, nämlich d = 1 und d = p − 1. Also ist c ∈
{1, p − 1}.
2. wird nachgereicht
Quadratwurzelziehen.
1. (einfach) p + 1 ist durch 4 teilbar. (z.B. bei p = 19). Wenn ein b gegeben ist, und dieses b
p+1
ist ein quadratischer Rest modulo p. Dann ist (b 4 mod p)2mod p = b
p −1
(b 2 mod p) · b = 1 · b = b, denn b ∈ QR p ist ein quadratischer Rest.
p+1
2
mod p =
2. p − 1 ist durch 4 teilbar. (z.B. p = 17). Dafür ist kein deterministischer Algorithmus
bekannt für das Quadratwurzelziehen mit Laufzeit poly(log p).
Algorithmus.
•
Input: a, p
1. Teil:
•
Finde b ∈ Z∗p − QR p (quadratischer Nichtrest):
•
repeat
◦
b: = Zufallszahl in {2, , p − 1}
until (b
p −1
2
2. Teil.
mod p) = p − 1 (erwartete Anzahl von Versuchen ist höchstens 2).
•
Konstruktion der Quadratwurzel:
•
Schreibe 2 (p − 1) = u · 2k, u ungerade, k ≥ 1.
1
gerade
35
5.2 Quadratwurzel mod p, Quadratwurzelziehen
•
Berechne Folge s0, , sk , gerade Zahlen mit
k −i
au·2
•
•
•
s 4 0;
· bsi mod p = 1
for i 4 2 to k do
k −i
· bs/2 mod p = 1 then s 4 s/2
◦
if au·2
◦
else s: = 2 +
s
return a
u+1
2
p−1
2
· bs/2 mod p (das ist eine Quadratwurzel modulo p).
Siehe auch Algorithmus 5.5 aus dem Skriptfragment zur Vorlesung. Die Laufzeit des ersten Teils
ist O(log p) (erwartete Multiplikationen und ≤ 2 Schleifendurchläufe). Im zweiten Teil kann die
Anzahl der Multiplikationen mit O(k · (log p)) = O((log p)2) angeben. Zu zeigen ist noch: es wird
Folge s0, , sk berechnet mit
k −i
au·2 · bsi mod p = 1 ∧ si gerade
Falls die Behauptung stimmt ist die Ausgabe a(u+1)/2 · bsk/2 mod p. Dabei gilt
2
a(u+1)/2 · bsk/2 mod p = a · (au · bsk) mod p
= a · 1 mod p
= a
Wir müssen nun also nur noch die Behauptung beweisen.
Beweis. (Induktion über i)
Sei i = 0:
k
au·2 · bs0 = a
= a
= 1
p −1
2
p −1
2
· b0 mod p
mod p
a ∈ QR p. Das galt nach dem Eulerkriterium.
Sei i > 0: Nach Induktionsvoraussetzung ist die Behuaptung richtig für i.
si k −(i+1)
· b 2 mod p
f 4 au·2
Was passiert, wenn wir f quadrieren?
f 2 mod p =
= 1
k −i
au·2
· bsi mod p
Dafür gibt es zwei Fälle, f = 1 oder f = − 1.
1. Fall: f = 1:
si+1 = si/2
⇒
u·2k −(i+1) si+1
a
·b
mod p = f
= 1
2. Fall: f = − 1:
si+1 = si/2 +

a
u·2k −(i+1)
·
b
si+1
p −1
bsi/2 ·b 2

mod p =
f·
φ−1
2
b
p −1
2
≡−1 m o dp,b QR p
= ( − 1)( − 1) mod p
= 1
!
mod p
36
Randomisierte Algorithmen für Probleme aus der Zahlentheorie
Noch zu zeigen: si gerade. Beweis durch Widerspruch. Annahme si ist ungerade. Dann folgt:
!
au·2
k −(i+1)
·
bsi +1
mod p = 1
quadratischer Rest kein quadratischer R est
Das ist allerdings ein Widerspruch. Quadratischer Rest und kein quadratischer Rest wird nicht
zu einem quadratischen Rest führen.
Bemerkung 5.5. Zentral im Algorithmus ist Finden von b ∈ Z∗p − QR p. Für p ≡ 5 mod 8, z.B.
p = 5, 13, 29, 37, : 2 ∈ Z∗p − QR p. Problematisch sind nur z.B. p = 17, 41, . Für n = p · q gibt es
kein (randomisiertes) effizientes Verfahren für Quadratwurzeln mod n bekannt.
Die Laufzeit ist beschränkt durch log p Schleifendurchläufe (jedesmal eine schnelle Exponentiation) ⇒ Anzahl Multiplikationen mod p: O((log p)2) und O((log p)4) Bitoperationen. Ein
alternativer Algorithmus für Quadratwurzelnziehen (randomisiert) läuft in O((log p)) Multiplikationen.
5.3 Der Miller-Rabin-Primzahltest
Ein Primzahltest soll im Idealfall für eine beliebige natürlich Zahl n bestimmen können, ob n
prim ist oder nicht. Die Ausgabe lautet „ja“(0) bzw. „nein“(1). Der erste Algorithmus, der wirklich ein wichtiger Algorithmus für den Primzahltest war, war 1977 der Algorithmus von
Solovay/Strassen bzw. 1978 dann Miller Rabin (beide randomisiert). Die zentralen Eigenschaften lauten wie folgt:
1. n prim ⇒ Ausgabe 0
1
2. n zusammengesetzt ⇒ Pr(Ausgabe 0) ≤ 2
Randomisierte Primzahltester spielen in der Kryptographie eine zentrale Rolle. Der Primzahltest ist dabei „leicht“ und sehr effizient. Schwierig ist es jedoch, eine Zahl n in Faktoren zu zerlegen (dies ist einfach gesagt die Sicherheitsgrundlage für das RSA-System). Im Jahre 2002
erschien eine Arbeit von Agarwal, Kayal, Saxena, die einen deterministischen Algorithmus vorschlug. Die Laufzeit des Algorithmus war auf typischen Inputs O((log n)4) Multiplikationen (was
nicht unbedingt effizient für große Testzahlen ist).
5.3.1 Der Fermat-Test
Hierfür benötigen wir wieder den kleinen Satz von Fermat. Dieser besagt folgendes:
n prim, 1 ≤ a < n ⇒ an−1 mod n = 1
Wir können diese Betrachtung „umdrehen“:
an−1mod n 1 ⇒ n nicht prim
Diese Aussage führt uns leider nicht zu Faktoren (was typisch ist für Primzahltests). a
bezeichnen wir in diesem Fall als Fermat-Zeuge. Wenn wir a = 2 betrachten, dann ist
a340 mod 341 ≡ 1, wobei 341 = 11 · 31. Wir sehen also, dass allein mit a = 2 alle Primzahlzahlen
bis 341 korrekt klassifiziert werden können.
Fakt. n keine Primzahl, ggT(a, n) > 1 ⇒ an−1 mod n 1.
Dies ist leicht einzusehen, in dem wir annehmen, dass an−1 mod n = 1. Dies ist äquivalent zu
!
n−2
a· a
mod n mod n
Inverses zu a
37
5.3 Der Miller-Rabin-Primzahltest
Daraus folgt, dass a ∈ Z∗m = {a|a teilerfremd zu n}. Daraus folgt der gewünschte Widerspruch,
denn nach Voraussetzung sind a und n nicht teilerfremd.
Die zentrale Idee im Fermat-Test ist es, die F-Zeugen zufällig zu suchen. Wir kommen auf
den folgenden Algorithmus:
1. Wähle a zufällig aus {2, , n − 2};
2. if an−1 mod n 1
then return 1;
else return 0;
Die Laufzeit ist genau eine schnelle Exponentiation: ≤ 2 log n Multiplikationen. Die Fehlerwahrscheinlichkeit verhält sich wie folgt:
•
•
Ausgabe 1: Algorithmus hat F-Zeugen gefunden ⇒ n nicht prim. Daher gilt:
n Primzahl ⇒ Ausgabe ist 0.
Falls n zusammengesetzt:
Pr(Ausgabe 0) =
Wieviele solcher F-Lügner gibt es nun?
#(F-Lügner in {2, , n − 2})
n−3
Auf jeden Fall gilt folgendes:
Pr(Ausgabe 0) ≤
Wie groß kann das werden?
(n − 3) − |Zn − Z∗n | − 1
n−3
Lemma 5.6. Wenn G eine endliche Gruppe ist und H ist eine Untergruppe von G, dann ist
|H | ein Teiler von |G|. Insbesondere: Wenn H echte Untergruppe von G ist, dann gilt |H | ≤
1
|G|.
2
Beobachtung. Ln = {a ∈ Z∗n |a F-Lügner} ist Untergruppe von Z∗n.
Dies kann einfach durch das Untergruppenkriterium gezeigt werden: Wenn G eine endliche
Gruppe mit neutralem Element 1 ist und A eine Teilmenge von G, derart dass
1. 1 ∈ A
2. A unter der Gruppenrelation G ist abgeschlossen, d.h., für a, b ∈ A gilt auch immer a, b ∈
A
dann ist A eine Untergruppe von G.
Wende dies nun auf Ln an. Ln ⊆ Z∗n und 1 ∈ Ln dann gilt
•
a, b ∈ Ln ⇒ an−1 mod n = 1, bn−1 mod n = 1, folgt (a b)n−1 ≡ an−1 · bn−1 = 1 · 1 ≡ 1(mod n)
Satz 5.7. Wenn n ≥ 3 eine ungerade zusammengesetzte Zahl ist derart, dass es mindestens
einen F-Zeugen a ∈ Z∗n gibt, dann liefert der Fermat-Test auf Eingabe n mit Wahrscheinlichkeit
1
größer als 2 die korrekte Antwort 1.
Beweis. Nach Voraussetzung und Beobachtung ist Ln eine echte Untergruppe von Z∗n. Daraus
folgt, dass die Kardinalität von Ln eine echter Teiler von |Z∗n | = ϕ(n). Daraus folgt, dass
Daraus folgt der Satz.
1
1
|Ln | ≤ |Z∗n | = · ϕ(n)
2
2
Um die Fehlerwahrscheinlichkeit weiter zu verbessern, können wir den Fermat-Test unab1
hängig wiederholen und senken somit die Fehlerwahrscheinlichkeit auf ≤ 2l . Dies wird dann
auch als „iterierter Fermat-Test“ bezeichnet.
38
Randomisierte Algorithmen für Probleme aus der Zahlentheorie
Wie gut ist dieser Test nun wirklich? Es gibt ungerade Zahlen n, die zusammengesetzt
sind und Ln = Z∗n. D.h. dann für alle a ∈ Z∗n ist an−1mod n = 1. Solche Zahlen n heißen Carmichael-Zahlen. Die kleinste Carmichael-Zahl ist 561 = 3 · 11 · 17. Weitere sind z.B. 1105 und
1729. Es gibt auch viel größe Carmichael-Zahlen, z.B. 651693055693681 = 72931 · 87517 · 102103
ϕ(n)
eine Charmichael-Zahl mit n > 0.99996. Dafür ist der Wiederholungstrick dann nicht mehr
anwendbar.
Bemerkung. Wenn n zufällig gewählt ist, dann ist
Pr(n Carmichael-Zahl)
sehr klein. Aber n kann natürlich von einem Gegner gewählt werden und deswegen darf ein
Primzahltest auch bei Carmichael-Zahlen nicht versagen.
Lemma 5.8. Wenn n eine Carmichael-Zahl ist, dann ist n keine Primzahlpotenz.
Beweis. indirekt. Annahme: n ist Carmichael-Zahl und n = pl, p prim und l ≥ 2.
Sei nun
a: = pl−1 + 1
Wir zeigen: a ∈ Z∗n ist ein F -Zeuge (also ist n keine Carmichael-Zahl). Sei nun
an−1 (mod n) ≡ (pl−1 + 1)n−1 (mod n)
n − 1 (n−1)(l−1)
n − 1 2(l−1)
+ +
(mod n)
p
≡ 1 + (n − 1)pl−1 +
p
n−1
2
≥n
n = pl teilt p2(l−1), , p(n−1)(l−1)
≡ 1 + (n − 1)pl−1 mod n
≡ 0 mod n
1
≥n
denn sonst wäre
pl−1(pl − 1) mod n = 0
d.h. n = pl teilt pl−1(pl − 1), d.h. p teilt pl − 1 geht nicht.
Folgerung. Jede Carmichael-Zahl n lässt sich als n = n1 · n2 schreiben, wo n1 und n2 teilerfremde ungerade Zahlen ≥ 3 sind.
5.3.2 Nichttriviale Quadratwurzeln der 1
Wir hatten schon folgendes: Wenn p Primzahl und 1 ≤ a < p mit a2 mod p = 1, dann ist a ∈ {1, −
1}. Das sind die trivialen Quadratwurzeln der 1. Wenn a ∈ Z∗p und a2 mod n = 1 mit a {1,
− 1} folgt daraus, dass n keine Primzahl ist. Zum Beispiel ist 112 mod 15 = 1 und damit ist 15
keine Primzahl. Artjukov hat 1966 dann folgendes vorgeschlagen:
n − 1 = u · 2k , k ≥ 1
Sei nun b0 = au mod n, b1 = au·2 mod n, , bk = au·2 mod n. Man sieht nun:
k
an −1
bi+1 = b2i mod n
Daraus können wir sehr leicht nichttriviale Quadratwurzeln finden (Wir quadrieren eine Zahl {1, − 1} und erhalten vielleicht ein Zahl ∈ {1}). Weiter auf dem Arbeitsblatt dazu, ab Seite 21.
Dies ist die Grundlage für den Miller-Rabin-Primzahltest, der in den Aufzeichnungen gefunden
werden kann.
39
5.3 Der Miller-Rabin-Primzahltest
Beobachtungen. Der Zeitaufwand entspricht dem Fermat-Test, also einer Potenzierung
an−1 ≤ 2 · log n Multiplikationen. Wenn die Ausgabe 1 ist, so ist a ein A-Zeuge und damit folgt,
dass n keine Primzahl ist. Wenn n eine Primzahl ist, dann ist die Ausgabe definitiv 0. Es verbleibt noch:
Sei n ≥ 3 zusammengesetzt. Zeige:
Pr(Ausgabe ist 0) ≤
1
2
Bemerkung. Es gilt sogar, dass die Wahrscheinlichkeit ≤
Beweis erfolgen.
1
4
ist, aber dafür müsste ein anderer
A
A
Beweis. Methode: Wir zeigen, dass LA
n = {a|a A-Lügner} ⊆ Bn , Bn ist echte Untergruppe von
∗
Zn.
i
a ist dabei ein A-Lügner, falls für bi = au·2 mod n b0 = 1 ist oder in {b0, , bk−1} kommt die
− 1 vor. Wir unterscheiden nun 2 Fälle.
1. n ist keine Carmichael-Zahl. Daraus folgt nun aber sofort, dass ∃b ∈ Z∗n mit bn−1 mod n F
n−1
1. Wir behaupten nun, dass LA
mod n = 1}. Dies folgt sofort.
n ⊆ Ln = {a|a
2. Sei n eine Carmichael-Zahl. Sei
i
i0 = max {i|0 ≤ i < k, es existiert a ∈ Z∗n mit au·2 mod = − 1}
Klar ist, dass bk = 1 ist für alle a ∈ Z∗n. Eine − 1 muss existieren, da n − 1 ∈ Z∗n. Also gibt
es einen maximalen Index i0, der für ein a nun − 1 ist. Sei nun BnA = {a ∈
i0
Z∗n |au·2 mod n ∈ {1, − 1}}.
A
Behauptung: LA
n ⊆ Bn .
A
Sei a ∈ Ln . Dann gilt
i0
a. au mod n = 1 ⇒ au·2 mod n = 1. Also ist a auch in LA
n.
i
i
b. in {au·2 mod n|0 ≤ i < k} kommt − 1 vor. Also ist au·2 mod n = − 1 ⇒ j ≤ i0. Wenn
i0
j = i0, dann ist a ∈ BnA. Wenn j < i0, dann ist au·2 mod n =
i0 − j
j
au·2 mod n)2
i0 − j
mod n = ( − 1)2
= 1.
Weitere Behauptung:
BnA ist Untergruppe von Z∗n
i0
i0
Klar ist, dass die 1 in BnA liegt. Seien a, b ∈ BnA ⇒ {au·2 mod n, bu·2 } ⊆ {1, − 1} ⇒
i0
(a b)u·2 mod n ∈ {1 · 1, 1 · ( − 1), ( − 1) · 1, ( − 1) · ( − 1)} ⊆ {1, − 1}
und damit ist a b ∈ BnA. Eine weitere Behauptung: BnA ist echte Teilmenge von Z∗n.
Wir hatten unsere Spalte i0 betrachtet (die am weitesten rechts stehende bi0 = − 1).
Wir behaupten nun, dass in diesesr Spalte auch ein Element existiert, dass weder 1 noch
− 1 ist. Weil n eine Carmichael-Zahl ist, kann man n = n1 · n2 schreiben, mit n1, n2 teilerfremd. Der chinesische Restsatz hat folgende Aussage:
Wenn n = n1n2 mit n1, n2 teilerfremd und 0 ≤ a1 < n1, 0 ≤ a2 < n2, dann existiert genau
ein a mit 0 ≤ a < n, so dass
a mod n1 = a1
a mod n2 = a2
i0
Wir nehmen a mit au·2 mod n = − 1. Nun wünschen wir uns
a1
a2
4
4
a mod n1
1
Nach dem chinesischen Restsatz gibt es nun b mit b mod n1 = a1 und b mod n2 = 1. Wir
nehmen nun an, dass
i0
bu·2 mod n = 1
40
Randomisierte Algorithmen für Probleme aus der Zahlentheorie
Dann folgt damit, dass erst recht gilt:
i0
bu·2 mod n1 = 1
Aber:
i0
i0
mod n1
bu·2 mod n1 = au·2
1
i0
= au·2 mod n1
= −1
Das ist ein Widerspruch. Dann versuchen wir es mit
i0
bu·2 mod n = − 1
Dann gilt
i0
Aber wir wissen bereits:
bu·2 mod n2 = − 1
i0
bu·2 mod n2 = 1
i0
Also ist bu·2 weder 1 noch − 1. Und damit ist BnA „nur“ eine echte Teilmenge von Z∗n.
Daraus folgt dann die gewünschte Aussage.
Unser Fazit ist also:
n zusammengesetzt, dann Pr(Augabe 0) ≤
|BnA | − 2 1
<
2
Z∗n
Und als Fakt sei nochmal erwähnt, dass die Wahrscheinlichkeit sogar nur
1
4
beträgt.
Wir wollen uns nun noch etwas mit der Primzahlerzeugung beschäftigen. Wir wollen dabei
eine zufällige Primzahl in [m, 2m) finden. Der native Ansatz ist logisch. Wir wählen eine ungerade Zahl n in [m, 2m) zufällig, bis der Miller-Rabin-Test bei k Wiederholungen die Primeigen1
schaft von n verifiziert (mit Wahrscheinlichkeit 4k ). Dieser Algorithmus ist natürlich sehr naheliegend. Wie sieht die erwartete Anzahl der Schleifendurchläufe aus? Die Frage ist, wieviele
Primzahlen zwischen m und 2m existieren.
m
E(#Schleifendurchläufe) ≤
#Primzahlen in [m,2m)
m · 3 ln (2m)
(Primzahlsatz, siehe Aufzeichnungen) ≤
m
≤ 3 · ln(2m)
= O(log m)
Wie hoch ist die Wahrscheinlichkeit, dass eine zusammengesetzte Zahl als Primzahl ausgegeben
wird? Wir überlegen uns zuerst, dass
Pr(p wird ausgegeben|PZ wird ausgegeben) =
Nun ist
Pr(Ausgabe ist keine Primzahl) ≤
1
#PZ in [m,2m)
1
4k
Das ist wahr, aber mit unseren Kenntnissen ist dies nicht zu rechtfertigen. Was wir beweisen
können, ist dass
E(#Schleifendurchläufe)
log m
Pr(Ausgabe ist keine Primzahl) ≤
=O
4k
4k
Kapitel 6
Algebraische Methoden
6.1 Der Satz von Schwartz-Zippel
Siehe herumgegebenes Blatt.
6.2 Identität von Polynomen
Wir betrachten hierbei multivariate Polynome, z.B:
17 · X12 · X22 · X45 − 23 · X25 + 6 − 19 · X32 · X52
mit Variablen X1, , Xn und Koeffizienten aus Körper K. Der Grad eines Terms ist:
a · X1l1 · · Xnln: l1 + + ln
Der Grad eines Polynoms ist der Maximalgrad der Terme, z.B.
max {10, 5, 0, 4} = 10
Die Aufgabe ist nun, für gegebenes f1, , fr und g1, , gs fragen wir uns, ob für
f = f1 · · fr , g = g1 · · gs
f = g gilt?
Beispiel 6.1. f ist gegeben durch
und g mit
(X1 − 1), (X2 − 1), , (Xn − 1), (X1 + 1), , (Xn + 1)
X12 − 1, X22 − 1, , Xn2 − 1
Wenn man dies sich kurz anschaut, sieht dass f = g gilt. Ein nativer Ansatz würde dies durch
Ausmultiplizieren lösen. Dies führt uns im schlimmsten Falle zu 2n Termen, dies ist exponentiell!
Wir gehen randomisiert so vor: Wähle S ⊆ K , |S | < ∞. Wähle Ka = (a1,
(uniform) zufällig und berechne
, an) aus S n rein
b = f1(a
K ) · f2(aK ) · · fr(aK ), c = g1(aK ) · · gs(aK )
und geben 1 aus, falls b c und 0 aus, falls b = c. Sei nun d = max {deg(f1) +
deg(g1) + + deg(gs)}. Die Menge S soll nun die Größe |S | ≥ 2d haben.
Behauptung. Wenn f = g ist, dann folgt Ausgabe 0. Wenn f g ist, dann
Pr(Ausgabe 0) ≤
41
d
1
≤
|S | 2
+ deg(fr),
42
Algebraische Methoden
Für die Analyse benötigen wir ein kleines Hilfsmittel (aus Kapitel 6.1). Wir wissen: Wenn ein
Polynom
f (X) = anX n + an−1 X n−1 + + a1 X + a0
mit an 0 über einem Körper k existiert, so hat das Polynom maximal n Nullstellen.
Satz 6.2. Wenn f ein Polynom mit n Variablen X1, , Xn und Grad d ≥ 0 ist, und S ⊆ K, so
besitzt f in S n höchstens d · |S |n−1 Nullstellen.
Wenn wir (a1, , an) ∈ S n zufällig wählen:
Pr(f (a1, , an) = 0) ≤
d · |S |n−1
d
=
|S |n
|S |
Den Beweis für den Satz findet man im Material. Diese Schranke ist optimal.
Sei f (X1, , Xn) = (X1 − 1)(X1 − 2) · · (X1 − d) mit K = Z p. Die Nullstellen von f in Z p ist
(i, a2, , an)
Davon gibt es genau d · p
viele.
Wir wollen nun die Analyse für f g und „Algorithmus gibt 0 zurück“ betrachten. Sei h 4
f − g. Wenn f g, dann ist h nicht das Nullpolynom. Der Grad von h kann dabei nicht größer
sein als d. Daraus folgt nun:
n−1
deg(h)
|S |
1
≤
2
Wir haben also einen Monte-Carlo-Algorithmus mit einseitigem Fehler.
Pr((a1, , an) ist Nullstelle von h) ≤
6.3 Polynomdeterminanten
Sei M eine Matrix, deren Einträge Polynome sind.

f11 M = fm1 f1m
fmm
mit fij = fij (X1, , Xn) sind multivariate Polynome.
Als Beispiel sei die Vandermonte-Matrix erwähnt.

1 X1 X12

 1 X2 X22
V (X1, , Xn) =
 2
1 Xm Xm


X1m−1
m−1
Xm





Wir fragen uns nun, ob die Determinante von M 0 ist. (Also das Nullpolynom). Die Determinante berechnet sich durch
X
Y
fi·σ(i)
sign(σ) ·
σ ∈Sn
1≤i≤m
Der Algorithmus für die Überprüfung, ob eine Determinante einer Matrix das Nullpolynom ist,
geht wie folgt:
•
•
S ⊆ K mit |S | ≥ 2d. d ist eine Abschätzung für deg(det(M )). Immer gilt: n · max
{deg(fij )}
Wähle a = (a1, , an) ∈ S n zufällig.
43
6.4 Perfekte Matchings auf bipartiten Graphen
•
berechne:

det(M (a)) = det
f11(a)
f1m(a)
fm1(a)
fmm(a)


Mit Gauß-Elimination über K können wir diese Determinante dann berechnen. Resultat ist als
s = det(M (a)) und falls s = 0: Ausgabe 0, sonst Ausgabe 1. Das Verhalten ist ähnlich zu 6.2:
•
•
det(M ) = 0 ⇒ Ausgabe 0
det(M ) 0: Polynom vom Grad ≤ d ⇒ Pr(Ausgabe 0) ≤ |S | ≤ 2 .
d
1
6.4 Perfekte Matchings auf bipartiten Graphen
Sei G = (U , V , E) mit |U | = |V | = n. Wir wollen auf diesem Graphen ein bipartites Matching
berechnen. Möglichst perfekt. Wir nutzen dafür die Edmonds-Matrix:


f11 f1n
MG = 
fn1 fnn
mit
0
(ui , v j ) E
fij =
Xij (ui , v j ) ∈ E
Wir betrachten einen lustigen Fakt:
Die Determinante von MG ist genau dann nicht 0, wenn G ein perfektes Matching besitzt.
Warum gilt das? Wir wissen, dass
det(MG) =
X
σ∈Sn
sign(σ)
Y
fiσ(i)
1≤i≤n
Das ist genau dann 0, wenn ein Term existiert, der keinen Faktor 0 enthält. Das ist genau
dann, wenn
∃σ ∈ Sn: (ui , vσ(i)) ∈ E , 1 ≤ i ≤ n ⇔ G hat perfektes Matching
Wie testen wir nun auf perfektes Matching? Sei p > 2 n Primzahl. Wähle aij aus Körper {0, ,
p − 1} zufällig, 1 ≤ i, j ≤ n. Berechne nun MG(a11 , , ann)
mit
MG(a11 , , ann) = (bij )1≤i,j ≤n
bij =
aij (ui , v j ) ∈ E
0 (ui , v j ) E
und s = det(MG(a11 , , ann)) über Z p. Falls s = 0 ist, so geben wir 0 zurück. Falls s
geben wir Ausgabe 1 zurück. Die Luafzeit ist dabei O(n3).
Das Verhalten ist wie folgt:
•
G hat kein perfektes Matching ⇒ Ausgabe ist 0.
0 ist,
•
G hat perfektes Matching ⇒ (det(MG) 0) Pr(Ausgabe 0) ≤
•
es gibt einen randomisierten Algorithmus mit Laufzeit O((log n)3) ⇒ Determinantenberechnung
•
es ist kein deterministischer Algorithmus mit Laufzeit (log n)O(1) für dieses Problem
bekannt.
n
p
1
≤2
Konstruktion von perfekten Matchings in allgemeinen (nicht bipartiten) Graphen auf Parallelrechnern: