Randomisierte und Approximative Algorithmen

Skript zur Vorlesung
Randomisierte und
Approximative Algorithmen
Prof. Dr. Heiko Röglin
Institut für Informatik I
Wintersemester 2011/12
19. Januar 2012
Vorwort
Das vorliegende Skript ist als Begleitmaterial für die Vorlesung „Randomisierte und Approximative Algorithmen“ im Wintersemester 2011/12 an der Universität Bonn konzipiert. Es
wird während des Semesters kontinuierlich erweitert.
Das Skript wird den Vorlesungsinhalt abdecken, aber dennoch empfehle ich den Teilnehmern
der Vorlesung, sich auch die Bücher von Rajeev Motwani und Prabhakar Raghavan [6] und
Michael Mitzenmacher und Eli Upfal [5] anzuschauen. Beide Bücher sind sehr gute Einführungen in das Thema der randomisierten Algorithmen und wurden für den Lesesaal der
Fachschaft beschafft. Wer an einer guten und ausführlichen Einführung in Wahrscheinlichkeitsrechnung interessiert ist, findet diese z. B. in dem Buch von Ulrich Krengel [2].
Ich danke Tobias Brunsch und Michael Etscheid für das Korrekturlesen des Skriptes. Für
Hinweise auf Fehler im Skript und Verbesserungsvorschläge bin ich stets dankbar. Bitte
senden Sie diese an die E-Mail-Adresse [email protected] oder sprechen Sie mich in
der Vorlesung an.
Heiko Röglin
2
Inhaltsverzeichnis
1 Grundlagen der Wahrscheinlichkeitstheorie
5
1.1
Diskrete Wahrscheinlichkeitsräume . . . . . . . . . . . . . . . . . . . . . . . .
5
1.2
Unabhängigkeit und bedingte Wahrscheinlichkeit . . . . . . . . . . . . . . . .
8
1.3
Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
1.3.1
Verifikation von Matrixprodukten . . . . . . . . . . . . . . . . . . . .
11
1.3.2
Berechnung eines minimalen Schnittes . . . . . . . . . . . . . . . . . .
13
Zufallsvariablen und Erwartungswerte . . . . . . . . . . . . . . . . . . . . . .
21
1.4.1
Anwendung: Analyse von Quicksort . . . . . . . . . . . . . . . . . . .
24
1.4.2
Anwendung: Hashing . . . . . . . . . . . . . . . . . . . . . . . . . . . .
27
1.4.3
Binomialverteilung und geometrische Verteilung
. . . . . . . . . . . .
29
1.4.4
Anwendung: Coupon Collector’s Problem . . . . . . . . . . . . . . . .
32
Konzentration von Verteilungen . . . . . . . . . . . . . . . . . . . . . . . . . .
33
1.5.1
Markow- und Tschebyschew-Ungleichung
. . . . . . . . . . . . . . . .
33
1.5.2
Anwendung: Bestimmung des Medians . . . . . . . . . . . . . . . . . .
36
1.4
1.5
2 Komplexitätstheorie für randomisierte Algorithmen
2.1
2.2
42
Rechnermodelle und Komplexitätsklassen . . . . . . . . . . . . . . . . . . . .
42
2.1.1
Probabilistische Rechnermodelle . . . . . . . . . . . . . . . . . . . . .
42
2.1.2
Monte-Carlo- und Las-Vegas-Algorithmen . . . . . . . . . . . . . . . .
44
2.1.3
Komplexitätsklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
45
Untere Schranken für randomisierte Algorithmen . . . . . . . . . . . . . . . .
48
2.2.1
Spielbaumauswertung . . . . . . . . . . . . . . . . . . . . . . . . . . .
48
2.2.2
Das Min-Max-Prinzip . . . . . . . . . . . . . . . . . . . . . . . . . . .
51
2.2.3
Eine untere Schranke für Spielbaumauswertung . . . . . . . . . . . . .
54
3
4
3 Chernoff-Schranken und randomisierte Lastverteilung
3.1
3.2
Chernoff-Schranken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
56
3.1.1
Momenterzeugende Funktionen . . . . . . . . . . . . . . . . . . . . . .
56
3.1.2
Chernoff-Schranken für die Summe von Bernoulli-Zufallsvariablen . . .
57
3.1.3
Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
60
Randomisierte Lastverteilung . . . . . . . . . . . . . . . . . . . . . . . . . . .
62
3.2.1
Anwendung: Bucketsort . . . . . . . . . . . . . . . . . . . . . . . . . .
64
3.2.2
Auslastung der vollsten Kiste . . . . . . . . . . . . . . . . . . . . . . .
65
3.2.3
Anwendung: Verwaltung einer Menge . . . . . . . . . . . . . . . . . .
66
3.2.4
Bloom-Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
67
3.2.5
The Power of Two Choices
69
. . . . . . . . . . . . . . . . . . . . . . . .
4 Markow-Ketten und Random Walks
4.1
4.2
4.3
56
71
Markow-Ketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
71
4.1.1
Anwendung: Randomisierter Algorithmus für 2-SAT . . . . . . . . . .
73
4.1.2
Anwendung: Randomisierter Algorithmus für 3-SAT . . . . . . . . . .
77
Eigenschaften von Markow-Ketten . . . . . . . . . . . . . . . . . . . . . . . .
81
4.2.1
Klassifikation von Zuständen . . . . . . . . . . . . . . . . . . . . . . .
81
4.2.2
Anwendung: Gambler’s Ruin Problem . . . . . . . . . . . . . . . . . .
83
4.2.3
Stationäre Verteilung
. . . . . . . . . . . . . . . . . . . . . . . . . . .
85
Random Walks auf Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
85
4.3.1
Anwendung: Zusammenhangstest . . . . . . . . . . . . . . . . . . . . .
89
4.3.2
Elektrische Schaltungen . . . . . . . . . . . . . . . . . . . . . . . . . .
90
Kapitel 1
Grundlagen der
Wahrscheinlichkeitstheorie
Wir werden uns in dieser Vorlesung mit der Frage beschäftigen, wie wir Zufall beim Entwurf
und der Analyse von Algorithmen einsetzen und ausnutzen können. Dabei werden wir zwei
große Themenkomplexe behandeln. Zunächst werden wir uns mit randomisierten Algorithmen beschäftigen, also Algorithmen, die zufällige Entscheidungen treffen. Auf den ersten
Blick mag es komisch erscheinen, Algorithmen zufällig handeln zu lassen, aber wir werden
sehen, dass randomisierte Algorithmen für viele Probleme effizienter und einfacher sind als
die besten bekannten deterministischen Algorithmen. Das zweite Thema, mit dem wir uns
beschäftigen werden, ist probabilistische Analyse. Dabei geht es darum, das Verhalten von
deterministischen oder randomisierten Algorithmen auf zufälligen Eingaben zu analysieren.
Dies ist sinnvoll, da die klassische Worst-Case-Analyse, bei der man Algorithmen nur basierend auf ihrem schlimmsten Verhalten beurteilt, oft zu pessimistische Ergebnisse liefert.
In diesem Kapitel werden wir die notwendigen Grundlagen der Wahrscheinlichkeitsrechnung
wiederholen und mit Beispielen illustrieren. Die Inhalte sind stark an die ersten Kapitel
von [5] angelehnt.
1.1
Diskrete Wahrscheinlichkeitsräume
Als erstes müssen wir klären, was genau wir unter Zufall verstehen. Dazu geben wir zunächst
eine formale Definition, bevor wir uns über die Interpretation Gedanken machen.
Definition 1.1. Sei Ω eine endliche oder abzählbare Menge, die wir im Folgenden die Ergebnismenge nennen werden. Die Elemente von Ω bezeichnen wir als Elementarereignisse
und jede Teilmenge A ⊆ Ω bezeichnen wir als Ereignis. Für ein Ereignis A bezeichnen wir
mit A = Ω \ A sein Gegenereignis.
Eine Wahrscheinlichkeit (oder Wahrscheinlichkeitsmaß) auf Ω ist eine Funktion Pr : 2Ω →
[0, 1], die jedem Ereignis einen Wert aus dem Intervall [0, 1] zuweist. Es muss dabei Pr(Ω) =
1 gelten und P muss σ-additiv sein, d. h. für jede abzählbare Folge A1 , A2 , . . . von paarweise
disjunkten Ereignissen muss
!
Pr
∞
[
Ai
=
i=1
∞
X
Pr(Ai )
i=1
gelten. Das Paar (Ω, Pr) nennen wir einen diskreten Wahrscheinlichkeitsraum.
5
6
1. Grundlagen der Wahrscheinlichkeitstheorie
Eine direkte Konsequenz aus dieser Definition ist, dass Pr(∅) = 0 gelten muss. Es ist äquivalent zu Definition 1.1, wenn wir die Wahrscheinlichkeit Pr : Ω → [0, 1] zunächst nur auf
P
den Elementarereignissen definieren und durch Pr(A) = a∈A Pr(a) auf beliebige Ereignisse A ⊆ Ω erweitern. Wir müssen dann lediglich Pr(Ω) = 1 fordern, um einen diskreten
Wahrscheinlichkeitsraum im Sinne der obigen Definition zu erhalten.
Bevor wir Beispiele für Wahrscheinlichkeitsräume kennenlernen, überlegen wir uns kurz, wie
Wahrscheinlichkeiten zu interpretieren sind. Tatsächlich gibt es verschiedene Möglichkeiten,
wir wollen hier aber nur kurz den frequentistischen Wahrscheinlichkeitsbegriff ansprechen.
Bei diesem interpretiert man die Wahrscheinlichkeit für ein Ereignis einfach als die relative
Häufigkeit, mit der es bei einer großen Anzahl unabhängig wiederholter Zufallsexperimente
auftritt. Möchten wir also beispielsweise den Wurf eines fairen Würfels modellieren, so setzen wir Ω = {1, 2, 3, 4, 5, 6} als die Ergebnismenge und Pr(i) = 1/6 für jedes i ∈ Ω. Die
Wahrscheinlichkeit Pr(1) = 1/6 ist dann so zu interpretieren, dass bei einer großen Anzahl
unabhängiger Würfe des Würfels in einem Sechstel der Fälle die Zahl 1 geworfen wird.
Kommen wir nun zu weiteren Beispielen für diskrete Wahrscheinlichkeitsräume.
• Bei dem obigen Beispiel eines Würfelwurfes entspricht das Ereignis, eine gerade Zahl
zu würfeln, der Menge A = {2, 4, 6}. Die Wahrscheinlichkeit dafür ergibt sich mittels
Additivität zu Pr(A) = Pr(2) + Pr(4) + Pr(6) = 1/2, was unserer Intuition entspricht, dass bei einer großen Anzahl an Würfen in der Hälfte der Fälle eine gerade
Zahl herauskommt.
• Werfen wir zwei faire Münzen nacheinander, so wählen wir als Ergebnismenge Ω =
{(K, K), (K, Z), (Z, K), (Z, Z)}, wobei (Z, K) zum Beispiel dafür steht, dass die erste
Münze „Zahl“ und die zweite „Kopf“ ergibt. Intuitiv ist klar, dass bei fairen Münzen alle Elementarereignisse die gleiche Wahrscheinlichkeit haben. Deshalb setzen wir
Pr((K, K)) = Pr((K, Z)) = Pr((Z, K)) = Pr((Z, Z)) = 1/4. Das Ereignis, dass die
erste Münze „Kopf“ ergibt, entspricht dann der Menge A = {(K, K), (K, Z)}. Gemäß
der Additivität ergibt sich Pr(A) = Pr((K, K)) + Pr((K, Z)) = 1/2, was unserer Intuition entspricht, dass die erste Münze bei einer großen Anzahl Wiederholungen in
der Hälfte der Fälle „Kopf“ ergibt.
• Wir werfen zwei faire Münzen; diesmal aber nicht nacheinander, sondern gleichzeitig.
Gehen wir davon aus, dass wir die Münzen nicht unterscheiden können, dann enthält
die Ergebnismenge nur noch drei Elementarereignisse: Ω = {{K, K}, {Z, Z}, {K, Z}}.
Entweder beide Münzen zeigen „Kopf“, beide Münzen zeigen „Zahl“ oder eine Münze
zeigt „Kopf“ und die andere „Zahl“. Diese drei Elementarereignisse sind aber nicht mehr
gleichwahrscheinlich. Man überlegt sich leicht, dass Pr({K, K}) = Pr({Z, Z}) = 1/4
und Pr({K, Z}) = 1/2 gelten.
Als nächstes Beispiel betrachten wir den ersten randomisierten Algorithmus, den wir in
dieser Vorlesung kennenlernen werden. Wir gehen davon aus, dass wir testen möchten, ob
zwei univariate Polynome über den reellen Zahlen gleich sind. Wir können aber auf die
Polynome nicht direkt zugreifen und die Koeffizienten auslesen, sondern die Polynome sind
lediglich als Black Box gegeben. Wir können einer Black Box, die ein Polynom p beschreibt,
einen Wert x ∈ N übergeben und erhalten als Ergebnis den Wert p(x) zurück. Wie testen
wir nun, ob zwei Polynome p und q, die jeweils durch eine Black Box beschrieben werden
und von denen wir nur wissen, dass ihr Grad maximal d ∈ N ist, gleich sind? Dazu halten
wir zunächst fest, dass auch die Differenz p − q ein Polynom mit Grad höchstens d ist, das
wir mit Hilfe der Black Boxes auswerten können. Diese Polynom ist genau dann gleich dem
1.1. Diskrete Wahrscheinlichkeitsräume
7
Nullpolynom, wenn p und q gleich sind. Ansonsten besitzt das Polynom p − q gemäß dem
Fundamentalsatz der Algebra höchstens d viele reelle Nullstellen.
Wir schlagen den folgenden einfachen randomisierten Algorithmus vor: Wähle uniform zufällig einen Wert x ∈ {1, . . . , 100d} und werte p(x) − q(x) aus. Falls p(x) − q(x) 6= 0 gilt,
so gib aus, dass die Polynome p und q nicht übereinstimmen. Ansonsten gib aus, dass die
Polynome p und q übereinstimmen. Formal ist die Ergebnismenge Ω = {1, . . . , 100d} und
uniform zufällig bedeutet, dass jedes Elementarereignis die gleiche Wahrscheinlichkeit hat,
also Pr(1) = . . . = Pr(100d) = 1/(100d).
Sind die Polynome p und q identisch, so wird p(x)−q(x) für jedes x ∈ Ω den Wert 0 annehmen.
In diesem Falle gibt der Algorithmus also mit Wahrscheinlichkeit Pr(Ω) = 1 aus, dass die
Polynome übereinstimmen und liefert somit stets das richtige Ergebnis. Sind die Polynome p
und q nicht identisch, so liefert der Algorithmus nur dann eine falsche Antwort zurück, wenn
das zufällig gewählte x eine Nullstelle von p − q ist. Seien y1 , . . . , yk die Nullstellen von p − q,
die in der Menge {1, . . . , 100d} liegen. Wir wissen, dass k ≤ d gilt, und somit beträgt die
Fehlerwahrscheinlichkeit Pr({y1 , . . . , yk }) = Pr(y1 ) + . . . + Pr(yk ) = k/(100d) ≤ 1/100.
Wir haben einen Algorithmus mit einseitigem Fehler entworfen: Sind p und q identisch, so
gibt der Algorithmus stets das richtige Ergebnis aus. Sind p und q nicht identisch, so liefert
der Algorithmus mit mindestens 99-prozentiger Wahrscheinlichkeit das richtige Ergebnis.
Ein deterministischer Algorithmus hätte p − q an d + 1 vielen Stellen auswerten müssen,
um das korrekte Ergebnis zu liefern. Wir haben also die Laufzeit um den Faktor d + 1 auf
Kosten einer kleinen Fehlerwahrscheinlichkeit reduziert. Wir werden später sehen, wie wir
die Fehlerwahrscheinlichkeit noch weiter reduzieren können.
Oft sind wir bei der Analyse von randomisierten Algorithmen in der Situation, dass wir mehrere Ereignisse definiert haben und die Wahrscheinlichkeit, dass mindestens eins von diesen
eintritt, oder die Wahrscheinlichkeit, dass alle eintreten, bestimmen möchten. Sind A ⊆ Ω
und B ⊆ Ω zwei Ereignisse, so entspricht A ∪ B dem Ereignis, dass A oder B eintritt,
und A ∩ B entspricht dem Ereignis, dass A und B gemeinsam eintreten.
Lemma 1.2. Sei (Ω, Pr) ein diskreter Wahrscheinlichkeitsraum und seien A ⊆ Ω und B ⊆ Ω
Ereignisse. Dann gilt
Pr(A ∪ B) = Pr(A) + Pr(B) − Pr(A ∩ B).
Beweis. Für disjunkte Ereignisse A und B folgt das Lemma direkt aus der σ-Additivität
der Wahrscheinlichkeit Pr und Pr(∅) = 0. Für nicht disjunkte Ereignisse folgt es durch
zweimalige Anwendung der σ-Additivität:
Pr(A ∪ B) = Pr(A) + Pr(B \ A) = Pr(A) + Pr(B) − Pr(A ∩ B).
Eine sehr einfache, aber extrem wichtige Konsequenz des vorangegangenen Lemmas ist, dass
für eine endliche oder abzählbare Folge A1 , A2 , . . . von Ereignissen stets
Pr
∞
[
i=1
!
Ai
≤
∞
X
Pr(Ai )
i=1
gilt. Diese Formel bezeichnen wir auch als Union Bound.
Wir betrachten als Beispiel noch einmal den Test, ob zwei Polynome identisch sind, und
fügen als zusätzliche Schwierigkeit hinzu, dass die Black Boxes nicht fehlerfrei arbeiten.
8
1. Grundlagen der Wahrscheinlichkeitstheorie
Konkret nehmen wir an, dass unabhängig von dem ausgewählten x ∈ N die Black Boxes mit Wahrscheinlichkeit 0,9 das korrekte Ergebnis p(x) − q(x) zurückliefern und mit
Wahrscheinlichkeit 0,1 ein falsches Ergebnis. Wir analysieren in diesem Szenario denselben Algorithmus wie oben. Dazu sei (Ω1 , Pr1 ) der oben definierte Wahrscheinlichkeitsraum
mit Ω1 = {1, . . . , 100d} und Pr1 (x) = 1/(100d) für x ∈ Ω1 , der die uniform zufällige Wahl
der Stelle x beschreibt. Ferner sei (Ω2 , Pr2 ) ein Wahrscheinlichkeitsraum mit Ω2 = {R, F },
Pr2 (R) = 0,9 und Pr2 (F ) = 0,1, der beschreibt, ob die Black Boxes das Polynom p − q
richtig oder falsch auswerten.
Um zu modellieren, dass beide Zufallsexperimente (die Wahl von x und das Funktionieren
der Black Boxes) unabhängig voneinander sind, betrachten wir das Produkt der Wahrscheinlichkeitsräume (Ω, Pr) mit Ω = Ω1 × Ω2 und Pr(x, y) = Pr1 (x) · Pr2 (y) für (x, y) ∈ Ω, wobei
wir zur Vereinfachung hier und im Folgenden Pr(x, y) statt Pr((x, y)) schreiben. Man kann
leicht nachrechnen, dass (Ω, Pr) ein diskreter Wahrscheinlichkeitsraum ist, wenn (Ω1 , Pr1 )
und (Ω1 , Pr2 ) es sind. Intuitiv kann man sich leicht davon überzeugen, dass (Ω, Pr) wirklich
die unabhängige Hintereinanderausführung der beiden Zufallsexperimente modelliert. Eine
weitere wichtige Eigenschaft von Produkträumen, die man leicht nachrechnet, ist, dass für
jedes x ∈ Ω1 und jedes y ∈ Ω2
Pr1 (x) = Pr({x} × Ω2 )
und
Pr2 (y) = Pr(Ω1 × {y})
gelten.
Es handelt sich nun um einen Algorithmus mit beidseitigem Fehler. Sind die Polynome p
und q gleich, so ist die Wahl von x unerheblich, da stets p(x) − q(x) = 0 gilt. Der Algorithmus liefert aber ein falsches Ergebnis zurück, wenn die Black Boxes das Polynom p − q
nicht korrekt auswerten, was mit Wahrscheinlichkeit Pr2 (F ) = 0,1 passiert. Sind hingegen p
und q unterschiedlich, so gibt es zwei Fehlerquellen: die zufällig gewählte Stelle x kann eine
Nullstelle des Polynoms p − q sein oder die Stelle x ist keine Nullstelle, aber die Black Boxes
werten das Polynom p−q falsch aus. Seien y1 , . . . , yk wie oben die Nullstellen von p−q in der
Menge {1, . . . , 100d} und sei A = {y1 , . . . , yk } × Ω2 das Ereignis, dass der Algorithmus eine
solche Nullstelle auswählt. Außerdem sei B = Ω1 × {F } das Ereignis, dass die Black Boxes
ein falsches Ergebnis liefern. Tritt weder A noch B ein, so wissen wir, dass der Algorithmus
korrekt ausgibt, dass die Polynome ungleich sind. Wir können die Fehlerwahrscheinlichkeit
mit Hilfe der Union Bound wie folgt abschätzen:
k
+ 0,1 ≤ 0,11.
100d
Abstrakt gesehen, haben wir zwei Fehlerereignisse identifiziert und gezeigt, dass der Algorithmus korrekt arbeitet, wenn keins dieser Ereignisse eintritt. Dann haben wir die Wahrscheinlichkeit jedes einzelnen Ereignisses nach oben abgeschätzt und die so erhaltenen Fehlerwahrscheinlichkeiten aufsummiert. Dies ist eine allgemeine Technik, die wir bei der Analyse
komplizierterer Algorithmen noch oft in dieser Vorlesung sehen werden. In diesem einfachen
Beispiel hätten wir die Fehlerwahrscheinlichkeit natürlich auch genau ausrechnen können,
aber oft sind die Analysen so kompliziert, dass eine genaue Rechnung nicht möglich ist.
Pr(A ∪ B) ≤ Pr(A) + Pr(B) = Pr1 ({y1 , . . . , yk }) + Pr2 ({F }) =
1.2
Unabhängigkeit und bedingte Wahrscheinlichkeit
Wir haben angenommen, dass die Black Boxes unabhängig von der Wahl von x das richtige Ergebnis mit Wahrscheinlichkeit 0,9 zurückliefern. Wir definieren nun allgemein, was es
bedeutet, dass zwei Ereignisse in einem Wahrscheinlichkeitsraum unabhängig sind.
1.2. Unabhängigkeit und bedingte Wahrscheinlichkeit
9
Definition 1.3. Sei (Ω, Pr) ein diskreter Wahrscheinlichkeitsraum. Wir nennen zwei Ereignisse A ⊆ Ω und B ⊆ Ω unabhängig, wenn Pr(A ∩ B) = Pr(A) · Pr(B) gilt. Wir nennen
eine Folge A1 , . . . , Ak von Ereignissen unabhängig, wenn für jede Teilmenge I ⊆ {1, . . . , k}
!
Pr
\
i∈I
Ai
=
Y
Pr(Ai )
i∈I
gilt. Die Folge A1 , . . . , Ak heißt paarweise unabhängig, wenn für alle i 6= j die Ereignisse Ai
und Aj unabhängig sind.
Intuitiv bedeutet die Unabhängigkeit zweier Ereignisse A und B, dass Informationen über
das Eintreten oder Nichteintreten von A keinerlei Konsequenzen für B haben. Zum besseren
Verständnis geben wir einige Beispiele an.
• Sei Ω = {(i, j) | i, j ∈ {1, . . . , 6}} und Pr(i, j) = 1/36 für alle (i, j) ∈ Ω die Modellierung zweier unabhängiger Würfe eines Würfels. Intuitiv hat das Ergebnis des
ersten Wurfes keinerlei Konsequenzen für das Ergebnis des zweiten Wurfes. Bezeichne A beispielsweise das Ereignis, dass der erste Wurf ein gerades Ergebnis zurückliefert, und bezeichne B das Ereignis, dass der zweite Wurf mindestens den Wert drei
zurückliefert. Dann rechnet man leicht nach, dass Pr(A) = 1/2, Pr(B) = 2/3 und
Pr(A ∩ B) = 1/3 = Pr(A) · Pr(B) gelten.
• Seien Ω und Pr wie in obigem Beispiel gewählt. Sei A das Ereignis, dass die Summe
der gewürfelten Zahlen gleich 6 ist, und sei B das Ereignis, dass der erste Würfel die
Zahl 3 zeigt. Intuitiv sind diese Ereignisse nicht unabhängig (als Summe kann nur 6
herauskommen, wenn im ersten Wurf nicht bereits eine 6 geworfen wurde). Tatsächlich
5
gelten Pr(A) = 36
, Pr(B) = 16 und
Pr(A ∩ B) =
5
1
> Pr(A) · Pr(B) =
,
36
216
was auch formal die Abhängigkeit der Ereignisse zeigt. Als Übung sollte der Leser sich
überlegen, wie sich die o. g. Wahrscheinlichkeiten ergeben.
• Für eine endliche Folge von Wahrscheinlichkeitsräumen (Ω1 , Pr1 ), . . . , (Ωn , Prn ) können wir durch Ω = Ω1 × . . . × Ωn und Pr(x1 , . . . , xn ) = Pr1 (x1 ) · . . . · Prn (xn ) wie
oben den Produktraum definieren. Ereignisse, die sich auf unterschiedliche Komponenten des Produktraumes beziehen, sind stets unabhängig. Sei beispielsweise n = 2 und
seien A ⊆ Ω1 und B ⊆ Ω2 beliebig, dann sind die Ereignisse A × Ω2 und Ω1 × B
unabhängig.
Durch unabhängige Wiederholungen kann man oft die Erfolgswahrscheinlichkeit von randomisierten Algorithmen erhöhen. Dazu betrachten wir noch einmal in dem einfachen Modell
mit fehlerfrei arbeitenden Black Boxes den Algorithmus zum Testen, ob zwei Polynome gleich
sind. Wir konzentrieren uns direkt auf den interessanten Fall, dass die Polynome p und q
nicht identisch sind. Anstatt den Algorithmus nur einmal auszuführen, führen wir ihn nun
n-mal unabhängig hintereinander aus. Das bedeutet, wir wählen unabhängig voneinander n
Stellen x1 , . . . , xn (diese sind nicht notwendigerweise verschieden und können auch zufällig
übereinstimmen), an denen wir das Polynom p − q auswerten. Ist mindestens eine von diesen
Stellen keine Nullstelle, so geben wir aus, dass die Polynome nicht gleich sind. Nur wenn
all diese Stellen Nullstellen sind, geben wir aus, dass die Polynome gleich sind. Sei Ai das
10
1. Grundlagen der Wahrscheinlichkeitstheorie
Ereignis, dass die Stelle xi eine Nullstelle von p − q ist. Aufgrund der Unabhängigkeit der
Ereignisse gilt
Pr(Algorithmus gibt fälschlicherweise aus, dass p und q übereinstimmen)
= Pr(A1 ∩ . . . ∩ An ) = Pr(A1 ) · . . . · Pr(An ) =
1
100
n
.
Die Fehlerwahrscheinlichkeit sinkt also exponentiell mit der Anzahl der unabhängigen Versuche. Um die unabhängige Wiederholung des Algorithmus formal zu modellieren, kann man
den Wahrscheinlichkeitsraum (Ω, Pr) nehmen, der die einmalige Ausführung des Algorithmus beschreibt, und den Produktraum mit Ergebnismenge Ω0 = Ω × . . . × Ω bilden. Wir
werden in Zukunft aber nicht mehr jeden Wahrscheinlichkeitsraum, den wir zur Analyse eines Algorithmus benötigen, formal beschreiben, da sich die Wahrscheinlichkeitsräume in der
Regel implizit aus der Beschreibung der Algorithmen ergeben.
Für die Unabhängigkeit war es wichtig, dass mehrere Wiederholungen des Algorithmus auch
die gleichen Stellen xi und xj wählen können. Wenn wir in der zweiten Ausführung des
Algorithmus nur noch aus denjenigen Stellen uniform zufällig eine wählen, die nicht im ersten
Schritt gewählt wurden, dann erzeugen wir Abhängigkeiten zwischen den Wiederholungen
und obige Analyse ist nicht mehr korrekt. Wir lernen nun mit bedingten Wahrscheinlichkeiten
ein Hilfsmittel kennen, mit dem wir auch dieses Szenario analysieren können.
Definition 1.4. Sei (Ω, Pr) ein diskreter Wahrscheinlichkeitsraum. Ferner seien A ⊆ Ω
und B ⊆ Ω zwei Ereignisse mit Pr(B) > 0. Wir bezeichnen mit
Pr(A | B) =
Pr(A ∩ B)
Pr(B)
die bedingte Wahrscheinlichkeit von A gegeben B.
Auch dieses Konzept illustrieren wir zunächst an einigen Beispielen.
• Wir betrachten zwei unabhängige Würfe eines Würfels. Sei A das Ereignis, dass der
erste Wurf 6 ergibt, und sei B das Ereignis, dass die Summe der gewürfelten Zahlen
genau 10 ist. Es gilt Pr(A) = 1/6 und intuitiv sollte Ereignis A wahrscheinlicher
werden, wenn wir schon wissen, dass B eintritt. Da das Eintreten von B ausschließt,
dass der erste Wurf eine Zahl kleiner oder gleich 3 liefert, sind nur noch die Zahlen 4, 5
und 6 übrig. Somit sollte intuitiv die Wahrscheinlichkeit von A ein Drittel sein, wenn
wir schon wissen, dass B eintritt. Tatsächlich gilt
Pr(A | B) =
Pr(A ∩ B)
1/36
1
=
= .
Pr(B)
3/36
3
• Seien A und B zwei unabhängige Ereignisse mit Pr(B) > 0. Dann gilt
Pr(A | B) =
Pr(A ∩ B)
Pr(A) · Pr(B)
=
= Pr(A).
Pr(B)
Pr(B)
Dies entspricht unserer Intuition, dass bei zwei unabhängigen Ereignissen das Eintreten
des einen Ereignis keine Konsequenzen für das Eintreten des anderen besitzt.
Wir analysieren nun wieder obigen Algorithmus, der das Polynom p−q an n Stellen x1 , . . . , xn
auswertet. Der einzige Unterschied ist, dass wir diesmal davon ausgehen, dass alle Stellen
1.3. Anwendungen
11
verschieden sind. Dies wird erreicht, indem der Algorithmus die Stelle x1 uniform zufällig aus
der Menge {1, . . . , 100d} wählt, die Stelle x2 uniform zufällig aus der Menge {1, . . . , 100d} \
{x1 } und so weiter. Wir gehen davon aus, dass n ≤ 100d gilt. Sei nun wieder Ai das Ereignis,
dass es sich bei xi um eine Nullstelle von p − q handelt. Nach wie vor möchten wir die
Fehlerwahrscheinlichkeit Pr(A1 ∩ . . . ∩ An ) abschätzen. Mit Hilfe von Definition 1.4 können
wir diese wie folgt schreiben:
Pr(A1 ∩ . . . ∩ An ) = Pr(An | A1 ∩ . . . ∩ An−1 ) · Pr(A1 ∩ . . . ∩ An−1 ).
Mehrmalige Anwendung der Definition liefert
Pr(A1 ∩ . . . ∩ An ) = Pr(A1 ) · Pr(A2 | A1 ) · Pr(A3 | A1 ∩ A2 ) · . . . · Pr(An | A1 ∩ . . . ∩ An−1 ).
Betrachten wir einen beliebigen Faktor Pr(Ai | A1 ∩ . . . ∩ Ai−1 ) in dieser Formel. Wenn
wir bereits wissen, dass die Ereignisse A1 , . . . , Ai−1 eingetreten sind, so wissen wir, dass
x1 , . . . , xi−1 Nullstellen von p − q sind. Die Stelle xi wird uniform zufällig aus {1, . . . , 100d} \
{x1 , . . . , xi−1 } gewählt. Diese Menge enthält genau 100d − (i − 1) Elemente, von denen
höchstens d − (i − 1) Nullstellen sind. Also können wir die Wahrscheinlichkeit von Ai gegeben
d−(i−1)
A1 ∩ . . . ∩ Ai−1 durch 100d−(i−1)
abschätzen. Insgesamt ergibt sich somit
Pr(A1 ∩ . . . ∩ An ) ≤
n
Y
d − (i − 1)
≤
100d
− (i − 1)
i=1
1
100
n
.
Die Fehlerwahrscheinlichkeit ist also höchstens so groß wie bei unabhängiger Wiederholung.
Für n ≥ 2 ist sie sogar echt kleiner, was der Leser sich auch intuitiv klar machen sollte.
1.3
1.3.1
Anwendungen
Verifikation von Matrixprodukten
Wir stellen nun einen randomisierten Algorithmus vor, der testet, ob AB = C für drei gegebene n × n-Matrizen A, B und C gilt. Der Einfachheit halber gehen wir davon aus, dass
wir mit ganzen Zahlen modulo 2 rechnen. Natürlich könnte man das Matrixprodukt AB
ausrechnen und mit C vergleichen, was aber selbst mit dem besten bekannten Algorithmus
zum Multiplizieren zweier Matrizen eine Laufzeit von Θ(n2.376 ) benötigen würde. Wir wollen
Randomisierung nutzen, um den Test effizienter durchführen zu können, und schlagen folgenden einfachen Algorithmus vor: Wähle r = (r1 , . . . , rn ) ∈ {0, 1}n uniform zufällig und teste,
ob ABr und Cr übereinstimmen. Wenn nein, gib AB 6= C aus; wenn ja, gib AB = C aus.
Erfolgt die Berechnung von ABr = A(Br) durch zwei Matrix-Vektor-Produkte, so beträgt
die Gesamtlaufzeit des Algorithmus Θ(n2 ), wobei wir annehmen, dass ein uniform zufälliger
Vektor r in Zeit O(n) erzeugt werden kann.
Genau wie beim ersten Test, ob zwei Polynome gleich sind, handelt es sich auch hier um
einen Algorithmus mit einseitigem Fehler. Ist AB = C, so wird der Algorithmus das stets
korrekt ausgeben. Seine Ausgabe ist nur fehlerhaft, falls AB 6= C, aber ABr = Cr für den
zufällig gewählten Vektor r gilt. Die Wahrscheinlichkeit hierfür können wir mit dem folgenden
Theorem abschätzen.
Theorem 1.5. Seien A, B, C ∈ {0, 1}n×n beliebige Matrizen mit AB 6= C und sei r ∈ {0, 1}n
uniform zufällig gewählt. Dann gilt
1
Pr(ABr = Cr) ≤ ,
2
12
1. Grundlagen der Wahrscheinlichkeitstheorie
wenn wir im Körper F2 (also modulo 2) rechnen.
Beweis. Einen Vektor r = (r1 , . . . , rn ) uniform zufällig aus der Menge {0, 1}n zu wählen, ist
äquivalent dazu, die Komponenten r1 , . . . , rn unabhängig voneinander und jeweils uniform
zufällig aus der Menge {0, 1} zu wählen, da in beiden Fällen jeder Vektor r ∈ {0, 1}n eine
Wahrscheinlichkeit von 2−n hat, gewählt zu werden.
Für die Matrix D = AB − C 6= 0 gilt Dr = 0n genau dann, wenn ABr = Cr gilt. Da D 6= 0
gilt, muss es mindestens einen Eintrag ungleich 0 geben. Da wir in dem Körper F2 rechnen,
ist dieser Eintrag gleich 1. Zunächst permutieren wir die Zeilen und Spalten so, dass dieser
Eintrag ohne Beschränkung der Allgemeinheit der Eintrag d11 ist. Ist der Vektor r so gewählt,
dass Dr = 0n gilt, so gilt insbesondere
n
X
d1i ri = 0
i=1
und somit
r1 = −
n
X
d1i ri .
i=2
Wir können somit die Wahrscheinlichkeit, die uns interessiert, wie folgt abschätzen:
Pr(ABr = Cr) ≤ Pr r1 = −
n
X
d1i ri .
(1.1)
i=2
Die Koeffizienten d12 , . . . , d1n ∈ {0, 1} sind durch die Wahl von A, B und C bestimmt.
Jeder der Werte r1 , . . . , rn wird unabhängig und uniform zufällig aus {0, 1} gewählt. Um die
Wahrscheinlichkeit in (1.1) abzuschätzen, wenden wir eine Technik an, die in vielen Analysen
hilfreich ist. Wir reduzieren den Zufall in dem Vektor r, indem wir davon ausgehen, dass
P
die Werte r2 , . . . , rn bereits gewählt wurden. Dann steht die Summe − ni=2 d1i ri fest und
nimmt entweder den Wert 0 oder den Wert 1 an. Aufgrund der Unabhängigkeit der ri hat die
Wahl der r2 , . . . , rn keinerlei Auswirkungen auf r1 . Die Wahrscheinlichkeit, dass r1 gerade
den festen Wert der Summe annimmt, ist somit genau 1/2.
Um diese Argumentation zu formalisieren, benötigen wir die folgende Formel der totalen
Wahrscheinlichkeit.
Theorem 1.6. Sei (Ω, Pr) ein diskreter Wahrscheinlichkeitsraum und sei B1 , . . . , Bn eine
Partition von Ω in paarweise disjunkte Ereignisse, d. h. B1 ∪ . . . ∪ Bn = Ω und Bi ∩ Bj = ∅
für i 6= j. Sei ferner A ⊆ Ω ein beliebiges Ereignis. Dann gilt
Pr(A) =
n
X
i=1
Pr(A ∩ Bi ) =
n
X
Pr(A | Bi ) · Pr(Bi ).
i=1
Ist Pr(Bi ) = 0 für ein i, so ist die bedingte Wahrscheinlichkeit Pr(A | Bi ) nicht definiert.
Wir setzen dann das Produkt Pr(A | Bi ) · Pr(Bi ) gleich Null.
Beweis. Die erste Gleichheit im Theorem folgt direkt aus der σ-Additivität der Wahrscheinlichkeit und der Tatsache, dass die Ereignisse A ∩ Bi paarweise disjunkt sind und ihre
Vereinigung A ergibt. Die zweite Gleichheit folgt direkt aus der Definition der bedingten
Wahrscheinlichkeit.
1.3. Anwendungen
13
In der Anwendung der Formel der totalen Wahrscheinlichkeit auf die Analyse des AlgorithP
mus entspricht A dem Ereignis, dass r1 = − ni=2 d1i ri gilt, und wir definieren für jede
mögliche Realisierung x = (x2 , . . . , xn ) ∈ {0, 1}n−1 des Vektors (r2 , . . . , rn ) ein Ereignis Bx .
Damit ergibt sich
Pr r1 = −
n
X
d1i ri
i=2
X
=
Pr
r1 = −
(x2 ,...,xn )∈{0,1}n−1
X
=
=
(x2 ,...,xn )∈{0,1}n−1
d1i xi ∩ (r2 , . . . , rn ) = (x2 , . . . , xn )
i=2
Pr r1 = −
(x2 ,...,xn )∈{0,1}n−1
X
n
X
n
X
d1i xi · Pr (r2 , . . . , rn ) = (x2 , . . . , xn )
i=2
1
· Pr (r2 , . . . , rn ) = (x2 , . . . , xn )
2
1
= .
2
Für die zweite Gleichheit haben wir die Unabhängigkeit der Komponenten ausgenutzt.
Der Algorithmus, den wir entworfen haben, liefert für AB = C stets das korrekte Ergebnis.
Für AB 6= C liefert er mit Wahrscheinlichkeit höchstens 1/2 das falsche Ergebnis. Genau
wie bei dem Test, ob zwei Polynome gleich sind, können wir auch hier die Fehlerwahrscheinlichkeit wieder dadurch verkleinern, dass wir den Test mehrfach unabhängig wiederholen.
Analog erreichen wir durch eine k-fache Wiederholung eine exponentiell kleine Fehlerwahrscheinlichkeit von 1/2k .
1.3.2
Berechnung eines minimalen Schnittes
In diesem Abschnitt betrachten wir das Problem, einen minimalen Schnitt eines Graphen
zu berechnen. Sei dazu ein ungerichteter und ungewichteter Graph G = (V, E) gegeben
und seien n = |V | ≥ 2 und m = |E|. Wir gehen davon aus, dass G zusammenhängend
ist. Ein Schnitt dieses Graphen ist eine Teilmenge E 0 ⊆ E der Kanten, nach deren Entfernung der Graph G in mindestens zwei Zusammenhangskomponenten zerfällt. Ein minimaler
Schnitt ist ein Schnitt mit kleinstmöglicher Kardinalität. Wir haben das Problem, einen minimalen Schnitt eines Graphen zu berechnen, bereits im Grundstudium im Zusammenhang
mit Flussproblemen kennengelernt. Tatsächlich kann man mit Hilfe von Algorithmen für
Flussprobleme auch minimale Schnitte bestimmen. Der beste bekannte deterministische Algorithmus zur Bestimmung minimaler Schnitte besitzt eine Laufzeit von O(nm log(n2 /m)).
Wir lernen nun zwei randomisierte Algorithmen kennen, die einfacher als der beste deterministische Algorithmus sind. Der zweite dieser Algorithmen ist zudem deutlich effizienter und
erreicht eine Laufzeit von O(n2 (log n)O(1) ), wobei der genaue Exponent des Logarithmus von
der gewünschten Fehlerwahrscheinlichkeit abhängt.
Beide randomisierten Algorithmen beruhen auf Kontraktionen von Kanten. Eine solche Kontraktion ist eine Operation, die einen ungerichteten Multigraphen in einen anderen ungerichteten Multigraphen überführt, wobei ein Multigraph ein Graph ist, bei dem zwischen
demselben Paar von Knoten mehrere Kanten verlaufen dürfen. Ist G = (V, E) ein Multigraph und ist e = {u, v} ∈ E, so ergibt die Kontraktion Contract(G, e) den Multigraphen G0 = (V 0 , E 0 ) mit der Knotenmenge V 0 = V \ {u, v} ∪ {w}, wobei w ein neuer Knoten
14
1. Grundlagen der Wahrscheinlichkeitstheorie
ist, der die beiden Knoten u und v ersetzt. Die Kantenmenge E 0 enthält alle Kanten von E,
die weder zu u noch zu v inzident sind. Alle Kanten, die in E zwischen u und v verlaufen, sind
in E 0 nicht mehr enthalten. Jede Kante {u, x} ∈ E oder {v, x} ∈ E mit x 6= u und x 6= v wird
in E 0 durch die Kante {w, x} ersetzt. Wir können uns das so vorstellen, dass die Kontraktion
bewirkt, dass die Knoten u und v zu einem gemeinsamen Knoten w verschmelzen. Kanten
zwischen u und v fallen hierdurch weg und alle Kanten, die vorher inzident zu u oder v
waren, sind nun stattdessen zu w inzident. In der folgenden Grafik ist links ein Beispiel für
einen Multigraphen G. Durch Kontraktion der Kante zwischen den Knoten 2 und 4 erhält
man den rechten Multigraphen mit neuem Knoten 2, 4.
1
2
1
2, 4
3
4
3
Der Contract-Algorithmus
Der erste randomisierte Algorithmus zur Berechnung eines minimalen Schnittes, welchen
wir Contract-Algorithmus nennen werden, startet mit dem Graphen G0 = G = (V, E) und
erzeugt daraus eine Folge G1 , . . . , Gn−2 von Multigraphen. Dabei wird jeder Multigraph Gi+1
aus Gi erzeugt, indem eine uniform zufällige Kante von Gi ausgewählt und kontrahiert wird.
Dabei speichert der Algorithmus für jeden Knoten, aus welchen Knoten des ursprünglichen
Graphen er entstanden ist. Wir gehen davon aus, dass V = {1, . . . , n} gilt und weisen in dem
Graphen G0 jedem Knoten k die Menge {k} als Label zu. Wird nun in einem Schritt eine
Kante des Graphen Gi kontrahiert, deren Endpunkte die Label A und B haben, so erhält
der neue Knoten des Graphen Gi+1 das Label A ∪ B.
Mit jeder Kontraktion reduziert sich die Anzahl an Knoten um eins. Das bedeutet, dass
der Graph Gn−2 , den der Algorithmus erzeugt, genau zwei Knoten enthält. Sind A und B
die Label der beiden übriggebliebenen Knoten, so stellt die Konstruktion sicher, dass A
und B eine disjunkte Partition der Menge {1, . . . , n} aller Knoten sind. Die Ausgabe des
Algorithmus besteht nun aus der Menge der Kanten, die in G zwischen A und B verlaufen:
{{u, v} ∈ E | u ∈ A und v ∈ B}.
Die folgende Grafik zeigt eine beispielhafte Ausführung des Algorithmus, wobei in jedem
Schritt die zu kontrahierende Kante gestrichelt gezeichnet ist.
G0
G1
G2
G3
1
1
1
1
2
3
2
3
2
4
5
6
4, 6
5
1, 2
2
3, 4, 6
3, 4, 5, 6
5
G4
3, 4, 5, 6
1.3. Anwendungen
15
Die Ausgabe besteht aus genau den Kanten, die in G zwischen den Knotenmengen {1, 2}
und {3, 4, 5, 6} verlaufen. Man überprüft in diesem Beispiel leicht, dass nach dem Entfernen
dieser Kanten der Graph in zwei Zusammenhangskomponenten zerfällt. Bei diesem Beispiel
zeigt sich, dass die uniform zufällige Auswahl einer Kante des Multigraphen nicht gleichbedeutend damit ist, in jedem Schritt ein zufälliges Knotenpaar, zwischen dem eine Kante
verläuft, zu verschmelzen. Betrachten wir den Übergang von G3 zu G4 , so sehen wir zum Beispiel, dass es zwei parallele Kanten zwischen den Knoten 2 und 3, 4, 5, 6 gibt, jedoch nur eine
Kante zwischen den Knoten 1 und 2. Also ist die Verschmelzung der Knoten 2 und 3, 4, 5, 6
doppelt so wahrscheinlich wie die Verschmelzung der Knoten 1 und 2. Wir beweisen nun
allgemein, dass der Contract-Algorithmus stets einen Schnitt des Graphen ausgibt und dass
dies mit einer gewissen Wahrscheinlichkeit sogar ein minimaler Schnitt ist.
Theorem 1.7. Die Ausgabe des Contract-Algorithmus ist immer ein Schnitt des Graphen G
2
und mit Wahrscheinlichkeit mindestens n(n−1)
ist es ein minimaler Schnitt.
Beweis. Der Beweis, dass der Algorithmus stets einen Schnitt ausgibt, ist einfach. Mittels
einer Invariante zeigt man, dass in jedem Multigraphen Gi , den der Algorithmus erzeugt, die
Label der Knoten eine disjunkte Partition der Knotenmenge des ursprünglichen Graphen
bilden und niemals ein Label der leeren Menge entspricht. Insbesondere gilt dies für den
letzten Graphen Gn−2 mit zwei Knoten. Seien A und B die Label dieser Knoten, dann
gilt A ∪ B = V und A ∩ B = ∅. Nach der Entfernung aller Kanten, die zwischen den
Mengen A und B verlaufen, kann es in G zwischen keinem Paar von Knoten u ∈ A und v ∈ B
einen Weg geben. Damit ist gezeigt, dass die Entfernung dieser Kanten den Graphen in
mindestens zwei Zusammenhangskomponenten zerlegt. Auf analoge Art und Weise kann man
sogar nachweisen, dass jeder Schnitt eines Graphen Gi einem Schnitt gleicher Kardinalität des
Ursprungsgraphen entspricht. Insbesondere enthält keiner der Graphen Gi einen kleineren
Schnitt als G.
Um die Wahrscheinlichkeit zu analysieren, dass die Ausgabe des Algorithmus ein minimaler
Schnitt ist, fixieren wir einen beliebigen minimalen Schnitt C ⊆ E und rechnen die Wahrscheinlichkeit aus, dass der Algorithmus genau diesen Schnitt C ausgibt. Bezeichne k die
Größe des minimalen Schnittes, also die Anzahl der Kanten in C. Da G zusammenhängend
ist, gilt k ≥ 1. Die erste wichtige Erkenntnis ist, dass der Graph G mindestens nk/2 Kanten
enthalten muss. Wäre dies nicht so, so gäbe es einen Knoten mit einem Grad echt kleiner
als k. Dann würden aber alle zu diesem Knoten inzidenten Kanten zusammen einen Schnitt
des Graphen bilden, der im Widerspruch zur Wahl von C weniger als k Kanten enthält.
Sei die Knotenmenge S ⊆ V mit S 6= ∅ so gewählt, dass in dem Graphen (V, E \ C) keine
Kanten zwischen den Knotenmengen S und V \ S verlaufen. Da C ein Schnitt des Graphen
ist, muss es eine solche Menge S geben. Wir können sogar davon ausgehen, dass C aus genau
den Kanten von E besteht, die zwischen den Mengen S und V \ S verlaufen. Würde C noch
Kanten enthalten, die innerhalb von S oder innerhalb von V \ S verlaufen, so wäre es kein
minimaler Schnitt. Diese Notationen sind in der folgenden Abbildung illustriert.
S
∈C
∈C
V \S
16
1. Grundlagen der Wahrscheinlichkeitstheorie
Solange der Algorithmus zur Kontraktion nur Kanten auswählt, die entweder innerhalb von
der Menge S verlaufen oder die innerhalb von der Menge V \ S verlaufen, bleiben die Kanten
aus dem Schnitt C im Graphen enthalten. Sobald jedoch eine Kante aus dem Schnitt C
kontrahiert wird, kann der Algorithmus am Ende nicht mehr C ausgeben. Der ContractAlgorithmus gibt also genau dann am Ende die Menge C aus, wenn er bei den n − 2 Kontraktionen niemals eine Kante aus C auswählt. Für i ∈ {1, . . . , n − 2} bezeichne Ai das
Ereignis, dass beim Übergang von Gi−1 zu Gi eine Kante kontrahiert wird, die nicht zu der
Menge C gehört. Uns interessiert die Wahrscheinlichkeit, dass alle Ai eintreten. Diese können
wir mit Hilfe von bedingten Wahrscheinlichkeiten wie folgt ausdrücken:
Pr(A1 ∩ . . . ∩ An−2 ) = Pr(A1 ) · Pr(A2 | A1 ) · . . . · Pr(An−2 | A1 ∩ . . . ∩ An−3 ).
Die Wahrscheinlichkeit von A1 können wir mit dem oben Gesagten leicht abschätzen. Da es k
Kanten in C und mindestens nk/2 in E gibt, ist die Wahrscheinlichkeit, dass im ersten Schritt
eine Kante aus C kontrahiert wird, höchstens |C|/|E| ≤ 2/n. Demnach ist Pr(A1 ) ≥ 1−2/n.
Um die bedingte Wahrscheinlichkeit von Ai gegeben A1 ∩. . .∩Ai−1 abzuschätzen, betrachten
wir die Situation nach den ersten i − 1 Schritten unter der Bedingung, dass in keinem von
diesen eine Kante aus C entfernt wurde. Wenn wir ausnutzen, dass es in dem Graphen Gi−1
keinen Schnitt mit weniger als k Kanten geben kann, dann können wir die Wahrscheinlichkeit
wieder analog abschätzen. Der Graph Gi−1 = (Vi−1 , Ei−1 ) enthält genau n − i + 1 Knoten,
die jeweils mindestens Grad k haben. Somit gibt es insgesamt mindestens (n − i + 1)k/2
Kanten in Gi−1 und davon sind unter der Bedingung A1 ∩ . . . ∩ Ai−1 immer noch k viele
in C. Somit gilt
Pr(Ai | A1 ∩ . . . ∩ Ai−1 ) = 1 −
n−i−1
|C|
2
≥1−
=
.
|Ei−1 |
n−i+1
n−i+1
Insgesamt ergibt sich nun wie gewünscht
Pr(Contract-Algorithmus berechnet minimalen Schnitt)
≥ Pr(Contract-Algorithmus gibt C aus)
= Pr(A1 ) · Pr(A2 | A1 ) · . . . · Pr(An−2 | A1 ∩ . . . ∩ An−3 )
n−3
n−2
≥
n
n−1
2
=
.
n(n − 1)
n−4
3
...
n−2
5
2
4
1
3
Einen Algorithmus mit einer Erfolgswahrscheinlichkeit von Θ(1/n2 ) würden wir natürlich in
der Praxis nicht verwenden. Deshalb nutzen wir auch hier wieder die Methode der unabhängigen Wiederholungen, um die Erfolgswahrscheinlichkeit zu erhöhen. Wir führen deshalb
den Contract-Algorithmus (cn2 /2)-mal unabhängig voneinander aus und geben zum Schluss
einen kleinsten Schnitt zurück, den wir in einer dieser Ausführungen erhalten haben. Dabei ist c > 0 eine Konstante, die wir beliebig wählen können. Die Wahrscheinlichkeit, dass
2
eine einzelne Ausführung keinen minimalen Schnitt zurückliefert, ist höchstens 1 − n(n−1)
.
Dementsprechend ist die Wahrscheinlichkeit, dass keine der Ausführungen einen minimalen
Schnitt zurückliefert, höchstens
2
1−
n(n − 1)
cn2 /2
2
1− 2
n
≤
n2 /2 !c
<
1
,
ec
1.3. Anwendungen
17
wobei wir ausgenutzt haben, dass (1−1/`)` < 1/e für alle ` > 1 gilt. Eine einzelne Ausführung
des Contract-Algorithmus benötigt bei geschickter Implementierung eine Laufzeit von Θ(n2 ).
Wiederholen wir den Algorithmus Θ(n2 ) oft, um auf eine konstante Fehlerwahrscheinlichkeit
zu kommen, so ergibt sich eine Gesamtlaufzeit von Θ(n4 ).
Der FastCut-Algorithmus
Wir werden den Contract-Algorithmus nun so modifizieren, dass er auf Kosten einer etwas
höheren Laufzeit eine deutlich höhere Erfolgswahrscheinlichkeit erzielt. Der in diesem Abschnitt vorgestellte Algorithmus ist auch in Kapitel 10.2 von [6] zu finden. Schaut man sich
die Abschätzung der Erfolgswahrscheinlichkeit des Contract-Algorithmus an, so stellt man
fest, dass es am Anfang noch relativ wahrscheinlich ist, keine Kante von C zu kontrahieren,
wohingegen es im letzten Schritt sogar mit Wahrscheinlichkeit 2/3 passieren kann, dass eine
Kante von C kontrahiert wird. Anstatt nun den Algorithmus einfach mehrfach komplett zu
wiederholen, so wie wir es oben getan haben, erscheint es sinnvoll, die Kontraktionen gegen Ende des Algorithmus häufiger zu wiederholen als die Kontraktionen am Anfang. Auf
diese Weise kann dem Fallen der Erfolgswahrscheinlichkeit Pr(Ai ) für steigendes i entgegen
gewirkt werden.
Diese Idee formalisieren wir in dem folgenden rekursiven Algorithmus, der den Graphen G
zunächst zweimal unabhängig voneinander
√ solange kontrahiert, bis die Knotenanzahl um
einen konstanten Faktor auf ungefähr n/ 2 geschrumpft ist. Für die beiden Multigraphen,
die man so erhält, wird dann rekursiv der gleiche Algorithmus noch einmal aufgerufen und
dann das bessere Ergebnis der beiden rekursiven Aufrufe zurückgeliefert, wobei die beiden rekursiven Aufrufe unabhängig sind. In dem folgenden Pseudocode wird die Funktion
Contract(G, t) benutzt. Dabei ist G stets ein Multigraph und t ist eine Zahl. Diese Funktion
erzeugt einen neuen Multigraphen, indem sie solange eine uniform zufällige Kante auswählt
und kontrahiert, bis die Knotenanzahl genau t ist. Der im letzten Abschnitt betrachtete
Contract-Algorithmus entspricht also dem Aufruf Contract(G, 2). Wir gehen davon aus, dass
unterschiedliche Ausführungen von Contract(G, t) unabhängig voneinander erfolgen.
FastCut(G = (V, E))
1. if n := |V | ≤ 6
2.
Berechne einen minimalen Schnitt C von G mittels Brute Force.
3.
return C;
4. else
5.
√
t := d1 + n/ 2e;
6.
H1 = Contract(G, t); H2 = Contract(G, t);
7.
C1 = FastCut(H1 ); C2 = FastCut(H2 );
8.
return C1 falls |C1 | ≤ |C2 | und C2 sonst;
Der Grund für das Abbrechen der Rekursion bei n ≤ 6 ist, dass in diesem Fall t nicht mehr
kleiner als n ist. Bei einem Graphen mit höchstens 6 Knoten können wir aber in konstanter
Zeit alle möglichen Schnitte generieren und so in konstanter Zeit einen minimalen Schnitt
finden. Interessanter ist es, die Rekursion an sich zu analysieren. Dazu überlegen wir uns
zunächst intuitiv einige Eigenschaften des Rekursionsbaumes, bevor wir sie formal nachweisen. Alle Aufrufe, die sich auf derselben Ebene des Rekursionsbaumes befinden, erhalten als
18
1. Grundlagen der Wahrscheinlichkeitstheorie
Eingabe Multigraphen mit
Knotenanzahl. Diese Anzahl sinkt exponentiell mit der
√ derselben
i
Tiefe und ist in etwa n/( 2) für alle Teilprobleme mit Tiefe i im Rekursionsbaum. Da die
Blätter des Rekursionsbaumes Teilprobleme mit 6 oder weniger Knoten darstellen, beträgt
die Tiefe des Rekursionsbaumes insgesamt in etwa
log√2
n
6
=
log2 (n)
√ − log√2 (6) = 2 log2 (n) − Θ(1).
log2 ( 2)
Damit ergibt sich die Anzahl an Blättern zu Θ(n2 ). Das bedeutet, dass der Algorithmus
FastCut insgesamt Θ(n2 ) verschiedene Schnitte erzeugt und den besten davon zurückgibt.
Das ist sehr ähnlich zu den Θ(n2 ) unabhängigen Wiederholungen des Contract-Algorithmus,
die wir im vorangegangenen Abschnitt vorgeschlagen haben. Im Unterschied zum ContractAlgorithmus sind die Kontraktionssequenzen bei FastCut jedoch nicht unabhängig. Schnitte,
die in zwei Blättern der Rekursion erzeugt werden, teilen sich alle Kontraktionen, die in
gemeinsamen Vorfahren im Rekursionsbaum durchgeführt wurden. Wie gewünscht werden
somit die anfänglichen Kontraktionen weniger oft wiederholt als die späteren. Die Konsequenz ist, dass der Algorithmus schneller ist als die Θ(n2 )-fache Wiederholung des ContractAlgorithmus, da Zwischenergebnisse wiederverwendet werden. Auf der anderen Seite sinkt
durch die Abhängigkeiten aber auch die Erfolgswahrscheinlichkeit, dass unter den Θ(n2 ) betrachteten Schnitten ein minimaler dabei ist. Wir werden nun sowohl die Laufzeit als auch
die Erfolgswahrscheinlichkeit genauer analysieren.
Theorem 1.8. Der FastCut-Algorithmus besitzt eine Laufzeit von O(n2 log n).
Beweis. Wir werden im Folgenden sowohl über Knoten des Multigraphen G als auch über
Knoten des Rekursionsbaumes sprechen. Aus dem Kontext wird aber stets hervorgehen,
welche Art von Knoten gemeint ist. Wir geben zunächst eine Rekursionsformel für die Laufzeit T (n) des FastCut-Algorithmus auf Multigraphen mit n Knoten an. Wir haben oben
gesagt, dass der Contract-Algorithmus mit einer geschickten Implementierung eine Laufzeit
von Θ(n2 ) besitzt. Da in den einzelnen Knoten des Rekursionsbaumes lediglich zwei Ausführungen des Contract-Algorithmus erfolgen, die auch noch vorzeitig abgebrochen werden,
sobald eine bestimmte Knotenanzahl erreicht ist, beträgt die Laufzeit für jeden Knoten des
Rekursionsbaumes ebenfalls nur O(n2 ). Berücksichtigt
man dann noch die beiden rekursiven
√
Aufrufe auf Multigraphen mit jeweils d1 + n/ 2e Knoten, so erhält man für n ≥ 7 und
eine geeignete Konstante c die folgende rekursive Abschätzung für die Laufzeit des FastCutAlgorithmus:
!
n
T (n) ≤ 2 · T 1 + √
+ cn2 .
2
Für n ≤ 6 gilt T (n) = Θ(1). Um aus dieser Formel eine explizite Abschätzung für T (n) zu
erhalten, rechnen wir zunächst aus, um welchen Faktor die Knotenanzahl mit jeder Ebene
der Rekursion mindestens schrumpft. Für n ≥ 7 gilt
√ m
1 + n/ 2
l
n
√
2 + n/ 2
2
1
≤
≤ + √ < 0,993 =: c1 .
n
n
2
Auf Tiefe ` ≥ 0 des Rekursionsbaumes gibt es 2` Knoten, die jeweils einen Aufruf auf einem
Graphen mit höchstens c`1 n Knoten darstellen. Die Tiefe des Rekursionsbaumes ist somit
durch
n
log1/c1
= Θ(log n)
6
1.3. Anwendungen
19
nach oben beschränkt.
Wir rechnen nun genauer nach, wie groß die Probleme auf Tiefe ` ≥ 0 im Rekursionsbaum
sind. Dabei schätzen wir wieder d1 + √n2 e durch √n2 + 2 nach oben ab. Das Problem auf
Tiefe 0 enthält noch alle n Knoten, die Probleme auf Tiefen 1, 2 und 3 enthalten höchstens
n
√
+2
2
√
√n
2
+2
√
+2
2
n
√ + 2,
2
2
√
bzw.
+2
+2
2
Knoten. Aus diesen drei Beispielen ist es nicht schwer zu sehen, dass die Anzahl Knoten bei
Problemen auf Tiefe ` ≥ 0 allgemein durch
`−1
∞
X
X
n
2
n
1
√
√
√
√
+
≤
+
2
`
i
`
( 2)
( 2)
2
i=0 ( 2)
i=0
i
n
n
2
√ ≤ √
≤ √ `+
+7
( 2)
1 − 1/ 2
( 2)`
nach oben beschränkt ist.
Da es 2` Knoten mit Tiefe ` im Rekursionsbaum gibt und die Laufzeit eines Knotens im Rekursionsbaum quadratisch in der Größe des zu lösenden Teilproblems nach oben beschränkt
ist, ist die Laufzeit für alle Knoten auf Ebene ` des Rekursionsbaums zusammen höchstens
n
2 ·c √ ` +7
( 2)
`
2
8n
≤2 ·c √ `
( 2)
`
2
= 64cn2 = O(n2 ).
Zusammen mit der Beobachtung, dass es O(log n) viele Ebenen gibt, folgt daraus das Theorem.
Als nächstes analysieren wir die Erfolgswahrscheinlichkeit des FastCut-Algorithmus.
Theorem 1.9. Der FastCut-Algorithmus gibt mit Wahrscheinlichkeit Ω(1/ log n) einen minimalen Schnitt aus.
Beweis. Zunächst überlegen wir uns, wie wahrscheinlich es ist, dass der Multigraph, der
durch die n−t Kontraktionen eines Aufrufs von Contract(G, t) entsteht, immer noch einen minimalen Schnitt des Graphen G enthält. Genau wie bei der Analyse des Contract-Algorithmus
fixieren wir dafür einen minimalen Schnitt C ⊆ E des Graphen G und berechnen die Wahrscheinlichkeit, dass dieser die Kontraktionen überlebt.
2
Für t = 2 haben wir die Wahrscheinlichkeit in Theorem 1.7 bereits durch n(n−1)
nach unten abgeschätzt. Schauen wir uns diese Analyse noch einmal an, so stellen wir fest, dass
wir sie einfach auf Contract(G, t) für allgemeine t erweitern können. Dazu definieren wir
Ereignisse A1 , . . . , An−t , wobei Ai wieder bedeutet, dass im i-ten Schritt keine Kante aus C
kontrahiert wird. Mit der in Theorem 1.7 hergeleiteten Abschätzung
Pr(Ai | A1 ∩ . . . ∩ Ai−1 ) ≥
n−i−1
n−i+1
gilt
Pr(C überlebt Contract(G, t))
= Pr(A1 ) · Pr(A2 | A1 ) · . . . · Pr(An−t | A1 ∩ . . . ∩ An−t−1 )
≥
n−2
n
n−3
n−1
l
=
t(t − 1)
=
n(n − 1)
1+
n−4
t+1
...
n−2
t+3
√n
2
m l
·
√n
2
n(n − 1)
m
l
1+
=
n
√n
2
t
t+2
m
l
·
√n
2
t−1
t+1
m
1
≥ .
n−1
2
20
1. Grundlagen der Wahrscheinlichkeitstheorie
Wir nennen einen Knoten des Rekursionsbaumes erfolgreich, wenn er einen Multigraphen
ausgibt, der einen minimalen Schnitt von G enthält. Wir bezeichnen mit P (n) eine untere
Abschätzung für die Wahrscheinlichkeit, dass die Wurzel bei einem Graphen G mit n Knoten erfolgreich ist. Die Wurzel ist dann erfolgreich, wenn für mindestens ein i ∈ {1, 2} der
Multigraph Hi einen minimalen Schnitt von G enthält und wenn der zu diesem Hi gehörige
rekursive Aufruf erfolgreich ist. Da die beiden Aufrufe von Contract(G, t) und die rekursiven Aufrufe unabhängig voneinander sind, können wir die Wahrscheinlichkeit, dass Hi einen
minimalen Schnitt von G enthält und dass zudem der rekursive Aufruf erfolgreich ist, durch
P (t)/2 nach unten abschätzen. Die Wahrscheinlichkeit, dass dies für kein i ∈ {1, 2} der Fall
ist, lässt sich auf Grund der Unabhängigkeit durch (1 − P (t)/2)2 nach oben abschätzen.
Damit ergibt sich für n ≥ 7
P (t)
P (n) ≥ 1 − 1 −
2
!2
und P (n) = 1 für n ≤ 6.
Da alle Teilprobleme, die sich auf derselben Ebene im Rekursionsbaum befinden, die gleiche
Knotenanzahl haben, ist es für uns einfacher, die Erfolgswahrscheinlichkeit eines Knotens
mit der Ebene im Rekursionsbaum zu parametrisieren anstatt mit der Knotenanzahl in dem
Teilproblem, das er darstellt. Sei dazu p(k) eine untere Schranke für die Erfolgswahrscheinlichkeit eines Knotens mit Höhe k. Wir verwenden die Konvention, dass Blätter die Höhe 0
haben, die Eltern der Blätter die Höhe 1 und so weiter. Aus obiger Formel ergibt sich für
die so parametrisierte Wahrscheinlichkeit direkt p(0) = 1 und für k ≥ 1
p(k − 1)
p(k) ≥ 1 − 1 −
2
!2
.
Wir können die Wahrscheinlichkeit p(k) auch wie folgt interpretieren: Man betrachte einen
vollständigen binären Baum der Höhe k und lösche jede Kante dieses Baumes unabhängig
von den anderen Kanten mit Wahrscheinlichkeit 1/2. Was groß ist die Wahrscheinlichkeit,
dass ein Weg von der Wurzel zu einem der Blätter erhalten bleibt?
Per vollständiger Induktion lässt sich leicht nachweisen, dass p(k) ≥
Für k = 0 folgt dies direkt. Für k ≥ 1 gilt per Induktion
p(k − 1)
p(k) ≥ 1 − 1 −
2
1
≥1− 1−
2k
für alle k ≥ 0 gilt.
!2
1
1
1
k+1 k+1
= − 2 =
−
k 4k
k+1
k
4k 2
1
3k − 1
1+
k+1
4k 2
=
!2
1
k+1
≥
1
.
k+1
Wir haben uns bereits im Beweis von Theorem 1.8 überlegt, dass die Rekursionstiefe Θ(log n)
beträgt. Somit ist die Erfolgswahrscheinlichkeit von FastCut mindestens Ω(1/ log n).
Auch bei FastCut erhöhen wir die Erfolgswahrscheinlichkeit durch unabhängige Wiederholungen. Sei die Erfolgswahrscheinlichkeit einer Ausführung von FastCut mindestens c/ log n
1.4. Zufallsvariablen und Erwartungswerte
21
für ein geeignet gewähltes c > 0. Wiederholen wir FastCut k log n/c oft, so erhalten wir eine
Fehlerwahrscheinlichkeit von
c
1−
log n
k log n/c
≤
c
1−
log n
log n/c !k
<
1
.
ek
Für k = Θ(log n) erhalten wir bereits eine sehr kleine Fehlerwahrscheinlichkeit von 1/nΘ(1) .
1.4
Zufallsvariablen und Erwartungswerte
Oft sind wir bei einem Zufallsexperiment gar nicht an seinem exakten Ausgang interessiert,
sondern nur an einer Kenngröße, die die für uns wesentliche Information enthält. Werfen wir
beispielsweise zwei Würfel, so sind wir oft nur an der Summe der Augenzahlen interessiert.
Ebenso sind wir bei einer Folge von Münzwürfen oft nicht an dem genauen Ausgang der Würfe
interessiert, sondern nur daran, wie oft „Zahl“ geworfen wurde. Um dies zu modellieren,
führen wir das Konzept von Zufallsvariablen ein.
Definition 1.10. Sei (Ω, Pr) ein diskreter Wahrscheinlichkeitsraum. Wir nennen eine Abbildung X : Ω → R, die die Ergebnismenge auf die reellen Zahlen abbildet, eine diskrete reelle
Zufallsvariable.
Bei einer Zufallsvariable X interessiert uns die Wahrscheinlichkeit, mit der sie bestimmte
Werte annimmt. Für eine reelle Zahl a ∈ R interpretieren wir X = a als das Ereignis {ω ∈
Ω | X(ω) = a} im Wahrscheinlichkeitsraum (Ω, Pr). Mit dieser Interpretation ergibt sich
Pr(X = a) = Pr {ω ∈ Ω | X(ω) = a} .
Für eine Teilmenge A ⊆ R der reellen Zahlen ergibt sich analog
Pr(X ∈ A) = Pr {ω ∈ Ω | X(ω) ∈ A} .
Wir betrachten zunächst zwei Beispiele für Zufallsvariablen.
• Sei (Ω, Pr) mit Ω = {1, . . . , 6}2 und Pr(ω) = 1/36 für ω ∈ Ω der Wahrscheinlichkeitsraum, der zwei unabhängige Würfelwürfe beschreibt, so können wir als Zufallsvariable X : Ω → {1, . . . , 12} die Summe der gewürfelten Zahlen definieren. Formal
setzen wir dafür X(ω) = ω1 + ω2 für ω = (ω1 , ω2 ) ∈ Ω. Für diese Zufallsvariable gelten
beispielsweise
Pr(X = 1) = 0, Pr(X = 2) =
1
1
und Pr(X = 7) = .
36
6
• Sei (Ω, Pr) mit Ω = {Z, K}10 und Pr(ω) = 1/1024 für ω ∈ Ω der Wahrscheinlichkeitsraum, der zehn unabhängige Münzwürfe beschreibt. Wir definieren als Zufallsvariable X : Ω → {0, 1, 2, . . . , 10} die Anzahl, wie oft „Zahl“ geworfen wurde. Als Übung
sollte der Leser sich überlegen, dass für diese Zufallsvariable
Pr(X = 0) =
gelten.
10
45
1
, Pr(X = 1) =
und Pr(X = 2) =
1024
1024
1024
22
1. Grundlagen der Wahrscheinlichkeitstheorie
Genauso wie bei Ereignissen können wir auch bei mehreren Zufallsvariablen wieder unterscheiden, ob sie unabhängig oder abhängig sind.
Definition 1.11. Sei (Ω, Pr) ein diskreter Wahrscheinlichkeitsraum und seien X : Ω → R
und Y : Ω → R diskrete reelle Zufallsvariablen. Wir nennen X und Y unabhängig, wenn für
alle x ∈ R und y ∈ R
Pr((X = x) ∩ (Y = y)) = Pr(X = x) · Pr(Y = y)
gilt. Wir nennen eine Familie X1 , . . . , Xn von diskreten reellen Zufallsvariablen unabhängig,
wenn für jede Teilmenge I ⊆ {1, . . . , n} und für alle xi ∈ R, i ∈ I,
!
Pr
\
(Xi = xi )
i∈I
=
Y
Pr(Xi = xi )
i∈I
gilt.
Diese Definition ist an Definition 1.3 angelehnt. Tatsächlich folgt unmittelbar, dass zwei
Zufallsvariablen X und Y genau dann unabhängig sind, wenn die Ereignisse {ω ∈ Ω | X(ω) =
x} und {ω ∈ Ω | Y (ω) = y} für alle x, y ∈ R unabhängig sind.
Oft möchte man den „durchschnittlichen Wert“ einer Zufallsvariable angeben. Dazu summiert man alle Werte auf, die die Zufallsvariable annehmen kann, wobei die einzelnen Werte
jeweils mit der Wahrscheinlichkeit gewichtet werden, dass sie von der Zufallsvariable angenommen werden.
Definition 1.12. Sei (Ω, Pr) ein diskreter Wahrscheinlichkeitsraum und sei X : Ω → R
P
eine diskrete reelle Zufallsvariable. Falls die Reihe ω∈Ω |X(ω)| · Pr({ω}) konvergiert, so
definieren wir
X
E(X) =
X(ω) · Pr({ω}).
ω∈Ω
als den Erwartungswert von X.
Sei X eine Zufallsvariable, für die der Erwartungswert gemäß obiger Definition existiert.
Bezeichnen wir mit R = X(Ω) die abzählbare Teilmenge der reellen Zahlen, die von X
angenommen werden können, dann können wir den Erwartungswert von X auch wie folgt
berechnen:
X
E(X) =
x · Pr(X = x).
(1.2)
x∈R
Für die Zufallsvariable X, die die Summe zweier unabhängiger Würfelwürfe beschreibt, gilt
E(X) = 2 ·
1
2
3
2
1
+3·
+4·
+ . . . + 11 ·
+ 12 ·
= 7.
36
36
36
36
36
Für die Zufallsvariable X, die beschreibt, wie oft in zehn Münzwürfen „Zahl“ geworfen wird,
ist es schon schwieriger, den Erwartungswert anhand der Definition nachzurechnen. Nur mit
viel Mühe rechnet man nach, dass
E(X) = 0 ·
1
10
45
1
+1·
+2·
+ . . . + 10 ·
=5
1024
1024
1024
1024
gilt. Um das Ausrechnen von Erwartungswerten zu vereinfachen, lernen wir jetzt einige
wichtige Rechenregeln kennen.
1.4. Zufallsvariablen und Erwartungswerte
23
Theorem 1.13. Sei (Ω, Pr) ein diskreter Wahrscheinlichkeitsraum und seien X : Ω → R
und Y : Ω → R diskrete reelle Zufallsvariablen, deren Erwartungswerte existieren. Dann gilt:
a) Für c, d ∈ R existiert der Erwartungswert der Zufallsvariable (cX + d) : Ω → R
mit (cX + d)(ω) = cX(ω) + d für ω ∈ Ω. Es gilt E(cX + d) = cE(X) + d.
b) Der Erwartungswert der Zufallsvariable (X + Y ) : Ω → R mit (X + Y )(ω) = X(ω) +
Y (ω) für ω ∈ Ω existiert und es gilt E(X + Y ) = E(X) + E(Y ).
c) Sind X und Y unabhängig, so existiert der Erwartungswert der Zufallsvariable (X ·
Y ) : Ω → R mit (X ·Y )(ω) = X(ω)·Y (ω) für ω ∈ Ω und es gilt E(X ·Y ) = E(X)·E(Y ).
Beweis. a) Aus Definition 1.12 folgt
E(cX + d) =
X
(cX + d)(ω) · Pr({ω})
ω∈Ω
=
X
(cX(ω) + d) · Pr({ω})
ω∈Ω
X
=c
X(ω) · Pr({ω}) + d
ω∈Ω
X
·Pr({ω})
ω∈Ω
= cE(X) + d.
Die Existenz des Erwartungswertes von cX + d rechnet man ebenfalls leicht nach.
b) Auch diese Aussage folgt direkt aus Definition 1.12:
E(X + Y ) =
X
(X + Y )(ω) · Pr({ω})
ω∈Ω
=
X
(X(ω) + Y (ω)) · Pr({ω})
ω∈Ω
=
X
X(ω) · Pr({ω}) +
ω∈Ω
X
Y (ω) · Pr({ω})
ω∈Ω
= E(X) + E(Y ).
c) Seien R = X(Ω) und S = Y (Ω) die abzählbaren Mengen von Werten, die X bzw. Y
annehmen können. Es gilt dann gemäß Definition 1.12
E(X · Y ) =
X
(X · Y )(ω) · Pr({ω})
ω∈Ω
=
X
(X(ω) · Y (ω)) · Pr({ω})
ω∈Ω
=
XX
xy · Pr (X = x) ∩ (Y = y)
x∈R y∈S
=
XX
xy · Pr(X = x) · Pr(Y = y)
x∈R y∈S
=
X
xPr(X = x)
x∈R
=
X
X
y · Pr(Y = y)
y∈S
xPr(X = x) · E(Y )
x∈R
= E(Y )
X
xPr(X = x)
x∈R
= E(X) · E(Y ),
24
1. Grundlagen der Wahrscheinlichkeitstheorie
wobei wir in der vierten Zeile die Unabhängigkeit der Zufallsvariablen ausgenutzt haben. Die
Existenz des Erwartungswertes rechnet man wieder analog nach, indem man in allen obigen
Summen x durch |x| und y durch |y| ersetzt.
Aussage b) des vorangegangenen Theorems werden wir auch als Linearität des Erwartungswertes bezeichnen. Es handelt sich dabei um eine äußerst nützliche Rechenregel, die sogar
für abhängige Zufallsvariablen X und Y gültig ist.
Nutzen wir die Linearität des Erwartungswertes, so ist es viel einfacher, die Erwartungswerte in den beiden obigen Beispielen zu berechnen. Betrachten wir dazu noch einmal den
Wahrscheinlichkeitsraum (Ω, Pr) mit Ω = {Z, K}10 und Pr(ω) = 1/1024 für ω ∈ Ω und die
Zufallsvariable X : Ω → {0, 1, 2, . . . , 10}, die angibt, wie oft „Zahl“ geworfen wurde. Diese
können wir darstellen als die Summe der Zufallsvariablen X1 , . . . , X10 , wobei Xi : Ω → {0, 1}
durch
(
1 falls i-ter Wurf „Zahl“ ergibt
Xi =
0 sonst
definiert ist. Eigentlich hätten wir in dieser Definition formal korrekt Xi (ω) statt einfach
nur Xi schreiben müssen. Um die Notation einfach zu halten, haben wir dies aber nicht
getan und werden auch im Folgenden in ähnlicher Weise Zufallsvariablen beschreiben. Für
jede Zufallsvariable Xi gilt
1
E(Xi ) = 1 · Pr(i-ter Wurf ergibt „Zahl“) = .
2
Somit ergibt sich
E(X) = E
X
10
Xi =
i=1
1.4.1
10
X
E(Xi ) =
i=1
10
X
1
i=1
2
= 5.
Anwendung: Analyse von Quicksort
Als erste algorithmische Anwendung analysieren wir die erwartete Laufzeit des QuicksortAlgorithmus. Dieser rekursive Sortieralgorithmus, der auf dem Prinzip Divide-and-Conquer
beruht, sollte aus vorangegangenen Vorlesungen bekannt sein, wir wiederholen ihn der Vollständigkeit halber an dieser Stelle aber noch einmal kurz. Wir gehen dabei davon aus, dass
wir als Eingabe eine Menge S von paarweise verschiedenen natürlichen Zahlen erhalten. Die
Ausgabe soll ein aufsteigend sortierter Vektor sein, der dieselben Zahlen wie S enthält.
QuickSort(S = {x1 , . . . , xn })
1. if (n = 0 or n = 1) then return S;
2. Wähle ein Pivotelement x ∈ S.
3. Bestimme S1 = {xi | xi < x} und S2 = {xi | xi > x}.
4. A1 = QuickSort(S1 ); A2 = QuickSort(S2 );
5. Sei A der Vektor, der durch Konkatenation von A1 , x und A2 entsteht.
6. return A;
Der obige Pseudocode lässt offen, auf welche Art und Weise das Pivotelement x ∈ S bestimmt wird. Wählt man stets die kleinste Zahl in S als Pivotelement, so ergibt sich eine
1.4. Zufallsvariablen und Erwartungswerte
25
Gesamtlaufzeit von Θ(n2 ). Wählt man jedoch stets den Median, so kann man leicht argumentieren, dass die Gesamtlaufzeit auf Θ(n log n) sinkt. Da das Bestimmen des Medians aber zu
aufwendig ist, bevorzugt man in der Praxis einfachere Regeln zur Wahl des Pivotelementes.
Wählt man stets eine uniform zufällige Zahl aus S als Pivotelement, so legen Experimente
die Vermutung nahe, dass die Laufzeit dann typischerweise in der Größenordnung Θ(n log n)
liegt. Tatsächlich ist diese Variante von Quicksort eines der in der Praxis besten Sortierverfahren. Um diese experimentellen Beobachtungen zu erklären, analysieren wir jetzt die
erwartete Laufzeit von Quicksort, wenn in jedem rekursiven Aufruf ein uniform zufälliges
Element als Pivotelement gewählt wird.
Aus vorangegangenen Vorlesungen sollte bekannt sein, dass wir bei Sortieralgorithmen häufig statt ihrer Laufzeit die Anzahl wesentlicher Vergleiche zählen, die sie durchführen. Ein
wesentlicher Vergleich ist einfach ein Vergleich zweier Zahlen der Eingabe. Bei vielen Algorithmen (inklusive Quicksort) dominieren die wesentlichen Vergleiche die Laufzeit für die
anderen Operationen. Das bedeutet, dass die Laufzeit in der gleichen Größenordnung wie
die Anzahl an wesentlichen Vergleichen liegt.
Theorem 1.14. Die erwartete Anzahl wesentlicher Vergleiche, die Quicksort durchführt,
wenn stets unabhängig ein uniform zufälliges Element als Pivotelement gewählt wird, beträgt 2n ln n + Θ(n).
Beweis. Es sei (y1 , . . . , yn ) der aufsteigend sortierte Vektor, der genau die Zahlen aus der
Menge S enthält. Für jedes Paar i, j ∈ {1, . . . , n} mit i < j definieren wir eine Zufallsvariable Xij wie folgt:
(
Xij =
1 falls während der Ausführung von Quicksort yi und yj verglichen werden,
0 sonst.
Wir nennen eine solche Zufallsvariable, die nur die Werte 0 und 1 annehmen kann, auch eine
Indikatorvariable, da sie ein Indikator für ein bestimmtes Ereignis ist (in diesem Falle für
das Ereignis, dass yi und yj verglichen werden). Wir sind interessiert an dem Erwartungswert der Zufallsvariable X, die die Anzahl wesentlicher Vergleich von Quicksort beschreibt.
Diese können wir als Summe über die Xij schreiben und Linearität des Erwartungswertes
ausnutzen. Damit erhalten wir
E(X) = E
n−1
X
n
X
i=1 j=i+1
!
Xij
=
n−1
X
n
X
i=1 j=i+1
E(Xij ) =
n−1
X
n
X
Pr(Xij = 1).
i=1 j=i+1
Im letzten Schritt dieser Umformung haben wir ausgenutzt, dass der Erwartungswert für
Zufallsvariablen, die nur die Werte 0 und 1 annehmen können, gemäß (1.2) der Wahrscheinlichkeit entspricht, dass sie den Wert 1 annehmen.
Wir bestimmen nun die Wahrscheinlichkeit dafür, dass yi und yj miteinander verglichen
werden. Dazu betrachten wir die Sequenz von Pivotelementen, die im Laufe der Ausführung
von Quicksort gewählt werden. Uns interessiert insbesondere das erste Pivotelement x, das im
Laufe des Algorithmus aus der Menge {yi , yi+1 , . . . , yj } gewählt wird. Genau dann, wenn x =
yi oder x = yj gilt, werden die Elemente yi und yj im Laufe des Quicksort-Algorithmus
miteinander verglichen. Um dies zu begründen, betrachten wir die folgenden beiden Fälle.
• Sei x 6= yi und x 6= yj . Da Quicksort in jedem Aufruf nur Vergleiche mit dem Pivotelement durchführt und bis zu diesem Zeitpunkt weder yi noch yj Pivotelement waren, wurden yi und yj bisher noch nicht miteinander vergleichen. In diesem Durchlauf
26
1. Grundlagen der Wahrscheinlichkeitstheorie
gilt yi < x < yj . Das bedeutet, dass yi der Menge S1 und yj der Menge S2 zugewiesen
werden. Somit kann es auch in keinem der weiteren rekursiven Aufrufe mehr zu einem
Vergleich von yi und yj kommen.
• Sei x entweder yi oder yj . Da bisher kein Element zwischen yi und yj als Pivotelement
gewählt wurde, sind in dem rekursiven Aufruf, in dem x gewählt wird, noch beide Elemente in der aktuellen Menge S enthalten. Somit findet in diesem Aufruf ein Vergleich
von yi und yj statt.
Wir müssen also nur noch die Wahrscheinlichkeit bestimmen, dass das erste Element, das
aus der Menge {yi , yi+1 , . . . , yj } gewählt wird, entweder yi oder yj ist. Solange kein Element
aus dieser Menge als Pivotelement gewählt wurde, sind in jedem rekursiven Aufruf entweder
noch alle Elemente dieser Menge in der aktuellen Menge S enthalten oder gar keins. Daraus
und aus der uniform zufälligen Wahl des Pivotelementes folgt zusammen, dass jedes Element
der Menge die gleiche Wahrscheinlichkeit besitzt, als erstes Element der Menge Pivotelement
2
zu werden. Damit folgt Pr(Xij = 1) = j−i+1
. Insgesamt erhalten wir
E(X) =
n−1
X
n
X
Pr(Xij = 1) =
i=1 j=i+1
=
n−1
X
X n−i+1
i=1 k=2
= (n + 1)
n−1
X
n
X
2
j−i+1
i=1 j=i+1
n n+1−k
n
X
X 2
X
2
2(n + 1 − k)
=
=
k k=2 i=1 k k=2
k
n
X
2
k=2
k
!
− 2(n − 1)
= (2n + 2)(Hn − 1) − 2(n − 1),
wobei Hn = ni=1 1i die n-te harmonische Zahl bezeichnet. Nutzt man aus, dass Hn =
ln n + Θ(1) gilt, so impliziert das
P
E(X) = (2n + 2)(ln n + Θ(1)) − 2(n − 1) = 2n ln n + Θ(n).
An dieser Stelle bietet es sich an, bereits kurz das zweite Thema dieser Vorlesung, die probabilistische Analyse von Algorithmen, anzusprechen. Dabei geht es darum, das Verhalten von
deterministischen oder randomisierten Algorithmen auf zufälligen Eingaben zu analysieren.
Die Variante von Quicksort, die stets das erste Element aus der Menge S als Pivotelement
wählt, hat im Worst-Case eine Laufzeit von Θ(n2 ), wenn die Elemente in S zum Beispiel
bereits sortiert sind. Kann man aber davon ausgehen, dass die initiale Reihenfolge der zu sortierende Element zufällig ist, so kann man zeigen, dass auch diese deterministische Variante
von Quicksort eine erwartete Laufzeit von Θ(n log n) hat.
Theorem 1.15. Die erwartete Anzahl wesentlicher Vergleiche, die Quicksort durchführt,
wenn stets das erste Element als Pivotelement gewählt wird, beträgt 2n ln n + Θ(n), wenn die
Eingabe eine uniform zufällige Permutation der zu sortierenden Elemente ist.
Beweis. Der Beweis erfolgt analog zu dem von Theorem 1.14. Da die Reihenfolge der Elemente in der initialen Eingabe S uniform zufällig gewählt wurde, haben alle Elemente in der
Menge {yi , yi+1 , . . . , yj } die gleiche Wahrscheinlichkeit, als erstes in S aufzutreten und somit
als erstes dieser Elemente Pivotelement zu werden. Dementsprechend kann man ganz analog
2
zeigen.
zum vorherigen Beweis Pr(Xij = 1) = j−i+1
1.4. Zufallsvariablen und Erwartungswerte
27
Wir weisen noch einmal explizit darauf hin, dass es zwischen Theorem 1.14 und Theorem 1.15
einen großen konzeptionellen Unterschied gibt. Während in Theorem 1.14 der Algorithmus
randomisiert ist, die Eingabe aber beliebig deterministisch gewählt sein kann, ist in Theorem 1.15 der Algorithmus deterministisch und die Eingabe ist zufällig gewählt.
1.4.2
Anwendung: Hashing
Wir betrachten als weitere Anwendung nun noch Hashing. Wir wissen bereits aus der Vorlesung „Algorithmen und Berechnungskomplexität I“, dass Hashing eine Möglichkeit ist,
dynamische Dateien zu verwalten. Wir gehen dabei davon aus, dass wir ein Universum U
haben, das alle möglichen Schlüssel enthält. Wir möchten in der Lage sein, Schlüssel in die
dynamische Datei einzufügen, zu suchen und zu löschen. Beim Hashing sind ein Feld der Größe m und eine Hashfunktion h : U → {1, . . . , m} gegeben, die jedem Schlüssel eine Position
im Feld zuweist.
Beim Hashing mit verketteten Listen werden Kollisionen dadurch gelöst, dass jede Position
des Feldes eine verkettete Liste ist und ein neu einzufügender Schlüssel einfach der entsprechenden Liste hinzugefügt wird. Können wir die Hashfunktion in konstanter Zeit auswerten,
so ist die Laufzeit für das Suchen und Löschen eines Schlüssels proportional zur Länge der
entsprechenden Liste. Die Laufzeit für das Einfügen von Schlüsseln ist konstant, wenn vorher
kein Test durchgeführt wird, ob der Schlüssel bereits vorhanden ist. Ansonsten ist sie auch
proportional zur Listenlänge. Neue Schlüssel werden dabei immer an den Anfang der Liste
angefügt.
Da die Laufzeit von Hashing im Worst-Case sehr schlecht ist, Hashing aber in der Praxis
gut funktioniert, analysiert man normalerweise die erwartete Laufzeit im Average-Case, um
realistischere Aussagen zu erhalten. Dazu trifft man oft vereinfachende Annahmen über die
Streuung der Hashfunktionen. Wir arbeiten hier zunächst mit der einfachen Annahme, dass
die Hashfunktion jeden Schlüssel aus U unabhängig von den anderen auf eine uniform zufällige Position aus {1, . . . , m} abbildet. Diese Annahme bezeichnen wir als uniformes Hashing.
Wir gehen im folgenden Theorem davon aus, dass bereits n Schlüssel in die Hashtabelle
eingefügt wurden, und bezeichnen mit α = n/m den Belegungsfaktor.
Theorem 1.16. Die erwartete Laufzeit einer Suche nach einem Schlüssel y ∈ U , der nicht in
der Hashtabelle enthalten ist, beträgt unter der Annahme des uniformen Hashings Θ(1 + α).
Die erwartete Laufzeit einer Suche nach einem Schlüssel, der in der Hashtabelle vorhanden
ist, beträgt im Durchschnitt über alle vorhandenen Schlüssel Θ(1 + α).
Beweis. Der erste Teil der Aussage folgt leicht. Seien dazu x1 , . . . , xn die Schlüssel, die in der
Hashtabelle vorhanden sind, und sei y ∈ U der Schlüssel, nach dem erfolglos gesucht wird.
Wir definieren Indikatorvariablen X1 , . . . , Xn , wobei Xi das Ereignis beschreibt, dass h(xi ) =
h(y) gilt. Dann können wir die Anzahl Zeiger, denen wir in der verketteten Liste bei der
Suche nach y folgen müssen, als 1 + X1 + . . . + Xn schreiben, wobei wir den letzte Nullzeiger
mitzählen. Auf Grund der Annahme, dass h(y) unabhängig von den Schlüsseln x1 , . . . , xn
auf eine uniform zufällig Position abgebildet wird, gilt Pr(Xi = 1) = 1/m. Nutzen wir nun
die Linearität des Erwartungswertes, so erhalten wir direkt
n
E(1 + X1 + . . . + Xn ) = 1 + E(X1 ) + . . . + E(Xn ) = 1 +
= 1 + α.
m
Die durchschnittliche erwartete Laufzeit bei einer erfolgreichen Suche zu bestimmen, erfordert etwas mehr Aufwand. Sei y das Element, das wir suchen, und seien x1 , . . . , xn die
28
1. Grundlagen der Wahrscheinlichkeitstheorie
Elemente in der Hashtabelle. Wir gehen davon aus, dass die Elemente x1 , . . . , xn in dieser
Reihenfolge eingefügt wurden und dass y = xi gilt. Wie vielen Zeigern folgen wir, wenn
wir nach y = xi suchen? Da neue Elemente an den Anfang der Liste angefügt werden, ist
nur wichtig, wie viele Schlüssel nach xi in die zugehörige Liste eingefügt wurden. Für j > i
definieren wir eine Indikatorvariable Xij mit
(
1
0
Xij =
falls h(xj ) = h(xi ),
falls h(xj ) 6= h(xi ).
Auf Grund der Unabhängigkeit von h(xi ) und h(xj ) gilt Pr(h(xj ) = h(xi )) = 1/m. Die
erwartete Anzahl Zeiger, denen wir folgen, wenn wir nach y = xi suchen, beträgt somit
E 1+
n
X
!
Xij
=1+
j=i+1
n
X
E Xij = 1 +
j=i+1
n−i
.
m
Der Durchschnitt über alle Wahlen y = xi beträgt
n
1X
n−i
1+
n i=1
m
=1+
n
1 X
1 n(n − 1)
(n − i) = 1 +
·
nm i=1
nm
2
=1+
α
α
n−1
=1+ −
= Θ(1 + α).
2m
2
2n
Beim Hashing mit offener Adressierung enthält jede Position des Feldes nur höchstens einen
Schlüssel und Kollisionen werden mittels Sondierung gelöst. Das bedeutet, dass eine erweiterte Hashfunktion h : U × {1, . . . , m} → {1, . . . , m} gegeben ist. Soll nun ein neuer Schlüssel x
eingefügt werden, so wird dies zunächst an der Position h(x, 1) versucht. Ist diese Position
bereits belegt, so wird als nächstes die Position h(x, 2) getestet und so weiter. Wird ein Element x gesucht, so werden die Positionen ebenfalls in dieser Reihenfolge besucht, solange,
bis entweder x oder eine leere Position gefunden wird. Wir gehen in diesem Falle davon aus,
dass keine Elemente gelöscht werden. Außerdem gehen wir davon aus, dass stets höchstens m
Elemente in der Hashtabelle vorhanden sind, da es ansonsten zu einem Überlauf kommt.
Zur Analyse von Hashing mit offener Adressierung machen wir wieder eine idealisierte
Annahme. Wir betrachten die Situation, dass wir eine Hashtabelle mit Auslastung α =
n/m < 1 haben, und einen Schlüssel x suchen. Dabei gehen wir davon aus, dass die Sequenz h(x, 1), h(x, 2), . . . , h(x, m) eine uniform zufällige Permutation der Menge {1, . . . , m}
ist. Wir nennen diese Annahme wieder uniformes Hashing.
Theorem 1.17. Die Laufzeit einer Suche nach einem Schlüssel y ∈ U , der nicht in
der
1
Hashtabelle enthalten ist, beträgt unter der Annahme des uniformen Hashings O 1−α
. Die
erwartete Laufzeit einer Suche nach einem Schlüssel, der in der Hashtabelle
enthalten ist,
1
beträgt im Durchschnitt über alle vorhandenen Schlüssel O α1 ln 1−α
.
Beweis. Wir betrachten zunächst den Fall einer erfolglosen Suche nach einem Schlüssel y,
der nicht in der Hashtabelle enthalten ist. Dazu definieren wir Ai für i ∈ {1, . . . , n} als das
Ereignis, dass die Position h(y, i) belegt ist. Sei X die Zufallsvariable, die angibt, wie viele
Positionen wir bei der erfolglosen Suche nach y betrachten. Dann gilt für i ∈ {1, . . . , n + 1}
Pr(X ≥ i) = Pr A1 ∩ . . . ∩ Ai−1 =
i−1
Y
j=1
Pr Aj | A1 ∩ . . . ∩ Aj−1 .
1.4. Zufallsvariablen und Erwartungswerte
29
Gehen wir davon aus, dass h(y, 1), . . . , h(y, m) eine uniform zufällige Permutation der Positionen ist, so gilt
n−j+1
Pr Aj | A1 ∩ . . . ∩ Aj−1 =
,
m−j+1
da für h(y, j) noch m − j + 1 mögliche Positionen zur Verfügung stehen, von denen unter
der Bedingung A1 ∩ . . . ∩ Aj−1 noch n − j + 1 viele belegt sind. Damit ergibt sich insgesamt
für i ∈ {1, . . . , n + 1}
i−1
Y
n−j+1
Pr(X ≥ i) =
≤
m
−j+1
j=1
n
m
!i−1
= αi−1 .
Da maximal n + 1 Positionen betrachtet werden, bis eine nicht belegte gefunden wird,
gilt Pr(X ≥ n + 2) = 0. Daraus folgt
E(X) =
∞
X
Pr(X ≥ i) =
i=1
n+1
X
Pr(X ≥ i) ≤
i=1
n+1
X
αi−1 ≤
i=1
∞
X
αi−1 =
i=1
1
.
1−α
Wir betrachten nun noch den Fall, dass die Schlüssel x1 , . . . , xn in dieser Reihenfolge in die
Hashtabelle eingefügt wurden und dass wir nach einem y = xi suchen. Diese Suche erzeugt
die gleiche Sequenz von Positionen wie das Einfügen des Schlüssels y. Zu dem Zeitpunkt,
zu dem der Schlüssel xi eingefügt wurde, waren bereits i − 1 andere Schlüssel vorhanden,
was einem Belegungsfaktor von αi = (i − 1)/m entspricht. Da das Einfügen zu diesem
Zeitpunkt zunächst einer erfolglosen Suche nach xi entspricht, besagt obige Rechnung, dass
1
Positionen angeschaut werden. Bilden wir
zur Einfügung von xi im Erwartungswert 1−α
i
den Durchschnitt über alle Schlüssel xi , so ergibt sich
n
m
X
X 1
X
1 X
1
1 n−1
1
1
1
m n−1
·
= ·
·
=
·
=
n i=1 1 − αi
n i=0 1 − mi
n i=0 m − i
α k=m−n+1 k
1
≤
α
1.4.3
Z m
m
1
1
dx = · ln
x
α
m−n
k=m−n
1
1
= ln
.
α
1−α
Binomialverteilung und geometrische Verteilung
Wir haben bereits gesehen, dass gewisse Fragestellungen bei der Analyse von randomisierten
Algorithmen wiederholt auftreten. Haben wir einen Algorithmus mit einer gewissen Erfolgswahrscheinlichkeit, so ist es zum Beispiel interessant, wie oft wir ihn unabhängig wiederholen
müssen, um mit hoher Wahrscheinlichkeit mindestens einmal erfolgreich zu sein. Manchmal
interessiert uns nicht nur die Wahrscheinlichkeit, dass mindestens eine Wiederholung erfolgreich war, sondern auch die Wahrscheinlichkeit, dass mindestens eine gewisse Anzahl an
Wiederholungen erfolgreich war. Um diese Wahrscheinlichkeiten nicht jedes Mal wieder neu
ausrechnen zu müssen, führen wir in diesem Abschnitt binomialverteilte Zufallsvariablen und
geometrische Zufallsvariablen ein.
Betrachten wir zunächst ein Zufallsexperiment, das mit Wahrscheinlichkeit p ∈ [0, 1] erfolgreich ist und mit Wahrscheinlichkeit 1 − p erfolglos. Dann nennen wir Y mit
(
Y =
1
0
falls erfolgreich
falls erfolglos
30
1. Grundlagen der Wahrscheinlichkeitstheorie
die Indikatorvariable für das Ereignis, dass das Zufallsexperiment erfolgreich ist. Eine solche
Zufallsvariable, die nur die Werte 0 und 1 annehmen kann, nennen wir auch BernoulliZufallsvariable mit Parameter p. Es gilt
E(Y ) = 0 · Pr(Y = 0) + 1 · Pr(Y = 1) = Pr(Y = 1) = p.
Führen wir einen randomisierten Algorithmus wie den Contract-Algorithmus zur Berechnung eines minimalen Schnittes aus, so können wir eine Bernoulli-Zufallsvariable definieren,
die angibt, ob der Algorithmus erfolgreich in dem Sinne ist, dass er einen minimalen Schnitt
ausgibt. Um die Frage zu beantworten, wie oft der Algorithmus bei mehrfacher Wiederholung erfolgreich ist, führen wir binomialverteilte Zufallsvariablen ein. Seien dazu Y1 , . . . , Yn
unabhängige Bernoulli-Zufallsvariablen mit demselben Parameter p ∈ [0, 1]. Die Zufallsvariable X = Y1 + . . . + Yn nennen wir binomialverteilte Zufallsvariable mit Parametern n
und p.
Theorem 1.18. Sei X eine binomialverteilte Zufallsvariable mit Parametern n und p. Es
gilt E(X) = pn und für j ∈ {0, . . . , n} gilt
!
Pr(X = j) =
n
· pj · (1 − p)n−j .
j
Beweis. Als erstes berechnen wir die Wahrscheinlichkeit für das Ereignis X = j. Dazu definieren wir für jede Möglichkeit, wie die j Erfolge sich auf die n Versuche
aufteilen können, ein
n
Ereignis. Seien dies die Ereignisse A1 , . . . , Am . Es gilt dann m = j , da dies der Anzahl von
Möglichkeiten entspricht, eine Teilmenge mit j Elementen aus einer Menge mit n Elementen
auszuwählen. Ein Ereignis Ai legt fest, welche j Versuche erfolgreich und welche n − j erfolglos sind. Die Wahrscheinlichkeit, dass Ai eintritt, ist somit für jedes i genau pj (1 − p)n−j .
Die Ereignisse A1 , . . . , Am sind paarweise disjunkt. Damit gilt
Pr(X = j) = Pr
m
[
i=1
!
Ai
=
m
X
!
j
n−j
Pr(Ai ) = m · p · (1 − p)
=
i=1
n
· pj · (1 − p)n−j .
j
Mit Hilfe dieser Wahrscheinlichkeit kann man mit ein wenig Rechnen den Erwartungswert
bestimmen:
!
!
n
X
n
j
n−j
E(X) =
j·
· p · (1 − p)
= . . . = np.
j
j=0
Viel einfacher geht es aber, wenn man die Linearität des Erwartungswertes ausnutzt. Damit
folgt nämlich direkt
!
E(X) = E
n
X
i=1
Yi
=
n
X
E(Yi ) = np,
i=1
wobei wir X = Y1 + . . . + Yn für Bernoulli-Zufallsvariablen Y1 , . . . , Yn mit Parameter p
ausgenutzt haben.
Nun betrachten wir noch die Frage, wie lange wir auf den ersten Erfolg warten müssen,
wenn wir einen Algorithmus unabhängig wiederholen, der eine Erfolgswahrscheinlichkeit
von p besitzt. Dies wird durch eine geometrische Zufallsvariable mit Parameter p beschrieben. Eine solche Zufallsvariable nimmt den Wert n ∈ N an, wenn die ersten n − 1 Versuche erfolglos sind und der n-te Versuch erfolgreich ist. Die Wahrscheinlichkeit hierfür beträgt (1 − p)n−1 · p. Wir definieren für eine geometrische Zufallsvariable X mit Parameter p
1.4. Zufallsvariablen und Erwartungswerte
31
dementsprechend Pr(X = n) = (1 − p)n−1 · p für jedes n ∈ N. Um den Erwartungswert
einer geometrischen Zufallsvariable zu bestimmen, leiten wir zunächst eine nützliche alternative Darstellung des Erwartungswertes her, die für alle Zufallsvariablen gilt, die nur Werte
aus N0 = {0, 1, 2, 3, . . .} annehmen können.
Lemma 1.19. Sei (Ω, Pr) ein diskreter Wahrscheinlichkeitsraum und sei X : Ω → N0 eine
diskrete Zufallsvariable, deren Erwartungswert existiert. Dann gilt
E(X) =
∞
X
Pr(X ≥ i).
i=1
Beweis. Es gilt
∞
X
Pr(X ≥ i) =
i=1
∞ X
∞
X
Pr(X = j)
i=1 j=i
=
=
j
∞ X
X
Pr(X = j)
j=1 i=1
∞
X
j · Pr(X = j) = E(X).
j=1
In obiger Rechnung haben wir ausgenutzt, dass wir bei absolut konvergenten Reihen die
Reihenfolge der Summanden beliebig vertauschen können.
Theorem 1.20. Für eine geometrische Zufallsvariable X mit Parameter p gilt E(X) = 1/p.
Beweis. Für die geometrische Zufallsvariable X und j ∈ N gilt
Pr(X ≥ j) =
∞
X
Pr(X = i) =
i=j
∞
X
(1 − p)i−1 · p = (1 − p)j−1 .
i=j
Die letzte Gleichung in obiger Formel rechnet man entweder nach oder man überlegt sich
einfach, was passieren muss, damit X ≥ j gilt. Dies ist genau dann der Fall, wenn die
ersten j − 1 Versuche erfolglos sind. Die Wahrscheinlichkeit dafür beträgt genau (1 − p)j−1 .
Nun folgt das Theorem leicht aus Lemma 1.19:
E(X) =
∞
X
j=1
Pr(X ≥ j) =
∞
X
(1 − p)j−1 =
j=1
1
1
= .
1 − (1 − p)
p
Das Theorem entspricht der Intuition, die wir im Laufe der Vorlesung gewonnen haben: Hat
ein Algorithmus eine Erfolgswahrscheinlichkeit von p, so müssen wir ihn 1/p mal wiederholen,
um mit konstanter Wahrscheinlichkeit mindestens einmal erfolgreich zu sein.
Eine wichtige Eigenschaft der geometrischen Verteilung, die man oft implizit oder explizit
ausnutzt, ist ihre Gedächtnislosigkeit. Das bedeutet, dass die Wahrscheinlichkeit eines Erfolges unabhängig davon ist, wie viele Misserfolge es bis jetzt gegeben hat. Das ist wie beim
Roulette: Die Information, dass in den letzten zehn Spielen immer rot geworfen wurde, ändert nichts an der Wahrscheinlichkeit, dass im nächsten Spiel rot geworfen wird. Formal
drückt das folgende Lemma die Gedächtnislosigkeit von geometrischen Zufallsvariablen aus.
32
1. Grundlagen der Wahrscheinlichkeitstheorie
Lemma 1.21. Es sei X eine geometrische Zufallsvariable mit Parameter p. Dann gilt für
alle n ∈ N und k ∈ N0
Pr(X = n + k | X > k) = Pr(x = n).
Beweis. Es gilt
Pr (X = n + k) ∩ (X > k)
Pr(X = n + k)
Pr(X = n + k | X > k) =
=
Pr(X > k)
Pr(X > k)
n+k−1
(1 − p)
·p
=
= (1 − p)n−1 · p = Pr(x = n).
k
(1 − p)
1.4.4
Anwendung: Coupon Collector’s Problem
Wir betrachten nun noch ein einfaches Zufallsexperiment, das in der Analyse von randomisierten Algorithmen oft auftritt. Das Coupon Collector’s Problem lässt sich anhand von
Sammelbildern beschreiben, wie sie zum Beispiel zu jeder Fußball-Weltmeisterschaft verkauft
werden. Wir gehen davon aus, dass es insgesamt n verschiedene solcher Bilder gibt. Diese
kann man nicht gezielt erwerben, sondern man kann nur verschlossene Tüten kaufen, in
denen sich jeweils unabhängig ein uniform zufällig ausgewähltes Sammelbild befindet. Wir
bezeichnen mit X die Zufallsvariable, die angibt wie viele Tüten wir kaufen müssen, bis wir
alle Bilder mindestens einmal in unserer Sammlung haben.
Theorem 1.22. Für das Coupon Collector’s Problem mit n Sammelbildern gilt E(X) =
n ln n + Θ(n).
Beweis. Zum Beweis des Theorems zerlegen wir den Zufallsprozess in n Phasen. Die erste
Phase beginnt mit dem ersten Sammelbild, das wir kaufen. Phase i für i ∈ {2, . . . , n} beginnt,
nachdem wir das (i − 1)-te verschiedene Sammelbild gekauft haben. Bezeichnen wir mit Xi
die Anzahl Sammelbilder, die wir in Phase i kaufen, dann gilt X = X1 + . . . + Xn . Außerdem
ist jedes Xi eine geometrisch verteilte Zufallsvariable mit Parameter
pi = 1 −
i−1
,
n
denn die Wahrscheinlichkeit, in Phase i ein Sammelbild zu kaufen, das nicht zu den (i − 1)
bereits erworbenen gehört, beträgt (n − i + 1)/n. Mit der Linearität des Erwartungswertes
und Theorem 1.20 folgt nun direkt
E(X) = E
n
X
i=1
=n
n
X
1
i=1
i
!
Xi
=
n
X
E(Xi ) =
i=1
n
X
1
i=1
pi
=
n
X
i=1
n
n−i+1
= n ln n + Θ(n).
Im letzten Schritt haben wir ausgenutzt, dass für die n-te harmonische Zahl
Θ(1) gilt.
Pn
1
i=1 i
= ln n +
1.5. Konzentration von Verteilungen
1.5
33
Konzentration von Verteilungen
Oft sind wir nicht nur daran interessiert, den Erwartungswert einer Zufallsvariable abzuschätzen, sondern wir möchten zusätzlich zeigen, dass es unwahrscheinlich ist, dass die Zufallsvariable stark von ihrem Erwartungswert abweicht. Wir möchten also zeigen, dass die
Zufallsvariable um ihren Erwartungswert herum konzentriert ist.
1.5.1
Markow- und Tschebyschew-Ungleichung
Die einfachste Möglichkeit, ein solches Konzentrationsergebnis für nicht-negative Zufallsvariablen zu erhalten, ist die Markow-Ungleichung.
Theorem 1.23. Es sei X : Ω → R≥0 eine Zufallsvariable, die nur nicht-negative Werte
annimmt und für die der Erwartungswert E(X) existiert. Dann gilt
Pr(X ≥ a) ≤
E(X)
a
für alle a > 0.
Wir können die Markow-Ungleichung umformulieren, um eine noch einprägsamere Form zu
erhalten. Sei X : Ω → R≥0 eine Zufallsvariable, die nur nicht-negative Werte annimmt. Dann
gilt für alle a ≥ 1
1
Pr(X ≥ a · E(X)) ≤ .
a
Die Wahrscheinlichkeit, dass X a-mal so groß ist wie sein Erwartungswert, ist also höchstens 1/a.
Beweis von Theorem 1.23. Für den Beweis definieren wir uns einfach eine Indikatorvariable I mit
(
1 falls X ≥ a,
I=
0 sonst.
Für diese Indikatorvariable gilt E(I) = Pr(I = 1) = Pr(X ≥ a). Außerdem gilt wegen X ≥ 0
stets I ≤ X/a. Damit folgt insgesamt, wie gewünscht,
Pr(X ≥ a) = E(I) ≤ E
X
a
=
E(X)
.
a
Mit der Markow-Ungleichung können wir beispielsweise die Wahrscheinlichkeit abschätzen,
dass wir in einer Folge von n unabhängigen fairen Münzwürfen mindestens (3n/4)-mal „Zahl“
sehen. Sei X die Zufallsvariable, die angibt, wie oft „Zahl“ geworfen wird. Dann gilt gemäß
der Markow-Ungleichung
Pr X ≥
3n
4
≤
E(X)
n/2
2
=
= .
3n/4
3n/4
3
Die Markow-Ungleichung ist die bestmögliche Schranke, wenn wir als einzige Information
ausnutzen, dass die Zufallsvariable nicht-negativ ist. Liegen uns noch weitere Informationen
vor, so können wir schärfere Schranken zeigen. Oft kennen wir noch die höheren Momente
einer Zufallsvariable im Sinne der folgenden Definition.
34
1. Grundlagen der Wahrscheinlichkeitstheorie
Definition 1.24. Es sei X eine Zufallsvariable und k ∈ N. Falls der Erwartungswert E(X k )
existiert, so nennen wir ihn das k-te Moment von X.
Mit Hilfe des zweiten Momentes einer Zufallsvariable können wir die Begriffe Varianz und
Standardabweichung definieren. Bei beiden Größen handelt es sich um ein Maß dafür, wie
wahrscheinlich es ist, dass die Zufallsvariable einen Wert annimmt, der von ihrem Erwartungswert stark abweicht.
Definition 1.25. Es sei X eine Zufallsvariable. Falls der Erwartungswert und das zweite
Moment von X existieren, so nennen wir
Var(X) = E (X − E(X))2 = E(X 2 ) − E(X)2 .
die Varianz von X. Die Standardabweichung σ(X) von X ist definiert als
σ(X) =
q
Var(X).
Dass die Gleichung in der obigen Definition der Varianz gültig ist, folgt aus der Linearität
des Erwartungswertes:
E (X − E(X))2 = E X 2 − 2XE(X) + E(X)2
= E(X 2 ) − E(2XE(X)) + E E(X)2
= E(X 2 ) − 2E(X)E(X) + E(X)2
= E(X 2 ) − E(X)2 .
In dieser Rechnung haben wir ausgenutzt, dass E(X) und E(X)2 für eine gegebene Zufallsvariable X Konstanten sind.
Um eine bessere Anschauung für Varianz und Standardabweichung zu erhalten, schauen wir
uns zwei Extremfälle an. Eine Zufallsvariable, die stets denselben Wert annimmt, besitzt
eine Varianz und Standardabweichung von 0. Eine Zufallsvariable X, die mit Wahrscheinlichkeit 1/k den Wert kE(X) und mit Wahrscheinlichkeit 1 − 1/k den Wert 0 annimmt,
besitzt eine Varianz von
1 2
· k E(X)2 − E(X)2 = (k − 1)E(X)2
k
√
und eine Standardabweichung von σ(X) = k − 1 · |E(X)|.
Var(X) = E(X 2 ) − E(X)2 =
Genau wie für den Erwartungswert gibt es einige Rechenregeln, die die Berechnung der
Varianz einer Zufallsvariablen vereinfachen.
Theorem 1.26. Seien X und Y zwei unabhängige Zufallsvariablen, für die die Varianzen Var(X) und Var(Y ) existieren, und seien a, b ∈ R. Dann gelten
Var(aX + b) = a2 · Var(X)
und
Var(X + Y ) = Var(X) + Var(Y ).
1.5. Konzentration von Verteilungen
35
Beweis. Die erste Aussage folgt direkt aus den bekannten Rechenregeln für Erwartungswerte:
Var(aX + b) = E (aX + b − E(aX + b))2
= E (aX + b − aE(X) − b)2
= E (aX − aE(X))2
= a2 · E (X − E(X))2
= a2 · Var(X).
Die zweite Aussage folgt ebenfalls direkt aus diesen Rechenregeln und der Unabhängigkeit
von X und Y , die E(X · Y ) = E(X) · E(Y ) impliziert:
Var(X + Y ) = E (X + Y )2 − E(X + Y )2
2
= E X 2 + 2XY + Y 2 ) − E(X) + E(Y )
= E(X 2 ) + 2E(X) · E(Y ) + E(Y 2 ) − E(X)2 + 2E(X) · E(Y ) + E(Y )2
= E(X 2 ) − E(X)2 + E(Y 2 ) − E(Y )2
= Var(X) + Var(Y ).
Nun können wir die Tschebyschew-Ungleichung angeben.
Theorem 1.27. Es sei X eine Zufallsvariable, deren Erwartungswert und Varianz existieren, und es sei a > 0. Dann gilt
Pr |X − E(X)| ≥ a ≤
Var(X)
.
a2
Auch die Tschebyschew-Ungleichung können wir anders formulieren. Für jedes t > 1 gelten
Pr |X − E(X)| ≥ t · σ(X) ≤
1
t2
und
Pr |X − E(X)| ≥ t · E(X) ≤
Var(X)
.
t2 E(X)2
Beweis von Theorem 1.27. Der Beweis besteht darin, die Markow-Ungleichung auf das zweite Moment von X anzuwenden. Es gilt
Pr |X − E(X)| ≥ a = Pr (X − E(X))2 ≥ a2
und die Zufallsvariable (X − E(X))2 nimmt nur nicht-negative Werte an und besitzt per
Definition den Erwartungswert E((X −E(X))2 ) = Var(X). Auf diese Zufallsvariable können
wir die Markow-Ungleichung anwenden, mit der wir die gewünschte Abschätzung erhalten:
Pr (X − E(X))2 ≥ a2 ≤
Var(X)
E((X − E(X))2 )
=
.
2
a
a2
Wir betrachten noch einmal das Beispiel mit n unabhängigen Münzwürfen. Sei wieder X
die Zufallsvariable, die angibt, wie oft „Zahl“ geworfen wird. Dann ist X binomialverteilt
36
1. Grundlagen der Wahrscheinlichkeitstheorie
mit den Parametern n und 1/2. Somit lässt sich X als die Summe von n unabhängigen
Bernoulli-Variablen X1 , . . . , Xn mit Parameter 1/2 darstellen. Damit ergibt sich
Var(X) = Var
n
X
!
Xi
i=1
=
n
X
i=1
Var(Xi ) =
n
X
E(Xi2 )
− E(Xi )
2
i=1
=
n X
1
i=1
1
−
2 4
=
n
.
4
Die Wahrscheinlichkeit, dass wir mindestens (3n/4)-mal „Zahl“ sehen, lässt sich mit der
Tschebyschew-Ungleichung wie folgt abschätzen:
Pr(X ≥ 3n/4) ≤ Pr(|X − E(X)| ≥ n/4) ≤
4
Var(X)
= .
2
(n/4)
n
In diesem Beispiel liefert die Tschebyschew-Ungleichung also eine deutlich bessere Schranke
als die Markow-Ungleichung.
Wir können hier allgemein festhalten, dass Var(X) = p − p2 = p(1 − p) für eine BernoulliZufallsvariable X mir Parameter p gilt. Außerdem gilt
Var(Y ) = n(p − p2 ) = np(1 − p) ≤
n
4
für eine binomialverteilte Zufallsvariable Y mit den Parametern n und p. Laut TschebyschewUngleichung gilt für jedes a > 0
Pr(|Y − E(Y )| ≥ a) ≤
np(1 − p)
n
≤ 2.
2
a
4a
Das bedeutet, dass die Wahrscheinlichkeit einer additiven Abweichung vom Erwartungs√
wert in der Größenordnung o( n) bei einer binomialverteilten Zufallsvariable mit Hilfe der
Tschebyschew-Ungleichung nicht sinnvoll nach oben beschränkt werden kann. Die Wahr√
scheinlichkeit einer Abweichungen in der Größenordnung Θ( n) kann durch eine Konstante
√
beschränkt werden. Für Abweichungen in der Größenordnung ω( n) geht die Wahrscheinlichkeit mit wachsendem n gegen Null.
1.5.2
Anwendung: Bestimmung des Medians
Wir geben nun einen randomisierten Algorithmus zur Bestimmung des Medians einer Menge S von n paarweise verschiedenen Zahlen an. Mit Median meinen wir das dn/2e-kleinste
Element, welches wir im Folgenden mit m ∈ S bezeichnen werden. Natürlich könnten wir
dieses Problem in Zeit Θ(n log n) lösen, indem wir die Zahlen zunächst sortieren und dann in
konstanter Zeit den Median der sortierten Folge bestimmen. Mit einem relativ komplizierten
deterministischen Algorithmus kann man das Problem sogar in Linearzeit lösen. Wir lernen
nun einen einfacheren randomisierten Algorithmus zur Bestimmung des Medians mit einer
erwarteten Laufzeit von O(n) kennen.
Die entscheidende Komponente in diesem Algorithmus ist die Bestimmung zweier Elemente a, b ∈ S, für die die folgenden beiden Eigenschaften gelten.
1. Es gilt a ≤ m ≤ b.
2. Für C = {x ∈ S | a ≤ x ≤ b} gilt |C| = o(n/ log n).
1.5. Konzentration von Verteilungen
37
Gelingt es uns, zwei Elemente a und b mit diesen beiden Eigenschaften zu bestimmen, so
können wir in Linearzeit deterministisch den Median m ∈ S bestimmen. Dazu berechnen
wir zunächst den Rang r(a) von a, d. h. r(a) = |{x ∈ S | x < a}|. Dies geht in Linearzeit, da wir das Element a lediglich mit allen anderen Elementen in S vergleichen müssen.
Anschließend bestimmen wir in Linearzeit die Menge C und sortieren sie mit Heapsort in
Zeit O(|C| log |C|) = o(n). Der Median ist dann das (dn/2e − r(a))-kleinste Element in C,
welches wir in der sortierten Menge C in konstanter Zeit finden können.
Es bleibt also nur noch die Frage zu klären, wie wir Elemente a und b mit den obigen beiden
Eigenschaften finden können. Dazu nutzen wir Randomisierung, insbesondere benutzen wir
die Methode des Samplings. Das bedeutet, dass wir eine zufällige Stichprobe der Menge S
bestimmen. Wir wählen dazu unabhängig dn3/4 e-mal hintereinander ein uniform zufälliges
Element aus S und fügen es zu der Stichprobe R hinzu. Insbesondere erlauben wir, dass
Elemente mehrfach ausgewählt werden, und betrachten R dementsprechend als Multimenge.
Dies wird uns die Analyse erleichtern.
Da die Stichprobe typischerweise relativ gut auf S verteilt ist, erwarten wir, dass der Median m0 der Stichprobe nicht weit vom Median m von S entfernt ist. Der Median m0 der
Stichprobe ist das dn3/4 /2e-kleinste Element von R. Wählen wir a als das (dn3/4 /2e − δ)kleinste Element von R und b als das (dn3/4 /2e+δ)-kleinste Element von R für einen genügend
großen Sicherheitsabstand δ, so erwarten wir, dass m zwischen a und b liegt. Dies ist in der
folgenden Abbildung illustriert.
C
a
r(a) viele Elemente
m
m0
b
s(b) viele Elemente
Die Zellen in der Abbildung stellen die Elemente von S in sortierter Reihenfolge dar. Graue
Zellen gehören zu der Stichprobe R, wobei wir der Einfachheit halber davon ausgehen, dass
kein Element mehrfach in R vorkommt. Der Median m0 der Stichprobe ist das dn3/4 /2ekleinste Element von R. In diesem Beispiel liegt er tatsächlich in der Nähe des zu bestimmenden Medians m und es gilt a ≤ m ≤ b.
Um nicht ständig mit gerundeten Werten arbeiten zu müssen, gehen wir der Einfachheit
√
halber im Folgenden davon aus, dass alle auftretenden Werte wie z. B. n/2, n und 21 n3/4
ganzzahlig sind. Insbesondere gehen wir davon aus, dass n gerade ist. Außerdem gehen wir
√
√
davon aus, dass n hinreichend groß ist, so dass 12 n3/4 − n ≥ 1 und 12 n3/4 + n ≤ n gelten.
38
1. Grundlagen der Wahrscheinlichkeitstheorie
Randomized-Median(S)
1. Bestimme eine Multimenge R mit n3/4 Elementen aus S.
Wähle dazu n3/4 Elemente aus S unabhängig und uniform zufällig aus.
Dabei dürfen Elemente aus S mehrfach ausgewählt werden.
2. Sortiere R mit Heapsort.
√ 3. Sei a das 21 n3/4 − n -kleinste Element in R.
√ 4. Sei b das 21 n3/4 + n -kleinste Element in R.
5. Bestimme r(a) = |{x ∈ S | x < a}| und s(b) = |{x ∈ S | x > b}|.
Vergleiche dazu a und b mit jedem Element aus S.
6. Bestimme C = {x ∈ S | a ≤ x ≤ b}.
7. Falls r(a) ≥ n/2 oder s(b) ≥ n/2 oder |C| > 4n3/4 , gib „Fehler“ aus.
8. Sortiere C mit Heapsort und gib das (n/2 − r(a))-kleinste Element von C aus.
Theorem 1.28. Der Algorithmus Randomized-Median besitzt eine Laufzeit von O(n). Falls
er keine Fehlermeldung ausgibt, so gibt er den Median von S aus.
Beweis. Wir gehen davon aus, dass in konstanter Zeit ein uniform zufälliges Element aus S
ausgewählt werden kann. Dann besitzt der erste Schritt eine Laufzeit von O(n3/4 ) = o(n).
Die Laufzeit des zweiten Schrittes beträgt O(|R| log |R|) = o(n). Ist R sortiert, so benötigen
die Schritte 3 und 4 Laufzeit O(1). Die Schritte 5 und 6 haben eine Laufzeit von O(n).
Schritt 7 hat konstante Laufzeit und Schritt 8 hat eine Laufzeit von O(|C| log |C|) = o(n),
wobei wir ausnutzen, dass |C| ≤ 4n3/4 gilt, wenn wir Schritt 8 erreichen.
Gibt der Algorithmus keine Fehlermeldung aus, so erreicht er Schritt 8. In diesem gibt er
das (n/2 − r(a))-kleinste Element x von C aus. Da der Algorithmus Schritt 8 erreicht,
gilt r(a) < n/2 und damit (n/2 − r(a)) ≥ 1. Außerdem muss
n
− r(a) ≤ |C| = n − r(a) − s(b)
2
gelten, damit Schritt 8 überhaupt durchgeführt werden kann. Dies ist äquivalent zu s(b) ≤
n/2, was gilt, wenn wir Schritt 8 erreichen. Somit ist gezeigt, dass das (n/2 − r(a))-kleinste
Element von C existiert.
Es gibt in S \ C genau r(a) Elemente, die kleiner als x sind. In C gibt es n/2 − r(a) − 1
solche Elemente. Damit gibt es insgesamt genau n/2 − 1 Elemente in S, die kleiner als x
sind. Somit ist x der Median von S.
Wir definieren nun drei Ereignisse und zeigen, dass der Algorithmus nur dann eine Fehlermeldung ausgibt, wenn mindestens eins dieser Ereignisse eintritt. Dann schätzen wir die
Wahrscheinlichkeit jedes einzelnen Ereignisses ab und wenden eine Union-Bound an, um die
Gesamtfehlerwahrscheinlichkeit abzuschätzen.
Lemma 1.29. Der Algorithmus gibt nur dann eine Fehlermeldung aus, wenn eines der
1.5. Konzentration von Verteilungen
39
folgenden drei Ereignisse eintritt:
√
1
F1 : |{x ∈ R | x ≤ m}| < n3/4 − n,
2
1 3/4 √
F2 : |{x ∈ R | x ≥ m}| ≤ n − n,
2
3/4
F3 : |C| > 4n .
Beweis. Wir betrachten die drei Bedingungen in Zeile 7, die zu einer Fehlermeldung führen.
Das Ereignis
F entspricht genau der dritten Bedingung. Gilt r(a) ≥ n/2, so ist a, das
3
1 3/4 √
n
−
n
-kleinste
Element in R, größer als m. Demzufolge gibt es in R weniger als 12 n3/4 −
√2
n viele Elemente, die höchstens so groß wie m sind. Dies entspricht F1 . Analog argumentiert
√
man, dass s(b) ≥ n/2 bedeutet, dass b, das 12 n3/4 + n -kleinste Element in R, höchstens
√ so groß wie m ist. Demzufolge gibt es in R höchstens 12 n3/4 − n viele Elemente, die
mindestens so groß wie m sind. Dies entspricht F2 .
Lemma 1.30. Es gelten Pr(F1 ) ≤ 14 n−1/4 und Pr(F2 ) ≤ 14 n−1/4 .
Beweis. Die Wahrscheinlichkeit, dass ein uniform zufälliges Element aus S höchstens so groß
wie der Median m ist, beträgt genau 1/2 (wir gehen davon aus, dass n gerade ist). Damit
ist die Anzahl an Elementen in C, die höchstens so groß wie m sind, eine binomialverteilte
Zufallsvariable X mit den Parametern n3/4 und 1/2. Das Ereignis F1 is äquivalent zu X <
√
1 3/4
− n. Die Varianz von X beträgt n3/4 /4. Mit der Tschebyschew-Ungleichung ergibt
2n
sich somit
√
√
1
1
Pr(F1 ) = Pr X < n3/4 − n ≤ Pr X ≤ n3/4 − n
2
2
√
Var(X)
1
≤ Pr |X − E(X)| ≥ n ≤
= n−1/4 .
n
4
Bis auf eine kleine Änderung, können wir die Wahrscheinlichkeit von F2 analog abschätzen.
Die Wahrscheinlichkeit, dass ein uniform zufälliges Element aus S mindestens so groß wie
der Median m ist, beträgt genau 1/2 + 1/n, wenn n gerade ist. Damit ist die Anzahl dieser
Elemente eine Zufallsvariable X mit den Parametern n3/4 und 1/2 + 1/n. Das Ereignis F2
√
ist äquivalent zu X ≤ 12 n3/4 − n. Die Varianz von X beträgt
n
3/4
·
1 1
+
2 n
·
1 1
−
2 n
1
≤ n3/4 .
4
Somit können wir die Tschebyschew-Ungleichung für F2 genauso wie für F1 anwenden.
Es bleibt, die Wahrscheinlichkeit des Fehlerereignisses F3 abzuschätzen.
Lemma 1.31. Es gilt Pr(F3 ) ≤ 21 n−1/4 .
Beweis. Falls die Menge C mehr als 4n3/4 Elemente enthält, so enthält sie mindestens 2n3/4
Elemente, die kleiner als der Median m sind, oder sie enthält mindestens 2n3/4 Elemente, die
größer als der Median m sind. Dementsprechend können wir zwei Ereignisse F3,1 und F3,2
wie folgt definieren:
F3,1 : C enthält mindestens 2n3/4 Elemente, die kleiner als der Median m sind,
F3,2 : C enthält mindestens 2n3/4 Elemente, die größer als der Median m sind.
40
1. Grundlagen der Wahrscheinlichkeitstheorie
Es gilt dann F3 ⊆ F3,1 ∪ F3,2 und wir können die Wahrscheinlichkeit von F3 mit Hilfe einer
Union-Bound abschätzen, wenn wir die Wahrscheinlichkeiten von F3,1 und F3,2 abgeschätzt
haben.
Wir schätzen nur die Wahrscheinlichkeit des Ereignisses F3,1 ab. Das Ereignis F3,2 ist zwar
nicht ganz symmetrisch, da n gerade ist, aber seine Wahrscheinlichkeit kann analog mit
demselben Ergebnis abgeschätzt werden. Das Ereignis F3,1 tritt genau dann ein, wenn |{x ∈
S | x ≤ a}| ≤ n/2 − 2n3/4 gilt, wie die folgende Abbildung illustriert.
C
a
m
m0
b
n/2 Elemente
mindestens 2n3/4 Elemente wegen F3,1
höchstens n/2 − 2n3/4 Elemente
√
Sei y ∈ S das (n/2 − 2n3/4 )-kleinste Element in S. Da a das ( 12 n3/4 − n)-kleinste Element
√
in R ist und gemäß obiger Argumentation a ≤ y gilt, gibt es in R mindestens ( 21 n3/4 − n)
viele Elemente, die höchstens so groß wie y sind.
Sei X die Zufallsvariable, die angibt, wie viele Elemente in R höchstens so groß wie y sind.
Dann ist X binomialverteilt mit den Parametern n3/4 und (1/2 − 2n−1/4 ). Somit gelten
√
1
E(X) = n3/4 − 2 n
2
und
Var(X) = n
3/4
1
− 2n−1/4
2
1
1
+ 2n−1/4 ≤ n3/4 .
2
4
Wir können nun die Tschebyschew-Ungleichung anwenden und erhalten
√
√
1
Var(X)
1
Pr(F3,1 ) ≤ Pr X ≥ n3/4 − n ≤ Pr |X − E(X)| ≥ n ≤
≤ n−1/4 .
2
n
4
Wegen Pr(F3,2 ) = Pr(F3,1 ) folgt das Lemma nun mit Hilfe einer Union-Bound:
1
Pr(F3 ) ≤ Pr(F3,1 ∪ F3,2 ) ≤ Pr(F3,1 ) + Pr(F3,2 ) ≤ n−1/4 .
2
Damit ist die Analyse des Algorithmus abgeschlossen und wir erhalten insgesamt das folgende
Theorem.
Theorem 1.32. Die Wahrscheinlichkeit, dass der Algorithmus Randomized-Median eine
Fehlermeldung ausgibt, ist höchstens n1/4 .
Beweis. Wir haben oben bereits gesagt, dass der Algorithmus nur dann eine Fehlermeldung
ausgibt, wenn F1 , F2 oder F3 gilt. Also folgt mit einer Union-Bound und den Lemmata 1.30
und 1.31 direkt, dass die Wahrscheinlichkeit, eine Fehlermeldung auszugeben, durch
Pr(F1 ) + Pr(F2 ) + Pr(F3 ) ≤ n−1/4
nach oben beschränkt ist.
1.5. Konzentration von Verteilungen
41
Der Algorithmus Randomized-Median hat unabhängig von den Zufallsentscheidungen immer eine lineare Laufzeit. Es besteht aber die Möglichkeit, dass er eine Fehlermeldung ausgibt. Wir können den Algorithmus leicht in einen randomisierten Algorithmus umbauen,
der stets den Median zurückgibt, dessen Laufzeit aber eine Zufallsvariable ist. Dazu wiederholen wir den Algorithmus Randomized-Median einfach solange unabhängig, bis er den
Median ausgibt. Da die Erfolgswahrscheinlichkeit in jeder Wiederholung unabhängig mindestens 1 − n−1/4 beträgt, können wir die Anzahl Wiederholungen durch eine geometrisch
Verteilte Zufallsvariable mit Parameter 1 − n−1/4 abschätzen. Im Erwartungswert benötigen
wir somit 1/(1 − n−1/4 ) = Θ(1) viele Wiederholungen und erhalten damit einen randomisierten Algorithmus, der immer das richtige Ergebnis zurückliefert und dessen Laufzeit im
Erwartungswert linear ist. Wir werden diese zwei Arten von randomisierten Algorithmen im
nächsten Kapitel systematischer betrachten.
Kapitel 2
Komplexitätstheorie für
randomisierte Algorithmen
Wir werden in diesem Kapitel genauer auf die formalen Grundlagen von randomisierten Algorithmen eingehen. Die Rechnermodelle wie Turing- und Registermaschinen, die wir bisher im
Studium kennengelernt haben, sind zur Modellierung von randomisierten Algorithmen nicht
geeignet, da sie es nicht vorsehen, dass zufällige Entscheidungen getroffen werden. Zwar haben wir bereits nichtdeterministische Turingmaschinen kennengelernt, diese kommen aber
zur Modellierung von randomisierten Algorithmen auch nicht in Frage, da sie (vermutlich)
keinem Rechnermodell entsprechen, das physikalisch umgesetzt werden kann.
Wir werden in diesem Kapitel erst ein geeignetes Rechnermodell zur Modellierung von randomisierten Algorithmen kennenlernen und dann entsprechende Komplexitätsklassen definieren. Anschließend werden wir uns mit der Frage beschäftigen, wie man untere Schranken
für randomisierte Algorithmen zeigen kann. Wir werden eine Technik kennenlernen, mit der
man für gewisse Probleme nachweisen kann, dass jeder randomisierte Algorithmus mindestens eine bestimmte Laufzeit benötigt.
Die Inhalte dieses Kapitels sind stark an die Kapitel 1.5, 2.1 und 2.2 von [6] angelehnt.
2.1
Rechnermodelle und Komplexitätsklassen
In diesem Abschnitt erweitern wir Begriffe, die wir in früheren Vorlesungen für deterministische Algorithmen kennengelernt haben, auf randomisierte Algorithmen. Dazu gehören
insbesondere Rechnermodelle und Komplexitätsklassen. Außerdem werden wir systematisch
auf die beiden verschiedenen Typen von randomisierten Algorithmen eingehen, die wir am
Ende von Abschnitt 1.5.2 bereits kurz angesprochen haben.
2.1.1
Probabilistische Rechnermodelle
Das Rechnermodell, das wir bei deterministischen Algorithmen zugrunde gelegt haben, ist
das Modell der Turingmaschine. Diese haben wir in der Vorlesung „Algorithmen und Berechnungskomplexität II“ als 7-Tupel (Q, Σ, Γ, B, q0 , q, δ) mit den folgenden Komponenten
kennengelernt.
• Q ist eine endliche Zustandsmenge.
42
2.1. Rechnermodelle und Komplexitätsklassen
43
• Σ ⊇ {0, 1} ist ein endliches Eingabealphabet.
• Γ ⊇ Σ ist ein endliches Bandalphabet.
• B ∈ Γ \ Σ ist das Leerzeichen (Blank).
• q0 ∈ Q ist der Startzustand.
• q ∈ Q ist der Stoppzustand.
• δ : (Q \ {q}) × Γ → Q × Γ × {R, L, N } ist die Zustandsüberführungsfunktion.
Eine Turingmaschine M berechnet eine Funktion fM : Σ∗ → Σ∗ ∪ {⊥}. Dabei gehen wir
davon aus, dass die Eingabe an der aktuellen Kopfposition beginnt und sich bis zum ersten Leerzeichen rechts davon erstreckt. Dann führt die Turingmaschine Schritte gemäß der
Funktion δ aus, bis sie den Stoppzustand erreicht. Die Ausgabe beginnt dann an der aktuellen Kopfposition und erstreckt sich wieder bis zum ersten Leerzeichen rechts davon. Hält
die Turingmaschine auf einer Eingabe x ∈ Σ∗ nicht, so definieren wir f (x) =⊥. Wir können
eine Turingmaschine auch einsetzen, um eine Sprache zu entscheiden. Wir sagen, dass die
Turingmaschine M die Sprache L ⊆ Σ∗ entscheidet, wenn für jedes x ∈ L gilt, dass f (x)
mit 1 beginnt, und wenn für jedes x ∈
/ L gilt, dass f (x) mit 0 beginnt. Lesern, die ihre
Kenntnisse über Turingmaschinen auffrischen möchten, sei [7] als Referenz empfohlen.
Eine probabilistische Turingmaschine (PTM) ist ein 8-Tupel (Q, Σ, Γ, B, q0 , q, δ0 , δ1 ). Der
einzige Unterschied zu einer herkömmlichen Turingmaschine ist, dass es zwei Zustandsüberführungsfunktionen δ0 und δ1 statt einer einzigen Funktion δ gibt. Anstatt in jedem Schritt
deterministisch einen Zustandsübergang gemäß δ zu machen, wird in jedem Schritt der PTM
unabhängig eine faire Münze geworfen. Zeigt diese „Kopf“ so wird der Zustandsübergang gemäß δ0 durchgeführt, ansonsten wird der Zustandsübergang gemäß δ1 durchgeführt. Somit
berechnet eine PTM M nicht mehr deterministisch eine Funktion fM : Σ∗ → Σ∗ ∪ {⊥}, sondern für jedes Paar (x, y) ∈ Σ∗ × (Σ∗ ∪ {⊥}) gibt es eine Wahrscheinlichkeit, dass y bei
Eingabe x ausgegeben wird. Geht es uns wieder darum, eine Sprache zu entscheiden, so
können wir analog für eine PTM M und ein Wort x ∈ Σ∗ die Wahrscheinlichkeit definieren, dass M das Wort akzeptiert. Deterministische Turingmaschinen sind der Spezialfall von
probabilistischen Turingmaschinen, in dem δ0 und δ1 übereinstimmen.
Wir sollten uns die Frage stellen, ob probabilistische Turingmaschinen ein gutes Modell realer
Rechner sind. Bei deterministischen Turingmaschinen hatten wir zunächst gezeigt, dass sie
genauso mächtig wie Registermaschinen sind. Dann haben wir uns überlegt, dass Registermaschinen ein gutes Modell realer Rechner darstellen. Obwohl es in fast allen Programmiersprachen die Möglichkeit gibt, Zufallszahlen zu erzeugen, stellt sich bei näherer Betrachtung
die Frage, wo diese Zufallszahlen eigentlich herkommen, wenn die Hardware deterministisch
arbeitet. Tatsächlich ist es ein nicht zu unterschätzendes Problem, eine längere Folge von
„Zufallsbits“ zu erzeugen. Dazu benutzt man normalerweise sogenannte Pseudozufallszahlengeneratoren. Diese werden mit einem kurzen hinreichend zufälligen Schlüssel initialisiert,
der zum Beispiel aus der Systemzeit oder den Mausbewegungen erzeugt wird. Aus dieser
zufälligen Initialisierung erzeugen sie dann eine lange Folge von Bits, die sich sehr ähnlich
verhält wie eine Folge von unabhängigen uniform zufälligen Bits. Damit kann das Modell
einer probabilistischen Turingmaschine mit realen Rechnern sehr gut nachgebildet werden.
Wir werden diese Diskussion hier aber nicht vertiefen.
Als eine Alternative zum Modell der probabilistischen Turingmaschine, das mehr Ähnlichkeit
zu realen Rechnern besitzt, können wir wieder Registermaschinen betrachten. Wir wissen
bereits, dass deterministische Turingmaschinen und Registermaschinen bis auf polynomielle
Faktoren in der Laufzeit gleichmächtig sind, wenn man das logarithmische Kostenmaß zu
44
2. Komplexitätstheorie für randomisierte Algorithmen
Grunde legt. Das bedeutet, dass man als Laufzeit nicht nur die Anzahl an Schritten zählt,
die die Registermaschine durchführt, sondern dass jeder Schritt eine Laufzeit proportional
zum Logarithmus der Zahlen besitzt, die in den Registern gespeichert sind, die für den Schritt
relevant sind. Erweitert man das Standardmodell der Registermaschine um einem Befehl, der
uniform zufällig und unabhängig von vorangegangenen Aufrufen entweder 0 oder 1 in den
Akkumulator schreibt, so erhalten wir ein Modell, das im logarithmischen Kostenmaß bis auf
polynomielle Faktoren in der Laufzeit gleichmächtig wie eine probabilistische Turingmaschine
ist.
Der Einfachheit halber haben wir in vorangegangenen Vorlesungen Registermaschinen oft im
uniformen Kostenmaß betrachtet. Das bedeutet, dass wir als Laufzeit lediglich die Anzahl
an Schritten gezählt haben. Wir haben argumentiert, dass dies für Algorithmen realistisch
ist, die nicht mit großen Zahlen operieren. Ähnlich werden wir es auch in dieser Vorlesung
wieder handhaben. Wir gehen sogar noch einen Schritt weiter und gehen davon aus, dass die
Registermaschine einen Befehl Uniform(k) besitzt, der ein uniform zufälliges Element aus
der Menge {1, . . . , k} erzeugt, wenn k polynomiell in der Eingabegröße beschränkt ist. Auf einer solchen probabilistischen Registermaschine können wir die randomisierten Algorithmen,
die wir in dieser Vorlesung kennengelernt haben und kennenlernen werden, einfach implementieren. Der Leser sollte sich aber klar machen, dass dieses Modell mächtiger ist als das
der probabilistischen Turingmaschine. Das liegt nicht nur am uniformen Kostenmaß, sondern
auch daran, dass zum Beispiel die uniform zufällige Auswahl eines Elementes aus einer Menge mit drei Elementen nur mit Hilfe von einer festen Anzahl an zufälligen Bits nicht möglich
ist. Dieses Problem werden wir in den Übungen noch weiter vertiefen. Da es sich hierbei
aber nur um ein technisches Detail handelt, werden wir Laufzeitanalysen von randomisierten
Algorithmen, die nicht mit großen Zahlen operieren, immer bezüglich Registermaschinen im
uniformen Kostenmaß durchführen, die um den Befehl Uniform(k) erweitert wurden.
2.1.2
Monte-Carlo- und Las-Vegas-Algorithmen
Wir haben nach der Vorstellung des Algorithmus Randomized-Median in Abschnitt 1.5.2
kurz diskutiert, dass wir randomisierte Algorithmen in zwei Kategorien einteilen können. Es
gibt randomisierte Algorithmen, bei denen die Laufzeit nicht zufällig ist, die aber eine gewisse
Fehlerwahrscheinlichkeit haben, und es gibt randomisierte Algorithmen, die stets das richtige
Ergebnis ausgeben, bei denen die Laufzeit aber eine Zufallsvariable ist. Algorithmen aus der
ersten Kategorie werden Monte-Carlo-Algorithmen genannt. Algorithmen aus der zweiten
Kategorie heißen Las-Vegas-Algorithmen. Die Namensgebung ist natürlich auf die Spielkasinos in diesen beiden Städten zurückzuführen, in denen Zufall auch eine wichtige Rolle
spielt. Als Eselsbrücke kann man die Anfangsbuchstaben nehmen: während Monte-CarloAlgorithmen „mostly correct“ sind, ist bei Las-Vegas-Algorithmen die Laufzeit variabel.
Wir können diese beiden Arten von randomisierten Algorithmen zueinander in Beziehung
setzen. Als erstes beobachten wir, dass jeder Las-Vegas-Algorithmus leicht in einen MonteCarlo-Algorithmus überführt werden kann.
Theorem 2.1. Es sei A ein Las-Vegas-Algorithmus für ein beliebiges Problem Π mit einer
erwarteten Laufzeit von höchstens f (n) für Instanzen von Π der Größe n. Dann existiert für
jedes α > 1 ein Monte-Carlo-Algorithmus Bα für Π mit einer Laufzeit von αf (n) und einer
Fehlerwahrscheinlichkeit von α1 .
Beweis. Der Algorithmus Bα simuliert maximal αf (n) viele Schritte des Algorithmus A auf
der gegebenen Eingabe der Länge n. Terminiert der Algorithmus im Laufe dieser Simulation,
2.1. Rechnermodelle und Komplexitätsklassen
45
so übernimmt Bα das korrekte Ergebnis von A. Ansonsten gibt Bα eine Fehlermeldung aus.
Dann ist Bα ein Monte-Carlo-Algorithmus, der nur dann eine Fehlermeldung ausgibt, wenn
die Laufzeit X von A auf der gegebenen Eingabe um mehr als den Faktor α größer ist als
die erwartete Laufzeit. Mit der Markow-Ungleichung ergibt sich
Pr(X > αf (n)) ≤ Pr(X ≥ αE(X)) ≤
1
.
α
Monte-Carlo-Algorithmen lassen sich nur dann leicht in Las-Vegas-Algorithmus überführen,
wenn es möglich ist, effizient zu testen, ob ihre Ausgabe korrekt ist.
Theorem 2.2. Es sei A ein Monte-Carlo-Algorithmus für ein Problem Π mit einer (deterministischen) Laufzeit von höchstens f (n) für Instanzen von Π der Größe n. Es sei p(n)
eine untere Schranke für die Wahrscheinlichkeit, dass die Ausgabe von A korrekt ist. Ferner
existiere ein deterministischer Algorithmus, der in einer Laufzeit von höchstens g(n) testet,
ob die Ausgabe von A korrekt ist. Dann existiert ein Las-Vegas-Algorithmus für Π mit einer
erwarteten Laufzeit von f (n)+g(n)
.
p(n)
Beweis. Wir wiederholen Algorithmus A und den deterministischen Test, ob die Ausgabe
korrekt ist, einfach solange, bis dies das erste Mal der Fall ist. Dann ist die Anzahl an
Wiederholungen X eine geometrische Zufallsvariable mit Parameter p(n). Somit beträgt die
erwartete Laufzeit
E((f (n) + g(n)) · X) = (f (n) + g(n)) · E(X) =
f (n) + g(n)
.
p(n)
In dem Monte-Carlo-Algorithmus zur Bestimmung des Medians war ein solcher Test auf
Korrektheit bereits integriert, aber wir können uns auch einen anderen randomisierten Algorithmus zur Bestimmung des Medians vorstellen, der stets ein Element aus der gegebenen
Menge S ausgibt, welches aber nur mit einer gewissen Wahrscheinlichkeit der Median ist.
Dann könnten wir in linearer Zeit testen, ob das zurückgegebene Element wirklich der Median
ist und mit Hilfe von Theorem 2.2 einen Las-Vegas-Algorithmus entwerfen.
2.1.3
Komplexitätsklassen
Nun definieren wir Komplexitätsklassen für randomisierte Algorithmen. In vorangegangenen Vorlesungen haben wir die beiden Klassen P und N P kennengelernt. Diese eignen sich
aber nicht zur Einordnung von Problemen, die von randomisierten Algorithmen gelöst werden. Genauso wie bisher werden wir uns bei der Definition von Komplexitätsklassen auf
Entscheidungsprobleme bzw. Sprachen beschränken. Dies ist dadurch gerechtfertigt, dass
die Komplexität der Optimierungsvariante eines Problems in der Regel polynomiell mit der
Komplexität der entsprechenden Entscheidungsvariante verknüpft ist.
Wir betrachten noch einmal das Problem aus Abschnitt 1.3.2, einen minimalen Schnitt zu
berechnen. Die Entscheidungsvariante dieses Problems entspricht der Sprache
L = {code(G, k) | der minimale Schnitt in G hat Kardinalität k},
wobei code(G, k) eine Kodierung eines Graphen G und einer Zahl k ist. Der Leser möge sich
selbst als Übung und Wiederholung überlegen, wie man einen effizienten Algorithmus für
dieses Entscheidungsproblem in einen effizienten Algorithmus für die Optimierungsvariante
46
2. Komplexitätstheorie für randomisierte Algorithmen
überführen kann, in der nur ein Graph G gegeben ist, für den ein minimaler Schnitt gesucht
wird.
Eine Sprache L gehört zu der Klasse P, wenn es eine deterministische Turingmaschine mit
polynomieller Laufzeit gibt, die sie entscheidet. Das heißt, die Turingmaschine akzeptiert
jedes Wort x ∈ L und verwirft jedes Wort x ∈
/ L. Für randomisierte Algorithmen definieren
wir mehrere Komplexitätsklassen, je nachdem, welche Fehler auftreten können.
Definition 2.3. Eine Sprache L ⊆ Σ∗ gehört zu der Klasse RP (Randomized Polynomial time), wenn es eine probabilistische Turingmaschine M gibt, deren Laufzeit immer polynomiell
beschränkt ist und für die für alle Eingaben x ∈ Σ∗ gilt:
x ∈ L ⇒ Pr(M akzeptiert x) ≥
1
2
und
x∈
/ L ⇒ Pr(M akzeptiert x) = 0.
Die Klasse RP enthält also alle Probleme, für die es einen Monte-Carlo-Algorithmus mit
einseitigem Fehler gibt. Während Nein-Instanzen sicher als solche erkannt werden, darf der
Algorithmus sich bei Ja-Instanzen mit einer Wahrscheinlichkeit von höchstens 1/2 irren. Um
auch Probleme klassifizieren zu können, für die wir einen Monte-Carlo-Algorithmus haben,
der Ja-Instanzen sicher erkennt und sich nur bei Nein-Instanzen irren kann, führen wir das
Komplement von Komplexitätsklassen ein. Sei C eine beliebige Komplexitätsklasse, d. h. eine
Menge von Sprachen über dem Alphabet Σ. Wir definieren das Komplement co-C von C
als co-C = {L ⊆ Σ∗ | L ∈ C}, wobei L = {x ∈ Σ∗ | x ∈
/ L} wie üblich das Komplement der
Sprache L bezeichnet. Die Klasse co-RP enthält alle Sprachen, für es eine probabilistische
Turingmaschine M gibt, deren Laufzeit immer polynomiell beschränkt ist und die alle Eingaben x ∈ L stets akzeptiert und alle Eingaben x ∈
/ L höchstens mit Wahrscheinlichkeit 1/2
akzeptiert.
Um dies zu verdeutlichen, betrachten wir noch einmal den Test auf Gleichheit zweier Polynome mit einseitigem Fehler, den wir in Abschnitt 1.1 kennengelernt haben. Dies war ein
Algorithmus für die Sprache
L = {code(p, q) | p und q stimmen überein},
wobei code(p, q) die Kodierung zweier Polynome p und q bezeichnet. Der Algorithmus, der eine zufällige Zahl in die Polynome einsetzt und die Ergebnisse vergleicht, erkennt Ja-Instanzen
mit Wahrscheinlichkeit 1, kann sich aber bei Nein-Instanzen irren. Somit gehört die Sprache L zu der Klasse co-RP. Denkt man an reelle Polynome, so ist natürlich klar, dass L sogar
zu P gehört, wenn die Polynome p und q explizit gegeben sind. Über allgemeinen Körpern
ist das allerdings nicht mehr der Fall, da dort zwei Polynome auch überall übereinstimmen
können, ohne dass alle ihre Koeffizienten übereinstimmen.
Analog zu der Klasse RP für Algorithmen mit einseitigem Fehler definieren wir nun die Klasse BPP, die alle Probleme enthält, für die es Monte-Carlo-Algorithmen mit beschränktem
zweiseitigem Fehler gibt.
Definition 2.4. Eine Sprache L ⊆ Σ∗ gehört zu der Klasse BPP (Bounded-error Probabilistic Polynomial time), wenn es eine probabilistische Turingmaschine M gibt, deren Laufzeit
immer polynomiell beschränkt ist und für die für alle Eingaben x ∈ Σ∗ gilt:
x ∈ L ⇒ Pr(M akzeptiert x) ≥
3
4
und
1
x∈
/ L ⇒ Pr(M akzeptiert x) ≤ .
4
Sowohl die Klasse RP als auch die Klasse BPP beziehen sich auf Monte-Carlo-Algorithmen.
Wir definieren nun noch eine Klasse für Las-Vegas-Algorithmen.
2.1. Rechnermodelle und Komplexitätsklassen
47
Definition 2.5. Eine Sprache L ⊆ Σ∗ gehört zu der Klasse ZPP (Zero-error Probabilistic
Polynomial time), wenn es eine probabilistische Turingmaschine M mit einer erwarteten
polynomiellen Laufzeit gibt, die die Sprache L immer korrekt entscheidet.
Die Klasse ZPP enthält somit genau die Probleme, die von einem Las-Vegas-Algorithmus
mit erwarteter polynomieller Laufzeit gelöst werden können. Bei einem solchen Algorithmus
spricht man auch von einem Algorithmus mit nullseitigem Fehler. Der Grund dafür ist, dass
man einen Las-Vegas-Algorithmus, wie wir in Abschnitt 2.1.2 gesehen haben, in einen MonteCarlo-Algorithmus umbauen kann, der niemals ein falsches Ergebnis ausgibt, der aber mit
einer gewissen Wahrscheinlichkeit eine Fehlermeldung ausgibt. Man kann außerdem zeigen,
dass ZPP = RP ∩ co-RP und damit insbesondere ZPP ⊆ RP gelten (siehe Übung).
Die Fehlerwahrscheinlichkeiten in den Definitionen 2.3 und 2.4 sind bis zu einem gewissen
Grad willkürlich. Anstatt einer Fehlerwahrscheinlichkeit von höchstens 1/2 in der Definition
von RP zu fordern, hätten wir auch jede andere Konstante größer Null wählen können, ohne
dadurch eine andere Komplexitätsklasse zu erhalten. Ebenso können wir bei der Definition
von BPP 3/4 und 1/4 durch beliebige Konstanten echt größer bzw. echt kleiner als 1/2
ersetzen, ohne eine andere Komplexitätsklasse zu erhalten. Der Leser sollte dies als Übung
beweisen.
Definiert man neue Komplexitätsklassen, so stellt sich natürlich sofort die Frage, wie sie in
Relation zu den bereits bekannten Klassen stehen. Da deterministische Turingmaschinen ein
Spezialfall von probabilistischen sind, ist P ⊆ RP, P ⊆ BPP und P ⊆ ZPP. Der Vergleich
mit N P ist schwieriger.
Theorem 2.6. Es gilt RP ⊆ N P.
Beweis. Sei eine beliebige Sprache L ∈ RP gegeben. Dann gibt es eine probabilistische
Turingmaschine, die L mit einem einseitigen Fehler von höchstens 1/2 entscheidet. Wir fassen
diese Turingmaschine einfach als nichtdeterministische Turingmaschine auf, die in jedem
Schritt zwei mögliche Übergänge besitzt und sich entscheiden kann, ob sie δ0 oder δ1 folgt.
Erhält diese Turingmaschine als Eingabe ein Wort x ∈
/ L, so gibt es gemäß der Definition
von RP keinen Rechenweg, der dazu führt, dass x akzeptiert wird. Ist hingegen x ∈ L, so
besagt die Definition von RP, dass mindestens die Hälfte der Rechenwege zum Akzeptieren
von x führt. Insbesondere gibt es also einen solchen Rechenweg und damit ist gezeigt, dass
die nichtdeterministische Turingmaschine die Sprache L entscheidet.
Insgesamt gilt somit ZPP ⊆ RP ⊆ N P. Der Beweis legt eine alternative Charakterisierung
von N P nahe, die an die Definition von RP angelehnt ist.
Korollar 2.7. Eine Sprache L ⊆ Σ∗ gehört genau dann zu N P, wenn es eine probabilistische
Turingmaschine M gibt, deren Laufzeit immer polynomiell beschränkt ist und für die für alle
Eingaben x ∈ Σ∗ gilt:
x ∈ L ⇒ Pr(M akzeptiert x) > 0
und
x∈
/ L ⇒ Pr(M akzeptiert x) = 0.
Bis heute ist es nicht gelungen, die Klassen BPP und N P zueinander in Beziehung zu setzen.
Obwohl wir BPP als die Klasse von Problemen auffassen, die effizient von randomisierten
Algorithmen gelöst werden können, und einige Forscher sogar glauben, dass P = BPP gilt,
ist es bisher noch nicht einmal gelungen zu zeigen, dass BPP ⊆ N P gilt. Mit dem heutigen
Wissen ist es selbst unter der Annahme P =
6 N P möglich, dass N P ⊆ BPP gilt. Dies wird
48
2. Komplexitätstheorie für randomisierte Algorithmen
im Allgemeinen aber als unwahrscheinlich angenommen, da es bedeuten würde, dass es für
alle Probleme aus N P effiziente Algorithmen mit beliebig kleiner Fehlerwahrscheinlichkeit
gäbe.
2.2
Untere Schranken für randomisierte Algorithmen
Bislang haben wir uns in der Vorlesung damit beschäftigt, randomisierte Algorithmen für
verschiedene Probleme zu entwerfen. Eine natürliche Frage ist, wie gut diese Algorithmen
eigentlich sind. Bei jedem Problem können wir uns fragen, ob es bessere Algorithmen mit
einer kleineren Laufzeit oder einer kleineren Fehlerwahrscheinlichkeit gibt. Leider hat es
sich als ziemlich schwierige Aufgabe erwiesen, untere Schranken für die Komplexität von
Problemen zu zeigen. Für randomisierte Algorithmen gibt es jedoch eine Methode, mit deren
Hilfe man für viele Probleme untere Schranken für die erwartete Laufzeit jedes Las-VegasAlgorithmus zeigen kann. Bevor wir diese Methode beschreiben, führen wir zunächst das
Problem der Spielbaumauswertung ein, anhand dessen wir die Methode illustrieren werden.
2.2.1
Spielbaumauswertung
Ein Spielbaum ist ein Baum, in dem jedes Blatt einen reellen Wert besitzt. Jeder innere Knoten besitzt ebenfalls einen Wert, der sich durch eine bestimmte Operation aus den Werten
seiner Kinder berechnet. Gängige Operationen sind zum Beispiel MIN und MAX, die den
kleinsten bzw. größten Wert eines der Kinder ausgeben. Unter Spielbaumauswertung verstehen wir das Problem, den Wert der Wurzel zu bestimmen. Der Name dieses Problems kommt
daher, dass Spielbäume bei Schach und anderen Spielen dazu genutzt werden, um möglichst
gute Strategien zu berechnen.
Wir betrachten Spielbaumauswertung für den Spezialfall, dass ein vollständiger binärer
Baum ausgewertet werden muss, dessen Blätter nur die Werte 0 oder 1 haben. Als Operationen erlauben wir nur MIN- und MAX-Operationen, die wir auf Grund der booleschen
Werte auch als AND- und OR-Operationen bezeichnen werden. Wir bezeichnen einen solchen
Baum als Tk -Baum, wenn er die Tiefe 2k besitzt und alle inneren Knoten mit einem geraden
Abstand von der Wurzel (insbesondere die Wurzel selbst) AND-Operationen berechnen und
alle anderen inneren Knoten OR-Operationen. Die folgende Abbildung zeigt einen T1 -Baum.
0
AND
0
0
OR
OR
0
1
1
0
Anstatt die Laufzeit von Algorithmen zur Spielbaumauswertung zu analysieren, betrachten
wir im Folgenden nur, wie viele Blätter zur Bestimmung des Wertes der Wurzel ausgelesen werden. Alle anderen Operationen, die die Algorithmen durchführen, vernachlässigen
wir. Zum einen erleichtert das die Analyse und zum anderen ist die erwartete Anzahl von
ausgelesenen Blättern bei dem Algorithmus, den wir betrachten werden, in der gleichen Größenordnung wie seine Laufzeit.
2.2. Untere Schranken für randomisierte Algorithmen
49
Einen Algorithmus können wir einfach als eine adaptive Reihenfolge betrachten, in der die
Werte der Blätter ausgelesen werden. Ein deterministischer Algorithmus liest beispielsweise
deterministisch zunächst immer den Wert desselben Blattes. Abhängig davon, ob dort eine 0
oder eine 1 steht, wählt er dann deterministisch das zweite zu lesende Blatt aus und so weiter. Es ist eine Übungsaufgabe für den Leser, zu zeigen, dass es für jeden deterministischen
Algorithmus eine Eingabe gibt, die ihn dazu zwingt, die Werte aller Blätter zu auszulesen.
Die wesentliche Idee zur Konstruktion dieser Eingabe können wir wie folgt beschreiben. Wir
nennen einen Knoten determiniert, wenn sich sein Wert aus Werten der bisher ausgelesenen Blätter ergibt. Wir nennen einen Knoten vollständig aufgedeckt, wenn die Werte aller
Blätter in dem Teilbaum, dessen Wurzel er ist, gelesen wurden. Wir wählen die Werte der
gelesenen Blätter so, dass nur vollständig aufgedeckte Knoten determiniert sind. Das heißt
insbesondere, dass wir alle Blätter auslesen müssen, bevor der Wert der Wurzel feststeht.
Man kann induktiv zeigen, dass stets eine solche Wahl der Werte der Blätter existiert.
Der naheliegende randomisierte Algorithmus, den wir nun betrachten werden, wertet die
Teilbäume eines jeden Knotens in zufälliger Reihenfolge aus. Wertet er beispielsweise einen
OR-Knoten aus, der den Wert 1 hat, so hat mindestens einer seiner beiden Söhne ebenfalls
den Wert 1. Wählt er diesen zuerst aus, was mit Wahrscheinlichkeit 1/2 passiert, so muss er
den anderen nicht mehr auswerten. Genauso verhält es sich mit AND-Knoten mit Wert 0.
Wie sieht es jedoch mit OR-Knoten mit Wert 0 und AND-Knoten mit Wert 1 aus? Es sieht
so aus, als könnten wir hier durch die zufällige Reihenfolge der Auswertung nichts sparen.
Aber auch diese Knoten helfen uns weiter, denn der Vater eines OR-Knotens mit Wert 0
ist ein AND-Knoten mit Wert 0, also ein für uns guter Knoten. Ebenso ist der Vater eines
AND-Knotens mit Wert 1 ein OR-Knoten mit Wert 1, also ebenfalls ein für uns guter Knoten.
RandomGameTree(T, v)
1. if v ist Blatt return Wert von v.
2. else
3.
Seien u0 und u1 die Kinder von v.
4.
Wähle i ∈ {0, 1} uniform zufällig.
5.
if v ist OR-Knoten then
6.
if RandomGameTree(T, ui )=1 then return 1.
7.
else return RandomGameTree(T, u1−i ).
8.
9.
10.
if v ist AND-Knoten then
if RandomGameTree(T, ui )=0 then return 0.
else return RandomGameTree(T, u1−i ).
Theorem 2.8. Die erwartete Anzahl an Blättern, die der Algorithmus RandomGameTree
ausliest, ist für jeden Tk -Baum höchstens 3k .
Beweis. Wir zeigen die Aussage mittels Induktion über k. Der Induktionsanfang für k = 0
ist trivial. Wir betrachten nun den Induktionsschritt für k ≥ 1. In diesem Falle hat der Tk Baum einen AND-Knoten v als Wurzel mit zwei OR-Knoten u0 und u1 als Söhnen, die jeweils
zwei Tk−1 -Bäume als Nachkommen haben. Diese Situation ist in der folgenden Abbildung
dargestellt.
50
2. Komplexitätstheorie für randomisierte Algorithmen
v
AND
u0
Tk−1
OR
OR
Tk−1
Tk−1
u1
Tk−1
Wir analysieren zunächst die OR-Knoten u0 und u1 . Wir können für beide Knoten dieselbe
Analyse durchführen, weswegen wir nicht zwischen den beiden Knoten unterscheiden und
einfach allgemein über den Knoten ui für i ∈ {0, 1} sprechen. Wir unterscheiden zwei Fälle.
Hat der OR-Knoten ui Wert 1, so liefert mindestens einer seiner Söhne ebenfalls den Wert 1
zurück. Werten wir diesen zuerst aus, was mit Wahrscheinlichkeit 1/2 passiert, so genügen
zur Auswertung von ui im Erwartungswert gemäß Induktionsvoraussetzung 3k−1 Blätter.
Der andere Sohn von ui ergibt im schlimmsten Fall eine 0. Werten wir diesen zuerst aus, so
müssen wir auch noch den anderen Sohn auswerten und mit der Linearität des Erwartungswertes ergibt sich eine erwartete Anzahl ausgelesener Blätter von 2 · 3k−1 . Da beide Fälle
mit Wahrscheinlichkeit 1/2 eintreten, können wir die erwartete Anzahl ausgelesener Blätter
durch
1 k−1 1
3
·3
+ · 2 · 3k−1 = · 3k−1
2
2
2
nach oben beschränken. Hat der OR-Knoten ui den Wert 0, so müssen beide Kinder ausgewertet werden, was eine erwartete Anzahl von höchstens 2 · 3k−1 ausgelesenen Blättern
bedeutet.
Nun betrachten wir die Wurzel v des Tk -Baumes. Dies ist ein AND-Knoten. Falls dieser den
Wert 1 hat, so haben bei Söhne ebenfalls den Wert 1. Nutzen wir wieder Linearität des
Erwartungswertes, so ergibt sich mit der obigen Analyse für ui , dass die erwartete Anzahl
ausgelesener Blätter durch
3
2 · · 3k−1 = 3k
2
nach oben beschränkt ist. Ist der Wert des AND-Knotens v gleich 0, so hat mindestens einer
seiner Söhne ebenfalls den Wert 0. Wird dieser zuerst ausgewertet, so ist die erwartete Anzahl
ausgelesener Blätter 2 · 3k−1 . Ansonsten, falls der andere Sohn den Wert 1 hat und dieser
zuerst ausgewertet wird, so ist die erwartete Anzahl ausgelesener Blätter höchstens 32 · 3k−1 +
2 · 3k−1 = 72 · 3k−1 . Da beide Fälle mit Wahrscheinlichkeit 1/2 eintreten, ist die erwartete
Anzahl ausgelesener Blätter insgesamt
1
1 7
11 k−1
· 2 · 3k−1 + · · 3k−1 =
·3
≤ 3k .
2
2 2
4
Da die Anzahl Blätter in einem Tk -Baum n = 4k beträgt, ist die erwartete Anzahl an
Blättern, die der Las-Vegas-Algorithmus RandomGameTree ausliest, durch
3k = 3log4 n = nlog4 3 ≤ n0.793
nach oben beschränkt.
2.2. Untere Schranken für randomisierte Algorithmen
2.2.2
51
Das Min-Max-Prinzip
2-Personen-Nullsummenspiele
Die Methode zum Beweis von unteren Schranken für randomisierte Algorithmen ist durch
Ideen aus der Spieltheorie inspiriert. Zunächst betrachten wir 2-Personen-Nullsummenspiele.
Dabei handelt es sich um Spiele, die durch eine (n×m)-Matrix mit reellen Einträgen beschrieben sind. Es gibt einen Spalten- und einen Zeilenspieler, die jeweils eine Spalte j und eine
Zeile i der Matrix auswählen. Der Spaltenspieler muss dann einen Betrag in Höhe von Mij an
den Zeilenspieler zahlen. Das bedeutet, der Spaltenspieler möchte Mij minimieren, während
der Zeilenspieler es maximieren möchte.
Wir können beispielsweise das berühmte Spiel Schere-Stein-Papier als ein 2-Personen-Nullsummenspiel mit der folgenden (3 × 3)-Matrix M auffassen.
Schere
Stein
Papier
Schere
0
1
-1
Stein
-1
0
1
Papier
1
-1
0
Verliert der Spaltenspieler, so zahlt er 1 an den Zeilenspieler. Gewinnt er, so zahlt er −1,
erhält also 1 vom Zeilenspieler. Bei Unentschieden findet keine Zahlung statt.
Spieler, die auf Nummer sicher gehen und sich gegen alle möglichen Strategien des anderen
Spielers wappnen möchten, verfolgen eine sogenannte Min-Max-Strategie. Das heißt, der
Zeilenspieler wählt die Zeile i, für die minj Mij am größten wird. Damit kann er erreichen,
dass er mindestens
VR = max min Mij
i
j
vom Spaltenspieler erhält. Der Spaltenspieler wählt die Spalte j, für die maxi Mij am kleinsten wird. Damit kann er erreichen, dass er höchstens einen Betrag von
VC = min max Mij
j
i
an den Zeilenspieler zahlen muss. Mit dieser Anschauung ist klar, dass VR ≤ VC für jede
Matrix M gilt.
Gilt sogar VR = VC , so ist es für beide Spieler vernünftig, sich an die Min-Max-Strategie zu
halten. Dadurch wird dann ein sogenanntes Nash-Gleichgewicht erreicht, in dem es für keinen
Spieler Sinn ergibt, seine Strategie zu ändern. Gilt aber VR < VC wie im Beispiel SchereStein-Papier, dann ist die Min-Max-Strategie kein Gleichgewicht, weil man das Wissen über
die Strategie des anderen Spielers ausnutzen kann, um die eigene Strategie zu verbessern.
Um dieses Problem zu lösen, nutzt man Randomisierung. Statt eine Zeile zu wählen, wählt der
Zeilenspieler eine Wahrscheinlichkeitsverteilung p auf den Zeilen. Wir können p ∈ [0, 1]n als
einen Vektor p = (p1 , . . . , pn ) mit p1 +. . .+pn = 1 auffassen. Ebenso wählt der Spaltenspieler
eine Wahrscheinlichkeitsverteilung q ∈ [0, 1]m auf den Spalten, wobei q = (q1 , . . . , qm ) ein
Vektor mit q1 + . . . + qm = 1 ist. Wählen beide Spieler ihre Strategie unabhängig gemäß
dieser Verteilungen, dann ist der erwartete Betrag, den der Spaltenspieler an den Zeilenspieler
zahlen muss, genau
pT M q =
n X
m
X
i=1 j=1
pi Mij qj .
52
2. Komplexitätstheorie für randomisierte Algorithmen
Wir definieren nun VR und VC wie vorhin, nur dass wir diesmal randomisierte Strategien
zulassen. Dann ist
VR = max min pT M q
p
q
die größte erwartete Auszahlung, die sich der Zeilenspieler gegen jede Gegenstrategie des
Spaltenspielers sichern kann. Ebenso kann der Spaltenspieler erreichen, dass er im Erwartungswert niemals mehr als
VC = min max pT M q
q
p
an den Zeilenspieler zahlen muss. John von Neumann hat das folgende erstaunliche Ergebnis
bewiesen.
Theorem 2.9. Für jede Matrix M gilt
VR = max min pT M q = min max pT M q = VC .
p
q
q
p
Lassen wir also Randomisierung zu, so besitzt jedes 2-Personen-Nullsummenspiel ein NashGleichgewicht, d. h. ein Paar von Strategien, von dem keiner der beiden Spieler einen Anreiz
hat, abzuweichen. Eine einfache Folgerung aus diesem Theorem ist das folgende Korollar.
Korollar 2.10. Es bezeichne ei den i-ten Einheitsvektor. Für jede Matrix M gilt
VR = max min pT M ej = min max eTi M q = VC .
p
j
q
i
Ist die randomisierte Strategie des Gegners bekannt, so existiert also stets eine beste Gegenstrategie, die deterministisch ist.
Anwendung auf randomisierte Algorithmen
Nun diskutieren wir, wie uns der obige Exkurs in die Spieltheorie dabei hilft, untere Schranken für randomisierte Algorithmen zu zeigen. Dazu betrachten wir ein Problem Π, für das
es für jedes n ∈ N nur eine endliche Anzahl an Eingaben der Länge n gibt. Wir gehen
davon aus, dass n fixiert ist und bezeichnen mit I die Menge der Eingaben der Länge n.
Außerdem darf es für jede Eingabelänge n ∈ N nur endlich viele essentiell verschiedene deterministische Algorithmen für das Problem Π geben. Wieder gehen wir davon aus, dass n
fixiert ist und bezeichnen mit A die Menge aller Algorithmen für Eingabelänge n. Natürlich
kann man für jedes Problem beliebig viele deterministische Algorithmen dadurch erhalten,
dass man einen beliebigen korrekten deterministischen Algorithmus nimmt und irgendwelche nicht notwendigen Operationen hinzufügt, die die Ausgabe nicht verändern. Wenn wir
von essentiell verschiedenen Algorithmen sprechen, so müssen wir für jedes Problem genau
definieren, was damit gemeint ist. Bei dem Problem der Spielbaumauswertung interessiert
uns beispielsweise nur die adaptive Reihenfolge, in der die Werte Blätter ausgelesen werden.
Von diesen Reihenfolgen gibt es für jedes feste n nur eine endliche Anzahl.
Für A ∈ A und I ∈ I sei C(A, I) ∈ R≥0 ein Maß dafür, wie gut Algorithmus A auf Eingabe I
arbeitet. Uns interessiert in dieser Vorlesung nur der Spezialfall, dass C(A, I) die Laufzeit
von A auf I angibt, prinzipiell sind aber auch andere Maße wie zum Beispiel die Güte bei
Approximationsalgorithmen denkbar. Wir definieren nun ein 2-Personen-Nullsummenspiel,
in dem der Spaltenspieler dem Algorithmendesigner entspricht und der Zeilenspieler einem
Gegner, der eine möglichst schlechte Eingabe wählen möchte. Für einen Algorithmus A ∈ A
und eine Eingabe I ∈ I enthält die (|I|×|A|)-Matrix M an der Stelle MIA den Wert C(A, I).
2.2. Untere Schranken für randomisierte Algorithmen
53
Eine reine Strategie des Spaltenspielers entspricht einem deterministischen Algorithmus aus
der Menge A. Eine gemischte Strategie des Spaltenspielers ist eine Wahrscheinlichkeitsverteilung q ∈ [0, 1]|A| auf den deterministischen Algorithmen. Diese können wir als einen LasVegas-Algorithmus betrachten, der zufällig gemäß der Verteilung q einen deterministischen
Algorithmus auswählt, welchen er dann auf die gegebene Eingabe anwendet. Andersherum
können wir jeden Las-Vegas-Algorithmus als eine Wahrscheinlichkeitsverteilung auf der Menge A der deterministischen Algorithmen darstellen. Der Leser möge an dieser Stelle über ein
formales Argument hierfür nachdenken. Das bedeutet insgesamt, dass die Menge der gemischten Strategien des Spaltenspielers genau mit der Menge der Las-Vegas-Algorithmen
übereinstimmt.
Das Min-Max-Theorem angewendet auf das soeben definierte 2-Personen-Nullsummenspiel
liefert folgendes Korollar.
Korollar 2.11. Es bezeichnen P und Q die Mengen der gemischten Strategien des Zeilenbzw. Spaltenspielers. Für p ∈ P und q ∈ Q bezeichnen Ip und Aq eine zufällige Eingabe,
die gemäß p gewählt wird, bzw. einen zufälligen Algorithmus, der gemäß q gewählt wird. Es
gelten
max min E(C(Ip , Aq )) = min max E(C(Ip , Aq ))
p∈P q∈Q
q∈Q p∈P
und
max min E(C(Ip , A)) = min max E(C(I, Aq )).
p∈P A∈A
q∈Q I∈I
Aus diesem Korollar ergibt sich direkt ein weiteres Korollar, das wir zum Beweis unterer
Schranken einsetzen werden.
Korollar 2.12. Für alle Verteilungen p ∈ P über I und für alle Verteilungen q ∈ Q über A
gilt
min E(C(Ip , A)) ≤ max E(C(I, Aq )).
A∈A
I∈I
Zunächst sollten wir uns klar machen, was die Terme in diesem Korollar bedeuten. Auf
der rechten Seite steht maxI∈I E(C(I, Aq )), wobei q eine beliebige Wahrscheinlichkeitsverteilung auf der Menge A ist, also ein beliebiger Las-Vegas-Algorithmus. Da das Maximum
über alle Eingaben I ∈ I gebildet wird, entspricht dieser Term genau der erwarteten Laufzeit des durch q beschriebenen Las-Vegas-Algorithmus auf der schlimmsten Eingabe. Der
Term minA∈A E(C(Ip , A)) auf der linken Seite bezeichnet die erwartete Laufzeit des besten
deterministischen Algorithmus auf Eingaben, die gemäß der Verteilung p gewählt werden.
Möchten wir mit Hilfe dieses Korollars also zeigen, dass es keinen Las-Vegas-Algorithmus
gibt, dessen erwartete Worst-Case-Laufzeit eine gewisse Schranke B unterschreitet, so genügt es, eine Wahrscheinlichkeitsverteilung p auf der Menge der Eingaben zu finden, für die
kein deterministischer Algorithmus eine erwartete Laufzeit kleiner als B erreichen kann. Auf
diese Weise können wir das Problem umgehen, über alle möglichen Las-Vegas-Algorithmen
argumentieren zu müssen. Stattdessen genügt es, eine einzige Verteilung auf den Eingaben
zu finden, für die alle deterministischen Algorithmen im Erwartungswert schlecht sind.
Zwar folgt Korollar 2.12 direkt aus dem Min-Max-Theorem über 2-Personen-Nullsummenspiele, da wir dieses aber nicht bewiesen haben, präsentieren wir hier noch einen elementaren
Beweis des Korollars, der ohne Spieltheorie auskommt.
54
2. Komplexitätstheorie für randomisierte Algorithmen
Beweis von Korollar 2.12. Es seien p ∈ P und q ∈ Q beliebig. Dann gilt
X max E(C(I, Aq )) = max
I∈I
I∈I
≥
A∈A
X
X p(I) ·
I∈I
=
q(A) · C(I, A)
A∈A
X X
A∈A
I∈I
q(A) ·
≥ min
A∈A
q(A) · C(I, A)
X
p(I) · C(I, A)
p(I) · C(I, A)
I∈I
= min E(C(Ip , A)),
A∈A
wobei wir in der dritten Zeile bei der Umordnung der Summe ausgenutzt haben, dass A
und I endlich sind.
2.2.3
Eine untere Schranke für Spielbaumauswertung
Wir möchten nun Korollar 2.12 anwenden, um zu zeigen, dass es keinen Las-Vegas-Algorithmus zur Spielbaumauswertung gibt, der im Erwartungswert weniger Blätter betrachtet
als der Algorithmus RandomGameTree, den wir oben beschrieben haben. Wir betrachten
wieder Tk -Bäume. Anstatt diese über wechselnde Ebenen von AND- und OR-Knoten zu
beschreiben, ersetzen wir alle Knoten durch NOR-Knoten. Mit Hilfe der De Morgan’schen
Gesetze sieht man leicht, dass sich der Wert der Wurzel des Spielbaumes dadurch nicht
verändert. Wir gehen also davon aus, dass wir einen vollständigen binären Baum der Höhe 2k
vorliegen haben, in dem alle inneren Knoten die NOR-Funktion berechnen.
Wir zeigen eine Schranke für die erwartete Anzahl an Blättern, die sich jeder Las-VegasAlgorithmus anschauen muss, bevor er sicher den korrekten Wert an der Wurzel kennt.
Korollar 2.12 besagt, dass es dazu genügt, eine Wahrscheinlichkeitsverteilung auf der Menge
der Eingaben anzugeben, auf der alle deterministischen Algorithmen schlecht abschneiden.
Wir wählen eine Verteilung auf Tk -Bäumen,√in der jedes Blatt unabhängig von den anderen
mit einer Wahrscheinlichkeit von r = 3 − 5 /2 auf 1 und sonst auf 0 gesetzt wird. Diese
Verteilung hat die Eigenschaft, dass die Wahrscheinlichkeit, dass ein NOR zweier Blätter
den Wert 1 ergibt, wieder genau
√
√
5−1 2 6−2 5
2
(1 − r) =
=r
=
2
4
beträgt. Somit verhalten sich alle Ebenen des Tk -Baumes in gewisser Weise identisch.
Sei v ein Knoten eines solchen Tk -Baumes. Intuitiv ergibt es Sinn, dass ein optimaler deterministischer Algorithmus zunächst den Wert eines Teilbaumes von v bestimmt, bevor er
damit beginnt, Blätter in dem anderen Teilbaum auszulesen. Wir nennen eine Reihenfolge
von Blättern DFS-Reihenfolge, wenn die Blätter in dieser Reihenfolge von einer Tiefensuche
besucht werden können. Dann ergibt es intuitiv Sinn, wenn der Algorithmus sich die Blätter
in einer DFS-Reihenfolge anschaut, wobei er Teilbäume überspringt, deren Werte nicht mehr
relevant sind. Solche Algorithmen nennen wir DFS-Pruning-Algorithmen. Tatsächlich kann
man zeigen, dass es für die Verteilung, die wir gewählt haben, einen optimalen Algorithmus
gibt, der ein DFS-Pruning-Algorithmus ist.
2.2. Untere Schranken für randomisierte Algorithmen
55
Lemma 2.13. Es sei T ein NOR-Baum dessen Blätter unabhängig mit einer festen Wahrscheinlichkeit r ∈ [0, 1] auf 1 gesetzt werden. Es sei W (T ) die erwartete Anzahl an Blättern,
die ein optimaler deterministischer Algorithmus auslesen muss, um T auszuwerten. Dann
gibt es einen DFS-Pruning-Algorithmus, der im Erwartungswert W (T ) Blätter ausliest, um T
auszuwerten.
Der Beweis dieses Lemmas, den wir hier nicht präsentieren, kann per Induktion über die
Höhe von T geführt werden.
Sei nun ein beliebiger deterministischer DFS-Pruning-Algorithmus fixiert. Die erwartete Anzahl an Blättern W (h), die er für einen NOR-Baum der Höhe h ausliest, können wir induktiv
wie folgt beschränken. Es gilt W (0) = 1 und für h ≥ 1 gilt
W (h) = W (h − 1) + (1 − r) · W (h − 1) = (2 − r) · W (h − 1).
Dies liegt daran, dass der erste Teilbaum der Wurzel, den der Algorithmus auswertet mit
einer Wahrscheinlichkeit von (1 − r) den Wert 0 besitzt. Nur in diesem Fall muss auch der
zweite Teilbaum ausgewertet werden. Somit gilt W (h) ≥ (2 − r)h . Die Anzahl Blätter eines
NOR-Baumes der Höhe h beträgt n = 2h und damit gilt
W (h) ≥ (2 − r)log2 n = nlog2 (2−r) ≥ n0.694 .
Damit ist gezeigt, dass jeder DFS-Pruning-Algorithmus im Erwartungswert mindestens n0.694
viele Blätter ausliest. Auf Grund von Lemma 2.13 bedeutet das, dass jeder deterministische
Algorithmus auf Eingaben, die gemäß der oben beschriebenen Verteilung gewählt werden, im
Erwartungswert mindestens n0.694 viele Blätter ausliest. Diese Schranke entspricht nicht ganz
der oberen Schranke, die der Algorithmus RandomGameTree erreicht. Mit deutlich mehr
Aufwand kann man jedoch sogar zeigen, dass der Algorithmus RandomGameTree optimal
ist.
Kapitel 3
Chernoff-Schranken und
randomisierte Lastverteilung
Wir haben mit den Markow- und Tschebyschew-Ungleichungen bereits zwei Möglichkeiten
kennengelernt, um die Wahrscheinlichkeit zu beschränken, dass eine Zufallsvariable von ihrem
Erwartungswert abweicht. Diese Ungleichungen sind recht allgemein formuliert und nutzen
außer dem Wissen, dass der Erwartungswert bzw. die Varianz existieren, und der Nichtnegativität im Falle der Markow-Ungleichung keine weiteren Eigenschaften der Zufallsvariable
aus. Für viele konkrete Verteilungen wie zum Beispiel die Binomialverteilung lassen sich
deutlich bessere Schranken zeigen, wenn mehr Informationen ausgenutzt werden. In diesem
Kapitel leiten wir eine Klasse von Ungleichungen her, die als Chernoff-Schranken bezeichnet
werden. Anschließend werden wir diese Schranken auf verschiedene Probleme anwenden.
Im zweiten Teil des Kapitels beschäftigen wir uns mit randomisierter Lastverteilung. Oft
müssen in der Informatik Lastverteilungsprobleme gelöst werden. Beispielsweise möchte man
Routen in einem Netzwerk so festlegen, dass die Last möglichst gleichmäßig auf die Kanten des Netzwerkes verteilt ist, oder man möchte Einträge in einer Hashtabelle möglichst
gleichmäßig auf die möglichen Hashwerte verteilen. Bei vielen Problemen nutzt man Randomisierung, um eine gute Verteilung zu finden.
Die Inhalte dieses Kapitels sind stark an die Kapitel 4 und 5 von [5] angelehnt.
3.1
Chernoff-Schranken
Bevor wir Chernoff-Schranken formulieren und beweisen können, präsentieren wir mit momenterzeugenden Funktionen zunächst ein wichtiges Hilfsmittel aus der Wahrscheinlichkeitstheorie.
3.1.1
Momenterzeugende Funktionen
Definition 3.1. Es sei X eine reelle Zufallsvariable. Falls es ein δ > 0 gibt, sodass der
Erwartungswert E etX für jedes t ∈ (−δ, δ) existiert, dann bezeichnen wir die Funktion MX : (−δ, δ) → R mit
MX (t) = E etX
als die momenterzeugende Funktion von X.
56
3.1. Chernoff-Schranken
57
Die momenterzeugende Funktion trägt ihren Namen, weil aus ihr alle Momente der Zufallsvariable abgeleitet werden können, wenn sie in einer Umgebung um Null existiert.
Theorem 3.2. Es sei X eine reelle Zufallsvariable mit der momenterzeugenden Funktion MX , die in einem Intervall (−δ, δ) für ein δ > 0 existiert. Dann gilt für jedes n ∈ N
(n)
E(X n ) = MX (0),
(n)
wobei MX die n-te Ableitung von MX bezeichnet.
Beweis. Für t ∈ (−δ, δ) gilt
(n)
MX (t)
dn tX
dn e
= n E etX = E
dt
dtn
!
= E X n · etX .
Bei dieser Rechnung haben wir ausgenutzt, dass man die Reihenfolge von Differenzieren und
Bilden des Erwartungswertes vertauschen kann. Dies folgt daraus, dass die Funktion MX
in einem Intervall um Null herum existiert. Auf einen formalen Beweis dafür verzichten wir
hier aber. Setzt man nun t = 0 in obige Formel ein, so erhält man direkt die zu beweisende
Aussage.
Genauso wie bei Erwartungswerten und Varianzen ist es hilfreich, Rechenregeln für momenterzeugende Funktionen zu haben. Uns interessiert insbesondere die momenterzeugende
Funktion der Summe zweier Zufallsvariablen.
Theorem 3.3. Es seien X und Y zwei unabhängige reelle Zufallsvariablen, deren momenterzeugende Funktionen in einem Intervall (−δ, δ) für ein δ > 0 existieren. Dann existiert
auch die momenterzeugende Funktion von X + Y und es gilt für jedes t ∈ (−δ, δ)
MX+Y (t) = MX (t) · MY (t).
Beweis. Es gilt
MX+Y (t) = E et(X+Y ) = E etX etY
= E etX · E etY
= MX (t) · MY (t),
wobei wir im dritten Schritt die Unabhängigkeit von etX und etY ausgenutzt haben, die aus
der Unabhängigkeit von X und Y folgt.
3.1.2
Chernoff-Schranken für die Summe von Bernoulli-Zufallsvariablen
Als Chernoff-Schranke bezeichnet man im weitesten Sinne jede Schranke für die Wahrscheinlichkeit einer Abweichung vom Erwartungswert, die man durch eine Anwendung der MarkowUngleichung auf die momenterzeugende Funktion einer Zufallsvariable erhält. Existiert für
eine Zufallsvariable X in einem Intervall (−δ, δ) die momenterzeugende Funktion MX , so gilt
für jedes t ∈ (0, δ)
E(etX )
Pr(X ≥ a) = Pr etX ≥ eta ≤
(3.1)
eta
und damit insbesondere
E(etX )
Pr(X ≥ a) ≤ min
.
eta
t∈(0,δ)
58
3. Chernoff-Schranken und randomisierte Lastverteilung
Analog gilt für Abweichungen nach unten für jedes t ∈ (−δ, 0)
Pr(X ≤ a) = Pr etX ≥ eta ≤
und damit insbesondere
E(etX )
eta
(3.2)
E(etX )
.
eta
t∈(−δ,0)
Pr(X ≤ a) ≤ min
Wenn wir diese Schranken anwenden, so wählen wir nicht unbedingt das beste t, für das der
obige Ausdruck minimiert wird, sondern wir wählen ein t, mit dem wir gut rechnen können.
Wir möchten nun als erstes spezielle Chernoff-Schranken für die Summe von BernoulliZufallsvariablen herleiten. Seien dazu X1 , . . . , Xn Bernoulli-Zufallsvariablen mit den Parametern p1 , . . . , pn ∈ [0, 1]. Es sei X = X1 + . . . + Xn und µ sei der Erwartungswert von X.
Dann gilt
µ = E(X) = E
X
n
Xi =
i=1
n
X
E(Xi ) =
i=1
n
X
pi .
i=1
Für ein δ > 0 sind wir daran interessiert, die Wahrscheinlichkeiten zu beschränken, dass X
einen Wert annimmt, der um den Faktor 1 + δ größer ist als sein Erwartungswert oder der
um den Faktor 1 − δ kleiner ist als sein Erwartungswert. Um diese Wahrscheinlichkeiten
beschränken zu können, bestimmen wir zunächst die momenterzeugende Funktion von X.
Für jedes Xi und jedes t ∈ R gilt
t −1)
MXi (t) = E etXi = pi et + (1 − pi )e0 = 1 + pi (et − 1) ≤ epi (e
,
wobei wir für die letzte Ungleichung ausgenutzt haben, dass 1 + y ≤ ey für jedes y ∈ R
gilt. Nun können wir mit Hilfe von Theorem 3.3 die momenterzeugende Funktion von X für
jedes t ∈ R wie folgt nach oben abschätzen:
MX (t) =
n
Y
MXi (t) ≤
i=1
n
Y
pi (et −1)
e
= exp
i=1
n
X
!
t
pi (e − 1)
t −1)
= eµ(e
.
(3.3)
i=1
Das folgende Theorem ergibt sich nun durch eine geeignete Wahl von t aus (3.1).
Theorem 3.4. Es seien X1 , . . . , Xn unabhängige Bernoulli-Zufallsvariablen mit den Parametern p1 , . . . , pn ∈ [0, 1]. Sei X = X1 + . . . + Xn und sei µ = E(X) = p1 + . . . + pn .
a) Für jedes δ > 0 gilt
Pr(X ≥ (1 + δ)µ) ≤
eδ
(1 + δ)1+δ
!µ
.
b) Für jedes 0 < δ ≤ 1 gilt
Pr(X ≥ (1 + δ)µ) ≤ e−µδ
2 /3
.
c) Für jedes R ≥ 6µ gilt
Pr(X ≥ R) ≤ 2−R .
Die erste im Theorem genannte Ungleichung ist die stärkste, aus der sich die anderen beiden
ergeben. Für Anwendungen eignen sich aber oft die zweite und dritte Form besser, da mit
ihnen einfacher zu rechnen ist.
3.1. Chernoff-Schranken
59
Beweis von Theorem 3.4. Die erste Ungleichung folgt direkt, wenn wir die Markow-Ungleichung für t = ln(1 + δ) auf die momenterzeugende Funktion anwenden. Wir erhalten dann
mit (3.1) und (3.3)
t
E(etX )
MX (t)
e(e −1)µ
Pr(X ≥ (1 + δ)µ) ≤ t(1+δ)µ = t(1+δ)µ ≤ t(1+δ)µ =
e
e
e
eδ
(1 + δ)1+δ
!µ
.
Für die zweite Ungleichung muss gezeigt werden, dass
eδ
2
≤ e−δ /3
1+δ
(1 + δ)
für alle 0 < δ ≤ 1 gilt. Wenn wir auf beide Seiten den natürlichen Logarithmus anwenden,
so erhalten wir die äquivalente Ungleichung
δ2
≤ 0.
3
Mit einer elementaren Kurvendiskussion kann man zeigen, dass diese Ungleichung für alle δ ∈
(0, 1] erfüllt ist.
δ − (1 + δ) ln(1 + δ) +
Für den Beweis der dritten Ungleichung setzen wir R = (1 + δ)µ. Für R ≥ 6µ gilt dann δ =
R/µ − 1 ≥ 5. Aus der ersten Ungleichung folgt dann
Pr(X ≥ (1 + δ)µ) ≤
eδ
(1 + δ)1+δ
!µ
≤
e
1+δ
!(1+δ)µ
≤
e
6
!R
≤ 2−R .
Damit sind alle drei Ungleichungen bewiesen.
Auf ähnliche Art und Weise kann man auch das folgende Theorem beweisen, das die Wahrscheinlichkeit beschränkt, dass eine Summe von Bernoulli-Zufallsvariablen einen Wert annimmt, der deutlich unter ihrem Erwartungswert liegt.
Theorem 3.5. Es seien X1 , . . . , Xn unabhängige Bernoulli-Zufallsvariablen mit den Parametern p1 , . . . , pn ∈ [0, 1]. Sei X = X1 + . . . + Xn und sei µ = E(X) = p1 + . . . + pn .
a) Für jedes 0 < δ < 1 gilt
Pr(X ≤ (1 − δ)µ) ≤
e−δ
(1 − δ)1−δ
!µ
.
b) Für jedes 0 < δ < 1 gilt
Pr(X ≤ (1 − δ)µ) ≤ e−µδ
2 /2
.
Oft kennen wir den Erwartungswert einer Zufallsvariable nicht genau, sondern wir haben nur
eine Abschätzung nach oben oder nach unten. Tatsächlich gilt Theorem 3.4 für jedes µ ≥
E(X) und Theorem 3.5 gilt für jedes µ ≤ E(X). Dies zu zeigen ist eine Übungsaufgabe für
den Leser.
Interessiert uns generell eine Abweichung vom Erwartungswert egal in welche Richtung, so
können wir das folgende Korollar anwenden, das sich direkt aus Theorem 3.4 und Theorem 3.5
ergibt.
Korollar 3.6. Es seien X1 , . . . , Xn unabhängige Bernoulli-Zufallsvariablen mit den Parametern p1 , . . . , pn ∈ [0, 1]. Sei X = X1 + . . . + Xn und sei µ = E(X) = p1 + . . . + pn . Dann
gilt für jedes 0 < δ < 1
2
Pr(|X − µ| ≥ δµ) ≤ 2e−µδ /3 .
60
3. Chernoff-Schranken und randomisierte Lastverteilung
Vergleich mit Markow- und Tschebyschew-Ungleichung
Um die Mächtigkeit von Chernoff-Schranken zu demonstrieren, betrachten wir noch einmal
das Beispiel von n unabhängigen fairen Münzwürfen. Wir haben die Wahrscheinlichkeit,
mindestens (3n/4)-mal „Zahl“ zu werfen, bereits mit der Markow- und der TschebyschewUngleichung abgeschätzt. Diese Rechnungen wiederholen wir kurz und wenden anschließend
Theorem 3.4 an. Sei X die Zufallsvariable, die angibt, wie oft wir „Zahl“ werfen. Mit der
Markow-Ungleichung ergibt sich
Pr X ≥
3n
4
≤
E(X)
n/2
2
=
= .
3n/4
3n/4
3
In Wirklichkeit ist es aber sehr viel unwahrscheinlicher, dass X ≥ 3n/4 gilt. Mit Hilfe der
Tschebyschew-Ungleichung erhalten wir zumindest eine Schranke für die Wahrscheinlichkeit,
die mit wachsendem n fällt:
3n
Pr X ≥
4
≤
Var(X)
4
= .
2
(n/4)
n
Auch diese Schranke ist aber noch weit von der Wahrheit entfernt. Mit der Chernoff-Schranke
aus Theorem 3.4 b) erhalten wir
3n
Pr X ≥
4
1
= Pr X ≥ 1 + E(X) ≤ e−n/24 .
2
Das bedeutet, dass die Wahrscheinlichkeit, mindestens (3n/4)-mal „Zahl“ zu werfen, sogar
exponentiell klein in n ist.
Wir betrachten die Chernoff-Schranke für δ ∈ (0, 1] noch einmal genauer. Laut Korollar 3.6
gilt für jedes δ ∈ (0, 1)
n
n 2
≤ 2e−nδ /6 .
Pr X − ≥ δ ·
2
2
Das bedeutet beispielsweise
r
n √
n 6 n
2
Pr X − ≥ 6n = Pr X − ≥
·
≤ .
2
und
2
n 2
e
s
n √
n 6 ln n n
2
Pr X − ≥ 6n ln n = Pr X − ≥
·
≤ .
2
2
n
2
n
Gemäß der Chernoff-Schranke haben additive Abweichungen vom Erwartungswert in der
√
Größenordnung Θ( n) also eine konstante Wahrscheinlichkeit,
√ während die Wahrscheinlichkeit einer additiven Abweichung in der Größenordnung Θ( n ln n) bereits relativ klein ist.
Dies entspricht ziemlich genau dem tatsächlichen Verhalten von der Summe von BernoulliZufallsvariablen.
3.1.3
Anwendungen
Verbesserung der Fehlerwahrscheinlichkeit bei BPP
In Kapitel 2.1.3 haben wir definiert, dass eine Sprache L zu der Klasse BPP gehört, wenn es
eine polynomiell zeitbeschränkte probabilistische Turingmaschine gibt, die alle Ja-Instanzen
3.1. Chernoff-Schranken
61
mit einer Wahrscheinlichkeit von höchstens 1/4 verwirft und die alle Nein-Instanzen mit
einer Wahrscheinlichkeit von höchstens 1/4 akzeptiert. Wir haben bereits in einer Übungsaufgabe gesehen, dass sich die Komplexitätsklasse BPP nicht ändert, wenn wir die Fehlerwahrscheinlichkeit von 1/4 auf 1/n reduzieren, wobei n die Länge der Eingabe ist. Mit Hilfe
von Chernoff-Schranken können wir zeigen, dass wir selbst eine exponentiell kleine Fehlerwahrscheinlichkeit fordern können, ohne die Klasse zu verändern.
Theorem 3.7. Zu jeder Sprache L ⊆ Σ∗ aus BPP gibt es eine polynomiell zeitbeschränkte
probabilistische Turingmaschine, die jedes Wort w ∈ L mit einer Wahrscheinlichkeit von
höchstens e−|w| verwirft und jedes Wort w ∈
/ L mit einer Wahrscheinlichkeit von höchstens e−|w| akzeptiert.
Beweis. Da L zu BPP gehört, existiert eine polynomiell zeitbeschränkte PTM, die jedes w ∈
L mit einer Wahrscheinlichkeit von höchstens 1/4 verwirft und die jedes w ∈
/ L mit einer
Wahrscheinlichkeit von höchstens 1/4 akzeptiert. Wir simulieren diese PTM unabhängig
k-mal für k = 12|w| und übernehmen dann die Ausgabe, die in diesen Wiederholungen
häufiger vorkam. Bei Gleichstand akzeptieren wir. Sei X die Zufallsvariable, die angibt, wie
viele Simulationen verwerfen. Für w ∈ L gilt E(X) ≤ k/4. Mit Theorem 3.4 folgt außerdem
Pr(X ≥ k/2) ≤ Pr(X ≥ 2E(X)) ≤ e−k/12 = e−|w| .
Den Fall w ∈
/ L können wir analog analysieren. Damit ist das Theorem bewiesen, da wir
nur polynomiell viele Simulationen benötigen, um die Fehlerwahrscheinlichkeit auf e−|w| zu
reduzieren.
Set Balancing
Bei dem Problem Set Balancing besteht die Eingabe aus einer (n × m)-Matrix A mit Einträgen aus {0, 1}. Gesucht ist ein Vektor b ∈ {−1, 1}m , für den die Maximumsnorm kAbk∞
so klein wie möglich wird. Sei Ab = (c1 , . . . , cn )T , dann ist kAbk∞ := maxi∈{1,...,n} |ci |.
Dieses Problem ist wichtig, wenn eine statistische Studie zu einem neuen Medikament durchgeführt wird. Dazu hat man eine Menge von Versuchspersonen, die man in zwei Klassen
einteilt. Versuchspersonen aus der einen Klasse erhalten das neue Medikament; Versuchspersonen aus der anderen Klasse erhalten ein Placebo oder ein anderes Medikament, mit dem
das neue verglichen werden soll. Um einen fairen Vergleich zu ermöglichen, sollen beide Gruppen ähnliche Merkmale aufweisen. Beispielsweise sollten beide Gruppen in etwa die gleiche
Anzahl an Rauchern enthalten, die gleiche Anzahl mit gewissen Vorerkrankungen usw. Die
Zeilen der Matrix A entsprechen dann den Merkmalen, die in der Studie von Interesse sind,
und jede Spalte entspricht einer Versuchsperson, für die vermerkt ist, welche Merkmale auf
sie zutreffen. Der gesuchte Vektor b ∈ {−1, 1}m entspricht dann der Einteilung der Personen
in zwei Klassen.
Der randomisierte Algorithmus zum Finden eines Vektor b, für den kAbk∞ klein wird, den wir
analysieren wollen, ist sehr einfach. Er wählt jeden Eintrag von b unabhängig und uniform
zufällig aus der Menge {−1, 1}. Dann ist der Erwartungswert jedes ci Null und wir können eine Chernoff-Schranke benutzen, um die Wahrscheinlichkeit von Abweichungen vom
Erwartungswert zu beschränken.
Theorem 3.8. Es sei A eine beliebige (n × m)-Matrix mit Einträgen aus {0, 1} und es
sei b ∈ {−1, 1}m ein zufälliger Vektor, in dem jeder Eintrag unabhängig und uniform zufällig
62
3. Chernoff-Schranken und randomisierte Lastverteilung
aus {−1, 1} gewählt wird. Dann gilt
Pr kAbk∞ ≥
√
12m ln n ≤
2
.
n
Beweis. Wir betrachten
zunächst eine beliebige Zeile i ∈ {1, . . . , n}. Sind in dieser Zei√
le weniger √
als 12m ln n Einsen vorhanden, so ist der Betrag
von ci für jeden Vektor b
√
kleiner als 12m ln n. Interessant ist also nur der Fall k ≥ 12m ln n. Dann ist ci die Summe X = X1 + . . . + Xk von k Zufallsvariablen, die unabhängig voneinander jeweils mit Wahrscheinlichkeit 1/2 die Werte −1 und 1 annehmen. Darauf können wir die Chernoff-Schranken,
die wir für Bernoulli-Zufallsvariablen hergeleitet haben, nicht direkt anwenden. Stattdessen
definieren wir Hilfszufallsvariablen Y1 , . . . , Yk mit Yi = (1 + Xi )/2. Wie man leicht nachrechnet, handelt es sich bei diesen Zufallsvariablen um unabhängige Bernoulli-Zufallsvariablen
mit Parameter 1/2. Es gilt
k+X
Y := Y1 + . . . + Yk =
2
und damit
k+a
k−a
X ≥ a ⇐⇒ Y ≥
und X ≤ −a ⇐⇒ Y ≤
.
2
2
Also gilt
k a k a
2
2
Pr |X| ≥ a = Pr Y − ≥
= Pr Y − ≥ · E(Y ) ≤ 2e−a /(6k) ≤ 2e−a /(6m) ,
2
2
2
k
√
wobei wir im letzten Schritt k ≤ m ausgenutzt haben. Für a = 12m ln n ergibt sich
Pr(|X| ≥ a) ≤ 2e−2 ln n =
2
.
n2
Damit haben wir für jedes ci gezeigt, dass die Wahrscheinlichkeit, dass |ci | zu groß ist,
durch 2/n2 nach oben beschränkt ist. Der Beweis des Theorems kann nun mit Hilfe einer
Union Bound über die n Zeilen der Matrix abgeschlossen werden.
√
Da eine positive Wahrscheinlichkeit besteht, dass kAbk∞ < 12m ln n für einen zufälligen
Vektor b gilt, besagt das vorangegangene
√ Theorem insbesondere, dass es für jede Matrix A
einen Vektor b gibt, für den kAbk∞ < 12m ln n gilt. Diese Art der Argumentation nennt
man probabilistische Methode.
3.2
Randomisierte Lastverteilung
Wir betrachten zunächst ein abstraktes Modell zur Lastverteilung, das wir später für einige
algorithmische Anwendungen nutzen werden. In diesem Modell gibt es n Kisten und es
werden m Bälle auf diese Kisten verteilt. Dabei wählen wir für jeden Ball unabhängig eine
uniform zufällige Kiste aus, in die er gelegt wird. Wir beantworten dann insbesondere die
Frage, wie viele Bälle in der vollsten Kiste im Erwartungswert liegen.
Ein Spezialfall dieses Problems ist einigen Lesern vielleicht schon unter dem Namen Geburtstagsparadoxon bekannt. Bei diesem betrachtet man m Personen, die unabhängig voneinander jeweils an einem uniform zufälligen Tag des Jahres Geburtstag haben. Dabei werden
Schaltjahre ignoriert und von n = 365 Tagen pro Jahr ausgegangen. Diese Wahrscheinlichkeit können wir mit dem Wissen aus dieser Vorlesung leicht abschätzen. Dazu führen
3.2. Randomisierte Lastverteilung
63
wir die Ereignisse A2 , . . . , Am ein, wobei Ai das Ereignis bezeichne, dass die i-te Person
nicht gemeinsam mit einer der Personen 1, . . . , i − 1 Geburtstag hat. Dann entspricht der
Schnitt A2 ∩ . . . ∩ Am dem Ereignis, dass alle Personen an verschiedenen Tagen Geburtstag
haben. Für jedes i gilt
n−i+1
Pr(Ai | A1 ∩ . . . ∩ Ai−1 ) =
,
n
da das Ereignis A1 ∩. . .∩Ai−1 garantiert, dass die ersten i−1 Personen paarweise verschiedene
Geburtstage haben, und somit für die i-te Person n − i + 1 noch nicht belegte Tage zur
Verfügung stehen. Insgesamt folgt damit
Pr(A1 ∩ . . . ∩ Am ) =
m
Y
Pr(Ai | A1 ∩ . . . ∩ Ai−1 ) =
i=1
m Y
i=1
i−1
1−
.
n
(3.4)
Diese Zufallsexperiment wird oft als Paradoxon bezeichnet, da die Wahrscheinlichkeit, die
sich aus (3.4) ergibt, viel größer ist, als viele Menschen intuitiv vermuten würden. Die Wahrscheinlichkeit zwei gleiche Geburtstage zu haben, ist bereits bei 23 Personen größer als 1/2.
Bei 50 Personen liegt sie bereits über 0,97.
Wir möchten nun zunächst herausfinden, in welcher Größenordnung die Anzahl an Personen m bei allgemeinem n liegen muss, damit die Wahrscheinlichkeit, zwei gleiche Geburtstage
zu haben, mindestens 1/2 ist. Zunächst nähern wir (3.4) mit einer Formel an, die einfacher
zu handhaben ist. Ist i im Verhältnis zu n klein, so gilt näherungsweise 1 − i/n ≈ e−i/n .
Setzen wir diese Näherung in (3.4) ein, so ergibt sich
m Y
i=1
1−
i−1
n
≈
m
Y
e−(i−1)/n = exp
−
m
X
i−1
i=2
i=1
n
= exp
−
m(m − 1)
2n
≈ e−m
2 /(2n)
.
p
Diese Überschlagsrechnung legt die Vermutung nahe, dass wir m ≈ 2 ln(2)n wählen sollten,
damit die Wahrscheinlichkeit 1/2 wird. Natürlich ist das noch kein formales Argument, aber
√
die folgenden Rechnungen zeigen, dass zumindest die Größenordnung Θ( n) korrekt ist. Wir
√
gehen der Einfachheit halber in den folgenden Rechnungen davon aus, dass n eine ganze
Zahl ist.
√
Ist m ≤ n, so ergibt eine Union Bound, dass die Wahrscheinlichkeit, dass zwei Geburtstage
übereinstimmen, kleiner als 1/2 ist. Dies entspricht dem Ereignis A2 ∪ . . . ∪ Am , für das gilt
m
X
Pr(A2 ∪ . . . ∪ Am ) ≤
Pr(Ai ) ≤
i=2
m
X
i−1
i=2
n
=
m(m − 1)
1
< .
2n
2
√
Ist m ≥ 2 n, so können wir ebenfalls leicht argumentieren, dass die Wahrscheinlichkeit, dass
√
zwei Geburtstage übereinstimmen, größer als 1/2 ist. Gehen wir davon aus, dass die ersten n
Personen an verschiedenen Tagen Geburtstag haben, so beträgt die Wahrscheinlichkeit, dass
√
√
√
eine Person i ∈ { n+1, . . . , 2 n} nicht am selben Tag Geburtstag hat wie eine der ersten n
Personen,
√
n− n
1
=1− √ .
n
n
√
√
Die Wahrscheinlichkeit, dass keine der Personen i ∈ { n + 1, . . . , 2 n} am selben Tagen
√
Geburtstag hat wie eine der ersten n Personen, beträgt somit
1
1− √
n
√n
<
1
1
< .
e
2
64
3. Chernoff-Schranken und randomisierte Lastverteilung
√
Somit ist die Wahrscheinlichkeit, dass alle 2 n Personen paarweise verschiedene Geburtstage
haben, kleiner als 1/e.
Das Zufallsexperiment, das wir soeben analysiert haben, entspricht dem Verteilen von m
√
Bällen unabhängig und uniform zufällig auf n Kisten. Wir haben gezeigt, dass ab Θ( n)
Bällen die Wahrscheinlichkeit, eine Kiste mit mindestens zwei Bällen zu erhalten, größer
als 1/2 ist.
3.2.1
Anwendung: Bucketsort
Bevor wir das Zufallsexperiment, in dem wir m Bälle zufällig in n Kisten verteilen, genauer
analysieren, betrachten wir als Anwendung den Sortieralgorithmus Bucketsort. Dabei handelt es sich um ein Sortierverfahren für Zahlen, das nicht vergleichsbasiert ist und deshalb
in bestimmten Situationen die untere Schranke von Ω(n log n) für das vergleichsbasierte Sortieren von n Elementen schlagen kann.
Angenommen, wir möchten n = 2m Zahlen sortieren, die alle unabhängig uniform zufällig
aus der Menge {0, 1, 2, . . . , 2k − 1} für ein k ≥ m gewählt werden. Bucketsort arbeitet in zwei
Phasen. In der ersten Phase werden die Zahlen in 2m viele Klassen gemäß ihrer ersten m
Bits eingeteilt. Das bedeutet, zwei Zahlen gehören zu derselben Klasse, wenn sie in den ersten m Bits (den m höchstwertigen Bits) übereinstimmen. Durch diese Klasseneinteilung ist
gewährleistet, dass es eine eindeutige Sortierung auf den Klassen gibt. Für eine geeignete
Nummerierung der Klassen gilt also, dass alle Zahlen in der ersten Klasse kleiner sind als
alle Zahlen in der zweiten Klasse und so weiter. In der zweiten Phase werden die Zahlen
innerhalb jeder Klasse mit einem beliebigen quadratischen Sortieralgorithmus wie zum Beispiel Insertionsort sortiert und anschließend werden die Klassen in der richtigen Reihenfolge
aneinander gehängt, sodass sich insgesamt eine sortierte Folge ergibt.
Die Klasseneinteilung ebenso wie das Aneinanderhängen der Klassen benötigen eine Laufzeit
von O(n). Die interessante Frage ist also, wie viel Zeit für das Sortieren der Zahlen innerhalb
einer Klasse benötigt wird. Im Durchschnitt enthält jede Klasse genau eine Zahl. Selbst
wenn jede Liste maximal eine konstante Anzahl an Zahlen enthält, benötigt das Sortieren
aller Listen eine Laufzeit von O(n). Da die Zahlen, die zu sortieren sind, aber uniform zufällig
gewählt werden, können wir nicht garantieren, dass jede Klasse nur eine konstante Anzahl an
Zahlen enthält. Für i ∈ {1, . . . , n} bezeichnen wir mit Xi die Zufallsvariable, die angibt, wie
viele Zahlen in Klasse i enthalten sind. Da jede Zahl eine Wahrscheinlichkeit von 2−m = 1/n
besitzt, in eine bestimmte Klasse zu fallen, ist jedes Xi binomialverteilt mit den Parametern n
und 1/n. Wir können die erwartete Laufzeit für das Sortieren der Klassen für eine geeignete
Konstante c durch
n
n
E
X
i=1
cXi2 = c
X
E(Xi2 ) = cnE(X12 )
i=1
nach oben abschätzen, wobei wir im letzten Schritt ausgenutzt haben, dass die Erwartungswerte aller Xi2 aus Symmetriegründen übereinstimmen.
Wir haben die Analyse von Bucketsort also auf die Bestimmung des Erwartungswertes
von E(X 2 ) zurückgeführt, wobei X binomialverteilt mit den Parametern n und p ist. Der
Erwartungswert von X beträgt np, aber an dieser Stelle sei der Leser noch einmal explizit gewarnt, dass das nicht bedeutet, dass der Erwartungswert E(X 2 ) gleich (np)2 ist. Im
Allgemeinen kann es sogar sein, dass der Erwartungswert E(X 2 ) gar nicht existiert. Für
binomialverteilte Zufallsvariablen ist dies aber nicht der Fall und es gilt
E(X 2 ) = n(n − 1)p2 + np.
3.2. Randomisierte Lastverteilung
65
Da wir bereits wissen, dass Var(X) = n(p−p2 ) gilt, folgt dies einfach mit folgender Rechnung
E(X 2 ) = E(X)2 + Var(X) = (np)2 + n(p − p2 ) = n(n − 1)p2 + np.
Insgesamt folgt damit, dass die erwartete Laufzeit für das Sortieren der Klassen durch
2
cnE(X12 ) = cn n(n − 1)
1
n
1
n
+n
< 2cn
nach oben beschränkt ist. Somit ist die erwartete Laufzeit von Bucketsort insgesamt linear
in der Anzahl der zu sortierenden Zahlen.
3.2.2
Auslastung der vollsten Kiste
Wir betrachten nun das Experiment mit m Bällen, die uniform auf n Kisten verteilt werden, genauer. Wir betrachten den Spezialfall n = m und interessieren uns insbesondere für
die Frage, wie groß die maximale Anzahl an Bällen in der vollsten Kiste ist. Mit Hilfe der
Linearität des Erwartungswertes sieht man leicht ein, dass jede Kiste im Erwartungswert
genau einen Ball enthält. Sei Xi die Zufallsvariable, die für i ∈ {1, . . . , m} angibt, wie viele
Bälle sich in Kiste i befinden. Dann gilt dementsprechend maxi E(Xi ) = 1. Uns interessiert
aber wie groß E(X) für X = maxi Xi ist. Wir werden sehen, dass dieser Erwartungswert
signifikant größer ist (siehe (3.5)). Dies zeigt insbesondere, dass man bei einem Maximum
im Gegensatz zu einer Summe nicht einfach die Reihenfolge mit der Bildung eines Erwartungswertes vertauschen darf.
Theorem 3.9. Für hinreichend große n gilt
3 ln n
Pr X >
ln ln n
≤
1
.
n
Beweis. Wir fixieren zunächst eine beliebige Kiste. Da alle Kisten symmetrisch sind, können
wir ohne Beschränkung der Allgemeinheit die erste betrachten. Die Wahrscheinlichkeit, dass
diese mindestens M Bälle enthält, können wir mit einer Chernoff-Schranke abschätzen, wenn
wir ausnutzen, dass E(X1 ) = 1 gilt. Für δ = M − 1 ergibt Theorem 3.4 a)
eδ
eM −1
Pr(X1 ≥ M ) = Pr(X1 ≥ (1 + δ) · E(X1 )) ≤
=
≤
(1 + δ)1+δ
MM
e
M
!M
.
Setzen wir nun M = 3 ln n/(ln ln n) ein und bilden eine Union Bound über alle n Kisten, so
ist die Wahrscheinlichkeit, dass eine Kiste mehr als M Bälle enthält, durch folgenden Term
nach oben beschränkt:
n
e
M
M
=n
e ln ln n
3 ln n
3 ln n/(ln ln n)
<n
ln ln n
ln n
3 ln n/(ln ln n)
= eln n (eln ln ln n−ln ln n )3 ln n/(ln ln n)
= e−2 ln n+3(ln n)(ln ln ln n)/(ln ln n)
1
≤ .
n
In der letzten Abschätzung haben wir ausgenutzt, dass für hinreichend große n der zweite
Summand im Exponenten kleiner als ln n ist.
66
3. Chernoff-Schranken und randomisierte Lastverteilung
Aus Theorem 3.9 folgt insbesondere, dass der Erwartungswert der Anzahl Bälle in der vollsten
3 ln n
Kiste durch ln
ln n + 1 nach oben beschränkt ist. Um dies zu zeigen, definieren wir eine
Zufallsvariable Y mit
(
3 ln n
3 ln n
falls X ≤ ln
ln n ,
Y = ln ln n
n
sonst.
Da X durch n nach oben beschränkt ist, gilt stets X ≤ Y und damit auch E(X) ≤ E(Y ).
Den Erwartungswert von Y können wir mit Hilfe von Theorem 3.9 durch
3 ln n
3 ln n
3 ln n
+ n · Pr X >
· Pr X ≤
ln ln n
ln ln n
ln ln n
3 ln n
1
3 ln n
≤
+n· =
+1
ln ln n
n
ln ln n
E(Y ) =
nach oben beschränken.
Der Faktor 3 in Theorem 3.9 kann durch eine bessere Analyse eliminiert werden. Tatsächlich
kann gezeigt werden, dass
E(X) = Γ−1 (n) −
3
ln n
+ o(1) = (1 + o(1)) ·
2
ln ln n
(3.5)
gilt.
Als kurze Anwendung von Theorem 3.9 betrachten wir noch einmal Hashing mit verketteten
Listen. Wir gehen davon aus, dass wir eine Hashtabelle der Größe n vorliegen haben, in die n
Schlüssel eingefügt werden. Wir haben in Theorem 1.16 gezeigt, dass die erwartete Laufzeit
einer Suche nach einem Schlüssel, der in der Hashtabelle vorhanden ist, im Durchschnitt
über alle vorhandenen Schlüssel Θ(1 + α) beträgt, wobei der Belegungsfaktor α in unserer
Anwendung genau Eins ist. Was ist aber, wenn wir nicht den Durchschnitt über alle Schlüssel
bilden, sondern an der erwarteten Laufzeit für den schlechtesten
Schlüssel interessiert sind?
ln n
Gleichung (3.5) besagt, dass diese Laufzeit Θ ln ln n beträgt.
3.2.3
Anwendung: Verwaltung einer Menge
Wir möchten eine Datenstruktur entwerfen, die mit möglichst geringem Speicherplatzbedarf
eine Menge S = {s1 , . . . , sm } von Elementen eines Universums U verwaltet. Dabei soll die
Datenstruktur für beliebige t ∈ U feststellen können, ob t zu der Menge S gehört oder nicht.
Die einfachste Möglichkeit, dies zu realisieren, ist die Elemente aus S abzuspeichern und
mit t zu vergleichen. Ist eine Ordnung auf dem Universum U gegeben, so kann man dieses
Verfahren beschleunigen, indem man die Menge S sortiert speichert und eine binäre Suche
nach t anwendet. Das Hauptproblem dieses Ansatzes ist aber der relativ hohe Speicherplatzbedarf. Wir sind stattdessen auf der Suche nach einer Lösung, die mit wenig Speicherplatz
auskommt, und erlauben dafür, dass mit einer kleinen Wahrscheinlichkeit falsche Ausgaben
produziert werden dürfen.
Um Speicherplatz zu sparen, definieren wir für ein b ∈ N eine Hashfunktion h : U →
{0, 1, . . . , 2b −1}, die jedes Element des Universums auf eine Zahl abbildet, die mit b Bits dargestellt werden kann. Anstatt nun die Elemente aus S selbst zu kodieren und abzuspeichern,
speichern wir nur ihre Hashwerte h(s1 ), . . . , h(sm ) in sortierter Reihenfolge und führen eine
binäre Suche nach dem Hashwert h(t) des Elementes t durch. Ist dieser nicht gespeichert, so
können wir sicher sein, dass t nicht zu der Menge S gehört. Ansonsten geben wir aus, dass t
3.2. Randomisierte Lastverteilung
67
zu S gehört, was aber mit einer gewissen Wahrscheinlichkeit falsch sein kann. Wir sagen
dann, dass t falsch positiv ist.
Wir treffen wie üblich die Annahme des uniformen Hashings, d. h. wir gehen davon aus, dass
die Funktion h jedes Element aus S unabhängig und uniform zufällig auf einen Hashwert
aus {0, 1, . . . , 2b − 1} abbildet. Dann können wir für jedes beliebige t ∈
/ S die Wahrscheinlichkeit, dass t falsch positiv ist, wie folgt beschränken:
Pr(t ist falsch positiv) = Pr(∃s ∈ S : h(s) = h(t))
= 1 − Pr(∀s ∈ S : h(s) 6= h(t))
=1−
Y
Pr(h(s) 6= h(t))
s∈S
1
=1− 1− b
2
=1−
≥1−e
m
1
1− b
2
− mb
2
2b ! 2mb
.
Wir haben in der Abschätzung in der letzten Zeile ausgenutzt, dass (1 − 1/x)x < 1/e für
alle x > 1 gilt. In der dritten Zeile haben wir ausgenutzt, dass die Ereignisse h(s) = h(t) für
verschiedene s ∈ S unabhängig sind.
Damit die Wahrscheinlichkeit, dass t falsch positiv ist, überhaupt kleiner als eine Konstan−m
te c ∈ (0, 1) sein kann, muss 1 − e 2b ≤ c gelten. Eine kurze Rechnung zeigt, dass dies
äquivalent zu
!
m
b ≥ log2
1
ln 1−c
ist. Wir benötigen also Ω(log(m)) Bits pro Element aus S, um eine konstante Fehlerwahrscheinlichkeit zu erreichen. Andererseits sieht man leicht, dass b = 2 log2 (m) Bits genügen,
denn
1 m
2b
1 m
=1− 1− 2
m
Pr(t ist falsch positiv) = 1 − 1 −
≤1−
1
2e
1/m
→ 0.
Bei der Abschätzung in der letzten Zeile haben wir ausgenutzt, dass (1 − 1/x)x > 1/(2e) für
alle x ≥ 2 gilt.
Wir können also insgesamt festhalten, dass man bei diesem Ansatz Θ(log(m)) Bits pro Element aus S benötigt, um eine konstante Fehlerwahrscheinlichkeit zu erreichen. Im folgenden
Abschnitt werden wir sehen, wie man den Speicherplatzbedarf noch deutlich verbessern kann.
3.2.4
Bloom-Filter
Bei Bloom-Filtern handelt es sich um eine Datenstruktur zur Verwaltung einer Menge, die
bereits mit konstant vielen Bits pro Element aus S eine konstante Fehlerwahrscheinlichkeit
68
3. Chernoff-Schranken und randomisierte Lastverteilung
erreicht. Dazu wird ein Feld mit n Bits A[0], . . . , A[n−1] verwaltet und es werden k Hashfunktionen h1 : U → {0, . . . , n − 1}, . . . , hk : U → {0, . . . , n − 1} benutzt. Für jedes Element s ∈ S
setzen wir die Bits A[h1 (s)], . . . , A[hk (s)] auf Eins. Ist eines dieser Bits bereits durch das
Einfügen eines anderen Elements auf Eins gesetzt, so lassen wir es auf Eins. Nachdem alle
Elemente aus S eingefügt wurden, gilt also für jedes j ∈ {0, . . . , n − 1}
A[j] = 1 ⇐⇒ ∃s ∈ S ∃i : hi (s) = j.
Erhalten wir nun ein Objekt t ∈ U , dann testen wir, ob für alle Hashfunktionen hi (t) = 1
gilt. Im positiven Fall geben wir aus, dass t zu S gehört. Ansonsten geben wir aus, dass t
nicht zu S gehört. Genauso wie bei der Datenstruktur aus dem vorangegangenen Abschnitt
sind bei Bloom-Filtern falsch positive Ergebnisse möglich, wohingegen im Falle t ∈ S stets
das korrekte Ergebnis ausgegeben wird.
Die folgende Abbildung zeigt ein Beispiel eines Bloom-Filters mit drei Hashfunktionen und
zwei Elementen s1 und s2 in S. Während das Element t ∈
/ S als solches erkannt wird, ist t0
falsch positiv.
s1
s2
0110011100
t
t0
Auch für einen Bloom-Filter wollen wir die Wahrscheinlichkeit beschränken, dass ein bestimmtes t ∈
/ S falsch positiv ist. Wir treffen dazu wieder die Annahme des uniformen
Hashings, dass jedes Element aus U von jeder Hashfunktion unabhängig von den anderen
Hashfunktionen und den anderen Elementen aus U auf eine uniform zufällige Position abgebildet wird. Wir betrachten zunächst die Wahrscheinlichkeit, dass ein bestimmtes Bit A[j]
den Wert Null hat. Es gilt
1
Pr(A[j] = 0) = Pr(∀s ∈ S ∀i : hi (s) 6= j) = 1 −
n
km
≈ e−
km
n
=: p.
km
Das bedeutet, dass im Erwartungswert genau n 1 − n1
Bits nach dem Einfügen der Menge S den Wert Null haben. Um die Argumentation im Folgenden zu vereinfachen, gehen
km
wir zunächst davon aus, dass exakt n 1 − n1
Bits den Wert Null haben. Unter dieser
vereinfachenden Annahme, können wir die Wahrscheinlichkeit, dass t ∈
/ S falsch positiv ist,
durch
1 km k
Pr(t ist falsch positiv) = 1 − 1 −
≈ (1 − p)k =: f (k)
n
ausdrücken. Wir vereinfachen die Rechnungen noch weiter, indem wir mit den Näherungswerten p und f (k) statt mit den exakten Werten rechnen.
Die Frage, die es zu beantworten gilt, ist, wie viele Hashfunktionen wir für gegebene Parameter n und m wählen sollten, damit die Wahrscheinlichkeit f (k) so klein wie möglich wird.
Es gibt dabei zwei gegenläufige Tendenzen. Je mehr Hashfunktionen wir wählen, desto mehr
Bits sind nach dem Einfügen von S auf Eins gesetzt. Dadurch kann sich die Wahrscheinlichkeit, dass für t ∈
/ S eines der Bits A[hi (t)] gleich Null ist, verringern. Auf der anderen Seite
testen wir aber auch mehr Positionen, wenn wir mehr Hashfunktionen wählen, wodurch sich
3.2. Randomisierte Lastverteilung
69
die Wahrscheinlichkeit, dass eines der A[hi (t)] gleich Null ist, erhöhen kann. Wir müssen
nun den richtigen Kompromiss für die Anzahl k an Hashfunktionen finden. Eine elementan
re Kurvendiskussion zeigt, dass die Funktion f (k) für k = ln(2) · m
ein globales Minimum
annimmt. Für dieses k gilt
n
Pr(t ist falsch positiv) ≈ f ln(2) ·
m
n
ln(2)· m
=
1
2
n
≈ (0.6185) m .
n
Der Quotient m
ist die durchschnittliche Anzahl an Bits, die wir pro Element aus S speichern.
Unsere Überlegungen zeigen, dass die Wahrscheinlichkeit eines falsch positiven Ergebnisses
exponentiell mit dieser Anzahl an Bits fällt. Sind wir also an einer konstanten Fehlerwahrscheinlichkeit interessiert, so genügt es, pro Element aus S eine konstante Anzahl an Bits zu
speichern. Ist man beispielsweise an einer Fehlerwahrscheinlichkeit von unter einem Prozent
interessiert, so genügt es, 10 Bits pro Element aus S zu wählen. Dies ist eine deutliche Verbesserung gegenüber der Lösung mit einer Hashfunktion, bei der Θ(log(m)) Bits notwendig
sind.
Eine interessante Beobachtung, die wir noch kurz festhalten wollen, ist, dass bei der optimakm
n
len Wahl k = ln(2) · m
für die Anzahl an Hashfunktionen, die Wahrscheinlichkeit p = e− n
genau den Wert 1/2 annimmt. Das bedeutet, dass in einem Bloom-Filter mit einer optimalen
Anzahl an Hashfunktionen jedes Bit nahezu uniform zufällig 0 oder 1 ist.
km
Zum Schluss kommen wir auf unsere Annahme zurück, dass genau n 1 − n1
Bits den
Wert Null haben. Es sind zwar im Erwartungswert genau so viele Bits gleich Null, aber
typischerweise wird die exakte Anzahl von ihrem Erwartungswert zumindest ein wenig abweichen. Man kann zeigen, dass große Abweichungen vom Erwartungswert unwahrscheinlich
sind. Dafür genügt es aber nicht, einfach nur Chernoff-Schranken anzuwenden, da die Bits
abhängig voneinander sind. Wissen wir beispielsweise bereits, dass ein Bit den Wert Null
annimmt, so erhöht das die Wahrscheinlichkeit, dass andere Bits den Wert Eins haben. Man
kann trotz dieser Abhängigkeiten zeigen, dass große Abweichungen vom Erwartungswert sehr
unwahrscheinlich sind. Diese relativ technische Analyse, die in Kapitel 5 von [5] zu finden
ist, werden wir hier jedoch nicht präsentieren. Hat man gezeigt, dass große Abweichungen
vom Erwartungswert sehr unwahrscheinlich sind, so kann man die obige Analyse leicht so
anpassen, dass sie ohne die vereinfachende Annahme auskommt.
3.2.5
The Power of Two Choices
Wir wollen in diesem Abschnitt noch kurz diskutieren, wie randomisierte Lastverteilung verbessert werden kann. Wieder betrachten wir den Fall, dass n Bälle auf n Kisten verteilt werden sollen, und uns interessiert die erwartete Auslastung der vollsten Kiste. In Abschnitt 3.2.2
haben wir gesehen, dass diese (1 + o(1)) · lnlnlnnn beträgt, wenn jeder Ball uniform zufällig eine
Kiste wählt, in die er gelegt wird. Natürlich können wir durch eine zentrale Koordination
erreichen, dass jede Kiste nur genau einen Ball enthält, wir sind aber auf der Suche nach
einem dezentralen randomisierten Prozess, der einfach lokal von jedem Ball ohne globales
Wissen ausgeführt werden kann.
Eine naheliegende Idee, den randomisierten Prozess zu verbessern, sieht wie folgt aus. Die
Bälle werden nach und nach in die Kisten eingefügt. Anstatt eine Kiste uniform zufällig zu
wählen, wählt jeder Ball unabhängig und uniform zufällig d ≥ 2 Kisten aus. Er wird dann
der Kiste von den d ausgewählten zugewiesen, die momentan die kleinste Anzahl an Bällen
enthält. Bei Gleichstand kann eine beliebige Kiste mit der momentan kleinsten Anzahl an
Bällen gewählt werden. Das folgende Theorem wird in Kapitel 14 von [5] bewiesen.
70
3. Chernoff-Schranken und randomisierte Lastverteilung
Theorem 3.10. Die erwartete Auslastung der vollsten Kiste beträgt in dem oben beschriebenen Zufallsexperiment für d ≥ 2
ln ln n
+ O(1).
ln d
Selbst für d = 2 ist somit der erwartete Füllstand der vollsten Kiste um einen exponentiellen
Faktor kleiner als bei dem einfachen Prozess, in dem jeder Ball nur eine Kiste wählt. Mehr
als zwei Kisten zu wählen, bringt hingegen nur noch eine relativ kleine Verbesserung.
Diesen Prozess der randomisierten Lastverteilung kann man beispielsweise zur Verbesserung
von Hashing einsetzen. Wir haben in Abschnitt 3.2.2 argumentiert, dass die erwartete Laufzeit für die Suche nach dem schlechtesten Schlüssel Θ( lnlnlnnn ) beträgt, wenn wir n Schlüssel
in eine Hashtabelle mit n Positionen einfügen. Haben wir zwei unabhängige Hashfunktionen,
die jedes Element auf zwei Positionen in der Hashtabelle abbilden, und fügen wir jedes Element in die momentan kürzere Liste ein, so besagt Theorem 3.10, dass die erwartete Laufzeit,
um nach dem schlechtesten Schlüssel zu suchen, nur Θ(ln ln n) beträgt. Bei der Suche nach
einem Element müssen dann beide in Frage kommenden Listen durchsucht werden.
Kapitel 4
Markow-Ketten und Random
Walks
In diesem Kapitel werden wir mit Markow-Ketten ein wichtiges Hilfsmittel zum Entwurf
und zur Analyse von randomisierten Algorithmen kennenlernen, das wir insbesondere auf
2-SAT und 3-SAT anwenden werden. Anschließend werden mit Random Walks spezielle
Markow-Ketten betrachten, die durch ungerichtete Graphen beschrieben werden, und ihre
algorithmischen Anwendungen diskutieren.
Die Inhalte dieses Kapitels sind stark an Kapitel 7 von [5] und Kapitel 6 von [6] angelehnt.
4.1
Markow-Ketten
Sprechen wir in dieser Vorlesung von einem stochastischen Prozess, so ist damit eine Familie
von Zufallsvariablen Xt für t ∈ N0 gemeint. Wir betrachten in dieser Vorlesung ausschließlich
diskrete stochastische Prozesse, bei denen jede Zufallsvariable Xt Werte aus einer abzählbaren Menge annehmen kann. Ohne Beschränkung der Allgemeinheit gehen wir davon aus,
dass jedes Xt nur Werte aus N0 annimmt. Wir werden den Wert von Xt auch als den Zustand
zum Zeitpunkt t bezeichnen. Im Allgemeinen können die Werte der Zufallsvariablen beliebig
voneinander abhängen. Uns interessieren aber besonders Prozesse, bei denen die Verteilung
von Xt nur vom unmittelbar vorangegangenen Zustand Xt−1 beeinflusst wird, nicht aber
von weiter zurückliegenden Zuständen. Diese Eigenschaft, die auch als Gedächtnislosigkeit
bezeichnet wird, ist in der folgenden Definition formalisiert.
Definition 4.1. Ein diskreter stochastischer Prozess heißt Markow-Kette, wenn für alle
Zeitpunkte t ∈ N0 und für alle a0 , . . . , at ∈ N0
Pr(Xt = at | X0 = a0 , . . . , Xt−1 = at−1 ) = Pr(Xt = at | Xt−1 = at−1 ).
gilt. Eine Markow-Kette heißt homogen, wenn es für jedes Zustandspaar i, j ∈ N0 ein pi,j ∈
[0, 1] gibt, sodass für alle t ≥ 1
Pr(Xt = j | Xt−1 = i) = pi,j
gilt. In einer homogenen Markow-Kette hängen die Übergangswahrscheinlichkeiten also nicht
vom Zeitpunkt ab.
71
72
4. Markow-Ketten und Random Walks
Wir werden in dieser Vorlesung ausschließlich homogene Markow-Ketten betrachten und
dies im Folgenden nicht immer explizit erwähnen. Wir können jede homogene Markow-Kette
durch ihre Übergangsmatrix P beschreiben. Dies ist im Allgemeinen eine unendliche Matrix,
deren Zeilen und Spalten jeweils mit den Elementen aus N0 indiziert sind, und die in der Zelle
in Zeile i und Spalte j den Wert pi,j enthält. Andersherum beschreibt jede solche Matrix mit
P
Einträgen aus [0, 1] eine Markow-Kette, wenn j∈N0 pi,j = 1 für jede Zeile i ∈ N0 gilt.
Gibt man eine Wahrscheinlichkeitsverteilung auf den Zuständen zum Zeitpunkt 0 vor, so
kann man mit Hilfe der Matrix P für jedes t ∈ N0 die Wahrscheinlichkeitsverteilung zum
Zeitpunkt t berechnen. Für t ∈ N0 sei p(t) = (p0 (t), p1 (t), p2 (t), . . .) mit pi (t) = Pr(Xt = i)
die Wahrscheinlichkeitsverteilung zum Zeitpunkt t. Kennen wir die Verteilung p(t) zu einem
Zeitpunkt t, so gilt
X
pj (t + 1) =
pi (t) · pi,j
(4.1)
i∈N0
für jedes j ∈ N0 . Diese Gleichung folgt, da für das Ereignis Xt+1 = j, nur der unmittelbar
vorangegangene Zustand relevant ist. Wir summieren über alle möglichen Zustände und
betrachten jeweils die Wahrscheinlichkeit, dass sich die Markow-Kette zum Zeitpunkt t in
Zustand i befindet und von dort in einem Schritt in Zustand j wechselt. Formal handelt es sich
um eine Anwendung der Formel der totalen Wahrscheinlichkeit. Wenn wir die Vektoren p(t)
und p(t + 1) als Zeilenvektoren betrachten, so folgt aus (4.1) direkt
p(t + 1) = p(t)P.
(4.2)
Mit Hilfe von (4.2) kann man auch für jedes Zustandspaar i, j ∈ N0 und jedes m ∈ N
(m)
die Wahrscheinlichkeit pi,j ausrechnen, in genau m Schritten von Zustand i in Zustand j
überzugehen. Ähnlich wie bei (4.1) argumentiert man zunächst, dass
(m)
pi,j =
X (m−1)
pi,k
· pk,j
(4.3)
k∈N0
gilt. Dabei haben wir über alle Zustände k summiert, die nach genau m − 1 Schritten von i
(m)
ausgehend erreicht werden können. Fasst man die Wahrscheinlichkeiten pi,j wieder in einer
Matrix P (m) zusammen, so folgt mit (4.3) leicht, dass P (m) = P · P (m−1) gilt. Daraus folgt
induktiv, dass P (m) = P m für jedes m ∈ N gilt.
Man kann sich Markow-Ketten auch als gerichtete Graphen vorstellen. Zu einer MarkowKette mit Übergangsmatrix P definieren wir einen gerichteten Graphen G = (V, E, w) mit
Gewichten w : E → [0, 1]. Dieser Graph enthält einen Knoten für jeden möglichen Zustand
der Markow-Kette, das heißt, es gilt im Allgemeinen V = N0 . Kann man in einer MarkowKette für eine gegebene Verteilung p(0) nur bestimmte Zustände überhaupt mit positiver
Wahrscheinlichkeit erreichen, dann kann man die Menge V auch auf diese Zustände einschränken. Für zwei Zustände i, j ∈ V gehört (i, j) genau dann zu der Menge der Kanten E,
wenn pi,j > 0 gilt. Das Gewicht w(i, j) dieser Kante entspricht dann der Wahrscheinlichkeit pi,j . Die gerichteten Kanten des Graphen entsprechen also den Übergängen, die mit
positiver Wahrscheinlichkeit erfolgen, und die Gewichte entsprechen den Übergangswahrscheinlichkeiten.
Wir betrachten als Beispiel die folgende Markow-Kette, die links als Graph und rechts als
Übergangsmatrix dargestellt ist.
4.1. Markow-Ketten
73
1
2
0
1
2
1
1
3
1
2
2
3

0
0

P =
0
0
1
2
3
1
2
1/2
1/2
0
0
1/2
1/3
0
0

0
2/3


1
1/2
Um in dieser Markow-Kette beispielsweise die Wahrscheinlichkeit zu bestimmen, dass man
sich startend in Zustand 0 nach genau 3 Schritten in Zustand 3 befindet, gibt es zwei Möglichkeiten. Wir können im Graphen alle Pfade von Knoten 0 zu Knoten 3 betrachten, die
aus genau drei Kanten bestehen. Dies sind die Pfade (0, 1, 3, 3), (0, 1, 2, 3) und (0, 2, 3, 3).
Die Wahrscheinlichkeit, dass die Zustandsübergänge in der Markow-Kette gemäß eines solchen Pfades erfolgen, entspricht dem Produkt der Übergangswahrscheinlichkeiten. Für die
drei Pfade ergeben sich dementsprechend die Wahrscheinlichkeiten 1/6, 1/12 und 1/4. In
der Summe ergibt dies eine Wahrscheinlichkeit von 7/12. Dies kann auch am der Matrix P 3
abgelesen werden. Es gilt

0
0

P3 = 
0
0
5/12
1/3
1/4
7/24
0
1/9
1/6
1/12

7/12
5/9 

7/12

5/8
(3)
und insbesondere p0,3 = 7/12. Anhand dieser Matrix können wir auch leicht die Wahrscheinlichkeitsverteilung p(3) zum Zeitpunkt 3 berechnen, wenn wir die Wahrscheinlichkeitsverteilung p(0) zum Zeitpunkt 0 kennen. Es gilt nämlich p(3) = p(0)P 3 . Startet man in einem
uniform zufälligen Zustand, so ergibt sich beispielsweise p(3) = (0, 31/96, 13/144, 169/288).
4.1.1
Anwendung: Randomisierter Algorithmus für 2-SAT
Wir wissen bereits, dass das Erfüllbarkeitsproblem SAT im Allgemeinen N P-hart ist. Wir
betrachten nun aber den Spezialfall 2-SAT, bei dem jede Klausel aus genau zwei Literalen
besteht. Eine mögliche Instanz dieses Problems wäre beispielsweise die Formel
(x1 ∨ x3 ) ∧ (x2 ∨ x3 ) ∧ (x1 ∨ x2 ) ∧ (x2 ∨ x3 ),
für die entschieden werden soll, ob es eine Belegung der binären Variablen x1 , . . . , x4 gibt, die
alle Klauseln erfüllt. Wir betrachten einen Algorithmus, der eine lokale Suche durchführt. Er
startet mit einer beliebigen Belegung der Variablen und versucht diese, Schritt für Schritt in
eine erfüllende Belegung umzuwandeln. Dazu wählt er, solange er noch keine erfüllende Belegung erreicht hat, eine beliebige nicht erfüllte Klausel aus. Dann wählt er eines der beiden
Literale dieser Klausel uniform zufällig aus und ändert die Belegung der zu diesem Literal
gehörigen Variable. Wird nach einer gewissen Anzahl an solchen Schritten keine erfüllende
Belegung gefunden, so gibt der Algorithmus aus, dass keine existiert. Diese Ausgabe kann
falsch sein und wir werden im Folgenden mit Hilfe einer Markow-Kette die Fehlerwahrscheinlichkeit analysieren. Zunächst geben wir den beschriebenen Algorithmus aber in Pseudocode
an. Dabei ist φ die Formel, m ∈ N ein Parameter, der beliebig gewählt werden kann, und n
bezeichne die Anzahl an binären Variablen.
74
4. Markow-Ketten und Random Walks
Rand-2-SAT(φ, m)
1. Wähle beliebige Belegung x der Variablen.
2. for i = 1 to 2n2 m do
3.
if x erfüllt nicht alle Klauseln then
4.
Wähle beliebige durch x nicht erfüllte Klausel.
5.
Wähle uniform zufälliges Literal dieser Klausel und ändere in x seine Belegung.
6. return „Ja“, falls x alle Klauseln erfüllt, und „Nein“ sonst.
Ist die Formel φ nicht erfüllbar, so gibt der Algorithmus stets das korrekte Ergebnis zurück.
Für die Analyse der Fehlerwahrscheinlichkeit interessiert uns also nur der Fall, dass die Formel erfüllbar ist. Es sei S eine beliebige erfüllende Belegung von φ und Ai sei die Belegung
der Variablen, die nach dem i-ten Durchlauf der for-Schleife erreicht wird. Dabei sei A0 die
initiale Belegung, die im ersten Schritt des Algorithmus gewählt wird. Wir definieren nun
Zufallsvariablen X0 , X1 , . . . , X2n2 m , wobei Xi angibt, in wie vielen Variablen die Belegungen S und Ai übereinstimmen. Nimmt eine von diesen Zufallsvariablen Xi den Wert n an,
so hat der Algorithmus die erfüllende Belegung S gefunden und gibt am Ende das korrekte
Ergebnis aus. Nimmt keine der Variablen Xi den Wert n an, so gibt der Algorithmus nicht
notwendigerweise das falsche Ergebnis aus, da er eine andere erfüllende Belegung gefunden
haben kann, die von S verschieden ist.
Die Zufallsvariablen X0 , X1 , . . . , X2n2 m beschreiben einen stochastischen Prozess. Da wir in
jedem Durchlauf der for-Schleife den Wert genau einer Variable ändern, folgt, dass stets
Xi+1 ∈ {Xi − 1, Xi + 1} gilt. Wir argumentieren zunächst, dass die Wahrscheinlichkeit,
dass Xi+1 um eins größer ist als Xi , immer mindestens so groß ist wie die Wahrscheinlichkeit,
dass es um eins kleiner ist. Zunächst ist klar, dass für jedes i
Pr(Xi+1 = 1 | Xi = 0) = 1
gilt, denn wenn die aktuelle Belegung in keiner Variable mit S übereinstimmt, so wird die
nächste Belegung stets genau in der Variable mit S übereinstimmen, deren Belegung geändert
wurde. Außerdem gilt für jedes i
Pr(Xi+1 = n | Xi = n) = 1,
da eine erfüllende Belegung nicht mehr geändert wird. Für j ∈ {1, . . . , n − 1} gilt außerdem
Pr(Xi+1 = j + 1 | Xi = j) ≥
1
2
und
1
Pr(Xi+1 = j − 1 | Xi = j) ≤ .
2
Der Grund hierfür ist, dass der Algorithmus eine beliebige nicht erfüllte Klausel und daraus
ein uniform zufälliges Literal wählt. Da die Klausel nicht erfüllt ist, ist mindestens eins der
beiden Literale anders als in S belegt. Die Wahrscheinlichkeit, dieses auszuwählen und seine
Belegung zu ändern, beträgt genau 1/2. Es kann sogar sein, dass beide Literale anders belegt
sind als in S. Dann ist die Wahrscheinlichkeit sogar 1, dass der Abstand zur Belegung S
verringert wird.
Der stochastische Prozess, der durch X0 , X1 , . . . , X2n2 m beschrieben wird, ist aber keine
Markow-Kette, denn ob in der ausgewählten Klausel nur ein Literal nicht mit S übereinstimmt oder beide, hängt von der Vergangenheit ab. Wir schätzen diesen Prozess jedoch
durch eine Markow-Kette Y0 , Y1 , Y2 , . . . ab, für die
Pr(Yi+1 = 1 | Yi = 0) = 1
und
Pr(Yi+1 = n | Yi = n) = 1
4.1. Markow-Ketten
75
und für j ∈ {1, . . . , n − 1}
1
1
und Pr(Yi+1 = j − 1 | Yi = j) = .
2
2
gelten. Der zu dieser Markow-Kette gehörige Graph ist in folgender Abbildung dargestellt.
Pr(Yi+1 = j + 1 | Yi = j) =
1
2
1
0
1
2
1
1
2
1
2
2
1
2
1
2
3
1
2
...
1
2
1
2
1
2
n−1
n
1
Intuitiv ist diese Markow-Kette eine pessimistische Abschätzung für den stochastischen Prozess X0 , X1 , X2 , . . .. Insbesondere sollte sie, wenn sie mit dem gleichen Wert initialisiert wird,
nicht schneller den Zustand n erreichen als der Prozess X0 , X1 , X2 , . . .. Um für diese Aussage, die dem Leser intuitiv hoffentlich einleuchtet, einen formalen Beweis zu geben, gibt es
Methoden, die wir in dieser Vorlesung aber nicht näher besprechen werden. Wir begnügen
uns hier mit der intuitiven Begründung.
Ein zentraler Bestandteil der Analyse der Fehlerwahrscheinlichkeit ist es, die erwartete Anzahl an Schritten zu bestimmen, die die Markow-Kette benötigt, um von einem beliebigen
Startzustand j ∈ {0, . . . , n} den Zustand n zu erreichen. Wir gehen pessimistisch davon
aus, dass wir im Zustand 0 starten. Bevor wir die erwartete Anzahl an Schritten formal
bestimmen, überlegen wir uns zunächst informell, in welcher Größenordnung sie liegt. Dazu
vereinfachen wir zunächst die Markow-Kette dahingehend, dass wir erlauben, dass sie links
über 0 und rechts über n hinauslaufen darf. Das entspricht dann folgendem Zufallsexperiment: Wir starten an Position 0 und werfen k mal eine Münze. Jedes Mal, wenn die Münze
Kopf zeigt, gehen wir einen Schritt nach rechts, jedes Mal, wenn die Münze Zahl zeigt, gehen
wir einen Schritt nach links. Wir erreichen die Position n oder eine rechts davon genau dann,
wenn es einen Präfix der k Münzwürfe gibt, in dem mindestens n mal häufiger Kopf als Zahl
geworfen wird.
Die Anzahl der Münzen, die Kopf zeigen, in einem Präfix der Länge ` ≤ k ist binomialverteilt mit den Parametern ` und 1/2. Im Erwartungswert enthält jeder Präfix der Länge `
also genau `/2 solcher Münzen. Gibt es einen Präfix, der mindestens `/2 + n/2 viele solcher
Münzen enthält, so erreicht die vereinfachte Markow-Kette den Zustand n. Ist ` = O(n), also
z. B. ` = 10n, so kann man mit einer Chernoff-Schranke leicht zeigen, dass dieses Ereignis
exponentiell unwahrscheinlich ist. Mit einer Union-Bound kann man dann sogar zeigen, dass
es exponentiell unwahrscheinlich ist, dass es einen Präfix gibt, der diese Eigenschaft erfüllt,
wenn k = O(n) gilt. Auf der anderen Seite haben wir in Abschnitt
3.1.2 diskutiert, dass Ab√
weichungen vom Erwartungswert in der Größenordnung Θ( `) bei einem Präfix der Länge `
eine konstante Wahrscheinlichkeit haben. Das bedeutet, dass nach Θ(n2 ) vielen Schritten eine signifikante Wahrscheinlichkeit besteht, Zustand n mindestens einmal zu erreichen. Diese
Intuition weisen wir in dem folgenden Lemma formal nach.
Lemma 4.2. Ist eine 2-SAT-Formel φ erfüllbar, so erreicht die Markow-Kette, die durch
die Zufallsvariablen Y0 , Y1 , . . . beschrieben wird, von jedem Startzustand j ∈ {0, . . . , n} im
Erwartungswert in höchstens n2 vielen Schritten den Zustand n.
Beweis. Wir definieren für jedes j ∈ {0, . . . , n} eine Zufallsvariable Zj , die angibt, wie viele
Schritte die Markow-Kette benötigt, um startend in Zustand j den Zustand n zu erreichen.
Mit hj bezeichnen wir den Erwartungswert von Zj . Es gilt hn = 0 und h0 = h1 + 1, da von
Zustand 0 deterministisch in Zustand 1 gewechselt wird. Für j ∈ {1, . . . , n − 1} gilt
1
1
Xj = (1 + Xj−1 ) + (1 + Xj+1 ),
2
2
76
4. Markow-Ketten und Random Walks
da von j jeweils mit Wahrscheinlichkeit 1/2 in den Zustand j − 1 oder den Zustand j + 1
gewechselt wird. Dementsprechend folgt mit der Linearität des Erwartungswertes
hj−1 hj+1
+
+ 1.
2
2
Nun kann man leicht mit vollständiger Induktion zeigen, dass hj = hj+1 + 2j + 1 für alle j ∈
{0, . . . , n − 1} gilt. Der Induktionsanfang für j = 0 folgt direkt aus der Formel h0 = h1 + 1.
Für j ≥ 1 gilt
hj =
hj−1 hj+1
+
+1
2
2
hj + 2(j − 1) + 1 hj+1
+
+ 1,
=
2
2
wobei wir im zweiten Schritt die Induktionsvoraussetzung ausgenutzt haben. Stellt man diese
Gleichung nach hj um, so erhält man, wie gewünscht
hj =
hj = hj+1 + 3 + 2(j − 1) = hj+1 + 2j + 1.
Damit folgt
h0 = h1 + 1 = h2 + 3 + 1 = . . . =
Außerdem folgt
n2
n−1
X
n−1
X
i=0
i=0
(2i + 1) = n + 2
i = n + n(n − 1) = n2 .
= h0 > h1 > . . . > hn , womit das Lemma bewiesen ist.
Wir können nun zeigen, dass die Fehlerwahrscheinlichkeit von Rand-2-SAT exponentiell klein
in dem Parameter m ist.
Theorem 4.3. Ist die Formel φ erfüllbar, so beträgt die Fehlerwahrscheinlichkeit von Rand2-SAT höchstens 1/2m .
Beweis. Lemma 4.2 besagt, dass der Algorithmus im Erwartungswert spätestens nach dem
n2 -ten Durchlauf der for-Schleife eine erfüllende Belegung findet. Die Wahrscheinlichkeit,
dass er nach dem 2mn2 -ten Durchlauf noch immer keine gefunden hat, lässt sich somit mit
der Markow-Ungleichung durch 1/(2m) nach oben abschätzen.
Um eine exponentiell kleine Wahrscheinlichkeit zu zeigen, wenden wir einen Trick an. Wir
zerlegen die Durchläufe der for-Schleife in m disjunkte Phasen der Länge jeweils 2n2 . Wir
sagen, dass eine Phase erfolgreich ist, wenn Rand-2-SAT während der Phase eine erfüllende
Belegung findet. Die Phasen sind abhängig voneinander, da die letzte Belegung einer Phase
gleichzeitig die initiale Belegung der nächsten Phase ist. Da wir die Aussage in Lemma 4.2
aber für jede mögliche initiale Konfiguration gezeigt haben, können wir die Phasen trotz
dieser Abhängigkeiten analysieren. Da unabhängig von der initialen Konfiguration im Erwartungswert nach höchstens n2 Schritten eine erfüllende Belegung gefunden wird, kann
man mit der Markow-Ungleichung zeigen, dass die Wahrscheinlichkeit, dass eine bestimmte
Phase erfolglos ist, höchstens 1/2 beträgt. Die Wahrscheinlichkeit, dass alle Phasen erfolglos
sind, beträgt somit höchstens 1/2m .
Da Rand-2-SAT stets das korrekte Ergebnis liefert, wenn die Formel φ nicht erfüllbar ist,
haben wir mit Theorem 4.3 gezeigt, dass das Problem 2-SAT zu der Komplexitätsklasse RP
gehört. Tatsächlich kann man sogar zeigen, dass 2-SAT zu P gehört und in Linearzeit gelöst
werden kann. Die Analyse des randomisierten Algorithmus Rand-2-SAT diente hauptsächlich
als Vorbereitung auf den nächsten Abschnitt, in dem wir einen randomisierten Algorithmus
für 3-SAT kennenlernen werden.
4.1. Markow-Ketten
4.1.2
77
Anwendung: Randomisierter Algorithmus für 3-SAT
Wir betrachten nun das Problem 3-SAT, bei dem jede Klausel aus genau drei Literalen besteht. Wir wissen bereits, dass dieses Problem N P-hart ist, und erwarten deshalb nicht,
einen polynomiellen deterministischen oder randomisierten Algorithmus zu finden. Stattdessen werden wir einen randomisierten Algorithmus mit einer Laufzeit von O(n3/2 · ( 43 )n )
kennenlernen, der auf einer Verallgemeinerung des Algorithmus Rand-2-SAT beruht. Diese
Laufzeit ist zwar exponentiell, sie ist aber deutlich besser als die Laufzeit von Ω(2n ) für das
Durchprobieren aller möglichen Belegungen der n Variablen.
Zunächst verallgemeinern wir den Algorithmus Rand-2-SAT kanonisch auf 3-SAT.
Rand-3-SAT(φ, m)
1. Wähle uniform zufällige Belegung x der Variablen.
2. for i = 1 to 2m do
3.
if x erfüllt nicht alle Klauseln then
4.
Wähle beliebige durch x nicht erfüllte Klausel.
5.
Wähle uniform zufälliges Literal dieser Klausel und ändere in x seine Belegung.
6. return „Ja“, falls x alle Klauseln erfüllt, und „Nein“ sonst.
Es gibt nur zwei Unterschiede zu Rand-2-SAT. Zum einen wird im ersten Schritt eine uniform
zufällige Belegung statt einer beliebigen gewählt. Der Grund hierfür ist lediglich, dass wir
Rand-3-SAT später an einer Stelle als Unterroutine einsetzen werden, an der es wichtig
ist, mit einer uniform zufälligen Belegung zu starten. Zum anderen wird in Schritt 5 eines
von drei Literalen der nicht erfüllten Klausel uniform zufällig gewählt und nicht eines von
zwei Literalen wie bei Rand-2-SAT. Dieser vermeintlich kleine Unterschied hat einen großen
Einfluss auf die Wahrscheinlichkeit, eine erfüllende Belegung zu finden.
Genauso wie bei Rand-2-SAT interessiert uns nur der Fall, dass die Formel φ erfüllbar ist, und
wir fixieren eine beliebige erfüllende Belegung S. Sei wieder Ai die Belegung der Variablen, die
nach dem i-ten Durchlauf der for-Schleife angenommen wird, und sei A0 die initiale Belegung,
die im ersten Schritt gewählt wird. Wir definieren wieder für jedes Ai eine Zufallsvariable Xi ,
die angibt, in wie vielen Variablen die Belegungen Ai und S übereinstimmen. Ganz analog
zu der Analyse von Rand-2-SAT erhalten wir
Pr(Xi+1 = 1 | Xi = 0) = 1
und
Pr(Xi+1 = n | Xi = n) = 1.
Für j ∈ {1, . . . , n − 1} erhalten wir nun aber nur
Pr(Xi+1 = j + 1 | Xi = j) ≥
1
3
und
2
Pr(Xi+1 = j − 1 | Xi = j) ≤ ,
3
da in einer nicht erfüllten Klausel nur eines der drei Literale einen anderen Wert als in S
annehmen muss. Es kann durchaus vorkommen, dass zwei Literale genauso belegt sind wie
in S. Dann beträgt die Wahrscheinlichkeit, sich von S zu entfernen, genau 2/3.
Genau wie bei Rand-2-SAT handelt es sich bei dem stochastischen Prozess X0 , X1 , X2 , . . .
nicht um eine Markow-Kette, wir können ihn jedoch pessimistisch durch eine MarkowKette Y0 , Y1 , Y2 , . . . mit
Pr(Yi+1 = 1 | Yi = 0) = 1
und
Pr(Yi+1 = n | Yi = n) = 1
78
4. Markow-Ketten und Random Walks
und für j ∈ {1, . . . , n − 1}
Pr(Yi+1 = j + 1 | Yi = j) =
1
3
und
Pr(Yi+1 = j − 1 | Yi = j) =
2
3
abschätzen. Diese Markow-Kette ist in der folgenden Abbildung dargestellt.
1
3
1
0
2
3
1
1
3
2
3
2
1
3
2
3
3
...
2
3
1
3
1
3
2
3
n−1
n
1
Diese Markow-Kette besitzt eine starke Tendenz nach links zu laufen, weshalb es viel länger
dauert, den Zustand n zu erreichen, als bei der Markow-Kette, die wir zur Analyse von Rand2-SAT betrachtet haben. Startet man beispielsweise bei n/2, so kann man den Zustand n nur
erreichen, wenn es eine Teilsequenz von Schritten gibt, in der die Anzahl an Schritten nach
rechts um n/2 größer ist als die Anzahl an Schritten nach links. Da aber jede Teilsequenz der
Länge ` im Erwartungswert 2`/3 Schritte nach links und nur `/3 Schritte nach rechts enthält,
kann man mit Hilfe einer Chernoff-Schranke leicht zeigen, dass man mindestens exponentiell viele Schritt benötigt, um mit einer signifikanten Wahrscheinlichkeit den Zustand n zu
erreichen. In dem folgenden Lemma geben wir die erwartete Anzahl an Schritten genauer
an.
Lemma 4.4. Ist eine 3-SAT-Formel φ erfüllbar, so erreicht die Markow-Kette, die durch
die Zufallsvariablen Y0 , Y1 , . . . beschrieben wird, von Startzustand j ∈ {0, . . . , n} im Erwartungswert in genau 2n+2 − 2j+2 − 3(n − j) vielen Schritten den Zustand n.
Dieses Lemma folgt mit genau denselben Argumenten wie Lemma 4.2, weshalb wir hier
auf seinen Beweis verzichten. Da durch die zufällige Wahl der initialen Belegung der Wert
von Y0 mit hoher Wahrscheinlichkeit in der Nähe von n/2 liegt, interessiert uns besonders die
erwartete Anzahl an Schritten, um von Zustand n/2 den Zustand n zu erreichen. Diese liegt
in der Größenordnung Θ(2n ). Deshalb müssen wir m = Θ(2n ) wählen, um eine konstante
Erfolgswahrscheinlichkeit zu erreichen. Mit dieser Wahl von m ist der Algorithmus Rand3-SAT aber nicht schneller, als deterministisch alle möglichen Belegungen der Variablen
auszuprobieren.
Wir verbessern den Algorithmus, indem wir alle 3n viele Schritten mit einer neuen uniform
zufälligen Belegung der Variablen starten, anstatt mit der aktuell erreichten Belegung weiter
zu machen. Wir erhalten dann den folgenden modifizierten Algorithmus.
Improved-3-SAT(φ, m)
1. for i = 1 to m do
2.
if Rand-3-SAT(φ, 3n) = „Ja“ then return „Ja“;
3. return „Nein“;
Die häufigen Neuinitialisierungen haben zwei positive Effekte auf die Erfolgswahrscheinlichkeit. Nach einer zufälligen Initialisierung befindet sich die Markow-Kette in der Nähe des
Zustands n/2. Von diesem Zustand aus kann der Zustand n schneller erreicht werden als von
einem Zustand, der sehr weit links liegt. Ist der Zustand n nach 3n Schritten noch immer
nicht erreicht worden, so besteht eine hohe Wahrscheinlichkeit, dass die Markow-Kette vom
Startzustand zu einem Zustand weiter links gelaufen ist. Durch die Neuinitialisierung setzen wir den Prozess neu in der Nähe von n/2 an, ohne darauf warten zu müssen, dass die
Markow-Kette von selbst wieder in die Mitte läuft. Ein anderer positiver Effekt ist, dass bei
4.1. Markow-Ketten
79
den häufigen Neuinitialisierungen die Chance besteht, signifikant rechts von n/2 zu starten.
Dies ist gemäß der Chernoff-Schranke zwar sehr unwahrscheinlich, aber da wir m exponentiell groß wählen werden, besteht durchaus die Chance, dass eine der Initialisierung weit rechts
von n/2 liegt.
Zur formalen Analyse des Algorithmus modifizieren wir die Markow-Kette Y0 , Y1 , Y2 , . . . zunächst so, dass sie links über den Zustand 0 und rechts über den Zustand n hinauslaufen
darf. Konkret betrachten wir eine Markow-Kette Y00 , Y10 , Y20 , . . ., bei der Y00 = X0 und für
alle j ∈ Z
0
Pr(Yi+1
= j + 1 | Yi0 = j) =
1
3
0
Pr(Yi+1
= j − 1 | Yi0 = j) =
und
2
3
gilt. Diese Markow-Kette ist eine pessimistische Abschätzung des stochastischen Prozesses X0 , X1 , X2 , . . . in dem Sinne, dass sie, wenn sie im gleichen Zustand startet, den Zustand n nicht früher erreicht als X0 , X1 , X2 , . . .. Wir definieren qj als die Wahrscheinlichkeit,
dass die Markow-Kette Y00 , Y10 , Y20 , . . . den Zustand n in 3n Schritten erreicht, wenn sie im
Zustand n − j initialisiert wird, und wir möchten für jedes qj eine untere Schranke finden.
Die Wahrscheinlichkeit, den Zustand n ausgehend vom Zustand n − j in genau j Schritten zu
erreichen, beträgt nur (1/3)j . Wenn wir jedoch für ein k ∈ {0, . . . , j} genau 2k + j Schritte
machen, von denen insgesamt k Schritte nach links und k + j Schritte nach rechts gehen, so
erreichen wir den Zustand n ebenfalls. Die Wahrscheinlichkeit hierfür beträgt genau
j + 2k
k
! k j+k
2
3
1
3
.
Bei dieser Formel haben wir ausgenutzt, dass der Binomialkoeffizient der Anzahl an Möglichkeiten entspricht, wie die k Schritte nach links auf die insgesamt 2k+j Schritte aufgeteilt sein
können. Für eine konkrete Aufteilung beträgt die Wahrscheinlichkeit, dass die Markow-Kette
die entsprechenden Zustandsübergänge macht, genau ( 32 )k ( 13 )j+k . Dementsprechend gilt
qj ≥
max
k∈{0,...,j}
j + 2k
k
! k j+k
2
3
1
3
≥
3j
j
! j 2j
2
3
1
3
(3j)!
2
j!(2j)! 27
=
j
,
(4.4)
wobei wir im zweiten Schritt k = j eingesetzt haben.
Um diesen Term abzuschätzen, nutzen wir die Stirling-Formel für Fakultäten, die in folgendem Lemma zusammengefasst ist.
Lemma 4.5. Für m ≥ 1 gilt
√
2πm
m
e
m
m
√
m
≤ m! ≤ 2 2πm
.
e
Zunächst nutzen wir die Stirling-Formel, um für j ≥ 1 die Fakultäten in (4.4) abzuschätzen.
Es gilt
√ j
√
3j j 2j
(3j)!
6πj
3j
e
e
3 27
√
≥ √
= √
.
j!(2j)!
j
2j
4 2πj 4πj e
8 πj 4
Setzen wir c =
√
√
3/(8 π), so erhalten wir für j ≥ 1 insgesamt
c 27
qj ≥ √
j 4
j 2
27
j
c 1
= √ j.
j2
80
4. Markow-Ketten und Random Walks
Außerdem gilt q0 = 1.
Wir wissen, dass eine zufällige Initialisierung mit einer konstanten Wahrscheinlichkeit im
Zustand n/2 oder rechts davon liegt. Die Wahrscheinlichkeit, von dort in 3n Schritten zum
Zustand n zu gelangen, beträgt
1
q =Ω √
n · 2n/2
n
2
1
.
=ω
1,42n
Mit dieser Erkenntnis kann man leicht zeigen, dass der Algorithmus Improved-3-SAT bereits für m = Θ(1,42n ) eine gegen Null gehende Fehlerwahrscheinlichkeit besitzt. Dies ist
eine deutliche Verbesserung gegenüber dem Ausprobieren aller möglichen Belegungen der
Variablen mit einer Laufzeit von Ω(2n ).
Wir nutzen als nächstes in der Analyse noch den Effekt aus, dass eine signifikante Wahrscheinlichkeit besteht, dass eine der Initialisierungen deutlich rechts von n/2 liegt. Dadurch
können wir die Laufzeit weiter verbessern. Sei q die Wahrscheinlichkeit, dass nach 3n Schritten startend von einer uniform zufälligen Initialisierung der Zustand n erreicht wird. Es
gilt
q≥
n
X
Pr(X0 = n − j) · qj
j=0
n
X
1
n
≥ n+
2
j
j=1
! n
1
2
c 1
√ j
j2
!
n X
n
n 1
c 1
≥√
n 2
j=0
j 2j
(1)n−j
n n
c 1
3
=√
n 2
2
n
c 3
=√
.
n 4
Wir haben in der zweiten Zeile ausgenutzt, dass die Wahrscheinlichkeit,
dass sich eine zu
fällige Belegung in genau j Positionen von S unterscheidet, genau nj ( 21 )n beträgt. In der
vorletzten Zeile haben wir den binomischen Lehrsatz ausgenutzt. Damit haben wir das folgende Lemma gezeigt.
Lemma 4.6. Die Wahrscheinlichkeit, dass ein Aufruf von Rand-3-SAT(φ, 3n) erfolgreich
ist, beträgt mindestens
c 3 n
α := √
.
n 4
Wählen wir m = b/α für ein b ≥ 1, so beträgt die Wahrscheinlichkeit, dass keiner der Aufrufe
erfolgreich ist, höchstens
1
(1 − α)b/α ≤ b .
e
Somit haben wir einen randomisierten Algorithmus mit einer beliebig kleinen konstanten Fehlerwahrscheinlichkeit für 3-SAT erhalten, der eine Laufzeit von O(n3/2 ( 43 )n ) = O(1,333334n )
besitzt.
Der hier beschriebene Algorithmus für 3-SAT wurde im Jahre 1999 von Uwe Schöning präsentiert und ist 2002 in einer Zeitschrift erschienen [3]. Seitdem gab es zahlreiche Verbesserungen. Der beste bekannte randomisierte Algorithmus für 3-SAT von Timon Hertli ist aus
4.2. Eigenschaften von Markow-Ketten
81
dem Jahre 2011 und erreicht eine Laufzeit von O(1,30704n ) [1]. Außerdem ist es Robin Moser und Dominik Scheder gelungen, den Algorithmus von Schöning zu derandomisieren, d. h.
einen deterministischen Algorithmus mit derselben Laufzeit von O(1,333334n ) anzugeben.
Dies ist der bisher beste bekannte deterministische Algorithmus für 3-SAT [4].
4.2
Eigenschaften von Markow-Ketten
Wir werden nun Markow-Ketten systematischer betrachten und einige grundlegende Eigenschaften diskutieren.
4.2.1
Klassifikation von Zuständen
Oft interessiert uns bei einer Markow-Kette, welche Verteilung auf den Zuständen sie nach
einer großen Anzahl an Schritten annimmt. Um diese Frage beantworten zu können, definieren wir zunächst verschiedene Attribute für die Zustände einer Markow-Kette. Grundlegend
für die weiteren Betrachtungen ist die folgende Definition.
Definition 4.7. Es seien eine Markow-Kette und zwei beliebige Zustände i und j dieser
Markow-Kette gegeben. Wir sagen, dass j von i erreichbar ist, wenn es ein m ≥ 0 gibt, für
(m)
das pi,j > 0 gilt. Ist sowohl i von j als auch j von i erreichbar, so sagen wir, dass i und j
gegenseitig erreichbar sind, und schreiben dies als i ↔ j.
Man kann leicht nachweisen, dass die durch ↔ definierte Relation auf der Zustandsmenge
reflexiv, symmetrisch und transitiv ist. Damit handelt es sich um eine Äquivalenzrelation, die
die Zustandsmenge in disjunkte Klassen einteilt. Betrachten wir die Markow-Kette wieder
als einen gerichteten Graphen, dessen Knoten den Zuständen entsprechen und dessen Kanten
Übergängen entsprechen, die mit einer positiven Wahrscheinlichkeit erfolgen, dann sind die
starken Zusammenhangskomponenten dieses Graphen identisch mit den Äquivalenzklassen
der Relation ↔.
Wir betrachten den gerichteten Graphen, dessen Knoten die Äquivalenzklassen sind und der
eine Kante von einer Äquivalenzklasse K1 zu einer anderen Äquivalenzklasse K2 genau dann
enthält, wenn es einen Zustand in K1 gibt, von dem aus ein Zustand in K2 erreichbar ist.
Man überlegt sich leicht, dass dieser Graph azyklisch ist. Wir nennen eine Äquivalenzklasse K
final, wenn es in dem Graphen keine Kanten von K zu einer andern Äquivalenzklasse gibt.
Definition 4.8. Eine Markow-Kette heißt nicht reduzierbar, falls alle ihre Zustände in
derselben Äquivalenzklasse bezüglich der Relation ↔ liegen.
t als die Wahrscheinlichkeit, dass die
Für zwei Zustände i und j und t ≥ 1 definieren wir ri,j
Markow-Kette startend in Zustand i nach genau t Schritten zum ersten Mal den Zustand j
erreicht:
t
ri,j
= Pr Xt = j und ∀s ∈ {1, 2, . . . t − 1} : Xs 6= j X0 = i .
Wir lassen die Markow-Kette nun unendlich viele Zustandsübergänge durchführen und interessieren uns dafür, welche Zustände unendlich oft besucht werden und welche nur endlich
oft in der Sequenz der besuchten Zustände vorkommen.
82
4. Markow-Ketten und Random Walks
t = 1
Definition 4.9. Ein Zustand i einer Markow-Kette heißt rekurrent, falls t≥1 ri,i
P
t < 1, so heißt Zustand i transient. Eine Markow-Kette heißt
gilt. Gilt stattdessen t≥1 ri,i
rekurrent, falls alle ihre Zustände rekurrent sind.
P
Startet die Markow-Kette bei einem rekurrenten Zustand i und führt unendlich viele Zustandsübergänge durch, so wird der Zustand i unendlich oft besucht. Startet die MarkowKette hingegen in einem transienten Zustande i, so ist die Anzahl der Besuche von i eine
P
t . Die erwartete Anzahl von Besuchen
geometrische Zufallsvariable mit Parameter 1− t≥1 ri,i
von i (inklusive des ersten) beträgt dann 1 −
t −1
t≥1 ri,i
P
< ∞.
Das folgende Lemma, das wir nicht beweisen, zeigt, dass rekurrent und transient Eigenschaften sind, die sich von den Zuständen auf die Äquivalenzklassen der Relation ↔ erweitern
lassen.
Lemma 4.10. Es seien i und j zwei Zustände einer Markow-Kette mit i ↔ j. Dann ist j
genau dann rekurrent, wenn i rekurrent ist.
In endlichen Markow-Ketten (d. h. Markow-Ketten mit einer endlichen Zustandsmenge) kann
man leicht die Äquivalenzklassen der Relation ↔ charakterisieren, die rekurrent sind. Dies
sind genau die finalen Äquivalenzklassen. Alle nicht finalen Äquivalenzklasse sind transient.
Wir interessieren uns nicht nur dafür, ob ein Zustand j von einem Zustand i erreichbar
ist, sondern auch dafür wie viele Zustandsübergänge die Markow-Kette im Erwartungswert
benötigt, um startend in Zustand i den Zustand j zu erreichen. Diesen Erwartungswert
bezeichnen wir mit hi,j und wir können ihn als
hi,j =
X
t
t · ri,j
t≥1
schreiben. Ist ein Zustand in einer Markow-Kette mit einer unendlichen Zustandsmenge
rekurrent, so bedeutet das nicht unbedingt, dass der Erwartungswert hi,i endlich ist. Deshalb
unterscheiden wir in der folgenden Definition zwei Arten von rekurrenten Zuständen.
Definition 4.11. Ein rekurrenter Zustand i einer Markow-Kette heißt positiv-rekurrent,
falls hi,i < ∞ gilt. Ansonsten heißt der Zustand i null-rekurrent.
Das folgende Beispiel zeigt eine Markow-Kette, in der der Zustand 1 null-rekurrent ist.
1
2
1
1
2
1
3
2
2
3
1
4
3
3
4
1
5
4
4
5
...
i−1
i
1
i+1
i
i
i+1
1
i+2
i+1
i+1
i+2
...
Die Wahrscheinlichkeit, dass startend in Zustand 1 nach t Schritten Zustand 1 kein einziQ
j
1
ges Mal wieder besucht wird, beträgt tj=1 j+1
= t+1
. Diese Wahrscheinlichkeit geht für
wachsendes t gegen Null und somit ist der Zustand 1 rekurrent. Die erwartete Anzahl an
Schritten, um zum Zustand 1 zurückzukehren, beträgt jedoch
h1,1 =
X
t≥1
t
t · r1,1
=
X
t≥1
t·
1
= ∞,
t(t + 1)
4.2. Eigenschaften von Markow-Ketten
83
t = 1/t(t + 1) ausgenutzt haben. Dies folgt, da die Wahrscheinlichkeit, in den
wobei wir r1,1
ersten t − 1 Schritten dem Pfad zu folgen, laut obiger Rechnung 1/t beträgt und da die
Wahrscheinlichkeit, dann von Zustand t zurück zu Zustand 1 zu gehen, 1/(t + 1) beträgt.
Wie dieses Beispiel schon vermuten lässt, kann es nur in unendlichen Markow-Ketten nullrekurrente Zustände geben. In endlichen Markow-Ketten sind alle rekurrenten Zustände auch
positiv-rekurrent. Während es unendliche Markow-Ketten gibt, die ausschließlich aus transienten Zuständen bestehen, enthält jede endliche Markow-Kette mindestens einen rekurrenten
Zustand. Diese Aussagen zu beweisen, überlassen wir dem Leser als Übungsaufgabe.
Uns interessiert nicht nur, wie oft ein Zustand im Laufe der Zeit besucht wird, sondern auch,
zu welchen Zeitpunkten dies geschieht. Betrachten wir beispielsweise eine Markow-Kette,
deren Zustände die ganzen Zahlen sind, die im Zustand 0 startet und von jedem Zustand i mit
einer Wahrscheinlichkeit von jeweils 1/2 zum Zustand i−1 oder i+1 wechselt, so können alle
gerade Zustände nur zu geraden Zeitpunkten erreicht werden und alle ungeraden Zustände
können nur zu ungeraden Zeitpunkten erreicht werden. Zustände mit dieser Eigenschaft
nennen wir periodisch. Dies präzisieren wir in der folgenden Definition.
Definition 4.12. Ein Zustand i heißt periodisch, falls ein ∆ ≥ 2 existiert, sodass die
Markow-Kette startend im Zustand i den Zustand i genau zu Zeitpunkten t mit positiver
Wahrscheinlichkeit erreichen kann, bei denen t ein Vielfaches von ∆ ist, d. h.
Pr(Xt = i | x0 = i) > 0 ⇐⇒ t ist Vielfaches von ∆.
Eine Markow-Kette heißt periodisch, falls mindestens einer ihrer Zustände periodisch ist.
Von besonderem Interesse sind Markow-Ketten, die ausschließlich aus aperiodischen und
positiv-rekurrenten Zuständen bestehen.
Definition 4.13. Ein Zustand einer Markow-Kette, der aperiodisch und positiv-rekurrent
ist, heißt ergodisch. Eine Markow-Kette heißt ergodisch, wenn alle ihre Zustände ergodisch
sind.
Aus den Überlegungen, die wir bisher gemacht haben, folgt leicht, dass eine endliche MarkowKette genau dann ergodisch ist, wenn sie nicht reduzierbar und aperiodisch ist. Besitzt die
Relation ↔ bei einer endlichen Markow-Kette nämlich nur eine Äquivalenzklasse, so sind auf
Grund von Lemma 4.10 und der Tatsache, dass es mindestens einen rekurrenten Zustand
gibt, alle Zustände der Markow-Kette rekurrent. Wegen der endlichen Zustandsmenge ist
dies gleichbedeutend damit, dass alle Zustände positiv-rekurrent sind.
4.2.2
Anwendung: Gambler’s Ruin Problem
Wir nutzen die Definitionen des vorangegangenen Abschnitts, um ein Zufallsexperiment zu
analysieren, das als Gambler’s Ruin Problem bekannt ist. Dabei gibt es zwei Spieler, die mit
einem Startkapital von a ∈ N bzw. b ∈ N Euro beginnen. Sie werfen eine faire Münze und je
nach Ausgang zahlt entweder der erste Spieler einen Euro an den zweiten oder umgekehrt.
Dies wird solange wiederholt, bis einer der beiden Spieler kein Geld mehr besitzt. Dieser
Spieler ist dann der Verlierer. Die Frage ist nun, wie hoch die Wahrscheinlichkeit ist, dass
der erste Spieler verliert. Klar ist zunächst, dass im Falle a = b aus Symmetriegründen beide
Spieler die gleiche Wahrscheinlichkeit besitzen, ihr Vermögen zu verlieren. Der interessante
Fall ist jedoch, wenn beide Spieler mit verschiedenen Beträgen starten.
84
4. Markow-Ketten und Random Walks
Theorem 4.14. In dem oben beschriebenen Spiel beträgt die Wahrscheinlichkeit, dass der
erste Spieler sein Vermögen verliert, b/(a + b). Dementsprechend beträgt die Wahrscheinlichkeit, dass der zweite Spieler sein Vermögen verliert, a/(a + b).
Beweis. Zunächst stellen wir das Spiel als Markow-Kette dar. Die Zustände dieser MarkowKette sind −a, −a + 1, . . . , b − 1, b, wobei Zustand i bedeutet, dass sich durch die bisherigen
Münzwürfe das Vermögen vom ersten Spieler um i Euro erhöht hat. Die Markow-Kette
startet im Zustand 0, der Zustand −a entspricht dem Ereignis, dass der erste Spieler sein
Vermögen verliert, und der Zustand b entspricht dem Ereignis, dass der zweite Spieler sein
Vermögen verliert. Wird einer dieser beiden Zustände erreicht, so ist das Spiel beendet und
der Zustand wird nicht mehr verlassen. Von jedem anderen Zustand i ∈ {−a + 1, . . . , b − 1}
erfolgt mit einer Wahrscheinlichkeit von jeweils 1/2 ein Übergang in den Zustand i − 1 oder
in den Zustand i + 1. Diese Markow-Kette, die in der folgenden Abbildung dargestellt ist,
ähnelt stark der, die wir zur Analyse des Algorithmus Rand-2-SAT eingesetzt haben.
1
1
2
−a
1
2
−a + 2
−a + 1
1
2
1
2
1
2
−a + 3
1
2
...
1
2
1
2
1
2
b−1
b
1
1
2
Die Zustände −a und b sind offensichtlich rekurrent, da sie nicht mehr verlassen werden
können. Andererseits sind alle anderen Zustände i ∈ {−a + 1, . . . , b − 1} transient, da von
jedem solchen Zustand i eine positive Wahrscheinlichkeit besteht, einen der Zustände −a
oder b zu erreichen, in welchem Fall die Markow-Kette nie wieder zu i zurückkehrt. Je mehr
Schritte die Markow-Kette durchführt, desto wahrscheinlicher wird es, dass sie einen der
beiden rekurrenten Zustände erreicht. Man kann leicht argumentieren, dass für alle Zustände i ∈ {−a + 1, . . . , b − 1}
lim Pr(Xt = i) = 0
t→∞
gilt. Es sei
q = lim Pr(Xt = b),
t→∞
die Wahrscheinlichkeit, dass der erste Spieler das Spiel gewinnt. Dann beträgt die Wahrscheinlichkeit, dass der zweite Spieler das Spiel gewinnt dementsprechend
1 − q = lim Pr(Xt = −a).
t→∞
Es gilt
lim E(Xt ) = lim
t→∞
t→∞
b X
i · Pr(Xt = i) = bq − a(1 − q).
(4.5)
i=−a
Falls wir den Grenzwert auf der linken Seite bestimmen können, so können wir daraus direkt
die Wahrscheinlichkeiten q und 1 − q bestimmen, mit denen der erste und zweite Spieler
gewinnen.
Es gilt X0 = 0 und damit insbesondere E(X0 ) = 0. Die Zufallsvariable X1 nimmt mit einer
Wahrscheinlichkeit von jeweils 1/2 entweder den Wert −1 oder den Wert +1 an. Demzufolge
gilt auch E(X1 ) = 0. Man kann nun mit Hilfe von vollständiger Induktion nachweisen,
dass E(Xt ) = 0 für jedes feste t ≥ 0 gilt. Insbesondere gilt
lim E(Xt ) = 0,
t→∞
4.3. Random Walks auf Graphen
85
woraus mit (4.5)
0 = bq − a(1 − q) = (b + a)q − a
folgt. Löst man diese Gleichung nach q bzw. nach 1 − q auf, so erhält man genau die im
Theorem angegebenen Gewinnwahrscheinlichkeiten.
4.2.3
Stationäre Verteilung
Es sei eine Markow-Kette mit einer Übergangsmatrix P gegeben. Wir haben gesehen, dass
sich mit Hilfe von P für eine gegebene Verteilung zum Zeitpunkt 0 für jeden Zeitpunkt eine
Wahrscheinlichkeitsverteilung auf der Zustandsmenge bestimmen lässt. Ist π die Verteilung
zu einem Zeitpunkt t, so ist πP die Verteilung zum Zeitpunkt t+1. Von besonderem Interesse
sind Verteilungen, die sich nicht mehr ändern, wenn sie einmal erreicht sind.
Definition 4.15. Eine Wahrscheinlichkeitsverteilung π auf der Menge der Zustände einer
Markow-Kette mit Übergangsmatrix P heißt stationär, wenn π = πP gilt.
Das folgende Theorem, welches wir nicht beweisen, wird auch als Fundamentalsatz über
Markow-Ketten bezeichnet.
Theorem 4.16. Jede endliche, nicht reduzierbare und aperiodische Markow-Kette besitzt die
folgenden Eigenschaften.
a) Alle Zustände sind ergodisch.
b) Es gibt eine eindeutige stationäre Verteilung π mit π = πP .
(t)
c) Für alle Zustände i und j der Markow-Kette existiert der Grenzwert limt→∞ pj,i und
er ist unabhängig von j. Des Weiteren gilt
πi =
1
(t)
= lim pj,i .
hi,i t→∞
d) Für einen Zustand i und ein t ≥ 1 bezeichne N (i, t) wie oft Zustand i in t Schritten
besucht wird. Unabhängig vom Startzustand gilt
N (i, t)
= πi .
t→∞
t
lim
Die wesentliche Erkenntnis von Theorem 4.16 ist, dass endliche, nicht reduzierbare und aperiodische Markow-Ketten eine eindeutige stationäre Verteilung besitzen, der sich die MarkowKette unabhängig von der Initialisierung nach einer hinreichend großen Anzahl an Schritten
annähert. Die stationäre Verteilung ist also deswegen interessant, da sie das Verhalten der
Markow-Kette nach einer großen Anzahl an Schritten beschreibt.
4.3
Random Walks auf Graphen
Wir betrachten nun spezielle Markow-Ketten, die durch ungerichtete Graphen beschrieben
werden, in denen sich ein Partikel zufällig entlang der Kanten von Knoten zu Knoten bewegt.
Sei G = (V, E) in diesem Abschnitt stets ein ungerichteter, zusammenhängender Graph mit n
86
4. Markow-Ketten und Random Walks
Knoten und m Kanten. Der Graph G induziert eine Markow-Kette mit Zustandsmenge V
und den Übergangswahrscheinlichkeiten
pu,v =

 1
falls (u, v) ∈ E
0
sonst
d(u)
für jedes Paar von Knoten u, v ∈ V , wobei d(u) den Grad des Knotens u bezeichnet. Die
Übergangswahrscheinlichkeiten sind so gewählt, dass das Partikel zu jedem Zeitpunkt zu
einem uniform zufälligen Nachbarn des aktuellen Knotens wechselt. Diese Markow-Kette
nennen wir auch Random Walk auf G.
Lemma 4.17. Der Random Walk auf G ist genau dann periodisch, wenn G bipartit ist.
Beweis. Ist G bipartit und startet der Random Walk bei einem Knoten v, so kann nur zu den
geraden Zeitpunkten eine positive Wahrscheinlichkeit bestehen, dass sich der Random Walk
bei v befindet. Des Weiteren besteht zu jedem geraden Zeitpunkt 2t auch tatsächlich eine
positive Wahrscheinlichkeit, da der Random Walk t mal eine von v ausgehende Kante hin
und zurück benutzt haben kann. Somit sind der Knoten v und der Random Walk periodisch.
Ein Graph ist genau dann bipartit, wenn er keinen Kreis ungerader Länge enthält. Ist G nicht
bipartit, so gibt es also einen Kreis C ungerader Länge. Sei v ∈ V ein beliebiger Knoten des
Graphen. Da der Graph G laut Annahme zusammenhängend ist, gibt es einen Weg P von v
zu einem Knoten u des Kreises C. Besteht dieser Weg aus `1 Kanten und der Kreis aus `2
Kanten, so gibt es einen Weg der Länge 2`1 + `2 von v zu sich selbst. Dieser Weg besteht
aus dem Pfad P von v nach u, konkateniert mit dem Kreis C und anschließend wieder
dem Pfad P von u nach v. Erweitert man diesen Pfad dadurch, dass eine von v ausgehende
Kante hin und zurück benutzt wird, so erhält man auch für jede ungerade Länge größer
als 2`1 + `2 einen Weg von v zu sich selbst. Ebenso gibt es für jede gerade Länge einen
(`)
solchen Weg. Demzufolge ist v nicht periodisch, da pv,v > 0 für jedes ` ≥ 2`1 + `2 gilt. Da
der Knoten v beliebig gewählt wurde, zeigt dieses Argument, dass die Markow-Kette nicht
periodisch ist.
Wir gehen ab jetzt davon aus, dass G zusammenhängend und nicht bipartit ist.
Theorem 4.18. Der Random Walk auf G konvergiert gegen die stationäre Verteilung π
d(v)
mit πv = 2|E|
für alle v ∈ V .
Beweis. Da G endlich, zusammenhängend und nicht bipartit ist, ist der Random Walk auf G
endlich, nicht reduzierbar und gemäß Lemma 4.17 aperiodisch. Gemäß Theorem 4.16 besitzt
der Random Walk auf G eine eindeutige stationäre Verteilung, gegen die er konvergiert.
Somit genügt es, nachzuweisen, dass die im Theorem angegebene Verteilung stationär ist.
Zunächst zeigen wir, dass es sich bei π tatsächlich um eine Wahrscheinlichkeitsverteilung
handelt. Offensichtlich sind alle πv nicht negativ und es gilt
X
v∈V
πv =
X d(v)
v∈V
2|E|
=
1 X
2|E|
d(v) =
= 1.
2|E| v∈V
2|E|
Nun betrachten wir die Wahrscheinlichkeit, dass sich die Markow-Kette nach einem Schritt
in einem Knoten v ∈ V befindet, wenn sie mit der Verteilung π startet. Diese Wahrscheinlichkeit können wir angeben, indem wir über alle Nachbarn u von v die Wahrscheinlichkeit
aufsummieren, dass der Random-Walk bei u startet und dann der Kante von u nach v folgt.
4.3. Random Walks auf Graphen
87
Die Wahrscheinlichkeit, dass sich der Random Walk nach einem Schritt in Knoten v befindet,
beträgt also
X
u∈N (v)
πu · pu,v =
X
d(u)
1
1
d(v)
·
=
=
= πv ,
2|E| d(u) u∈N (v) 2|E|
2|E|
u∈N (v)
X
wobei N (v) ⊆ V die Menge der zu v adjazenten Knoten bezeichnet. Damit ist gezeigt, dass π
eine stationäre Verteilung ist.
Wir führen nun einige Begriffe ein, die in der Analyse von Random Walks eine große Rolle
spielen.
Definition 4.19. Es seien u, v ∈ V .
a) Die erwartete Zeit hu,v , um von u zu v zu gelangen, bezeichnen wir als Hitting-Time.
b) Die erwartete Zeit Cu,v = hu,v + hv,u , um von u zu v und wieder zurück zu u zu
gelangen, bezeichnen wir als Commute-Time.
c) Wir bezeichnen mit Cu (G) die erwartete Zeit, um von u startend alle Knoten von G
mindestens einmal zu erreichen.
d) Wir bezeichnen mit C(G) = maxu∈V Cu (G) die Cover-Time von G.
Aus den Theoremen 4.16 und 4.18 folgt direkt das folgende Korollar über Hitting-Time.
Korollar 4.20. Für alle v ∈ V gilt
hv,v =
1
2|E|
=
.
πv
d(v)
Insbesondere die Cover-Time eines Graphen G ist für viele Anwendungen von Interesse. Um
eine bessere Intuition zu bekommen, betrachten wir die Cover-Time für einige Beispielgraphen.
• Als erstes betrachten wir den Fall, dass G eine Clique auf n Knoten ist. Befindet
sich der Random Walk dann an einem Knoten v ∈ V , so wechselt er zu einem uniform
zufälligen Knoten aus V \{v}. Dieser Prozess ähnelt stark dem Coupon Collector’s Problem, bei dem in jedem Schritt eines von n Sammelbildern uniform zufällig gewählt
wird. Wenn wir die Knoten mit den Sammelbildern identifizieren, so besteht der einzige
Unterschied darin, dass es im Gegensatz zum Coupon Collector’s Problem nicht vorkommen kann, dass dasselbe Sammelbild zweimal direkt hintereinander gezogen wird.
Intuitiv sieht man leicht ein, dass dies bei hinreichend großem n keine gravierende
Änderung des Modells ist und dass sich die erwartete Zeit, bis jedes Bild mindestens
einmal gezogen wurde, asymptotisch dadurch nicht ändert. Dies legt die Vermutung
nahe, dass die Cover-Time des vollständigen Graphen mit n Knoten genauso wie im
Coupon Collector’s Problem Θ(n log n) beträgt.
• Als nächstes betrachten wir einen Graphen Pn , der aus einem Pfad mit n Knoten besteht. Der Random Walk auf Pn entspricht nahezu der Markow-Kette, die wir zur Analyse des Algorithmus Rand-2-SAT eingesetzt haben. Der einzige Unterschied besteht
darin, dass der Random Walk auf Pn , wenn er eines der Enden erreicht hat, mit Wahrscheinlichkeit 1 im nächsten Schritt wieder das Ende verlässt. Für alle inneren Knoten
88
4. Markow-Ketten und Random Walks
sind die Übergangswahrscheinlichkeiten in beiden Markow-Ketten identisch. Auch hier
liegt die Vermutung nahe, dass diese kleine Änderung für hinreichend große n keine
Konsequenz für das asymptotische Verhalten der Cover-Time hat. Wir überlassen es
dem Leser, formal zu beweisen, dass die Cover-Time des Pfades mit n Knoten genauso
wie bei der Markow-Kette aus der Analyse von Rand-2-SAT Θ(n2 ) beträgt.
• Als letztes Beispiel betrachten wir den sogenannten Lollipop-Graphen Ln mit n Knoten.
Wir nehmen der Einfachheit halber an, dass n gerade ist. Der Graph Ln besteht aus
einer Clique mit n/2 Knoten und einem Pfad mit n/2 Knoten, der an einen beliebigen
Knoten u der Clique angehängt ist. Den Knoten am anderen Ende des Pfades nennen
wir v. Der Lollipop-Graph ist in der folgenden Abbildung dargestellt.
Clique mit
n/2 Knoten
... u
...
v
n/2 Knoten
Die erwartete Zeit hv,u , um von Knoten v zu Knoten u zu gelangen, beträgt gemäß des
vorangegangenen Beispiels Θ(n2 ). Andererseits beträgt die erwartete Zeit hu,v , um von
Knoten u zu Knoten v zu gelangen Θ(n3 ). Wir werden dies später formal nachweisen,
begnügen uns hier aber mit einer anschaulichen Erklärung. Startet der Random Walk
im Knoten u, so ist es sehr wahrscheinlich, dass er zunächst zu einem anderen Knoten
der Clique läuft. Solange sich der Random Walk innerhalb der Clique befindet, ist die
Verteilung auf den Knoten der Clique nahezu uniform. Das bedeutet, dass sich der
Random Walk im Erwartungswert alle Θ(n) Schritte an Knoten u befindet. Die Wahrscheinlichkeit, von dort auf den Pfad und nicht zu einem anderen Knoten der Clique zu
laufen, beträgt 1/Θ(n). Also muss der Knoten u im Erwartungswert Θ(n) oft besucht
werden, bis der Knoten u0 auf dem Pfad neben u erreicht wird. Wie wahrscheinlich ist
es, dass der Random Walk von u0 zuerst Knoten v erreicht, bevor er zurück in die Clique läuft? Dies entspricht dem Gambler’s Ruin Problem, bei dem die Spieler mit einem
und mit n/2 − 1 Euro Startkapital starten. Demzufolge beträgt die Wahrscheinlichkeit
nur 1/Θ(n) und somit benötigt man im Erwartungswert Θ(n) Versuche. Fassen wir
alles zusammen (erwartete Zeit Θ(n) um zu u zu gelangen, erwartete Anzahl Θ(n) an
Versuchen, um von dort zu u0 zu gelangen, erwartete Anzahl Θ(n) an Versuchen, um
von dort zu v zu gelangen), so kommen wir auf hu,v = Θ(n3 ). Insbesondere zeigt dies,
dass C(Ln ) = Ω(n3 ) gilt.
An diesem Beispiel sieht man, dass die Hitting-Times hu,v und hv,u im Allgemeinen
nicht identisch sind und sich sogar stark unterscheiden können. Außerdem sieht man,
dass das Einfügen von Kanten in einen Graphen die Cover-Time erhöhen kann, denn
ein Pfad der Länge n hat im Gegensatz zu dem Lollipop-Graphen eine Cover-Time von
nur Θ(n2 ).
Wir kommen nun zur allgemeinen Analyse der Cover-Time. Dazu beweisen wir zunächst das
folgende Lemma.
4.3. Random Walks auf Graphen
89
Lemma 4.21. Es sei G = (V, E) ein zusammenhängender, nicht bipartiter Graph und es
sei (u, v) ∈ E eine beliebige Kante. Dann gilt hv,u ≤ 2|E|.
Beweis. Es gilt
X
2|E|
1
= hu,u =
(1 + hw,u ),
d(u)
d(u) w∈N (u)
dabei ergibt sich die erste Gleichung aus Theorem 4.18 und die zweite folgt, indem man
über alle Möglichkeiten für den ersten Schritt summiert. Multipliziert man diese Gleichung
mit d(u), so erhält man
X
2|E| =
(1 + hw,u ),
w∈N (u)
woraus wegen v ∈ N (u) direkt die Behauptung folgt.
Mit Hilfe dieses Lemmas können wir nun eine obere Schranke für die Cover-Time beliebiger
Graphen angeben.
Theorem 4.22. Es sei G = (V, E) ein zusammenhängender, nicht bipartiter Graph. Dann
gilt C(G) < 4|V ||E|.
Beweis. Da G zusammenhängend ist, existiert ein Spannbaum T von G. Wir betrachten den
Multigraphen, der dieselbe Knotenmenge V wie G enthält und der nur die Kanten aus T
enthält, aber jeweils zweimal. In diesem Multigraphen hat jeder Knoten geraden Grad und
somit existiert ein Eulerkreis, also ein Kreis, der jede Kante genau einmal enthält (dem Leser
mag dieses Argument bei dem Entwurf von Approximationsalgorithmen für das metrische
TSP bereits begegnet sein). Da der Spannbaum T aus |V | − 1 Kanten besteht, besteht der
Eulerkreis aus 2|V | − 2 Kanten. Es sei v0 , v1 , v2 , . . . , v2|V |−2 = v0 die Sequenz der besuchten
Knoten. Es gilt
2|V |−3
C(G) ≤
X
hvi ,vi+1 ,
i=0
denn egal, wo der Random Walk startet, dauert es höchstens so lange, alle Knoten zu besuchen, wie es dauert, die Knoten in genau der Reihenfolge zu besuchen, die durch den
Eulerkreis vorgegeben ist. Mit Hilfe von Lemma 4.21 folgt
2|V |−3
C(G) ≤
X
hvi ,vi+1 ≤ (2|V | − 2)2|E| < 4|V ||E|.
i=0
4.3.1
Anwendung: Zusammenhangstest
Als eine algorithmische Anwendung betrachten wir ein einfaches Problem. Gegeben seien
ein ungerichteter nicht bipartiter Graph G = (V, E) und zwei Knoten s, t ∈ V , und es soll
entschieden werden, ob es in G einen Weg zwischen s und t gibt. Selbstverständlich kann
dieses Problem mit Hilfe einer Tiefen- oder Breitensuche in linearer Zeit O(|V | + |E|) gelöst
werden. Da bei einer solchen Suche aber für jeden Knoten gespeichert werden muss, ob
er bereits besucht wurde, beträgt der Speicherplatzbedarf dieser Algorithmen Θ(|V |). Bei
großen Graphen kann dies zu groß sein, so dass man an Algorithmen interessiert ist, die mit
weniger Speicherplatz auskommen. Der folgende randomisierte Algorithmus liegt nach der
obigen Diskussion nahe.
90
4. Markow-Ketten und Random Walks
Zusammenhangstest(G, s, t)
1. Führe einen Random Walk auf G startend bei s für 4|V |3 Schritte durch.
2. return „Ja“, falls zu einem Zeitpunkt Knoten t erreicht wurde, und „Nein“ sonst.
Theorem 4.23. Gibt es im Graphen G keinen Weg zwischen s und t, dann gibt der obige Algorithmus stets das richtige Ergebnis zurück. Ansonsten gibt er mit einer Wahrscheinlichkeit
von mindestens 1/2 das richtige Ergebnis zurück. Der Speicherplatzbedarf des Algorithmus
beträgt O(log |V |).
Beweis. Die erste Aussage des Theorems ist klar. Liegen s und t in verschiedenen Zusammenhangskomponenten des Graphen, so kann der Random Walk den Knoten t niemals erreichen,
wenn er von s startet. Ansonsten besagt Theorem 4.22, dass
hs,t ≤ C(G) < 4|V ||E| ≤ 2|V |3
gilt. Die Wahrscheinlichkeit, dass die tatsächliche Anzahl an Schritten, um von s nach t zu
kommen, doppelt so groß ist, wie ihr Erwartungswert, beträgt wegen der Markow-Ungleichung höchstens 1/2.
Der Speicherplatzbedarf des Algorithmus beträgt O(log |V |), da der Algorithmus zu jedem
Zeitpunkt nur den aktuellen Knoten speichern muss, an dem sich der Random Walk befindet.
Hat jeder Knoten eine eindeutige Nummer, so genügen O(log |V |) Bits, um diese zu speichern.
4.3.2
Elektrische Schaltungen
Wir werden nun ein Hilfsmittel kennenlernen, mit dem man die Cover-Time von Graphen
genauer analysieren kann. Bislang kennen wir nur eine obere Schranke, die für alle Graphen gültig ist. Wie aber das Beispiel der Clique zeigt, ist diese Schranke im Allgemeinen
nicht optimal. Zunächst betrachten wir elektrische Schaltungen und erinnern uns an einige
Eigenschaften über Stromstärken, Widerstände und Spannungen aus dem Physikunterricht.
Wir betrachten elektrische Schaltungen, die ausschließlich aus Widerständen bestehen. Eine
solche Schaltung können wir als ungerichteten Graphen darstellen, an dem jede Kante mit
einem gewissen Widerstand beschriftet ist. Die folgende Abbildung stellt eine Schaltung mit
drei Knoten dar. Die direkte Verbindung zwischen den Knoten a und b hat beispielsweise
einen Widerstand von einem Ohm.
1
b
a
2
1
c
Wir interessieren uns im Folgenden dafür, was passiert, wenn in einige Knoten der Schaltung
Strom hineinfließt, der an anderen Knoten wieder herausfließt. Dabei sind zwei physikalische
Gesetze zu beachten.
• Das kirchhoffsche Gesetz besagt, dass in jeden Knoten genauso viel Strom hineinfließt
wie aus dem Knoten Strom herausfließt.
• Das ohmsche Gesetz besagt, dass die Spannung zwischen den Enden eines Widerstandes
genau dem Produkt aus der durch den Widerstand fließenden Stromstärke und dem
Widerstand entspricht.
4.3. Random Walks auf Graphen
91
Mit Hilfe dieser beiden Gesetze kann man die Spannungen und Stromstärken in einer beliebigen Schaltung bestimmen. Fließt in obiger Schaltung beispielsweise 1 Ampere Strom von
außen in den Knoten b, der am Knoten c wieder aus der Schaltung herausfließt, so ergibt
sich, dass die Spannung zwischen den Knoten b und c 1 Volt beträgt und dass auf jeder
Kante der Schaltung ein halbes Ampere fließt.
Wir definieren den Gesamtwiderstand Ru,v zwischen zwei Knoten u und v der Schaltung als
die Spannung, die zwischen u und v anliegt, wenn von außen 1 Ampere Strom in u hineinfließt,
der am Knoten v wieder aus der Schaltung herausfließt. Ferner definieren wir R(G) für einen
Graphen G als den größten Gesamtwiderstand, der zwischen zwei Knoten der Schaltung
besteht, also
R(G) = max Ru,v .
u,v∈V
Der Leser erinnert sich aus dem Physikunterricht sicherlich noch daran, dass eine Reihenschaltung von Widerständen der Größen R1 , R2 , . . . , Rn einen Gesamtwiderstand R von R1 +
. . . + Rn erzeugt, während bei einer Parallelschaltung 1/R = 1/R1 + . . . + 1/Rn gilt. Beide
Aussagen lassen sich auch aus dem ohmschen und kirchhoffschen Gesetz ableiten.
Kommen wir nun zu dem Zusammenhang zu Random Walks. Dazu fassen wir den gegebenen
Graphen G = (V, E), auf dem der Random Walk erfolgt, als elektrische Schaltung auf, in der
jede Kante einem Widerstand mit einem Ohm entspricht. Wie vorhin gehen wir davon aus,
dass der Graph G zusammenhängend und nicht bipartit ist. Für Knoten u, v ∈ V des Graphen
setzen wir die Hitting-Time hu,v in Beziehung zu Eigenschaften der elektrischen Schaltung.
Dazu betrachten wir das folgende Szenario A für einen ausgezeichneten Knoten v ∈ V :
• In jeden Knoten x ∈ V fließen d(x) Ampere, wobei d(x) den Grad von x bezeichne.
• In Knoten v fließen 2|E| Ampere nach außen ab.
Für zwei Knoten x, y ∈ V bezeichnen wir mit φA
x,y die Spannung, die zwischen x und y in
diesem Szenario anliegt.
Lemma 4.24. Für alle Knoten u ∈ V \ {v} gilt
hu,v = φA
u,v ≤ 2mR(G).
Beweis. Wir bezeichnen mit Ix,y die Stromstärke auf der Kante (x, y). Dann gilt für jeden
Knoten u ∈ V \ {v}
d(u) =
X
Iu,x
x∈N (u)
=
X
φA
u,x
x∈N (u)
=
X A
φA
u,v − φx,v .
x∈N (u)
Dabei folgt die erste Gleichung aus dem kirchhoffschen Gesetz und die zweite folgt aus dem
ohmschen Gesetz. Die dritte Gleichung folgt, wenn man die Spannung zwischen zwei Knoten
explizit als die Potentialdifferenz zwischen diesen beiden Knoten ausdrückt. Dann kürzt sich
das Potential von v in der dritten Zeile. Diese Gleichung ist äquivalent zu
φA
u,v = 1 +
φA
x,v
.
d(u)
x∈N (u)
X
92
4. Markow-Ketten und Random Walks
Setzt man zusätzlich φA
v,v = 0, so erhält man ein lineares Gleichungssystem dessen eindeutige
Lösung die Spannungen φA
u,v für u ∈ V sind. Den Nachweis, dass das Gleichungssystem eine
eindeutige Lösung besitzt, überlassen wir dem Leser.
Betrachten wir nun die Hitting-Times hu,v . Auch diese lassen sich durch ein Gleichungssystem
beschreiben. Für jeden Knoten u ∈ V \ {v} gilt wegen der Linearität des Erwartungswertes
hu,v = 1 +
hx,v
.
d(u)
x∈N (u)
X
Hierbei haben wir über allen Möglichkeiten für den ersten Zustandsübergang summiert.
Entgegen der ursprünglichen Definition der Hitting-Time, ist diese Formel aber nur korrekt,
wenn man hv,v = 0 definiert. Mit dieser Definition erhalten wir für die Variablen hu,v exakt
das gleiche Gleichungssystem wie für die Variablen φA
u,v . Da die Lösung eindeutig ist, folgt
A
hiermit direkt, dass hu,v = φu,v für alle u ∈ V gilt. Damit ist das Theorem bewiesen, denn
die Ungleichung φA
u,v ≤ 2mR(G) folgt direkt aus dem ohmschen Gesetz.
Nun betrachten wir die Commute-Time Cu,v = hu,v + hv,u genauer. Dazu interessiert uns
das folgende Szenario B für einen ausgezeichneten Knoten u ∈ V :
• In jeden Knoten x ∈ V fließen d(x) Ampere, wobei d(x) den Grad von x bezeichne.
• In Knoten u fließen 2|E| Ampere nach außen ab.
Szenario B ist also identisch mit Szenario A, nur dass der Strom an einem anderen Knoten
nach außen fließt. Für zwei Knoten x, y ∈ V bezeichnen wir mit φB
x,y die Spannung, die
zwischen x und y in diesem Szenario anliegt.
Szenario C entspricht Szenario B mit invertierter Stromrichtung, d. h. aus jedem Knoten x ∈
V fließen d(x) Ampere und in Knoten u fließen von außen 2|E| Ampere. Szenario D ist die
Überlagerung von den Szenarien A und C. In Szenario D löschen sich an allen Knoten x ∈
V \ {u, v} die Ströme aus. Lediglich in den Knoten u fließen 2|E| Ampere, die von Knoten v
nach außen fließen. Die Spannungen zwischen zwei Knoten x, y ∈ V in den Szenarien C
und D bezeichnen wir entsprechend mit φC (x, y) und φD (x, y). Die folgenden Abbildungen
illustrieren die einzelnen Szenarien.
d(x)
d(x)
x
d(u)
d(v)
u
v
x
d(u)
2|E|
2|E|
d(v)
u
v
y
y
d(y)
d(y)
Szenario A
Szenario B
d(x)
x
d(u)
2|E|
d(v)
u
x
v
2|E|
u
v
y
d(y)
Szenario C
y
Szenario D
2|E|
4.3. Random Walks auf Graphen
93
Lemma 4.25. Für alle Knoten u, v ∈ V gilt
Cu,v = hu,v + hv,u = 2|E|Ru,v
B
Beweis. Gemäß Lemma 4.24 gilt hu,v = φA
u,v . Außerdem besagt das Lemma, dass hv,u = φv,u
B
gilt. Dementsprechend gilt φC
v,u = −φv,u = −hv,u , da sich beim Umkehren der Stromrichtung
lediglich die Vorzeichen der Spannungen ändern. Da sich bei einer Addition von Stromstärken
gemäß dem Superpositionsprinzip auch die Spannungen addieren, gilt, wie gewünscht,
A
C
A
C
A
B
φD
u,v = φu,v + φu,v = φu,v − φv,u = φu,v + φv,u = hu,v + hv,u .
Da in Szenario D ein Strom von 2|E| Ampere von u nach v fließt, folgt außerdem mit dem
ohmschen Gesetz
φD
u,v = 2|E|Ru,v ,
womit insgesamt das Lemma bewiesen ist.
Mit Hilfe des vorangegangenen Lemmas können wir die Analyse des Lollipop-Graphen formalisieren. Es sei wieder u der Knoten in der Clique, der mit dem Pfad verbunden ist,
und v der Endknoten des Pfades. Dann gilt, wie man leicht sehen kann, Ru,v = n/2. Demzufolge besagt Lemma 4.25, dass die Commute-Time Cu,v zwischen den Knoten u und v
genau n|E| = Θ(n3 ) beträgt. Da wir aus der Analyse des Algorithmus Rand-2-SAT wissen,
dass hv,u = Θ(n2 ) gilt, impliziert dies hu,v = Θ(n3 ).
Wir erhalten nun das folgende allgemeine Ergebnis über die Cover-Time eines Graphen G.
Theorem 4.26. Es sei G = (V, E) ein beliebiger zusammenhängender, nicht bipartiter
Graph. Dann gilt für die Cover-Time
mR(G) ≤ C(G) ≤ 2e3 mR(G) ln(n) + 2n.
Beweis. Die untere Schranke folgt aus Lemma 4.25, da für zwei Knoten u, v ∈ V mit R(G) =
Ru,v gilt
1
C(G) ≥ max{hu,v , hv,u } ≥ (hu,v + hv,u ) = mRu,v = mR(G).
2
Für die obere Schranke zeigen wir zunächst, dass die Wahrscheinlichkeit nach 2e3 mR(G) ln(n)
Schritten noch nicht alle Knoten besucht zu haben, höchsten 1/n2 beträgt. Dazu teilen
wir den Random Walk in ln(n) viele Epochen der Länge jeweils 2e3 mR(G) ein. Für jeden
Knoten v ∈ V gilt hu,v ≤ 2mR(G) gemäß Lemma 4.25 für alle Knoten u ∈ V \ {v}. Unabhängig vom Startknoten u einer Epoche besagt die Markow-Ungleichung also, dass die
Wahrscheinlichkeit, Knoten v in der Epoche nicht zu besuchen, höchstens 1/e3 beträgt. Die
Wahrscheinlichkeit, dass ein Knoten v in keiner der ln(n) Phasen besucht wird, beträgt somit
höchstens (1/e3 )ln(n) = 1/n3 . Eine Union-Bound über alle n Knoten liefert nun, dass höchstens mit einer Wahrscheinlichkeit von 1/n2 ein Knoten existiert, der in keiner der Epochen
besucht wird. Dieses Ereignis bezeichnen wir mit F.
Tritt das Ereignis F ein, so lassen wir den Random Walk nach Abschluss der ln(n) Epochen
solange weiter laufen, bis er alle Knoten besucht hat. Im Erwartungswert dauert dies, unabhängig von dem Knoten, an dem der Random Walk nach den ln(n) Epochen startet, gemäß
Theorem 4.22 weniger als 4|V ||E| ≤ 2n3 viele Schritte. Es gilt insgesamt
C(G) ≤ 2e3 mR(G) ln(n) + Pr(F) · 2n3 ≤ 2e3 mR(G) ln(n) + 2n.
94
4. Markow-Ketten und Random Walks
Im Allgemeinen lässt sich Theorem 4.26 asymptotisch nicht verbessern, da man sowohl Graphen angeben kann, für die die untere Schranke asymptotisch scharf ist, als auch Beispiele,
für die die obere Schranke asymptotisch scharf ist. Für die obere Schranke genügt es, sich
eine Clique G mit n Knoten anzuschauen. Für diesen Graphen gilt m = Θ(n2 ) und man
rechnet leicht nach, dass R(G) = Θ(1/n) gilt. Demzufolge ergibt Theorem 4.26 eine obere
Schranke von Θ(n ln(n)). Wir haben uns bereits weiter oben überlegt, dass diese Schranke
in der richtigen Größenordnung liegt.
Für die untere Schranke betrachten wir einen Pfad Pn mit n Knoten. Es gilt dann m = n − 1
und R(G) = n − 1. Demzufolge liefert Theorem 4.26 eine untere Schranke von Θ(n2 ). Auch
diese Schranke liegt laut unseren Vorüberlegungen in der richtigen Größenordnung.
Weiterhin überlegt man sich leicht, dass keines der Theoreme 4.22 und 4.26 das andere dominiert. Während Theorem 4.26 für den Lollipop-Graphen Ln wegen m = Θ(n2 )
und R(G) = Θ(n) eine obere Schranke von Θ(n3 ln(n)) liefert, liefert Theorem 4.22 eine
bessere und asymptotisch korrekte Schranke von Θ(n3 ). Auf der anderen Seite liefert Theorem 4.22 für eine Clique mit n Knoten ebenfalls nur eine Schranke von Θ(n3 ), wohingegen
Theorem 4.26 eine bessere und asymptotisch korrekte Schranke von Θ(n ln(n)) liefert.
Literaturverzeichnis
[1] Timon Hertli. 3-SAT faster and simpler - unique-SAT bounds for PPSZ hold in general.
CoRR, abs/1103.2165, 2011.
[2] Ulrich Krengel. Einführung in die Wahrscheinlichkeitstheorie und Statistik.
eg+Teubner Verlag, 2005.
View-
[3] Uwe Schöning. A probabilistic algorithm for k-SAT based on limited local search and
restart. Algorithmica, 32(4):615–623, 2002.
[4] Robin A. Moser und Dominik Scheder. A full derandomization of schoening’s k-SAT
algorithm. CoRR, abs/1008.4067, 2010.
[5] Michael Mitzenmacher und Eli Upfal. Probability and Computing. Cambridge University
Press, 2005.
[6] Rajeev Motwani und Prabhakar Raghavan. Randomized Algorithms. Cambridge University Press, 1995.
[7] Berthold Vöcking.
Berechenbarkeit und Komplexität, Wintersemester 2011/12.
http://algo.rwth-aachen.de/Lehre/WS1112/VBuK/BuK.pdf.
95