Graphenalgorithmen und lineare Algebra Hand in Hand

Transkript

1 Graphenalgorithmen und lineare Algebra Hand in Hand Henning Meyerhenke 1. September 2014

2

3 iii Inhaltsverzeichnis 1. Grundlegende Graphenalgorithmen Dualität zwischen Graphen und Matrizen Starke Zusammenhangskomponenten Definition Algorithmus Konvergenz Kürzeste Wege Definitionen Algorithmus von Bellman und Ford Paarweise kürzeste Distanzen Paarweise kürzeste Wege mit dem Algorithmus von Seidel Nicht erweiterbare unabhängige Mengen Weiterführende Literatur Datenstrukturen für dünn besetzte Matrizen Cache-Effizienz I/O-Modell Modell-Annahmen Grundlegende Algorithmen im I/O-Modell Grundlegende Matrix-Operationen Teilmatrizen addressieren (SpRef/SpAsgn) Matrix-/Vektormultiplikation (SpMV) Addition dünner Matrizen (SpAdd) Sparse matrix-sparse matrix multiplication (SpGEMM) Tripel Ungeordnete Tripel Zeilenweise geordnete Tripel Zeilendominant geordnete Tripel CSR/CSC CSR und Adjazenzlisten Grundoperationen mit CSR Multiplikation dünn besetzter Matrizen Der Sparse Accumulator SpGEMM mit CSR Hyperdünne Matrizen DCSC Multiplikation hyperdünner Matrizen Weiterführende Literatur Clusteranalyse von Graphen Label Propagation Der Algorithmus

4 iv Inhaltsverzeichnis Probleme Komplexität Algebraische Formulierung Markov Clustering Konvergenz des Markov Clustering Algorithmus Zusammenhänge zwischen Graphen und Eigenwerten Random Walks als Analysewerkzeug Bildsegmentierung mit spektraler Clusteranalyse Graphrepräsentation von Bildern Optimierungsproblem Relaxiertes Optimierungsproblem Laufzeit des NCut-Algorithmus Verallgemeinerung auf k Segmente Weiterführende Literatur Visualisierung von Graphen Spektrales Zeichnen Kräftegesteuertes Zeichnen Quadtree-Datenstruktur Multilevel-Verfahren für kräftegesteuertes Zeichnen Weiterführende Literatur Lastbalancierung paralleler Berechnungen Parallelität Dynamische Balancierung unabhängiger Lasten Das Diffusionsverfahren erster Ordnung (FOS) Weitere Verfahren zur dynamischen Lastbalancierung Balancierung abhängiger Lasten mittels Graphpartitionierung Bubble-Framework Gestörte Diffusion (FOS/C) Bubble-FOS/C Theoretische Ergebnisse zu Bubble-FOS/C DibaP Weiterführende Literatur Ausdünnung von Graphen und Laplace-Löser Schnitterhaltende Ausdünnung von Graphen Definitionen Der Sampling-Prozess Konzentration um den Erwartungswert Das Hauptresultat Spektrale Approximation Definitionen Graphen und elektrische Netzwerke Algorithmus und Beweis des Haupttheorems Kombinatorische Löser für Laplace-Systeme Grundidee Flüsse, Energie und Baumzyklen Der Algorithmus SimpleSolver Konvergenz des Algorithmus

5 Inhaltsverzeichnis v Beweis des Haupttheorems Weiterführende Literatur Literaturverzeichnis 94 A. Anhang 97 A.1. Grundlagen der linearen Algebra A.1.1. Spektrale Zerlegung einer symmetrischen Matrix

6

7 vii Vorwort Dieses Skript basiert im Wesentlichen auf der Vorlesung Graphenalgorithmen und lineare Algebra Hand in Hand, die ich im Sommersemester 2014 am Karlsruher Institut für Technologie (KIT) gehalten habe. Es sind jedoch teilweise zusätzlich Inhalte aus meinen anderen Vorlesungen bearbeitet worden und hier eingeflossen, u. a. aus Vorläuferskripten zu Vorlesungen von Robert Elsässer bzw. von Burkhard Monien an der Universität Paderborn. Das Skript erhebt keinen Anspruch auf Vollständigkeit, es ergänzt lediglich die Folien zur Vorlesung. Nehmen Sie zur Prüfungsvorbereitung auf jeden Fall sowohl Skript als auch Folien zur Hand. Beides zusammen ist wiederum nicht als Ersatz zum Besuch der Vorlesung gedacht, sondern als Hilfestellung bei der notwendigen Vor- und Nachbereitung. Sollten Sie auf Fehler stoßen, bitte ich um einen entsprechenden Hinweis. Auch für Verbesserungsvorschläge bin ich sehr dankbar. Mein großer Dank gilt den studentischen Hilfskräften Lukas Hartmann und Michael Wegner. Beide waren maßgeblich an der Anfertigung des Skriptes beteiligt. Karlsruhe, im Sommer 2014 Henning Meyerhenke

8

9 ix Versionen Version 0.1 Allgemein: Struktur der Vorlesung im Skript nachvollziehbar, auch wenn Inhalte fehlen Kapitel 1 im Wesentlichen vollständig, beinhaltet auch den Algorithmus von Seidel, der nicht Teil der aktuellen Vorlesung (SS 2014) ist Kapitel 1: Algorithmus von Seidel vorhanden, aber noch nicht gründlich auf Fehler überprüft Kapitel 5: Dynamische Lastbalancierung mit Diffusion im Wesentlichen vollständig Kapitel 5: Diffusionsbasierte Partitionierung nur in Ansätzen vorhanden (mehr folgt in Version 0.2.1) Versionen 0.2, und (15. bis 17. Juli 2014) Kapitel 5: Enthält eine leicht erweiterte Fassung zur Diffusion Kapitel 5: Diffusionsbasierte Partitionierung deutlich erweitert Kapitel 6: Schnitterhaltende Ausdünnung Version 0.3 (23. Juli 2014) Kapitel 6: Spektrale Ausdünnung, kombinatorischer Laplace-Löser sind nun enthalten. Weitere Verbesserungen in der Darstellung sind erst für spätere Versionen geplant. Version 0.4 und (31. Juli und 4. August 2014) Kapitel 2 Version 0.5 (6. August 2014) Kapitel 3 Version 0.6 (1. September 2014) Kapitel 4 Version (Mitte/Ende September 2014) Verbesserungen, Korrekturen der eingereichten Fehler

10

11 1 1. Grundlegende Graphenalgorithmen In dieser Vorlesung werden Sie eine Reihe von Algorithmen kennenlernen, die auf Graphen operieren. Ein Graph modelliert allgemein gesprochen eine Menge von Entitäten (dargestellt als Knoten) und die Beziehungen der Entitäten (dargestellt durch Kanten). Definition. Ein Algorithmus ist eine eindeutige Beschreibung eines Verfahrens zur Lösung einer bestimmten Klasse von Problemen. Genauer gesagt ist ein Algorithmus eine Menge von Regeln für ein Verfahren, um aus gewissen Eingabegrößen bestimmte Ausgabegrößen herzuleiten. Dabei muss dass Verfahren in einem endlichen Text beschreibbar sein. Jeder Schritt dieses Verfahrens muss auch tatsächlich ausführbar sein und darüber hinaus muss der Ablauf des Verfahrens zu jedem Zeitpunkt eindeutig definiert sein. Hier einige typische Beispielprobleme, in denen Graphenalgorithmen eine wichtige Rolle spielen: Wie findet ein Navigationssystem gute Verbindungen zwischen zwei Orten? Wie werden im Internet Informationen geroutet? Wie berechnet ein Unternehmen eine möglichst gute Aufteilung seiner Ressourcen, um seinen Gewinn zu maximieren? Wie finden Suchmaschinen Informationen schnell wieder? Um über die Qualität eines Algorithmus urteilen zu können, bedarf es bestimmter Kriterien, um entsprechende Urteile treffen zu können. 1. Algorithmen müssen korrekt sein. D.h. zu jedem Algorithmus gehört ein Korrektheitsbeweis, der in allgemeiner Form die Korrektheit der Berechnung der Ausgabegröße zu einer gegebenen Eingabegröße zeigt. 2. Algorithmen sollen zeit- und speichereffizient sein. Hierzu bedarf es Analysemethoden für den Zeit- und Speicherbedarf eines Algorithmus. Diese Analyse basiert in der klassischen Algorithmik nicht auf empirischen Untersuchungen, sondern auf mathematischen Analysen. Wir nutzen hierfür Pseudocode und Basisoperationen. Zum Entwurf eines Algorithmus gehören im Allgemeinen grundsätzlich drei Dinge: 1. Die Beschreibung des Algorithmus selbst in Pseudocode. 2. Ein vollständiger Korrektheitsbeweis. 3. Die Analyse des Zeit- und Speicherbedarfs des Algorithmus. In dieser Vorlesung (und somit auch in diesem Skript) wird aus Zeitgründen bei einigen Inhalten teilweise auf eine detaillierte Darstellung der obigen drei Punkte verzichtet. Diese Darstellung ist dann üblicherweise in der angegebenen Literatur zu finden.

12 2 1. Grundlegende Graphenalgorithmen 1.1. Dualität zwischen Graphen und Matrizen Für viele Graphenalgorithmen ist es vorteilhaft, die Dualität zwischen Graphen und ihren dazugehörigen Matrizen auszunutzen. Graphenalgorithmen können so zu Sequenzen von einfachen algebraischen Operationen umgeschrieben werden, meist Multiplikationen einer Matrix mit einem Vektor. In diesem Abschnitt werden die wichtigsten Verbindungen der beiden Konzepte vorgestellt. Grundlegend ist die Darstellung eines Graphen durch seine Adjazenzmatrix. Definition 1.1. Sei G = (V, E) ein ungewichteter Graph mit V = n. Die Adjazenzmatrix A ist eine n n-matrix, definiert durch: { 1, die Knoten i und j sind adjazent A ij = 0, sonst. Betrachte als Beispiel den ungerichteten Graphen G aus Abbildung und die zugehörige Adjazenzmatrix A A= Abbildung : Ungerichteter Graph G = (V, E) und die zugehörige Adjazenzmatrix A Eine weitere wichtige Verbindung besteht zwischen der Matrix-Vektor-Multiplikation und der Breitensuche (BFS). Sei e k R n der k-te Einheitsvektor (d.h. alle Einträge bis auf die k-te Stelle haben den Wert null). Dann gilt: (A T e k ) i = 1 genau dann, wenn der Knoten i vom Knoten k durch einen Schritt der Breitensuche erreichbar ist. Beachten Sie dabei, dass die transponierte Adjanzenzmatrix verwendet werden muss. Die Multiplikation mit e k wählt die Einträge der k-ten Spalte von A T, also die Einträge der k-ten Zeile von A aus. Ein Eintrag a ki in der k-ten Zeile von A ist nach Definition genau dann 1, wenn k und i durch eine Kante verbunden sind, also der Knoten i in einem Breitensuchschritt von k erreichbar ist. Wir werden nun die Prinzipien der gewöhnlichen Matrix-Vektor-Multiplikation auf einen Halbring erweitern. Definition 1.2. Ein Halbring ist eine Menge M mit zwei binären Verknüpfungen + und, genannt Addition und Multiplikation, sodass für alle x, y, z M gilt: Addition und Multiplikation besitzen je ein neutrales Element 0 bzw. 1. x + (y + z) = (x + y) + z (Addition ist assoziativ) x (y z) = (x y) z (Multiplikation ist assoziativ) x + y = y + x (Addition ist kommutativ) x (y + z) = x y + x z und (x + y) z = x z + y z (Distributivität) 0 x = x 0 = 0

13 1.1. Dualität zwischen Graphen und Matrizen 3 Die ganzen Zahlen Z und die reellen Zahlen R bilden bezüglich der gewöhnlichen Addition und Multiplikation einen Halbring. Fügen wir + zu Z oder zu R hinzu, so erhalten wir einen Halbring bezüglich der Verknüpfungen min als Addition und + als Multiplikation. Lineare Algebra über diesem Halbring ist oft nützlich, um Kürzeste-Wege-Probleme zu lösen. Wir werden nun Vektor- und Matrix-Operationen auf einem allgemeinen Halbring (R n, +, ) definieren. Definition 1.3. Seien c R, v R m, w R n und A = (a ij ) ij R m n. Die Addition mit einem Skalar c + v wird punktweise ausgeführt, d.h. c + v = (c + v 1,..., c + v n ). Das dyadische ( manchmal: äußere) Produkt v w ist eine m n-matrix definiert durch (v w) ij = v i w j. Ist m = n, so ist das innere Produkt oder Skalarprodukt v w definiert durch v w = i v i w i = (v 1 w 1 ) + + (v n w n ). Das Matrix-Vektor-Produkte v T A R n und Aw R m ist gegeben durch (v T A) k = i v i a ik bzw. (Aw) k = i a ki w i.. In einem gegebenen Halbring, der nicht die gewöhnliche Addition und Multiplikation besitzt, werden wir die Matrix-Vektor-Multiplikation Aw auch als A +. w darstellen, z. B. A min. + w für die Multiplikation bezüglich min und +. A min. + w ist dann ein n-dimensionaler Vektor, dessen i-ter Eintrag gerade min(a ij + w j ; 1 j n) ist. Definition 1.4. Seien A = (a ij ) ij und B = (b ij ) ij Matrizen. Die Addition mit einem Skalar c + A wird punktweise ausgeführt, d.h. (c + A) ij = c + a ij. Seien A R m n,v R m und w R n, so sind die punktweisen Matrix-Vektor-Produkte v. A und A. w Matrizen in R m n gegeben durch (v. A) ij = v i a ij bzw. (A. w) ij = w j a ij. Sind A, B R m n, so ist das punktweise Matrizenprodukt A. B von A und B eine Matrix in R m n mit (A. B) ij = a ij b ij. Analog definiere auch andere punktweise Operationen, wie A. + B. Sind A R m n und B R n p, dann ist das Matrizenprodukt AB R m p definiert durch (AB) ij = k a ik b kj. Auch beim Matrizenprodukt werden wir die Schreibweise A +. B benutzen, wenn wir die gegebenen Verknüpfungen explizit nennen möchten.

14 4 1. Grundlegende Graphenalgorithmen Mit Hilfe eines Halbrings lassen sich nun viele Graphenalgorithmen einfach durch Matrizen darstellen. So kann im Bellman-Ford-Algorithmus (siehe Abschnitt 1.3.2) für kürzeste Wege die Aktualisierung des Distanzvektors d als Multiplikation mit der Adjazenzmatrix A als d d min. + A geschrieben werden. Ein weiteres Anwendungsbeispiel ist die Bestimmung von Teilgraphen, welches sich mit Hilfe der Adjazenzmatrix auf ein Zeilen- und Spalten-Auswahlproblem zurückführen lässt. Sei dazu v R n und diag(v) die Diagonalmatrix mit Dimension n n, deren Einträge gerade die Werte von v sind. Dann können wir eine (gewichtete) Zeilen- oder Spaltenauswahl durch Matrizenmultiplikationen, bezüglich der gewöhnlichen Addition und Multiplikation, folgendermaßen darstellen: Zeile auswählen: diag(u) A Spalte auswählen: A diag(v) Zeile und Spalte auswählen: diag(u) A diag(v) Als letztes Beispiel geben wir die Berechnung der Zeilen- und der Spaltensumme einer Matrix an. Sei A = (a ij ) ij R m n eine Matrix und u = (1,..., 1) R m und v = (1,..., 1) R n Vektoren mit Einträgen 1. Dann ist Av ein Vektor und es gilt (Av) i = k a ik v k = k a ik, d.h. der Eintrag (Av) i ist die Summe der Einträge der i-ten Zeile von A. Analog folgt, dass (ua) j gerade die Summe der Einträge der j-ten Spalte von A ist Starke Zusammenhangskomponenten Definition Definition 1.5. Ein (möglicherweise) gerichteter Multigraph ist ein Paar G = (V, E) aus einer endlichen Menge V von Knoten und einer Multimenge E V V von Kanten. Eine Kante e {(v, v) v V } heißt Schleife. Kanten e E mit #e = k > 1 (Mehrfachauftreten) heißen Multikanten. Einen Multigraphen, der weder Schleifen noch Multikanten besitzt, nennen wir schlicht. Wir werden nun den Zusammenhang und darauf aufbauend Zusammenhangskomponenten eines Graphen definieren. Definition 1.6. Sei G = (V, E) ein Multigraph. G heißt stark zusammenhängend, wenn für jedes Paar (u, v) V V sowohl ein (gerichteter) (u, v)-weg, als auch ein (v, u)-weg in G existiert. G heißt (schwach) zusammenhängend, wenn der zu G gehörige Multigraph stark zusammenhängend ist. Sei G nun ein ungerichteter Multigraph. G heißt k-fach zusammenhängend, falls jeder durch Entfernen von höchstens k 1 Knoten (und aller inzidenten Kanten) aus G entstehende Teilgraph zusammenhängend ist.

15 1.2. Starke Zusammenhangskomponenten 5 G heißt k-fach kantenzusammenhängend, falls jeder durch das Entfernen von höchstens k 1 beliebigen Kanten aus G entstehende Teilgraph zusammenhängend ist. Definition 1.7. Zu einem schlichten Multigraphen G heißt ein maximaler stark zusammenhängender Teilgraph starke Zusammenhangskomponente. Analog definieren wir eine schwache, k-fach zusammenhängende bzw. k-fach kantenzusammenhängende Zusammenhangskomponente. Ein Beispiel für starke Zusammenhangskomponenten kann unter folgender Adresse gefunden werden: Algorithmus Wir möchten nun einen Algorithmus entwickeln, um starke Zusammenhangskomponenten in einem gegebenen Graphen zu finden. Als Grundidee benutzen wir das nachfolgende Resultat: Theorem 1.8. Sei A die Adjazenzmatrix des Graphen G. Dann ist (A k ) ij die Anzahl der Wege der Länge k zwischen den Knoten i und j. Beweis. Wir beweisen das Theorem mittels Induktion über k. Für k = 1 ist ein Weg der Länge 1 genau eine Kante und damit gilt die Aussage nach Definition der Adjazenzmatrix. Sei nun die Aussage für ein k bewiesen. Dann gilt: (A k+1 ) ij = l A il (A k ) lj. Also ist (A k+1 ) ij die Summe aus der Zahl der Kanten von i nach l und dann (nach Induktionsvoraussetzung) der Wege der Länge k von l nach j. Die Kante von i nach l verlängert somit den Weg um 1, also gibt (A k+1 ) ij die Anzahl der Wege der Länge k + 1 von i nach j an. Sei nun die Matrix C mittels punktweiser oder-funktion definiert als C = I A A 2 A 3 A 4... Nach Theorem 1.8 ist C ij genau dann 0, wenn ein Pfad beliebiger Länge zwischen den Knoten i und j existiert. Beachten Sie dabei, dass wir hier auch triviale Wege der Länge 0 zulassen. Analog enthält C T somit einen Eintrag (C T ) ij 0 genau dann, wenn ein Pfad zwischen j und i existiert. Für C C T gilt folglich, dass (C C T ) ij genau dann 0 ist, wenn die Knoten i und j in der gleichen starken Zusammenhangskomponente liegen. Ist die Adjazenzmatrix A symmetrisch, so gilt auch C = C T und somit liefert uns die Matrix C bereits alle benötigten Informationen. Wir verwenden allerdings im Folgenden statt der Oder-Verknüpfung die Addition und definieren die Matrix D als D = I + A + A 2 + A 3 + A Der Grund für die Verwendung der Addition statt der Oder-Verknüpfung liegt in der einfacheren Umformbarkeit und wird nachfolgend klar. Es gilt nun D ij = 0 C ij = 0 und somit auch D ij 0 genau dann, wenn die Knoten i und j durch einen Pfad verbunden sind. Weiterhin gilt mit F = (I A)D: F = D AD = I +A + A 2 + A 3 + A = I A A 2 A 3 A 4...

16 6 1. Grundlegende Graphenalgorithmen Das bedeutet, dass D = (I A) 1 gilt und sich so die benötigte Matrix D berechnen lässt. Allerdings konvergiert die Reihe D häufig nicht Konvergenz Um die Konvergenz der Reihe D zu erhalten, wandeln wir die Reihe etwas ab. Sei α > 0 und definiere D als D = I + (αa) + (αa) 2 + (αa) 3 + (αa) Die Matrix D besitzt noch immer die gewünschten Eigenschaften und für hinreichend kleines α konvergiert die Reihe. Wie α gewählt werden muss, wird in der nachfolgenden Aufgabe geklärt. Aufgabe 1.9. Die Zeilensummennorm einer Matrix A ist definiert als A = max i=1,...,n k=1 n a ik. Es gilt: BA B A für Matrizen A und B R n n (sogar noch allgemeiner). Außerdem gilt α A = α A für α R. Leiten Sie eine passende Wahl von α her, so dass die Reihe lim k k i=0 αi A i konvergiert! Sie können z. B. das Quotientenkriterium von d Alembert anwenden. Beweis. Wenn α < 1 A, dann folgt: α 2 A 2 = α 2 A 2 < A 2 = 1. Dies gilt auch für A 2 alle weiteren Reihenglieder. Also folgt nach dem Quotientenkriterium von d Alembert, dass die Reihe konvergiert. Sei daher nun 0 < α < 1 A. Setzen wir F = (I αa)d, dann ergibt sich: F = D αad = I +(αa) + (αa) 2 + (αa) 3 + (αa) = I (αa) (αa) 2 (αa) 3 (αa) Also gilt D = (I αa) 1, wobei D konvergiert. Wir können nun D berechnen und zusammenfassend gilt (D + D T ) ij 0 genau dann, wenn die Knoten i und j in der selben starken Zusammenhangskomponente liegen Kürzeste Wege Definitionen In diesem Abschnitt betrachten wir das Problem kürzester Wege in gerichteten Graphen mit Kantengewichten. In einem unidirektionalen, zusammenhängenden Graphen G = (V, E) mit V = {1,..., n} und E = m als Eingabegrößen soll als Ausgabegröße für jedes Paar von Knoten u, v V die Distanz von u nach v, sowie ein kürzester Weg zwischen den beiden Knoten im Graphen G berechnet werden. Definition Sei ein gerichteter und gewichteter Graph G = (V, E) mit der Gewichtsfunktion w : E R gegeben. Das Gewicht eines Weges P = v 0, v 1,..., v k ist die Summe der

17 1.3. Kürzeste Wege 7 Abbildung : Unidirektionaler, gewichteter Graph G = (V, E) Gewichte seiner Kanten: w(p ) = k w(v i 1, v i ). i=1 Definition Das Gewicht eines kürzesten Weges P in einem gerichteten und gewichteten Graphen G = (V, E) zwischen den Knoten u, v V ist definiert als: { min{w(p ) : v ist von u über P erreichbar}, δ(u, v) =, falls v von u nicht erreichbar ist. Ein kürzester Weg zwischen u, v V ist dann ein Weg P mit w(p ) = δ(u, v). Die Eingabe wird als Gewichtsmatrix W = (w ij ) ij dargestellt, die den Graphen repräsentiert. Die Matrix-Einträge w ij sind wie folgt definiert: 0, wenn i = j w ij = Gewicht der ger. Kante (i, j), wenn i jund (i, j) E, wenn i jund (i, j) / E Aus dieser Definition folgt für den Graphen G aus Abbildung 1.11 die Gewichtsmatrix w ij, abgebildet in der nachfolgenden Tabelle. Tabelle 1.1.: Gewichtsmatrix W zum Graphen G aus Abbildung 1.11 a b c d e f a b 0 4 c d e f Algorithmus von Bellman und Ford Der Algorithmus von Bellman und Ford berechnet von einem gegebenen Startknoten s V die kürzesten Wege in G (single-source shortest paths). Dabei wird auch erkannt, ob in G ein negativer Kreis existiert. In diesem Fall ist eine Berechnung nicht möglich und der Algorithmus bricht mit einer Fehlermeldung ab. Somit ist dieser Algorithmus im Gegensatz zu Dijkstras Algorithmus auch verwendbar, wenn der Eingabegraph negative Kantengewichte hat. Der komplette Algorithmus ist in Algorithmus 1 darstellt.

18 8 1. Grundlegende Graphenalgorithmen Für jeden Knoten v V wird in d(v) das Gewicht des bisher gefundenen kürzesten Weges von s nach v gespeichert. Initial setzen wir d(v) = für v V \ {s} und d(s) = 0. Der Algorithmus führt nun eine Reihe von Kantenrelaxierungen aus. Wird eine Kante e = (u, v) relaxiert, so wird überprüft, ob durch e ein besserer, d.h. kürzerer, Weg von s nach v verläuft. Wir setzen also d(v) min {d(v), d(u) + w uv }. Der Algorithmus besteht aus n 1 Runden, in denen jeweils alle Kanten (in einer beliebigen Reihenfolge) relaxiert werden. Können die bis jetzt berechneten Distanzen nochmals verbessert werden, so existiert ein negativer Kreis im Graphen. Andernfalls gilt nach Berechnung die gewünschte Eigenschaft δ(s, v) = d(v). Um nicht nur das Gewicht des kürzesten Weges von s nach v zu erhalten, wird zusätzlich der Vaterknoten π(v) von v gespeichert, der vor v auf dem kürzesten Weg von s nach v liegt. Somit kann der kürzeste Weg rekonstruiert werden. Algorithmus 1 : Bellman-Ford Input : Graph G = (V, E), Gewichtsfunktion w, Startknoten s Output : Distanz des kürzesten Wegs d(v), Vaterknoten π(v) (für v V ) 1 foreach v V do 2 d(v) 3 π(v) NIL 4 d(s) 0 5 for k = 1 to n-1 do 6 foreach (u, v) E do // Relaxierung der Kante (u, v) 7 if d(v) > d(u) + w ij then 8 d(v) d(u) + w ij 9 π(v) u 10 foreach (u, v) E do 11 if d(v) > d(u) + w ij then 12 return Negativer Kreis existiert! Wir möchten nun den Algorithmus mit algebraischen Mitteln formulieren. Wir definieren dazu { min {w(p ) : P ist Pfad von unach vmit P k} δ k (u, v) =, sonst als die Länge des kürzesten Weges zwischen u und v, der höchstens k Kanten benutzt. Falls δ n (s, v) < δ n 1 (s, v) für einen beliebingen Knoten v V gilt, dann gibt es einen Zyklus negativer Länge. Andernfalls gilt δ(s, v) = δ n 1 (s, v). Die Berechnung von δ k (s, v) mittels δ k 1 (s, v) ist äquivalent zur Relaxierung aller zu v inzidenten Kanten. Insbesondere gilt somit δ k (s, v) = min {δ k 1(s, u) + w uv }. u N(v) Wir stellen ferner fest, dass δ k alleine mit Hilfe von δ k 1 und der gegebenen Gewichtsmatrix W berechnet werden kann. Alle vorher berechneten δ i können folglich gelöscht werden. Sei d k R n nun ein Vektor zum Speichern der Informationen von δ k, d.h. es gilt d k (v) = δ k (s, v). Dann lässt

19 1.3. Kürzeste Wege 9 sich d k und somit δ k mittels Matrix-Vektor-Multiplikation berechnen durch d k = d k 1 min. + W, wobei wir initial d 0 setzen als d 0 (v) = { 0, v = s, sonst. Da wir nach obiger Überlegung δ k 1 nach der Berechnung von δ k nicht mehr benötigen, können wir die Informationen in einem einzigen Vektor d speichern und verwenden somit d d min. + W. Sofern der Graph keinen negativen Kreis besitzt, gilt folglich nach n 1 Runden δ(s, v) = d(v). Zusammengefasst ergibt sich Algorithmus 2. Algorithmus 2 : Algebraischer Bellman-Ford-Algorithmus Input : Adjazenzmatrix A, Startknoten s Output : Distanzvektor d 1 d 2 d s 0 3 for k = 1 to n 1 do 4 d d min. + A 5 if d d min. + A then 6 return Negativer Kreis existiert! 7 return d Paarweise kürzeste Distanzen Der Floyd-Warshall-Algorithmus Der Floyd-Warshall-Algorithmus basiert auf der Idee, das Problem schrittweise zu vergrößern. In Iteration k werden alle Wege berücksichtigt, die über Knoten aus der Menge {1,..., k} verlaufen (direkte Kanten des Graphen eingeschlossen). Nach Ende der äußersten Schleife hat k den Wert n überschritten, so dass alle möglichen Wege berücksichtigt worden sind. Algorithmus 3 : Floyd-Warshall-APSP Input : Graph G = (V, E) Output : Distanzmatrix 1 D (0) W 2 for k 1 to n do 3 for i 1 to n do 4 for j 1 to n do 5 d (k) ij min(d (k 1) ij, d (k 1) ik + d (k 1) kj ) 6 return D (n)

20 10 1. Grundlegende Graphenalgorithmen Lemma Sei G ein Graph ohne negative Zyklen und sei j von i aus erreichbar. Dann gibt es einen kürzesten i j-weg, der keinen Knoten doppelt benutzt. Theorem Sei G = (V, E) ein Graph mit nicht-negativen Zyklen. Dann berechnet der Algorithmus von Floyd-Warshall die Entfernung zwischen jedem Knotenpaar in O( V 3 ) Schritten. Die Beweise von Lemma 1.12 und Theorem 1.13 werdem dem Leser anhand der obigen Erläuterungen als Übung empfohlen. Bemerkung Das als Algorithmus 3 angegebene Verfahren löst nur das Problem All-Pairs- Distances (APD), d.h. es werden die paarweisen Distanzen und nicht auch die zugehörigen kürzesten Wege berechnet. Eine entsprechende Erweiterung des Algorithmus für APSP wird dem Leser ebenfalls als Übungsaufgabe empfohlen Matrix-Multiplikation Wir betrachten nun ungerichtete Graphen G = (V, E) mit der Knotenmenge V = {1,..., n}. Ein Graph G = (V, E) ist gegeben durch seine Adjazenzmatrix A. Im Folgenden betrachten wir zunächst das Problem der Matrixmultiplikation. Es seien D, W (R { }) n n quadratische Matrizen. Verwenden wir die Verknüpfungen (min, +) bei der Matrizenmultiplikation, so gilt bekanntlich: (DW ) ij = min 1 k n {D ik + W kj } Diese Tatsache setzen wir nun ein, um mit Hilfe eines modifizierten Algorithmus zur Matrixmultiplikation die Distanzen aller paarweise kürzesten Wege zu berechnen. Die wichtige Idee dabei ist, D (n 1) = δ n 1 (i, j) durch fortgesetzte Matrixmultiplikation zu berechnen: D (1) = W, D (2) = W 2 = W W, D (4) = W 4 = W 2 W 2,... D (2 log n 1 ) = D 2 log n 1 = D log n 1 1 log n 1 1 D Algorithmus 5 namens mmapd zeigt nun, wie man durch fortgesetzte Aufrufe an eine Subroutine zur modifizierten Matrixmultiplikation die Distanzen der paarweise kürzesten Wege berechnen kann. Algorithmus 4 : MatrixMultiply Input : Matrizen A, B Output : Matrizenprodukt AB 1 for i = 1 to n do 2 for j = 1 to n do 3 C ij 4 for k = 1 to n do 5 C ij min{c ij, A ik + B kj } 6 return C Momentan liegt die beste bekannte Laufzeit eines Algorithmus für Matrixmultiplikation bei O(n ) [LG14]. Eine bessere untere Schranke als Ω(n 2 ) ist nicht bekannt, so dass hier eine noch nicht geschlossene Lücke zwischen unterer und oberer Laufzeitschranke klafft. Die obere Laufzeitschranke kann auf die Multiplikation von boolschen Matrizen angewandt werden, wie wir in Kürze sehen werden. Bedauerlicherweise folgt aus dieser Beobachtung aber

21 1.3. Kürzeste Wege 11 Algorithmus 5 : mmapd Input : Gewichtsmatrix W Output : Distanzmatrix 1 D (1) W 2 m 1 3 while m < n 1 do 4 D (2m) MatrixMultiply(D (m), D (m) ) 5 m 2m 6 return D (m) auch eine Laufzeit für das APD Problem, die größer als O(n 2 ) ist (jedenfalls solange man über keinen Algorithmus mit quadratischer Zeitkomplexität zur Matrixmultiplikation verfïügt). Die Laufzeit des Algorithmus mmapd ist O(mm(n) log n), wobei mm(n) die Zeit ist, um zwei n n Matrizen miteinander zu multiplizieren. Es gibt allerdings einen Nachteil, denn es gibt keine implizite Darstellung der kürzesten Wege, denn dazu wären alle Matrizen D 1,..., D m notwendig und die Laufzeit würde auf O(mm(n) n) ansteigen Distanzberechnung mit dem Algorithmus von Seidel Wir betrachten nun das Problem Distanzberechnungen in ungerichteten und ungewichteten Graphen. Problem APD: Gegeben: Ungerichteter, ungewichteter Graph G = (V, E). Gesucht: Matrix D = (δ(i, j)) ij, wobei δ(i, j) die Distanz von i nach j in G ist. Wir werden zunächst einen alternativen Algorithmus kennenlernen, der das APD-Problem in Zeit O(mm(n) log n) für ungewichtete, ungerichtete Graphen löst. Dieser Algorithmus wird anschließend so erweitert, dass auch die kürzesten Wege zu den Distanzen schnell berechnet werden können. Bemerkung Es sei G(V, E) ein ungerichteter, ungewichteter Graph mit Adjazenzmatrix A. Ist Z = A 2, so ist Z ij > 0 genau dann, wenn es einen Weg der Länge 2 von i nach j gibt. Z ij gibt die Anzahl der verschiedenen Wege der Länge 2 von i nach j an, was aus Theorem 1.8 folgt. Damit können wir durch eine einfache Matrixmultiplikation eine Matrix Z berechnen, die es erlaubt, schnell einen Graphen G zu berechnen, in dem zwei Knoten i und j genau dann miteinander verbunden sind, wenn δ(i, j) 2 in G ist: Z = A { 2 A ij = 1, falls i j und (A ij = 1 oder Z ij > 0) 0, sonst G = der durch A induzierte Graph Lemma Es sei G = (V, E) ein ungerichteter, ungewichteter Graph mit Adjazenzmatrix A. Ist A derart, dass A ij = 1 genau dann gilt, wenn i j und (A ij = 1 oder Z ij > 0), und ist D die Distanzmatrix des durch A gegebenen Graphen G, so gilt:

22 12 1. Grundlegende Graphenalgorithmen 1. D ij = 2D ij, wenn D ij gerade ist und 2. D ij = 2D ij 1, wenn D ij ungerade ist. Beweis. Wir betrachten die beiden Fälle: Fall D ij = 2k ist gerade: kürrzester Weg P = i = i 0, i 1,..., i 2k 1, i 2k = j von i nach j in G. P = i = i 0, i 2,..., i 2k 2, i 2k = j ist Weg von i nach j in G. D ij k Wäre D ij = l < k, so existierte ein Weg Q von i nach j in G der Länge 2l (Widerspruch, da D ij = 2k). Daraus folgt D ij = k. Also D ij = 2k = 2D ij. Fall D ij = 2k + 1 ungerade: kürrzester Weg P = i = i 0, i 1,..., i 2k, i 2k+1 = j von i nach j in G. P = i = i 0, i 2,..., i 2k, i 2k+1 = j ist Weg von i nach j in G. D ij k + 1 Wäre D ij = l k, so existierte ein Weg Q von i nach j in G der Länge 2k (Widerspruch, da D ij = 2k + 1). Daraus folgt D ij = k + 1. Also D ij = 2k + 1 = 2D ij 1. Die Idee für einen Algorithmus beläuft sich auf drei hauptsächliche Schritte: 1. Berechne die Distanzen D für G (rekursiv). 2. Berechne die Parität der Distanzen in G. 3. Dann liefert Lemma 1.16 eine Berechnungsvorschrift für die Distanzen D in G. Lemma Betrachte ein beliebiges Paar disjunkter Knoten i, j V des Graphen G. 1. Für alle Nachbarn k Γ(i) gilt D ij 1 D kj D ij Es existiert ein Nachbar k Γ(i) mit D kj = D ij 1. Beweis. Sei P = i = i 1, i 2,..., i p+1 = j kürzester Weg von i nach j in G, also D ij = p. 1. Sei k Γ(i), d. h. {i, k} E. a) k = i 2 P 1 = k = i 2,..., i p+1 = j ist Weg von k nach j D kj p + 1 b) k i 2 P 2 = k = i 0, i 1,..., i p+1 = j ist Weg von k nach j D kj p + 1 In jedem Fall: D kj p + 1 = D ij + 1 c) Annahme: D kj = q < D ij 1. Dann existiert P 3 = k = k 1, k 2,..., k q+1 = j von k nach j P 4 = i = k 0, k 1, k 2,..., k q+1 = j ist ein Weg der Länge q + 1 < D ij von i nach j (Widerspruch zur Definition von D ij ). 2. Folgt aus 1 (a) und (c). Lemma Betrachte ein beliebiges Paar disjunkter Knoten i, j V des Graphen G.

23 1.3. Kürzeste Wege Ist D ij gerade, so ist D kj D ij für alle Nachbarn k Γ(i). 2. Ist D ij ungerade, so ist D kj D ij für alle Nachbarn k Γ(i). Außerdem existiert ein k Γ(i) derart, dass D kj < D ij. Beweis. Wir betrachten die beiden Fälle: Fall 1. D ij = 2l ist gerade. }{{} Nachbarn k Γ(i): D kj 2l 1 Lemma 1.17 Dann ist D ij = l nach Lemma 1.16 a). Weiter folgt aus Lemma 1.16 a,b), dass D kj D kj/2 l 1 2 D kj ist ganzzahlig D kj l = D ij Fall 2. D ij = 2l 1 ist ungerade. }{{} Nachbarn k Γ(i): D kj 2l Lemma 1.17 Dann ist D ij = l nach Lemma 1.16 b). Weiter folgt aus Lemma 1.16 a,b), dass D kj (D kj + 1)/2 l D kj ist ganzzahlig D kj l = D ij Weiter gilt, dass ein k Γ(i) mit D kj = D ij 1 = 2l 2 existiert, also gilt D kj = l 1 < l = D ij nach Lemma 1.16 a). Lemma Betrachte ein beliebiges Paar disjunkter Knoten i, j V des Graphen G. 1. D ij ist gerade genau dann, wenn k Γ(i) D kj D ij deg (i). 2. D ist ungerade genau dann, wenn k Γ(i) D kj < D ij deg (i). Beweis. Es gilt: Fall 1. D ij ist gerade }{{} k Γ(i) D kj k Γ(i) D ij = deg(i)d ij. Lemma 1.18 a) Fall 2. D ij ist ungerade }{{} k Γ(i) D kj k Γ(i) D ij 1 = deg(i)d ij 1. Lemma 1.18 b) Die jeweilige Rückrichtung ergibt sich durch die Betrachtung der beiden komplementären Fälle. Wir betrachten nun den Algorithmus APD, der die Distanzen D ij für alle Knotenpaare (i, j) für einen gegebenen ungerichteten Graphen G berechnet. Der Graph wird durch seine Adjazenzmatrix A repräsentiert. Theorem Der Algorithmus APD berechnet die Distanzmatrix D eines n-knoten Graphen G in Zeit O(mm(n) log n) mit Hilfe der ganzzahligen Matrixmultiplikation, wobei die Einträge der Matrix nicht größer als O(n 2 ) sind. Beweis. Sei δ der Durchmesser von G. Dann hat G Durchmesser δ = δ/2. Sei T (n, δ) die Zeit, die APD auf Graphen mit n Knoten und Durchmesser δ benötigt. Ist δ = 1, so ist G vollständig. Ist δ = 2, so ist T (n, δ) = mm(n) + O(n 2 ). Wegen δ < n, mm(n) = Ω(n 2 ) und Rekursionstiefe log n folgt die Laufzeit O(mm(n) log n). Wegen D ij < n und somit D ij < n sind die Einträge von S durch n 2 nach oben beschränkt.

24 14 1. Grundlegende Graphenalgorithmen Algorithmus 6 : APD Input : Adjazenzmatrix A Output : Distanzmatrix D 1 Z A 2 2 Berechne A mit A ij = 1 i j und (A ij = 1 oder Z ij > 0) // A ij = 1 es ex. Weg der Länge 1 od. 2 v. i nach j 3 if A ij = 1 i j then 4 return D 2A A // Rekursionsabbruch 5 D AP D(A ) // Rekursion 6 S A D // S ij = { k Γ(i) D kj 2D ij 7 return D mit D ij =, falls S ij D ij Z ii 2D ij 1, falls S ij < D ij Z // Z ii = deg(i) ii Paarweise kürzeste Wege mit dem Algorithmus von Seidel Wir werden nun den Algorithmus von Seidel für das Problem APD so erweitern, dass nicht nur die Distanzen D ij, sondern auch für jedes Knotenpaar (i, j) ein kürzester Weg berechnet wird. Der erweiterte Algorithmus löst somit das Problem APSP: Problem APSP: Gegeben: Ungerichteter, ungewichteter Graph G = (V, E). Gesucht: Matrix D = (δ(i, j)) ij wie bei APD und eine implizite Darstellung der kürzesten Wege. Dabei soll die Laufzeit des neuen Algorithmus subkubisch sein. Wir werden zeigen, dass das APSP-Problem in erwarteter Zeit O(mm(n) log 2 n) durch einen randomisierten Algorithmus lösbar ist. Das Problem ist jedoch, dass es Graphen G = (V, E) von der Gestalt gibt, dass Ω(n 2 ) Knotenpaare Distanz Ω(n) haben. Beispiel G = (V, E) ist eine Linie : V = {1,..., n}, E = {(i, i + 1) 1 i < n}. Setze δ = n 2 = Ω(n), dann haben n δ k = k=1 (n δ + 1)(n δ) 2 > n2 8 = Ω(n2 ) Knotenpaare mindestens den Abstand δ zueinander. Explizites Speichern der kürzesten Wege würde daher Platzbedarf Ω(n 3 ), also auch Zeitaufwand Ω(n 3 ), bedeuten. Daher werden die kürzesten Wege nur implizit gespeichert, indem zu jedem Knotenpaar (i, j) der Nachfolger S ij von i auf einem kürzesten Weg nach j gespeichert wird. S = (S ij ) hat O(n 2 ) Einträge und ein kürzester Weg von i nach j kann in Zeit proportional zu seiner Länge bestimmt werden: Wir bezeichnen im Folgenden: die boolsche 1 Matrixmultiplikation mit als Multiplikation und als Addition durch " " 1 Da diese Bezeichnung auf George Boole ( ) zurückgeht, findet man auch häufig die Schreibweise boolesche Matrixmultiplikation.

25 1.3. Kürzeste Wege 15 Algorithmus 7 : SPN Input : S, i, j 1 x 0 i 2 k 0 3 repeat 4 x k+1 S xk j 5 k + +; 6 until x k = j 7 return {x 0,..., x k } und die ganzzahlige Matrixmultiplikation mit " ". Definition Es seien A, B {0, 1} n n boolsche Matrizen, P = A B {0, 1} n n das boolsche Produkt von A und B. Ein Zeuge für P ij ist ein Index k {1,..., n} derart, dass A ik = 1 = B kj. Bemerkung Es gilt: 1. P ij = 1 es gibt einen Zeugen k für P ij. 2. Ist C = A B, so ist C ij die Anzahl der Zeugen für P ij. 3. Ist A Adjazenzmatrix eines Graphen G = (V, E), P = A A und C = AA, so ist P ij = 1 genau dann, wenn ein Weg der Länge 2 zwischen i und j existiert. C ij ist die Anzahl dieser Wege (vgl. Lemma 1.15). 4. Für P = A A ist ein Zeuge k für P ij = 1 Zwischenknoten auf einem Weg der Länge 2 von i nach j. 5. Für jedes P ij bzgl. P = A B kann es bis zu n Zeugen geben. Zeugen sind interessant, wenn man den APD-Algorithmus so erweitern will, dass er kürzeste Wege berechnet. Da Zeugen Zwischenknoten auf Wegen der Länge 2 darstellen, helfen sie bei der Konstruktion einer Nachfolgermatrix. Wie genau dies funktioniert, wird nachfolgend erläutert. Definition Es seien A, B {0, 1} n n boolsche Matrizen, P = A B {0, 1} n n. Eine Zeugenmatrix (Bpwm = Boolean Product Witness Matrix) für P ist eine Matrix W {0,..., n} n n mit { 0, wenn P ij = 0 W ij = k, k ist Zeuge für P {ij} = 1 Problem Bpwm: gegeben: boolsche Matrizen A und B. gesucht: eine Zeugenmatrix W für P = A B. Ein trivialer Algorithmus für Bpwm, der für alle (i, j) {1,..., n} 2 alle k {1,..., n} testet, hat Zeitaufwand O(n 3 ). Da wir einen niedrigeren Aufwand anstreben, vereinfachen wir zunächst das Problem Bpwm:

26 16 1. Grundlegende Graphenalgorithmen Problem UniqueBpwm: gegeben: boolsche Matrizen A und B, so dass jeder Eintrag in P = A B einen eindeutigen Zeugen hat. gesucht: die Zeugenmatrix W für P = A B. Lemma Es seien A, B {0, 1} n n boolsche Matrizen und die Matrizen  und W gegeben durch Âik = ka ik und W = ÂB. Dann gilt: 1. W ij ist Zeuge für P ij, wenn P ij einen eindeutigen Zeugen hat. 2. Hat jeder Eintrag von P ij einen eindeutigen Zeugen, so ist W die Lösung von UniqueBpwm. Beweis. Es ist n W =  ik B kj = k=1 = n k A ik B kj k=1 k, falls genau ein A ik B kj = 1 0, falls A ik B kj = 0 k > k, falls A ik B kj = 1 und A il B lj = 1 für ein l k. Beispiel A = 1 0 0, B = 1 1 0, P =  = und W = Die grünen und blauen Einträge von W sind schon korrekte Einträge für eine Zeugenmatrix, der rote jedoch nicht. Bemerkung Das Problem UniqueBpwm kann durch eine ganzzahlige Matrixmultiplikation, also in Zeit O(mm(n)), gelöst werden. Problematisch ist nun, dass wir eine Zeugenmatrix W für P = A A mit einer Adjazenzmatrix A berechnen wollen. Dabei ist natïrlich nicht garantiert, dass die Zeugen immer eindeutig sind. Die Idee zur Lösung des Problems lässt sich so beschreiben: Randomisierung liefert den gleichen Effekt wie eindeutige Zeugen für genügend viele Einträge P ij, denn bei einer zufälligen Auswahl von Kandidatenmengen trifft man wahrscheinlich auf eine Menge mit genau einem Zeugen. Die wenigen verbleibenden Einträge werden dann mit dem trivialen Algorithmus berechnet.

27 1.3. Kürzeste Wege Nicht eindeutige Zeugen Wir betrachten boolsche Matrizen A, B {0, 1} n n, P = A B, C = AB und einen festen Eintrag P ij von P. Es sei w = C ij die Anzahl der Zeugen für P ij (OE w 2, denn nach den Vorbetrachtungen ist es einfach, einen eindeutigen Zeugen zu finden). Außerdem sei r N mit n 2 wr n. Ziel ist es, eine Menge R {1,..., n} mit R zu finden, die den eindeutigen Zeugen k für P ij enthält. Lemma Es sei n N, w {1,..., n}, r N mit n 2 wr n. Eine Urne enthalte n Bälle, von denen w weiß und n w schwarz sind. Zieht man zufällig r Bälle aus der Urne, ohne diese zwischendurch zurückzulegen, so ist: P r(genau ein weißer Ball wurde gezogen) 1 2e. Beweis. Durch elementare Rechenoperationen kann die gesuchte Wahrscheinlichkeit wie folgt beschränkt werden: ( w n w ) 1)( r 1 ( n ) = w r! (n w)! (n r)! (r 1)! n! (n w r + 1)! r ( w 1 ) w 2 1 = wr (n r j) n i i=0 j=0 = wr w 2 n r j n n 1 j j=0 wr w 2 n r j (w j 1) siehe (*) n n 1 j (w j 1) j=0 = wr w 2 n w (r 1) n n w = wr n 1 2 j=0 ( 1 r 1 n w ) w 1 ( 1 1 w ) w 1 siehe (**) (*) Gilt faktorweise: a = n r j, b = n 1 j, c = w j 1. Dann ist a(b c) b(a c) ac bc a b. (**) r 1 n w 1 w (r 1)w n w rw n. Die letzte Ungleichung folgt von den Beobachtungen, dass wr/n 1/2 und (r 1)/(n w) 1/w, was aus der Annahme, dass n/2 wr n, folgt. Beispiel n = 8, w = 3, n w = 5. Einzig mögliche Wahl für r mit n 2 wr n ist r = 2: 3 Möglichkeiten, genau 2 weiße Bälle zu ziehen 10 Möglichkeiten, genau 2 schwarze Bälle zu ziehen 15 Möglichkeiten, genau 1 weißen und 1 schwarzen Ball zu ziehen

28 18 1. Grundlegende Graphenalgorithmen 28 Möglichkeiten insgesamt. Damit ist P r(genau ein weißer Ball wurde gezogen) = = > 1 2 > 1 2e Sei jetzt R {1,..., n} derart, dass R einen eindeutigen Zeugen für P ij enthällt. R sei gegeben durch einen Vektor R {0, 1} n mit R k = 1 genau dann, wenn k R. Definiere: eine Matrix A R N n n 0 durch A R ik = kr ka ik und eine Matrix B R N n n 0 durch B R kj = R kb kj Weiterhin sind die Matrizen  mit Âik = ka ik sowie B und W =  B so wie bereits weiter oben verwendet. A R ist die Matrix, die aus  entsteht, indem jede Spalte von Â, die zu einem Element k / R gehört, durch eine Nullspalte ersetzt wird und jede andere Spalte k mit k multipliziert wird. B R ist die Matrix, die aus B entsteht, indem jede Zeile von B, die zu einem Element k / R gehört, durch eine Nullzeile ersetzt wird. Lemma Es seien A, B {0, 1} n n boolsche Matrizen, A R und B R wie oben, W = A R B R. Wenn P ij einen eindeutigen Zeugen in R hat, so ist W ij Zeuge für P ij. Beweis. W ij = (A R B R ) ij = n k=1 AR ik BR kj = n k=1 k R k A ik R k B kj = k R k A ik B kj. Wenn R nur einen einzigen Zeugen enthält, folgt aus der Zeugeneigenschaft: W ij = k A ik B kj = k, wobei k der eindeutige Zeuge ist. Die weiteren Ideen, die zum fertigen Algorithmus führen, lassen sich so umschreiben: W = A R B R liefert Zeugen für alle Einträge in P = A B, die einen eindeutigen Zeugen in R haben. Nach Lemma 1.28 ist die Wahrscheinlichkeit dafür, dass eine zufällig gewählte Menge R der Größe R = r einen eindeutigen Zeugen für einen Eintrag von P mit w Zeugen enthällt, größer oder gleich der Konstanten 1 2e, wenn n 2 wr n ist. Wir wählen O(log n) Mengen R zufällig aus. Damit wird es sehr unwahrscheinlich, dass für einen Eintrag von P kein Zeuge identifiziert wird. Zeugen für die Einträge, für die kein Zeuge identifiziert wird, werden mit dem trivialen Algorithmus berechnet. Da nicht alle Einträge von P die gleiche Anzahl Zeugen haben, müssen Mengen R mit verschiedenen Kardinalitäten r benutzt werden. Es reicht jedoch, für r die Zweierpotenzen zwischen 1 und n zu benutzen, da nur die Bedingung n 2 wr n erfüllt sein muss. Theorem Der Algorithmus Bpwm ist ein Las-Vegas-Algorithmus für das Problem Bpwm mit erwarteter Laufzeit O(mm(n) log 2 n). Beweis. Die Initialisierung benötigt O(mm(n)) Zeit. Der Algorithmus durchläuft die innere Schleife O(log 2 n)-mal und führt jedes Mal eine ganzzahlige Matrixmultiplikation von n n Matrizen durch. Die anderen Operationen in der Schleife sind weniger zeitaufwändig. Die Laufzeit O(mm(n) log 2 n) folgt, wenn nicht zu oft der triviale Algorithmus aufgerufen werden muss. Beh.: Ist P ij = 1, so wird im randomisierten Teil des Algorithmus ein Zeuge mit Wahrscheinlichkeit 1 1 n gefunden.

29 1.3. Kürzeste Wege 19 Algorithmus 8 : BPWM Input : Boolsche Matrizen A, B {0, 1} n n Output : Zeuge für P 1 W AB // W ij < 0 Zeuge für P ij muss noch gefunden werden 2 for t = 0,..., log n do // teste alle Zweierpot. r = 2 t zwischen 1 und n 3 r 2 t 4 repeat 3.77 log n times 5 Wähle R {1,..., n} mit R = r 6 Berechne A R und B R // vgl. Lemma Z A R B R 8 forall the (i, j) do // teste, ob neuer Zeuge für P ij gefunden wurde 9 if W ij < 0 und Z ij ist Zeuge für P ij then 10 W ij Z ij 11 forall the (i, j) do 12 if W ij < 0 then // kein Zeuge für P ij gefunden 13 Berechne W ij mit dem trivialen Algorithmus Bew.: Sei w die Anzahl der Zeugen für P ij. Die äußere Schleife wird mindestens einmal mit einem Wert r mit n 2 wr n durchlaufen. In diesem Durchlauf ist die Wahrscheinlichkeit, dass R keinen eindeutigen Zeugen für P ij enthällt, höchstens 1 1 2e nach Lemma Damit ist die Wahrscheinlichkeit, dass kein Zeuge für P ij identifiziert wird höchstens (1 1 2e )3.77 log n 1 n. Damit ist die erwartete Anzahl der nicht gefundenen Zeugen begrenzt durch n, anstelle der ursprïnglichen n 2. Somit benötigen alle Aufrufe des trivialen Algorithmus zusammen Zeit O(n 2 ) Randomisierter Algorithmus Wir schließen das Thema in diesem Abschnitt mit der Beschreibung des randomisierten Algorithmus ab, der anhand einer Zeugenmatrix eine Nachfolgermatrix berechnet. Zuvor muss noch festgelegt werden, wie genau diese Nachfolgermatrix berechnet wird. Definition Es sei G = (V, E) ein Graph mit n Knoten. Eine Nachfolgermatrix S für G ist eine n n-matrix, so dass für alle i j S ij ein Nachfolger von i ist, der auf einem kürzesten Weg von i nach j liegt. Weiter ist S ii = 0. Sei nun A die Adjazenzmatrix eines Graphen G = (V, E), D die Distanzmatrix von G. Seien i, j {1,..., n}, i j beliebig mit D ij = d. S ij = k ist genau dann möglich, wenn D ik = 1 und D kj = d 1. Sei B d {0, 1} n n mit B d kj = 1 genau dann, wenn D kj = d 1 (B d kann aus D in Zeit O(n 2 ) berechnet werden). Lemma Es sei A Adjazenzmatrix eines Graphen G = (V, E) und B d {0, 1} n n wie oben definiert. Der Aufruf Bpwm(A, B d ) liefert für alle i, j mit D ij = d Einträge S ij einer Nachfolgermatrix S für G. Der Beweis von Lemma 1.33 ist dem Leser zur Übung empfohlen. Das Problem ist, dass es n mögliche Werte für d gibt. Damit wäre die Laufzeit eines Algorithmus mindestens Ω(nmm(n)) und somit superkubisch. Aber es reichen drei Berechnungen von Zeugenmatrizen aus, denn:

30 20 1. Grundlegende Graphenalgorithmen Für alle i, j und alle Nachfolger k von i gilt D ij 1 D kj D ij + 1. Jeder Nachfolger k von i mit D kj = D ij 1 ist ein möglicher Eintrag für S ij. Also: Jedes k mit A ik = 1 und D kj D ij 1 (mod 3) ist ein möglicher Eintrag für S ij. Für s = 0, 1, 2 definiere D (s) durch D (s) kj = 1 genau dann, wenn D kj + 1 s (mod 3). Eine Nachfolgermatrix S von A kann dann aus den Zeugenmatrizen für A D (s), s = 0, 1, 2 berechnet werden. Algorithmus 9 : Apsp Input : Adjazenzmatrix A für G = (V, E) Output : Nachfolgematrix von G 1 Berechne Distanzmatrix D AP D(A) 2 for s = 0, 1, 2 do 3 Berechne D (s) {0, 1} n n derart, dass D (s) kj = 1 gdw. D kj + 1 s (mod 3) 4 Berechne Zeugenmatrix W (s) BP W M(A, D (s) ) 5 Berechne Nachfolgematrix S mit S ij = W (D ij (mod 3)) ij Theorem Der Algorithmus Apsp berechnet eine Nachfolgermatrix eines Graphen G mit n Knoten in erwarteter Zeit O(mm(n) log 2 n) Nicht erweiterbare unabhängige Mengen Definition Sei G = (V, E) ein Graph. Eine Menge I V heißt unabhängig, wenn je zwei beliebige Knoten aus V nicht adjazent sind. Eine unabhängige Menge I heißt nicht erweiterbar (engl.: maximal), falls keine unabhängige Menge J existiert mit I J und I < J. Der von einer unabhängigen Menge induzierte Subgraph besitzt folglich keine Kanten. Beachten Sie, dass eine nicht erweiterbare unabhängige Menge nicht notwendigerweise kardinalitätsmaximal unter allen unabhänigen Mengen ist! Ein sehr einfacher Algorithmus zur Berechnung einer nicht erweiterbaren unabhängigen Menge nimmt einen beliebigen Knoten v V, fügt ihn zu I hinzu und löscht v und N(v) aus dem Graphen. Dieses Vorgehen wird dann iteriert, bis der Graph leer ist. Zwar bekommt man auf diese Weise eine nicht erweiterbare unabhängige Menge. Aber das Verfahren ist inhärent sequentiell. Ein bekannter Algorithmus, der Parallelität nutzt, geht zurück auf Luby. Auch Lubys Algorithmus (Algorithmus 10) operiert in Phasen, aber in jeder Phase werden mehrere Knoten gleichzeitig in I eingefügt. Wir folgen hier der Darstellung von D. C. Kozen [Koz91]. Beachten Sie, dass wir im Schritt 1 des Algorithmus Knoten mit niedrigem Knotengrad bevorzugen. Hingegen werden in Schritt 2 Knoten mit hohem Knotengrad bessergestellt. Wir wollen nun das folgende Theorem beweisen. Theorem Die erwartete Anzahl von Runden in Lubys Algorithmus ist O(log m). Wir werden dieses Theorem jedoch nicht vollständig beweisen. Vielmehr werden wir ein Hauptlemma zeigen, das besagt, dass in jeder Runde ein konstanter Anteil von Kanten aus dem aktuellen Graphen gelöscht wird. Wie man sich dann überlegen kann (was wir hier nicht tun), folgt daraus die logarithmische Rundenanzahl. Zum Beweis des Hauptlemmas benötigen wir zunächst einige Hilfsresultate.

31 1.4. Nicht erweiterbare unabhängige Mengen 21 Algorithmus 10 : Lubys MIS-Algorithmus 1. Berechne eine Menge S V von Kandidaten für I, indem jeder Knoten v V parallel 1 mit Wahrscheinlichkeit 2d(v) in S eingefügt wird. 2. Prüfe für jede Kante e E, ob beide Endpunkte in S sind. Ist dies der Fall, lösche den Endknoten mit kleinerem Grad aus S. Löse evtl. Konflikte beliebig auf, z. B. gemäß Knotennummer. Füge die resultierende Menge zu I hinzu. 3. Lösche S und N(S) aus G und gehe zu 1., falls G nicht leer ist. Lemma Für jeden Knoten u V gilt: P r(u I u S) 1 2. Beweis. Zum Beweis der Aussage werden wir das Gegenereignis P r(u / I u S) von oben beschränken. Ein Knoten u S wird genau dann nicht in I aufgenommen, wenn ein Nachbar mit mindestens gleich großem Grad in S aufgenommen wird. Es gilt: P r(u / I u S) = P r( v N(u) S, d(v) d(u) u S) P r(v S u S) v N(u), d(v) d(u) v N(u), d(v) d(u) v N(u), d(v) d(u) v N(u), d(v) d(u) d(u) 1 2d(u) = 1 2. P r(v S) 1 2d(v) 1 2d(u) (da d(v) d(u)) Ein Knoten, der in S landet, wird also mindestens mit Wahrscheinlichkeit 1 2 auch in I in derselben Runde aufgenommen. Daraus ergibt sich eine weitere Abschätzung, wie wahrscheinlich es ist, dass ein Knoten in I aufgenommen wird. Lemma Für jeden Knoten u V gilt P r(u I) 1 4d(u). Beweis. Nach Definition der bedingten Wahrscheinlichkeit und mit Lemma 1.37 ergibt sich: P r(u I) = P r(u I u S) P r(u S) d(u) 1 4d(u). Für den Rest des Beweises benötigen wir zunächst eine weitere Definition. Definition Wir sagen, dass ein Knoten u V gut ist, falls v N(u) 1 2d(v) 1 6.

32 22 1. Grundlegende Graphenalgorithmen Eine Kante ist gut, falls mindestens einer ihrer Endpunkte gut ist. Ein Knoten oder eine Kante sind schlecht, wenn sie nicht gut sind. Damit lässt sich ein weiteres Hilfsresultat folgern. Lemma Falls u gut ist, dann gilt P r(u N(I)) Beweis. Wir betrachten zwei Fälle. Im ersten Fall existiere ein Knoten v N(u) mit d(v) 2. Nach Lemma 1.38 folgt P r(u N(I)) P r(v I) 1 4d(v) 1 8. Der zweite Fall ist das Komplement und muss detaillierter untersucht werden. Es gilt also d(v) 3 1 für alle v N(u) und somit 2d(v) 1 6. Da der Knoten u gut ist, gilt nach Definition 1.39 v N(u) 1 2d(v) 1 6. (1.4.1) Da jeder Summand einzeln kleiner als 1/6 ist, lässt sich immer eine Teilmenge M(u) N(u) derart finden, dass d(v) 1 3. v M(u) Da nach dem Prinzip des Ein- und Ausschließens für eine Menge von Ereignissen A die Ungleichung P r( A) A A P r(a) A,B A, A B P r(a B) gilt, folgt in unserem Fall: P r( v M(u) I) Insgesamt ergibt sich somit: v M(u) P r(v I) v,w M(u), v w P r(v I w I) (1.4.2)

33 1.4. Nicht erweiterbare unabhängige Mengen 23 P r(u N(I)) P r( v M(u) I) P r(v I) v M(u) (nach 1.4.2) 1 4d(v) v M(u) v M(u) v,w M(u), v w v,w M(u), v w (nach Lemma 1.38) 1 4d(v) v,w M(u), v w P r(v I w I) P r(v S w S) P r(v S) P r(w S) (wegen paarweiser Unabhänigkeit) 1 4d(v) 1 2d(v) 1 2d(w) v M(u) v M(u) w M(u) 1 1 2d(v) 2 1 2d(w) v M(u) = 1 36 (nach 1.4.1) w M(u) Jetzt zeigen wir, dass mindestens die Hälfte aller Kanten gut sind. Lemma Mindestens die Hälfte der Kanten in G sind gut. Beweis. Richte jede Kante zu ihrem Endpunkt mit höherem Knotengrad. Dabei werden die Konflikte so wie im Algorithmus aufgelöst. Jeder schlechte Knoten hat dabei mindestens doppelt so viele Kanten, die ihn verlassen, wie Kanten, die in ihn hineinführen. Wäre dies nicht der Fall, hätte mindestens ein Drittel der zu v adjazenten Knoten Grad d(v) oder niedriger. Das würde implizieren, dass v gut ist. Indem wir diese Tatsache nutzen, weisen wir jede schlechte Kante e, die in einen schlechten Knoten v hineinführt, einem Paar von Kanten (gut oder schlecht) zu, die aus v hinausführen. Dies geschieht derart, dass jede schlechte Kante an ein eindeutiges Paar zugewiesen wird. Dies impliziert, dass es mindestens doppelt so viele Kanten insgesamt wie schlechte Kanten gibt. Anders gesagt ist mindestens die Hälfte aller Kanten gut. Wir können nun das Hauptlemma beweisen. Lemma Bezeichne die Zufallsvariable X die Zahl der Kanten, die in der aktuellen Phase gelöscht werden. Dann gilt: E(X) E 72. Beweis. Sei E G die Menge der guten Kanten. Für e E definiere die Zufallsvariable { 1, falls e gelöscht wird X e = 0, sonst.

34 24 1. Grundlegende Graphenalgorithmen Dann folgt X = e E X e und wegen der Linearität des Erwartungswertes, E(X) = e E E(X e ) E(X e ) e E G 1 (nach Lemma 1.40) 36 e E G E G 36 E 72 (nach Lemma 1.41) Wir haben also gezeigt, dass in jeder Runde des Algorithmus ein konstanter Anteil der Kanten des jeweils aktuellen Graphen entfernt wird. Diese Feststellung impliziert, dass man nach erwartet logarithmisch vielen Runden fertig ist Weiterführende Literatur Eine ausführliche Darstellung zur Dualität von Matrizen und Graphen findet sich im Buch Graph Algorithms in the Language of Linear Algebra von Kepner und Gilbert (Hrsg.) [KG11]. Besonders in den ersten beiden Kapiteln dieses Buches wird verstärkt auf allgemeine Halbringe und Matrizenmultiplikationen und ihre Verwendung in Graphenalgorithmen eingegangen. Die Darstellung von Lubys Algorithmus sowie dessen Analyse folgt im Wesentlichen dem Lehrbuch von Kozen [Koz91].

35 25 2. Datenstrukturen für dünn besetzte Matrizen Beim Entwurf und der Implementierung von Algorithmen spielt die Wahl der Datenstruktur eine zentrale Rolle. Hier bilden Algorithmen für dünn besetzte Matrizen (bzw. Graphen ohne reichhaltige semantische Informationen) keine Ausnahme, denn die Darstellung dünner Matrizen bestimmt nicht nur die Effizienz der eingesetzten Algorithmen. Sie wirkt sich auch auf den gesamten Entwurfsprozess aus. Aus softwaretechnischer Sicht ist zu beachten, dass die Details der Datenstruktur von den Algorithmen abgekapselt werden. In dem Fall lässt sich die Datenstruktur intern ändern, ohne dass man die Algorithmen anpassen muss. In diesem Kapitel werden wir die bekanntesten Datenstrukturen für dünn besetzte Matrizen kennenlernen. Für die grundlegenden Matrizenoperationen werden wir spezielle Algorithmen vorstellen, wobei der zusätzliche Speicherbedarf und die zusätzlichen Berechnungskosten berücksichtigt werden Cache-Effizienz Aufgrund der unregelmäßigen Verteilung von Einträgen und der verhältnismäßig hohen Speicherzugriffszeit auf den Hauptspeicher (RAM) ist die Cache-Effizienz bei Berechnungen auf dünn besetzten Matrizen besonders wichtig, insbesondere bei iterativen Algorithmen mit vielen Schleifendurchläufen. Deshalb wird in diesem Kapitel nicht nur auf die Berechnungskomplexität, sondern auch auf die Komplexität im I/O-Modell eingegangen, das je nach wissenschaftlicher Community auch EM-Modell (EM für external memory) genannt wird I/O-Modell Das I/O-Modell beschreibt ein hierarchisches Speichermodell, bei dem grundlegend zwischen zwei Arten von Speicher unterschieden wird, einem schnellen und einem langsamen. Der schnelle Speicher wird Cache genannt, der langsame Speicher normalerweise Disk. Manchmal findet man auch die Bezeichnungen Cache vs. RAM bzw. RAM vs. Disk. Wichtig ist eigentlich nur, dass die Einsichten meist für zwei beliebige aufeinanderfolgende Ebenen der Speicherhierarchie gelten. Wir wollen daher in unserem Fall beim schnellen Speicher vom Cache und beim langsamen Speicher vom Arbeitsspeicher oder RAM sprechen. Dabei sind beide Speicher in Blöcke derselben Größe L unterteilt. Benötigt der Prozessor Daten, die sich nicht im Cache befinden, tritt ein Cache miss auf und der ganze Speicherblock, der die benötigten Daten enthält, muss vom langsamen RAM geladen werden. Deshalb ist es wichtig, die Daten blockweise unter Ausnutzung von Lokalität abzuarbeiten, um die Anzahl der Cache misses zu minimieren. Definition. Unter der I/O-Komplexität eines Algorithmus versteht man die Anzahl der nötigen Speichertransfers zwischen dem schnellen und dem langsamen Speicher. Beispiel. Bei einer angenommenen Blockgröße von L hat das Lesen eines Speichers der Größe N eine I/O-Komplexität von N/L.

36 26 2. Datenstrukturen für dünn besetzte Matrizen Definition. Wir definieren scan(a) = nnz(a)/l als Abkürzung für die I/O-Komplexität, um alle Nichtnull-Einträge einer Matrix A zu lesen Modell-Annahmen Für das restliche Kapitel gelten die folgenden beiden Annahmen: Annahme: Für die Anzahl der Nichtnull-Einträge (nnz) einer dünn besetzten Matrix der Dimensionen M N gilt: nnz = Ω(N, M). Dies vereinfacht die asymptotische Analyse der Algorithmen in diesem Kapitel, da wir nun bei Komplexitäten, die die Dimension der Matrix enthalten, auf diese verzichten und stattdessen stets nnz verwenden können. Annahme: Der schnelle Speicher ist nicht groß genug, um eine Datenstruktur der Größe O(N) zu halten, wobei N die Dimension der Matrix ist. Ein Beispiel soll zeigen, dass die zweite Annahme gerechtfertigt ist: Bei der kleinsten Repräsentation einer dünn besetzten Matrix haben die Nichtnull-Einträge eine Größe von 16 Byte (8 Byte zur Indizierung, 8 Byte für die Daten). Das ergibt 2 30 /16 = 2 26 Nichtnull-Einträge pro GB. Eine quadratische, dünn besetzte Matrix mit 8 Einträgen pro Zeile füllt demnach ein GB RAM, wenn sie die Dimension besitzt. Ein dichter double-vektor der Dimension 2 23 würde demnach 64 MB L2 Cache pro GB benötigen, was üblicherweise deutlich größer als ein typischer L2 Cache ist Grundlegende Algorithmen im I/O-Modell Sortieren Folgt Minimaler Spannbaum Folgt Grundlegende Matrix-Operationen In diesem Abschnitt werden die grundlegenden Operationen auf dünn besetzten Matrizen und ihre Entsprechungen bei Graphen beschrieben. Die meisten Operationen auf dünn besetzten Matrizen sind durch die numerische lineare Algebra motiviert, einige sind aber auch für Graphenalgorithmen nützlich: Teilmatrizen addressieren (SpRef/SpAsgn) Die Abkürzung bezieht sich auf die englischen Ausdrücke sparse matrix indexing and assignment. Diese Operationen entsprechen der Auswahl eines Teilgraphen. SpRef: B = A(p, q) : Speichert eine Teilmatrix von A in B. SpAsgn: B(p, q) = A : Zuweisung einer Matrix an eine Teilmatrix B. Diese Operatoren können recht mächtig aber auch kompliziert sein, wenn p und q beliebige Vektoren von Indizes sein können. Deshalb beschränken wir uns in diesem Kapitel auf zeilenweise (A(i, :)), spaltenweise (A(:, i)) und elementweise (A(i, j)) Indizierung, welche auch am häufigsten Gebrauch finden.

37 2.2. Grundlegende Matrix-Operationen 27 Abbildung : Links die Operation SpRef, rechts SpAsgn Matrix-/Vektormultiplikation (SpMV) Die Abkürzung bezieht sich auf den englischen Ausdruck sparse matrix dense vector multiplication. Wie wir bereits in Kapitel 1 gesehen haben, entspricht SpMV einem Schritt einer Breitensuche im Graphen. Eine dünn besetzte Matrix kann von rechts (y = Ax) oder von links (y = x A) mit einem dichten Vektor multipliziert werden. In diesem Skript beschränken wir uns auf die Multiplikation von rechts. Es ist im Allgemeinen einfach, die entsprechenden Algorithmen für die Matrixmultiplikation von links umzuformulieren. Einige Vertreter von Graphalgorithmen, die SpMV nutzen, sind PageRank, BFS, Bellman-Ford und Prim s MST-Algorithmus Addition dünner Matrizen (SpAdd) Die Abkürzung bezieht sich auf den englischen Ausdruck sparse matrix addition. Die Operation entspricht der Vereinigung von Graphen und berechnet C = A B. Dabei steht die Operation für einen beliebigen punktweisen, binären Operator zwischen zwei Matrizen. Beispiele sind Addition, Subtraktion, MIN & MAX (Minimum bzw. Maximum der Operanden), logisches UND und logisches ODER Sparse matrix-sparse matrix multiplication (SpGEMM) Die Abkürzung bezieht sich auf den englischen Ausdruck generalized sparse matrix-matrix multiplication. Diese Operation entspricht aus Graphen-Sicht einem Schritt einer Breitensuche von mehreren Startknoten gleichzeitig aus bzw. APSP. Sie berechnet C = AB, wobei die Eingabematrizen A R M K und B R K N beide dünn besetzt sind. SpGEMM findet häufig Verwendung beim Arbeiten auf großen Graphen, z.b. bei der Graphenkontrakion, bei der algebraischen Formulierung von Peer Pressure Clustering (das wir in Kapitel 3 in der Variante Label Propagation behandeln) oder Markov-Clustering sowie bei iterativen APD-Formulierungen (siehe z.b. Abschnitt ). Für die Berechnung der Matrixmulitplikation gibt es mehrere Möglichkeiten. Eine übliche Methode berechnet den Eintrag C(i, j) mit Hilfe des Skalarproduktes der Zeile i von A und der Spalte j von B (siehe Algorithmus 11). Angelehnt an das Skalarprodukt, wird dieser Ansatz auch als inner product matrix multiply bezeichnet. Eine andere Möglichkeit besteht darin, das Matrixprodukt als Summe von n Matrizen mit Rang eins zu berechnen. Jede dieser Matrizen mit Rang eins ist das dyadische Produkt (outer product) einer Spalte k von A und einer Zeile k von B (siehe Algorithmus 12 und Abbildung 2.2.2). Eine weitere Möglichkeit ist die zeilen- bzw. spaltenweise Berechnung des Matrixprodukts. Algorithmus 13 zeigt die spaltenweise Formulierung, hierbei wird die Spalte j von C als Linearkombination aus Spalten von A und den Nichtnull-Einträgen der Spalte j von B berechnet. Abbildung veranschaulicht dieses Konzept. Analog wird bei der zeilenweisen Formulierung

38 28 2. Datenstrukturen für dünn besetzte Matrizen Algorithmus 11 : Matrixmultiplikation mit Hilfe des Skalarprodukts Input : A : R M K, B : R K N Output : C : R M N 1 for i = 1 to M 2 for j = 1 to N 3 C(i, j) A(i, :) B(:, j); 4 return C Algorithmus 12 : Matrixmultiplikation mit Hilfe des dyadischen Produkts Input : A : R M K, B : R K N Output : C : R S(M N) 1 C 0 2 for k = 1 to K 3 C C + A(:, k) B(k, :); 4 return C Abbildung : Schematische Matrixmultiplikation mit Hilfe des dyadischen Produkts

39 2.3. Tripel 29 Abbildung : Schematische Darstellung der spaltenweisen Matrixmultiplikation die Zeile i von C als Linearkombination aus Zeilen von B und Nichtnull-Einträgen der Zeile i von A berechnet. Algorithmus 13 : Spaltenweise Matrixmultiplikation Input : A : R M K, B : R K N Output : C : R M N 1 C 0 2 for j = 1 to N 3 for k where B(k, j) 0 4 C(:, j) C(:, j) + A(:, k) B(k, j); 5 return C 2.3. Tripel Das Tripel- oder Koordinatenformat ist die einfachste Art, dünn besetzte Matrizen darzustellen. Hierbei wird für jeden Nichtnull-Eintrag A(i, j) 0 ein Tripel (i, j, A(i, j)) gespeichert. Jeder Eintrag eines Tripels wird üblicherweise in einem der drei Arrays A.I (Zeilenindizes), A.J (Spaltenindizes) oder A.V (Werte) gespeichert, die die komplette Matrix A repräsentieren. Der Speicherverbrauch pro Tripel beträgt bei 8-Byte-Integers = 24 Byte pro Nichtnull- Eintrag. In modernen Programmiersprachen ist die Repräsentation von Tupeln als Struktur in einem Array einfacher und kann auch den Cache besser ausnutzen, da oft alle Werte eines Tripels von Interesse sind und so nicht aus drei unterschiedlichen Arrays gelesen werden muss. Bei drei unterschiedlichen Arrays kann es nämlich passieren, dass alle drei in dieselbe Cachezeile geladen werden und sich gegenseitig verdrängen. Diese Cache-Optimierung wird auch als array merging bezeichnet. In diesem Kapitel werden wir das Tripelformat mit unterschiedlichen Ordnungen der Einträge kennenlernen Ungeordnete Tripel Die Tripel werden nicht sortiert, der Verwaltungsaufwand der Tripel ist somit sehr gering. Allerdings besteht daher beim Zugriff auf die Einträge einer Zeile oder Spalte keinerlei Lokalität, d.h. im schlechtesten Fall müssen alle Tripel durchsucht werden, um einen bestimmten Eintrag zu finden. Ein Beispiel einer Matrix in ungeordneter Tripeldarstellung zeigt Abbildung Bei der Berechunng von SpMV (y = Ax) spielt die Ordnung der Einträge aus theoretischer Sicht keine Rolle, d.h. die RAM-Komplexität ist schon bei ungeordneten Tripeln optimal. Wenn der Cache zuvor keine Einträge von A enthält, treten O(scan(A)) Cache-Fehlzugriffe auf. Zusätzlich wird für jedes Tripel (i, j, A(i, j)) ein Zugriff auf den j-ten Eintrag von x benötigt und

40 30 2. Datenstrukturen für dünn besetzte Matrizen das Ergebnis dieser Multiplikation muss nach y(i) geschrieben werden. Nach unserer Modell- Annahme passen die dichten Vektoren x und y allerdings nicht in den Cache. Pro Tripel treten also bis zu zwei zusätzliche Cache-Fehlzugriffe auf, d.h. die I/O-Komplexität von SpMV ist nnz(a)/l + 2 nnz(a) = O(nnz(A)). A = A.I A.J A.V Abbildung : Matrix in ungeordneter Tripeldarstellung Zeilenweise geordnete Tripel Falls die Tripel nach ihrer Zeilenzugehörigkeit geordnet werden, bleibt die Indizierung ineffizient. Ein schneller Zeilenzugriff ist ohne die Kenntnis des Startindex nicht möglich. Um auf die Einträge einer Zeile i zuzugreifen, wird zunächst eine binäre Suche auf A.I verwendet. Diese findet einen (beliebigen) Eintrag der Zeile i, von dem aus anschließend in beide Richtungen in den restlichen Nichtnull-Einträgen dieser Zeile gesucht wird. Analog zu zeilenweise geordneten Tripeln funktionieren auch spaltenweise geordnete Tripel. Falls die Einträge einer Zeile Spaltenindizes mit großem Abstand zueinander haben, kann sich die fehlende Sortierung auch hier negativ auswirken, etwa bei SpMV Zeilendominant geordnete Tripel Die dritte Möglichkeit der Tripeldarstellung ist die der zeilendominant geordneten Tripel. Hierbei werden die Einträge zunächst wie bei zeilenweise geordneten Tripeln nach der Zeile sortiert und anschließend innerhalb jeder Zeile noch nach der Spalte. Der Zugriff auf eine komplette Zeile erfolgt wie bei den zeilenweise geordneten Tripeln, jedoch ist die Referenzierung eines einzelnen Eintrags A(i, j) schneller. Hierfür reicht eine gewöhnliche Binärsuche allerdings nicht aus, da Anfang und Ende der i-ten Zeile im Voraus nicht bekannt sind. Deshalb wird wie folgt verfahren: 1. Finde mittels binärer Suche ein Tripel das zur i-ten Zeile der Matrix gehört. 2. Führe von diesem Tripel eine unbeschränkte binäre Suche in beide Richtungen aus. Dabei wird die Schrittgröße nach jeder Iteration verdoppelt. Die Suche terminiert, wenn in der entsprechenden Richtung ein Tripel gefunden wird, das nicht zur i-ten Zeile gehört. Diese beiden Tripel (eines aus jeder Richtung) bilden die Grenze. 3. Führe eine normale binäre Suche zwischen den beiden Grenztripeln aus. Abbildung veranschaulicht das Verfahren. Die RAM-Komplexität für die Referenzierung beträgt O(log nnz(a) + log nnz(a(i, :)). Im I/O-Modell kann eine einfache lineare Suche auf einem sortierten Array schneller sein als die unbeschränkte binäre Suche. Das Suchen eines Elements in einer geordneten Menge mit N Elementen im I/O-Modell kostet mit Hilfe von B-Bäumen (siehe [BM72]) Θ(log L N). Wird dafür

41 2.3. Tripel Chapter 13. Implementing Sparse Matrices for Graph Algorithms Step 3 A.I A.J A.V Step 2 Abbildung : Referenzierung Figure vonindexing A(i, j) imrow-major zeilendominant triples. geordneten Tripelformat Element-wise indexing of A(12, 16) on row-major ordered triples. values. Accesses to x are also with increasing indices, which is an improvement over row ordered triples. However, memory strides when accessing x can still be high, depending on the number of nonzeros in each row and the bandwidth of the matrix. In the worst case, each access to x might incur a cache miss. Bender et al. came up with cache-efficient algorithms for SpMV, using the column-major layout, that have an optimal number of cache misses [Bender et al. 2007]. From a high-level view, their method first generates all the intermediate triples of y, possiblywithrepeatingindices. Then,thealgorithmsortsthoseintermediate triples with respect to their row indices, performing additions on the triples with same row index as they occur. I/O optimality of their SpMV algorithm relies on the existence of an I/O optimal sorting algorithm. Their complexity measure assumes afixedk number of nonzeros per column, leading to I/O complexity of Abbildung : Schematische Darstellung ( von SpAdd auf zeilendominant ) geordneten Tripeln N O scan(a) log Z/L (13.10) max{z, k} SpAdd is now more efficient even without using any auxiliary data structure. A scanning-based array-merging algorithm is sufficient as long as we do not forget allerdings ein normales Array verwendet, so treten bei der Suche im schlechtesten Fall log N to sum duplicates while merging. Such an implementation has O(nnz (A)+nnz(B)) Cache-Fehlzugriffe auf, was mehr sein kann als scan(n). Deshalb RAM complexity and O(scan(A)+scan(B)) I/O complexity. * werden die Kosten der Suche in einer geordneten Row-major Zeile einer ordered Matrix tripleswie allow folgt outer definiert: product and row wise SpGEMM implementations at least as efficiently as row ordered triples. Indeed, some finer improvements are search(a(i, possibly by:)) exploiting = min {log thennz(a(i, more specialized :)), scan(a(i, structure. :))} In the case of row wise SpGEMM, a technique called finger search [Brodal 2005] canbeusedto improve the RAM complexity. While enumerating all triples (i, k, A) A(i, :), they Für denare Spaltenzugriff naturally sorted sowie withspasgn-operationen increasing k values. Therefore, ergibt sich accesses gegenüber to B(k, dem :) arezeilenweise also geordneten Tripelformat with increasingkeine k values. Verbesserung. Instead of restarting Bei SpMV the(y binary = Ax) search wirdfrom sowohl the beginning auf A als auch auf y mit überwiegend of B, onecanusefingersandonlysearchtheyetunexploredsubsequence. konsekutivem, aufsteigendem Index zugegriffen. Auch auf x Note wird mit aufsteigendem Index zugegriffen, was eine Verbesserung gegenüber zeilenweise geordneten Tripeln * These bounds are optimal only if nnz (A) =Θ(nnz (B)); see [Brown & Tarjan 1979]. darstellt. Jedoch kann die Anzahl der Cache-Fehlzugriffe trotzdem hoch sein, abhängig von der Anzahl der Nichtnull-Einträge in jeder Zeile und der Bandbreite der Matrix. Im schlimmsten Fall kann jeder Zugriff auf x ein Cache-Fehlzugriff sein. SpAdd mit zeilendominanten Tripeln ist ohne zusätzliche Hilfsdatenstruktur effizienter als SpAdd auf zeilenweise geordneten Tripeln. Das Scannen und Verschmelzen der sortierten Arrays Downloaded 09 Dec 2011 to Redistribution subject to SIAM license or copyright; see genügt, wobei Duplikate addiert werden (siehe Abbildung 2.3.3). Daraus ergibt sich eine RAM- Komplexität von O(nnz(A) + nnz(b)) und eine I/O-Komplexität von O(scan(A) + scan(b)). Die dyadische und zeilenweise Matrix-Matrix-Multiplkation SpGEMM ist bei zeilendominant geordneten Tripeln mindestens so effizient wie bei zeilenweise geordneten Tripeln.

42 32 2. Datenstrukturen für dünn besetzte Matrizen 2.4. CSR/CSC Die populärsten und am häufigsten eingesetzten Formate dünn besetzter Matrizen sind Compressed Sparse Row (CSR) und Compressed Sparse Column (CSC). Beispielsweise verwendet MATLAB das CSC-Format, um dünn besetzte Matrizen zu speichern [GMS92]. Wir beschränken uns in diesem Skript auf das CSR-Format, das Gustavson 1972 als sparse row wise representation eingeführt hat [Gus72]. Das CSC-Format ist symmetrisch zum CSR-Format. Das CSC-Format schauen wir uns dann in verallgemeinerter Form für hyperdünne Matrizen genauer an CSR und Adjazenzlisten Im Prinzip ist das CSR-Format fast identisch zur Adjazentlisten-Darstellung gerichteter Graphen. Man spricht daher auch manchmal von Adjazenz-Arrays. Allerdings hat das CSR-Format in der Praxis eine deutlich bessere Cache-Effizienz als Adjazenzlisten. Denn CSR verwendet statt verketteter Listen insgesamt drei Arrays. Wegen des kontinuierlichem Speicherlayouts der Arrays ist dies cacheeffizienter als N verkettete Listen. Die drei Arrays von CSR sorgen dafür, dass die Einträge der Adjazenzlisten einer Matrix A R N M kontinuierlich hintereinander gespeichert werden: JC der Größe nnz speichert die Spaltenindizes der Nichtnull-Einträge NUM der Größe nnz speichert die Werte der Nichtnull-Einträge IR der Größe N +1 speichert für jede Zeile den Index des Zeilenstarts in den beiden anderen Arrays Im Sinne der Dualität zwischen dünn besetzter Matrix und Graphen ist es sinnvoll, bei IR vom Knoten-Array zu sprechen und bei JC vom Kanten-Array. Das Knoten-Array speichert für jeden Knoten den Offset (also die Startposition) im Kanten-Array. Demnach sind die Nichtnull- Einträge der i-ten Zeile in NUM(IR(i)) bis NUM(IR(i + 1) - 1) gespeichert und die entsprechenden Spaltenpositionen in dieser Zeile sind in JC(IR(i)) bis JC(IR(i + 1) - 1) gespeichert. In Abbildung ist die CSR-Darstellung der Matrix A von Abschnitt angegeben. Die Pfeile in der Adjazenzliste repräsentieren Zeiger auf die Speicherstellen während sie im CSR-Format Indirektionen über die Offset-Indizierung des IR Arrays darstellen. Die bessere Cache-Effizienz gegenüber Adjazenzlisten ist durch die moderne Computer-Architektur zu erklären. Um auf alle Nichtnull-Einträge einer gegebenen Zeile i zuzugreifen, entstehen im CSR-Format maximal nnz(a(i, :))/L Cache-Fehlzugriffe. Ein gleicher Zugriff auf das Adjazenzlisten- Format erzeugt im worst-case nnz(a(i, :)) Cache-Fehlzugriffe. Die gesteigerte Cache-Effizienz kommt allerdings zu einem Preis: Das Einfügen und Löschen von Nichtnull-Einträgen ist ineffizient und sollte möglichst vermieden werden. Daher ist das CSR-Format am besten für statische Graphen geeignet. Dies stellt aber keine große Einschränkung dar, da außer SpAsgn alle grundlegenden Operationen aus Abschnitt 2.2 mit statischen Graphen arbeiten Grundoperationen mit CSR Im Gegensatz zum Tripel-Format ermöglicht das CSR-Format eine Zeilenindizierung in konstanter Zeit. Das Iterieren über alle Einträge einer Zeile i hat im RAM-Modell eine Komplexität von O(nnz(A(i, :)) und im I/O-Modell O(scan(A(i, :)). Diese Eigenschaft macht das CSR-Format zu einer sehr guten Datenstruktur für zeilenweises SpRef. Der Zugriff auf einen einzelnen Nichtnull- Eintrag A(i, j) benötigt mit Hilfe einer binären Suche sowohl im RAM- als auch im I/O-Modell maximal O(log nnz(a(i, :))) Zeit, jedoch kann eine lineare Suche in der Praxis, insbesondere bei

43 2.5. Multiplikation dünn besetzter Matrizen 33 Abbildung : Matrix A als Adjazenzliste (links) und im CSR-Format (rechts) Knoten mit kleinem Grad, bezüglich der Cache-Performance besser sein. Beim spaltenweisen Zugriff ist das CSR-Format hingegen ineffizient. Ein solcher Zugriff sollte daher vermieden werden. Hier bietet CSR gegenüber dem Tripel-Format keinerlei Vorteile. Für manche Algorithmen ist ein schneller Zugriff auf das Diagonalelement wichtig. Hierfür existieren unterschiedliche Abwandlungen des CSR-Formats, z.b. können die Diagonaleinträge zusätzlich in einem separaten Array gespeichert werden oder es wird das normale CSR-Format genutzt, wobei das erste Element jeder Zeile immer den Diagonaleintrag repräsentiert (auch wenn dieser 0 ist) SpMV Algorithmus 14 zeigt, wie SpMV bei einer dünn besetzten Matrix A im CSR Format ausgeführt werden kann. SpMV im CSR-Format bietet im Vergleich zum zeilendominant geordneten Tripelformat ähnliche Performance. Wenn N nnz gilt, dann hat das CSR-Format einen Vorteil, da innerhalb einer Zeile nur ein Index (A.JC(k)) pro Iteration ausgewertet werden muss und beim Tripelformat zwei Indizes (A.I(k) und A.J(k)). Daher hat das CSR-Format bis zu Faktor 2 weniger Cache-Fehlzugriffe als das zeilendominant geordnete Tripelformat. Außerdem benötigt es weniger Speicher, wenn die Zahl der Nichtnull-Einträge deutlich größer ist als die Zahl der Zeilen bzw. Knoten. Algorithmus 14 : SpMV (y = Ax) im CSR-Format Input : A : R M N, x : R N Output : y : R M 1 y 0 2 for i = 1 to M do 3 for k = A.IR(i) to A.IR(i) 1 do 4 y(i) y(i) + A.NUM(k) x(a.jc(k)) 5 return y 2.5. Multiplikation dünn besetzter Matrizen In diesem Abschnitt wollen wir die Matrixmultiplikation auf dünn besetzten Matrizen (SpGEMM) im CSR-Format genauer betrachten. Dabei wird eine Hilfsdatenstruktur eingeführt, die zur Berechnung der Zwischenergebnisse dient. Hinsichtlich des Produkts von zwei dünn besetzten Matrizen C = A B ist zu erwähnen, dass C nicht wieder dünn besetzt sein muss. Außerdem muss das Produkt zweier symmetrischer Matrizen A und B nicht symmetrisch sein.

44 34 2. Datenstrukturen für dünn besetzte Matrizen Da der Zugriff auf eine Zeile und die Iteration über eine Zeile im CSR-Format sehr effizient möglich sind, ist die zeilenweise Matrixmultiplikation die beste Wahl Der Sparse Accumulator Die meisten Algorithmen zur Ausführung von Matrixoperationen, die als Ergebnis wieder eine Matrix liefern, berechnen diese Zeile für Zeile. Daher ist es sinnvoll, die gerade zu berechnende Zeile in einer geeigneten Datenstruktur abzuspeichern, die das Indizieren einer Spalte in dieser Zeile in konstanter Zeit erlaubt, um Einträge schnell einfügen zu können. Die Sparse Accumulator (SPA) Datenstruktur erfüllt diese Anforderung und speichert temporär die jeweils aktive Zeile. Da es ein abstrakter Datentyp ist, existieren unterschiedliche Varianten des SPA. Für diese Vorlesung verwenden wir die folgende Definition: w ist der dichte Vektor der Werte, b ist der dichte, boolesche Vektor für Besetzt -Einträge und LS ist die Liste, welche eine ungeordnete Liste von Indizes der Nichtnull-Einträge speichert. Abbildung veranschaulicht die Datenstruktur. Die Accumulate-SPA Funktion, die in Algorithmus 15 definiert ist, addiert einen Skalar (value) zu einer bestimmten Position (pos) des SPA. Diese Funktion arbeitet in konstanter Zeit. Um die Nichtnull-Einträge des SPA auszugeben, wird O(nnz(SP A)) Zeit benötigt. Der Pseudocode für Output-SPA ist in Algorithmus 16 beschrieben. Dabei greift der SPA nur auf Werte zu, die auch tatsächlich vorhanden sind. Es ist wichtig, den Sparse Accumulator nur einmal am Anfang zu initialisieren, da dies O(M) Zeit benötigt. Das Zurücksetzen des SPA für eine neue Zeile geht in O(nnz(SP A)), da hierfür die Einträge in LS verwendet werden können, um alle Nichtnull- Einträge der vorherigen Zeile zu erreichen und nur diese Indizes von w und b zu löschen. In der Praxis treten bei dieser Datenstruktur allerdings häufig Cache-Fehlzugriffe auf. Da der SPA Arrays der Größe N speichert (bei einer M N Matrix) passt die Datenstruktur nach der zweiten Modell-Annahme in Abschnitt nicht komplett in den Speicher weshalb im worst-case pro flop ein Cache-Fehlzugriff auftritt. Zusätzlich treten bis zu scan(a) weitere Cache- Fehlzugriffe beim Zugriff auf die Nichtnull-Einträge von A auf, also insgesamt O(scan(A)+flops) Cache-Fehlzugriffe im worst-case. Abbildung : SPA Datenstruktur Algorithmus 15 : AccumulateSPA Input : SPA, value, pos 1 if SPA.b(pos) then 2 SP A.w(pos) SP A.w(pos) + value 3 else 4 SP A.w(pos) value 5 SP A.b(pos) true 6 Insert(SP A.LS, pos)

45 2.6. Hyperdünne Matrizen 35 Algorithmus 16 : OutputSPA Input : SPA, val, col, nzcur Output : nzi 1 cptr head(sp A.LS) 2 nzi 0 // number of nonzeros in the current row of C 3 while cptr NIL do // for all entries in SPA.LS 4 col(nzcur + nzi) element(cptr) // set column index 5 val(nzcur + nzi) SP A.w(element(cptr)) // set value 6 nzi nzi Advance(cptr) SpGEMM mit CSR Die zeilenweise Matrixmultiplikation im CSR-Format erfolgt mit Hilfe des Sparse Accumulators und ist in Algorithmus 17 dargestellt, Abbildung stellt eine Iteration der äußersten Schleife dar und Abbildung zeigt ein Beispiel mit Zahlen. Algorithmus 17 : CSR-SpGEMM Input : A : R N K, B : R K N Output : C = AB 1 SetSPA(SP A) // set w = 0, b = 0 and create empty list LS 2 C.IR(1) 1 3 for i 1 to M do 4 for k A.IR(i) to A.IR(i + 1) 1 do 5 for j B.IR(A.JC(k)) to B.IR(A.JC(k) + 1) 1 do 6 value A.NUM(k) B.NUM(j) 7 AccumulateSPA(SP A, value, B.JC(j)) 8 nznew OutputSPA(SP A, C.NUM, C.JC, C.IR(i)) 9 C.IR(i + 1) C.IR(i) + nznew 10 ResetSPA(SP A) // reset w = 0, b = 0 and empty LS 2.6. Hyperdünne Matrizen Definition. Eine Matrix A R N M ist hyperdünn (engl.: hypersparse), wenn nnz(a) < N gilt. Hyperdünne Matrizen kommen im Bereich der linearen Algebra zumindest in sequentiellen Algorithmen eher selten vor, da eine Matrix mit vollem Rang bereits nnz N erfüllt. Bei Graphen sind hyperdünne Matrizen allerdings ein häufiges Muster. So bilden beispielsweise unzusammenhängende Graphen mit vielen Einzelknoten hyperdünne Matrizen. Aber auch bei der 2D-Partitionierung eines Graphen bzw. einer Matrix für die Parallelverarbeitung ergeben sich häufig hyperdünne Matrizen. Große Matrizen müssen häufig verteilt gespeichert werden, da sie entweder zu groß für den Hauptspeicher eines einzelnen Rechners sind oder sie sind zu groß, um eine ausreichend schnelle Berechnung auf einem einzelnen Rechner zu gewährleisten. Dabei sind zwei verschiedene Partitionierungsvarianten üblich:

46 36 2. Datenstrukturen für dünn besetzte Matrizen Abbildung : Ein Iterationsschritt des CSR-SpGEMM Algorithmus 1D-Partitionierung: Jeder Prozessor erhält bestimmte Zeilen der Matrix. Dies entspricht einer Knotenpartitionierung des Graphen. 2D-Paritionierung: Jeder Prozessor erhält einen Block der Matrix. Dies entspricht einer Kantenpartitionierung des Graphen. Wie bereits erwähnt, ergeben sich insbesondere bei der 2D-Partitionierung häufig Blöcke mit sehr wenigen Nichtnull-Elementen. Obwohl CSR bzw. CSC recht effiziente Speicherformate für dünn besetzte Matrizen mit nnz = Ω(N) sind, eignen sie sich weniger gut für solche hyperdünne Matrizen. Betrachten wir beispielsweise das CSC-Format bei einer 2D-Partitionierung. Nehmen wir dafür an, dass jeder Prozessor einen quadratischen Block der Größe (N/ p) (N/ p) der Matrix erhält (p :=# Prozessoren). Wenn nun jede dieser Teilmatrizen im CSC-Format gespeichert wird, beläuft sich der parallele Gesamtspeicherverbrauch auf O((N/ p) p + nnz) = O(N p + nnz). Speichert man die Matrix hingegen sequentiell auf einem einzigen Prozessor, beträgt der Gesamtspeicherverbrauch im CSC-Format nur O(N + nnz). Wenn die Anzahl der Prozessoren steigt, so wird der N p Term dominant und der Speicherverbrauch im parallelen Fall steigt. Es ist allerdings sehr wünschenswert, dass der Speicherverbrauch unabhängig von der Zahl der Prozessoren ist. Neben der Skalierbarkeit der Problemgröße hat diese Ineffizienz von CSC nämlich auch Einfluss auf die Skalierbarkeit von Algorithmen. Darum definieren wir im folgenden Abschnitt eine neue Datenstruktur für hyperdünne Matrizen DCSC Die DCSC-Datenstruktur (DCSC steht für doubly compressed sparse columns) hat die folgenden Eigenschaften: Speicherverbrauch von O(nnz), d.h. unabhängig von der Anzahl der Prozessoren und der Matrixdimension Schneller Zugriff auf die Spalten der Matrix SpGEMM skaliert mit zunehmender Anzahl von Null-Einträgen

47 2.7. DCSC 37 Abbildung : Zeilenweise Matrix-Matrix-Multiplikation (SpGEMM) Als Beispiel betrachten wir die 9 9 Matrix A mit 4 Nichtnull-Einträgen, die in der Tripeldarstellung in Abbildung zu sehen ist. Abbildung zeigt die Matrix im CSC-Format; hier gibt es redundate Einträge im Array JC. Die wesentliche Idee des DCSC-Formats ist die Verwendung der von CSC bekannten Arrays IR und NUM und der Komprimierung des JC-Arrays, um Wiederholungen zu vermeiden. Dafür braucht es zusätzlich ein Array CP, welches die Startindizes für IR und NUM der Spalten mit Nichtnull-Einträgen bzw. die kumulierte Anzahl aller Nichtnull- Einträge bis zur jeweiligen Spalte angibt (Indizes beginnen bei 1). Die Matrix A im DCSC-Format ist in Abbildung zu sehen. Das AUX-Array wird nur bei Bedarf angelegt, um eine schnelle Spaltenindizierung zu ermöglichen. Es speichert Zeiger auf Nichtnull-Spalten (also Spalten, die mindestens einen Nichtnull-Eintrag enthalten). Die Gesamtanzahl der Nichtnull-Spalten wollen wir mit nzc bezeichnen. Jeder Eintrag im AUX-Array bezieht sich auf einen Spaltenblock der Größe (N + 1)/nzc und zeigt auf die erste Nichnull-Spalte in diesem Block. Das DCSC-Format hat somit einen Speicherverbrauch von O(nnz), da für die Größen der verwendeten Arrays gilt: NUM = IR = nnz, JC = nzc, CP = nzc und AUX nzc. A.I A.J A.V Abbildung : Matrix A im Tripel Format

48 38 2. Datenstrukturen für dünn besetzte Matrizen JC = IR = NUM = Abbildung : Matrix A im CSC Format AUX = JC = CP = IR = NUM = Abbildung : Matrix A im DCSC Format 2.8. Multiplikation hyperdünner Matrizen In diesem Abschnitt wollen wir die sequentielle Matrixmultiplikation C = A B auf hyperdünnen Matrizen (HypSpGEMM) kennen lernen. Diese basiert auf der Summierung von dyadischen Produkten, weshalb die Operation schnellen Zugriff auf die Zeilen von B benötigt. Hierfür könnte man jede Eingabematrix sowohl im DCSC- als auch im DCSR-Format (entspricht der Transponierten im DCSC-Format) speichern, was allerdings den Speicherverbrauch verdoppelt. Hier verwenden wir eine Lösung, bei der B in einem Vorverarbeitungsschritt transponiert wird (Kosten: trans(b)). Die tatsächliche Laufzeit für das Transponieren beträgt je nach Implementierung O(N + nnz(b)) oder O(nnz(B) log nnz(b)). Als erste Beobachtung fällt uns beim DCSC-Format auf, dass das JC-Array bereits sortiert ist, d.h. A.JC gibt uns die sortierten Indizes der Nichnull-Spalten und B T.JC gibt uns die sortierten Indizes der Nichtnull-Zeilen. Der naive Algorithmus berechnet jeweils das dyadische Produkt C k der k-ten Spalte von A und der k-ten Zeile von B für alle k N und summiert die so erhaltenen N Rang-1 Matrizen zu C auf. Um nur die Indizes zu berücksichtigen, deren dyadisches Produkt nichttrivial ist, wird ein Vorverarbeitungsschritt benötigt, der Isect := A.JC B T.JC berechnet. Dieser Schritt benötigt O(nzc(A) + nzr(b)) Zeit, da A.JC = nzc(a) und B T.JC = nzr(b). Abbildung veranschaulicht die Bestimmung der Menge Isect. Für die Nichtnull-Einträge der Matrix C k gilt: (C k ) ij = A ik B kj 0 A ik 0 B kj 0. Daher werden im nächsten Schritt Isect kartesische Produkte gebildet und in fiktiven Listen der Größe nnz(a(:, k)) nnz(b(k, :)) gespeichert. In Abbildung ist dieser Schritt anhand eines Beispiels zu sehen. Die Listen sind fiktiv, da sie nicht explizit gespeichert werden. Sie können sortiert erstellt werden, da die Nichtnull-Einträge in einer Spalte bzw. Zeile aufsteigend nach dem Zeilen- bzw. Spaltenindex sortiert sind. Nun verschmilzt der Algorithmus die sortierten Listen, wobei die Einträge mit gleicher Position (i, j) in C aufsummiert werden. Diese Phase entspricht dem k-fachen Verschmelzen (k-way multiway merge) sortierter Liste, wie es etwa aus MergeSort bekannt ist. Der einzige Unterschied besteht darin, dass die Listen nie explizit erstellt werden, sondern jeder Eintrag auf Anforderung berechnet wird. Das Verschmelzen benutzt eine Prioritätswarteschlange mit binärem Heap der Größe n i := Isect. Der Wert eines Eintrags ist der NUM-Wert und der Schlüssel das Indexpaar (i, j) in spaltendominanter Reihenfolge. Die Idee besteht darin, wiederholt das Minimum min aus der Warteschlange zu entfernen und das nächste Element aus der fiktiven Liste von min einzufügen. Mehrere Elemente mit demselben Schlüssel werden dabei akkumuliert. Für jede arithmetische Operation pro Eintrag in C wird eine Extract-Min Operation benötigt, d.h. die Zeitkomplexität dieser Phase beträgt O(flops log n i ), wobei flops = k Isect nnz(a(:, k)) nnz(b(k, :)). Die

49 2.9. Weiterführende Literatur 39 Abbildung : Bestimmung der Menge Isect Speicherkomplexität beträgt O(nnz(C) + ni) - nnz(c) für die Ausgabematrix und ni für die Prioritätswarteschlange. Die Ausgabe dieser Phase ist eine Warteschlange mit NUM-Werten in spaltendominanter Sortierung. Als letzter Schritt erstellt der Algorithmus aus der Warteschlange der vorherigen Phase die DCSC-Datenstruktur für die Matrix C, was noch einmal O(nnz(C)) Zeit und Speicher benötigt. Die Gesamtzeitkomplexität beträgt O(trans(B) + nzc(a) + nzr(b) + f lops log ni). Der Term nnz(c) taucht hier nicht auf, da nnz(c) flops gilt. Es ist noch zu erwähnen, dass die Kosten für das Transponieren der Matrix B (trans(b)) in der Praxis bei Amortisierung vernachlässigbar sind. Algorithmus 18 zeigt den kompletten Pseudocode der HypSpGEMM-Operation. Die Funktion CartM ultinsert generiert das nächste Element der j-ten fiktiven Liste und fügt es in die Prioritätswarteschlange ein. Die Funktion IncrementList verschiebt den Zeiger auf das nächste Element der j-ten fiktiven Liste oder löscht die Liste, wenn sie leer ist Weiterführende Literatur Dieses Vorlesungskapitel basiert vor allem auf den Kapiteln 13 und 14 im Buch Graph Algorithms in the Language of Linear Algebra [KG11]. Dort finden Sie auch eine ausführlichere Betrachtung zur parallelen Multiplikation von dünn besetzten Matrizen.

50 40 2. Datenstrukturen für dünn besetzte Matrizen Abbildung : Bestimmung der kartesischen Produkte und Speicherung in fiktiven Listen Algorithmus 18 : HypSpGEMM Input : A : R N K, B : R K M Output : C = AB 1 isect Intersection(A.JC, B T.JC) // intersection of sorted column arrays 2 for j 1 to isect do // create first element of fictitious list and insert it into PQ 3 CartMultInsert(A, B T, P Q, isect, j) 4 IncrementList(isect, j) 5 while IsNotFinished(isect) do 6 (key, value) ExtractMin(P Q) // extract next element from PQ 7 (product, j) Unpair(value) 8 if key Back(Q) then 9 Enqueue(Q, key, product) // insert non-existing element 10 else 11 UpdateBack(Q, product) // update existing element on the fly 12 if ISNOT EMP T Y (isect(j)) then // insert appropriate list element into PQ 13 CartMultInsert(A, B T, P Q, lists, isect, j) 14 IncrementList(isect, j) 15 ConstructDCSC(Q)

51 41 3. Clusteranalyse von Graphen In diesem Kapitel wollen wir uns mit der Clusteranalyse in Graphen beschäftigen. Dabei handelt es sich um die Problemstellung, natürliche Gruppen in Graphen zu bestimmen. Salopp könnte man dazu auch Strukturierung des Chaos im Graphen sagen. Das Bestimmen von Clustern ist eine weitverbreitete Analysemethode, sie findet unter anderem Anwendung in den Bereichen Marketing und Werbung, in der Strukturvorhersage, im Maschinellen Lernen und im Data Mining, bei der Bildsegmentierung sowie in vielen weiteren Gebieten. In der Forschung werden die Begriffe Clusteranalyse, Clustering und Community Detection oft anhand verschiedener Eigenschaften der Problemstellung und/oder der eingesetzten Algorithmen unterschieden. Der Einfachheit halber wollen wir das in diesem Kapitel nicht tun und die Begriffe synonym verwenden, was auch nicht selten in Forschungsarbeiten zum Thema geschieht. Clustering-Algorithmen lassen sich in zahlreiche Algorithmenklassen einteilen, einige dieser Algorithmen wollen wir in diesem Kapitel kennen lernen. Bevor wir uns mit den Algorithmen zur Clusteranalyse beschäftigen können, benötigen wir zunächst eine formale Definition einer Clusterung bzw. eines Clusters. Definition 3.1. Sei G = (V, E) ein ungerichteter, einfacher (schlichter) Graph. Eine Clusterung C = (C 1,..., C k ) ist eine Partitionierung der Knotenmenge V in nicht-leere, disjunkte Teilmengen, deren Vereinigung V überdeckt. Eine solche Teilmenge C i heißt Cluster. Korollar 3.2. Jede Clusterung C kann eindeutig durch die Äquivalenzrelation (reflexiv, symmetrisch, transitiv) u C v : C i C : u, v C i beschrieben werden. Die Cluster C i entsprechen genau den Äquivalenzklassen Label Propagation Die Idee des Label-Propagation-Algorithmus (LPA) besteht darin, jedem Knoten bereits von Anfang an eine Clusternummer (Label) zuzuordnen. Iterativ übernimmt jeder Knoten dann das Label, das die meisten seiner direkten Nachbarn haben. Ein Beispiel davon ist in Abbildung zu sehen, bei dem Knoten 4 noch zum falschen Cluster (blau) gehört Der Algorithmus Gegeben ist also ein Graph G = (V, E) mit einer initialen Clusterung C. Als initiale Clusterung wird, wie im klassischen Label Propagation Algorithmus, jeder Knoten einem eigenen Cluster zugeordnet (Ein-Knoten-Clusterung), oder sie kann von einem anderen Algorithmus stammen, z.b.: Ausführung einer Runde des Luby-Algorithmus zur Berechnung einer maximal unabhängigen Menge (Maximum Independent Set). Die Zuordnung der restlichen Knoten, die nicht zur unabhängigen Menge gehören, erfolgt an den nächstgelegenen Knoten, der in der unabhängigen Menge enthalten ist.

52 42 3. Clusteranalyse von Graphen Abbildung : Beispielgraph mit Clusterung Berechnung einer Startlösung durch ein Multilevel-Verfahren. Hierbei wird der Graph zunächst rekursiv vergröbert um dann auf der gröbsten Ebene eine Startlösung zu berechnen. Während der Rückkehr aus der Rekursion wird die Lösung stufenweise verbessert. Die experimentelle Erfahrung zeigt allerdings, dass LPA auf einem Graphen mit guter Cluster- Struktur robust gegenüber der initialen Clusterung ist. Gesucht ist nun eine bessere Clusterung C. Der Algorithmus geht dabei iterativ (oder rekursiv) wie folgt vor: Stimmabgabe: Jeder Knoten stimmt dafür, dass seine Nachbarn zum eigenen Cluster gehören. Zuweisung: Jeder Knoten wird nach der Berechnung aller Stimmabgaben dem benachbarten Cluster mit den meisten Stimmabgaben zugeordnet, dies kann natürlich auch das eigene Cluster sein. Ist der Einfluss bzw. die Stimmanzahl verschiedener benachbarter Cluster gleich hoch, so wird dieser Konflikt beliebig aufgelöst, bspw. indem der Cluster mit der kleinsten Clusternummer gewählt wird. Der Pseudocode ist in Algorithmus 19 abgebildet und Abbildung zeigt einen Schritt des Algorithmus mit der Ausgangssituation von Abbildung Dabei wurden die Anzahl der Kanten von jedem Cluster zu jedem Knoten gezählt. Für jeden Knoten wurde dabei implizit eine Schleife mitgezählt Probleme Ein Problem des Algorithmus liegt in den unterschiedlichen Knotengraden, die im Graphen vorkommen können. Besonders bei Netzwerken der realen Welt wie beispielsweise sozialen Netzwerken oder manchen Transportnetzwerken treten stark unterschiedliche Knotengrade auf. Besonders wichtig ist dies bei gerichteten Netzwerken bzw. Graphen (Ein- und Ausgangsgrad können hier sehr unterschiedlich sein). Dieses Problem hat zur Folge, dass einige Knoten sehr starken Einfluss bei der Stimmabgabe haben. Eine mögliche Lösung besteht darin, eine Normalisierung der Abstimmung durchzuführen. Hierfür werden beispielsweise die Kantengewichte der ausgehenden Kanten jedes Knotens durch die Summe aller ausgehenden Kantengewichte geteilt um die Stimmen jedes Knotens auf 1 zu normalisieren. Ein weiteres Problem stellen Knoten mit Grad 1 dar. Hier ist nicht klar, ob diese einen eigenen Cluster bilden sollen oder beser zum Cluster des Nachbarn hinzugefügt werden sollten.

53 3.1. Label Propagation 43 Algorithmus 19 : Label Propagation Input : G = (V, E) : Graph, θ : Konvergenz-Schranke Output : ζ : V N : Communities 1 for v V do 2 ζ(v) id(v) // Initiale Clusterung 3 updated V 4 V active V 5 while updated > θ do 6 updated 0 7 for v {u V active : deg(u) > 0} do 8 l argmax l { u N(v):ζ(u)=l ω(v, u)} // Stimmabgabe // Zuweisung 9 if ζ(v) l then 10 ζ(v) l 11 updated updated V active = V active N(v) 13 else 14 V active V active \ {v} 15 return ζ Bei einem kleinen Cluster ist es wahrscheinlich, dass dieser von einem anderen Cluster aufgesogen wird, wenn zu diesem mehrere Kanten existieren. Es ist in diesem Fall anwendungsabhängig, ob man diesen Effekt verhindern will oder nicht. Eine Möglichkeit, dieses Phänomen zu verhindern, besteht wiederum in der Normalisierung der Abstimmung, allerdings unter Berücksichtigung der Clustergröße. Dafür wird der Einfluss bzw. die Anzahl der Stimmen mit einem Stärkeexponenten skaliert, genauer werden die ausgehenden Kantengewichte jedes Knotens durch die Größe seines Clusters, potenziert um einen Wert 0 p 1, geteilt. Der Exponent p kann während der Laufzeit verändert werden um die Änderungen in Anzahl und Größe der Cluster widerzuspiegeln Komplexität Raumkomplexität Werden die Stimmen als Liste an jedem Knoten verwaltet, so reichen insgesamt E Listeneinträge über alle Kanten gesehen, da jede Kante in jeder Iteration einmal Einfluss nehmen kann Zeitkomplexität Der Vorteil des LPA liegt in der Laufzeit. Jede Iteration benötigt O( E ) Zeit und es konnte empirisch gezeigt werden, dass der Algorithmus bereits nach wenigen Iterationen, typischerweise O(1), einen stabilen Zustand erreicht, wenngleich dies bisher noch nicht mathematisch bewiesen wurde. In der Praxis hat sich gezeigt, dass die Anzahl der Iterationen eher von der Struktur des Graphen abhängt und weniger von dessen Größe. Wenn der Graph eine gute Cluster-Struktur besitzt, so ergibt sich (zumindest aus empirischer Sicht) eine Gesamtlaufzeit von O( E ).

54 44 3. Clusteranalyse von Graphen B: 1 R: 2 B: 4 R: 1 B: 0 R: 3 B: 2 R: 3 B: 5 R: 0 B: 3 R: 0 B: 1 R: 3 B: 3 R: 1 B: 0 R: 3 B: 4 R: 1 B: 0 R: 3 B: 1 R: 4 B: 4 R: 1 B: 3 R: 0 B: 0 R: 4 B: 3 R: 1 Abbildung : Iterationsschritt des Algorithmus Algebraische Formulierung V V Definition 3.3. Sei C F 2 die Matrix, für die gilt: C ij = 1 gdw. Knoten j befindet sich in Cluster i. C repräsentiert also die Clusterung des Graphen. Bemerkung. Als Startlösung wird C = I gewählt. Definition 3.4. Sei A die gewichtete Adjazenzmatrix des Graphen. Dann definieren wir T = CA als die Stimmauszählungsmatrix (engl.: tally matrix). Bemerkung. Es gilt T ij = k gdw. es k Stimmen für den Knoten j in Cluster i gibt. Ist die Stimmabgabe abgeschlossen, erfolgt die Zuweisung der Clusterung wie folgt: m = T max. C = m.== T Hier wird für jeden Knoten in m R V + die maximale Anzahl Stimmen, die er in einem der Cluster besitzt, gespeichert und anschließend daraus die neue Clusterung C generiert. Algorithmus 20 zeigt den Pseudocode für die algebraische Formulierung des LPA. Weitere Operationen sind: Normalisierung 1 (Entschärfung verschiedener Knotengrade):

55 3.1. Label Propagation 45 Algorithmus 20 : Algebraische Formulierung des Label Propagation Algorithmus V V Input : G = A : R +, C i : F Output : C f : F 2 1 T C i A 2 m T max. 3 C f m.== T 4 if C i == C f then V V V V 2 5 return C f 6 else 7 return LabelPropagation(G, C f ) w = A +. A = 1/w.x A Normalisierung 2 (kleine Cluster und Einzelknoten erhalten): w = C +. A = (1/w.ˆp).x A Konflikte: Finde in jeder Spalte von T das erste Maximum Raumkomplexität Algorithmus 20 verwendet die folgenden Variablen: Name Typ Anzahl Elemente A V V R + O( E ) T V V R + O( E ) C i V V F 2 O( V ) C f V V F 2 O( V ) m R V + O( V ) T benötigt nur O( E ) Einträge, da jede Kante einer Stimme entspricht und es demnach nicht mehr Stimmen als Kanten im Graphen geben kann. Der Gesamtspeicherverbauch der algebraischen Formulierung beläuft sich demnach auf O( E ) Zeitkomplexität Da jede Kante genau einer Stimme entspricht benötigt die Stimmabgabe O( E ) Operationen, gleiches gilt für die Auszählung. Wenn der Algorithmus p Durchläufe benötigt, beträgt die Gesamtlaufzeit O(p E ). Wird wie beim normalen Label Propagation Algorithmus davon ausgegange, dass nur wenige Iterationen nötig sind (also p eine Konstante ist), so hat auch die algebraische Formulierung eine Laufzeit von O( E ).

56 46 3. Clusteranalyse von Graphen 3.2. Markov Clustering Ein alternativer Ansatz ist das sogennante Markov-Clustering. In diesem Abschnitt wollen wir diesen Ansatz vorstellen und ihn mit dem LPA vergleichen. Definition 3.5. Ein Random Walk ist ein Pfad, der auf einem beliebigen Knoten j startet und dann zufällig und gleichverteilt über einen Nachbarn i von j verläuft. Von Knoten i wird dieser Prozess fortgesetzt. Abbildung : Schematische Darstellung eines Random Walks in einem Graphen Abbildung zeigt schematisch einen Random Walk in einem Graphen. Der Markov-Clustering- Algorithmus (MCL) basiert auf Random Walks. Die Idee dabei ist, dass ein Random Walk mit hoher Wahrscheinlichkeit lange in einem dichten Gebiet (also einem Cluster) verweilt, bevor er eine der wenigen externen Kanten findet, über die er das Gebiet verlassen kann. Definition 3.6. Eine n n Matrix M heißt Markov-Matrix, wenn alle Einträge nichtnegativ sind und die Summe jeder Spalte 1 ergibt. Man nennt M dann auch spaltenstochastisch. Definition 3.7. Sei G ein gewichteter Graph und A die gewichtete Adjazenzmatrix von G. Weiter sei D die Diagonalmatrix der Spaltensummen von A. Dann definieren wir M := AD 1 als Transitionsmatrix von G. Bemerkung 3.8. Die Transitionsmatrix M von G ist eine Markov-Matrix. Beweis. Betrachte die j-te Spalte von M. Es gilt: und damit: M ij = n k=1 A ik D 1 kj = A ijd 1 jj n M ij = i=1 n i=1 n A ij Djj 1 i=1 = A ij n i=1 A ij = 1

57 3.2. Markov Clustering 47 Demnach definiert M ij die Wahrscheinlichkeit des Übergangs von Knoten j nach Knoten i. Die e-fache Matrix-Matrix-Multiplikation der Matrix M mit sich selbst liefert uns also die Matrix M e, wobei Mij e die Wahrscheinlichkeit ausdrückt, einen Pfad der Länge e von Knoten j nach Knoten i zu gehen. Algorithmus 21 zeigt das Markov Clustering Verfahren. Der Algorithmus besteht im Wesentlichen aus zwei Schritten. Zunächst wird eine Expansion durchgeführt, d.h. es wird mit Hilfe von Random Walks der Graph erkundet. Dies geschieht durch die Potenzierung der Markovmatrix mit einem Exponenten e 2. Anschließend werden die Einträge der Matrix punktweise mit einem Skalar r > 0 potenziert. Dies führt zu einer Verstärkung guter und zur Abschwächung schwacher Bindungen zwischen den Knoten. Dieser Schritt wird auch als Inflation bezeichnet. Da durch den Infaltionsschritt die Matrix nicht mehr spaltenstochastisch ist, folgt in einem letzten Schritt noch eine Normalisierung der Spalten, um wieder eine Markovmatrix zu erhalten. Dieser Prozess wird bis zur Konvergenz wiederholt. Der MCL Algorithmus wird beim Start mit der Markovmatrix C i := M = AD 1 aufgerufen, bei der die Schleifenwahrscheinlichkeit optional größer Null sein kann. Algorithmus 21 : Markov Clustering Input : C i : Markovmatrix, e : Expansionsexponent, r : Inflationsexponent 1 C f C e i // Expansion: Matrix-Matrix-Multiplikation 2 C f C f. r // Inflation: Punktweise Potenzierung 3 w C f.+ // Spaltensummen 4 C f C f. 1/w // Spaltennormalisierung 5 if C i == C f then 6 return C f 7 else 8 return MarkovClustering(C f, e, r) Es bleibt zu zeigen, dass der Algorithmus konvergiert. Das wollen wir im nächsten Abschnitt mit Hilfe der Eigenwerte und Eigenvektoren der Markovmatrix beweisen. Eigenwerte und Eigenvektoren bieten uns eine Möglichkeit zur Analyse der wiederholten Anwendung eines Operators auf einen Vektor. Im Anschluss an den Beweis der Konvergenz des MCL Algorithmus wollen wir noch einige weitere Eigenschaften eines Graphen anhand der Eigenwerte bzw. Eigenvektoren kennen lernen Konvergenz des Markov Clustering Algorithmus Wir müssen zeigen, dass sich die Einträge der iterativ berechneten Markovmatrix ab einem bestimmten Zeitpunkt nicht mehr ändern. Da die Markovmatrix eine Wahrscheinlichkeitsverteilung für einen Random Walk auf dem Graphen beschreibt, ist die Konvergenz des Random Walks gegen eine bestimmte Wahrscheinlichkeitsverteilung damit äquivalent. Die Eigenvektoren und Eigenwerte der Markovmatrix M = AD 1 geben uns dafür wichtige Informationen über die Struktur von G. Aus der linearen Algebra ist bekannt, dass die Eigenvektoren einer symmetrischen Matrix eine orthonormale Basis bilden (siehe Anhang A.1). Allerdings ist M im Allgemeinen nicht symmetrisch. Wir verwenden deshalb die Matrix S := D 1/2 AD 1/2 = D 1/2 MD 1/2. Demnach besitzt S die spektralen Zerlegung S = n λ i v i vi T, i=1

58 48 3. Clusteranalyse von Graphen wobei ω 1 ω 2 ω n die Eigenwerte von S und z 1,..., z n die zugehörigen und normierten Eigenvektoren sind. Dann gilt für alle i = 1,..., n M(D 1/2 z i ) = D 1/2 SD 1/2 D 1/2 z i = D 1/2 Sz i = D 1/2 ω i z i = ω i (D 1/2 z i ). Daraus folgt, dass M dieselben n Eigenwerte ω i besitzt wie S und D 1/2 z i die zugehörigen Eigenvektoren sind. Theorem 3.9. Ist G zusammenhängend und ungerichtet, dann hat der größte Eigenwert ω 1 von M = AD 1 die Vielfachheit 1, den Wert 1 und Eigenvektor d = (d(1),..., d(n). Beweis. Zunächst werden wir durch einfaches Nachrechnen überprüfen, dass d ein Eigenvektor von M zum Eigenwert 1 ist. Ist d ein Eigenvektor von M, so existiert ein Eigenwert z von S mit Dann gilt: D 1/2 z = d z = d. Sz = S d = D 1/2 AD 1/2 d = D 1/2 A = d = 1 z. Somit ist d ein Eigenvektor von M zum Eigenwert ω 1 = 1. Weiter gilt für einen bel. Eigenvektor ω und den korrespondierenden Eigenvektor v von M: M x M = sup wv = w v x 0 x v v = w. Da M eine Markovmatrix ist, gilt M 1 = 1 und damit w 1, daher ist ω 1 der größte Eigenwert von M. Es bleibt noch zu zeigen, dass ω 1 die Vielfachheit 1 besitzt. Hierfür verwenden wir den Satz von Perron-Frobenius, der besagt, dass der größte Eigenwert einer positiven Matrix (alle Einträge sind positiv) ein einfacher Eigenwert ist. Folgerung Sei G wie in Theorem 3.9 definiert und sei ω n > 1. Dann konvergiert der Random Walk auf G gegen die Verteilung π = d v d(v). Der Beweis von Folgerung 3.10 kann in der einschlägigen Literatur nachgelesen werden, zur Übung kann die Aussage aber durch das Nachrechnen von Mπ = π überprüft werden. Nun wissen wir, dass der Markov Clustering Algorithmus konvergiert, allerdings würden wir noch gerne eine Aussage über die Konvergenzgeschwindigkeit machen. Sei dazu p t R n die Wahrscheinlichkeitsverteilung, die für jeden Knoten j die Wahrscheinlichkeit angibt, dass der Pfad des Random Walks nach t Schritten an j endet. Der Wahrscheinlichkeitsverteilung p 0 wird dabei meist auf einen Startknoten a gesetzt, also p 0 (a) = 1. Für t > 0 gilt dann p t = Mp t 1.

59 3.2. Markov Clustering 49 Theorem Sei der Startknoten des Random Walks Knoten a. Dann gilt für jeden Knoten b: d(b) p t (b) π(b) d(a) (max{ ω 2, ω n }) t Beweis. Der Beweis funktioniert auf ähnliche Weise wie der Beweis von Theorem 5.6. Damit konvergiert der MCL Algorithmus eher langsam. Der Grund dafür ist zugleich der Ansatz des gesamten Algorithmus, die Random Walks überwinden Flaschenhälse nur schlecht Zusammenhänge zwischen Graphen und Eigenwerten In diesem Abschnitt wollen wir noch einige weitere interessante Zusammenhänge zwischen einem Graphen bzw. der Matrixrepräsentation des Graphen und den Eigenwerten erwähnen Eigenwerte und Zusammenhang des Graphen Theorem Sei L die Laplacematrix eines ungerichteten Graphs G. Dann enspricht die Zahl der Zusammenhangskomponenten von G der Häufigkeit des Eigenwerts 0 von L. Beweisskizze. Wir führen eine vollständige Induktion über die Zahl k der Zusammenhangskomponenten von G. Fall 1. k = 1: Sei v ein Eigenvektor zum Eigenwert 0. Dann gilt: 0 = v T 0 = v T Lv = 1 2 n i=1 n j=1 w ij(v(i) v(j)) 2. Knoten derselben Zusammenhangskomponente haben den gleichen Wert in v. Da nach Voraussetzung nur eine Zusammenhangskomponente existiert, ist demnach v ein konstanter Vektor. Fall 2. k > 1: Da die Reihenfolge der Knoten keinen Einfluss auf die Eigenvektoren bzw. die Eigenwerte hat, können wir L in eine Blockmatrix überführen. Dabei entspricht jeder Block einer Zusammenhangskomponente und stellt für diese eine Laplacematrix dar. Nun sind wir für jeden Block in Fall 1 und (0,..., 0, v i (1),..., v i (n i ), 0,..., 0) T ist ein Eigenvektor des i-ten Blocks (mit der korrekten Anzahl Nullen an den Stellen der anderen Blöcke). Insgesamt haben wir also k solcher Blöcke mit linear unabhängigen Eigenvektoren, weshalb der Eigenwert 0 von L die Vielfachheit k besitzt Eigenwerte und Konnektivität Definition Partition Sei G = (V, E) ein ungerichteter Graph. Dann ist (V 1, V 2 ) mit V 1, V 2 V, V 1 V 2 = und V 1 V 2 = V eine Partition von G. Dabei müssen V 1 und V 2 nicht zwingend zusammenhängend sein. Eine Partition (V 1, V 2 ) heißt balanciert, wenn V 1 V 2 1 gilt.

60 50 3. Clusteranalyse von Graphen Bei einer Partitionierung in zwei Teile spricht man auch von einer Bipartition. Definition Schnitt Die Menge Ext(V 1, V 2 ) = {{u, v} E; u V 1, v V 2 } beschreibt die Kanten, die zwischen V 1 und V 2 verlaufen und wird Schnitt der Partition genannt. Abbildung zeigt den Schnitt eines Graphen. Abbildung : Schnitt in einem ungerichteten Graphen Definition Bisektionsweite Sei G = (V, E) ein ungerichteter Graph. Die Bisektionsweite σ(g) ist definiert als: σ(g) := min{ Ext(V 1, V 2 ) ; (V 1, V 2 ) ist eine balancierte P artition von G} Theorem Untere Schranke für σ Sei G = (V, E) ein ungerichteter Graph mit gerader Knotenanzahl n = V und λ 2 der zweitkleinse Eigenwert der Laplacematrix L von G. Für die Bisektionsweite von G gilt dann: σ(g) n λ2 4 Beweis. Da (1... 1) ein Eigenvektor zum kleinsten Eigenwert 0 der Laplacematrix ist, müssen folglich alle Eigenvektoren von λ 2 orthogonal zu diesem Vektor sein, d.h. ist x ein Eigenvektor zu λ 2, so gilt x, (1... 1) = 0, also n i=1 x i = 0. Mit Hilfe des Rayleigh-Quatienten und des Courant-Fisher Theorems folgt dann, dass λ 2 = Lx, x min x 0 x, x. xi =0 Nun sei V 1, V 2 eine minimale, balancierte Partition von G, also V 1 = V 2 = n/2 und Ext(V ) 1, V 2 ) = σ(g). Weiterhin sei y Z n ein Indikatorvektor für den gilt: { 1, falls v i V 1 y i = +1, falls v i V 2 Damit gilt offensichtlich n i=1 y i = 0 und darum gilt auch:

61 3.3. Random Walks als Analysewerkzeug 51 λ 2 Ly, y y, y wobei y, y = n i=1 y2 i = n. Im Folgenden bezeichne N(i) die Nachbarschaft von Knoten v i. Für einen beliebigen Vektor x Z n gilt dann: Lx, x = = = = = = n n ( L ij x j )x i i=1 i=1 j=1 n n ( liix i x j )x i j=1 v j N(i) n ( N(i) x i i=1 n ( i=1 v j N(i) {v i,v j } E {v i,v j } E x j )x i v j N(i) (x i x j ))x i ((x i x j )x i + (x j x i )x j ) (x i x j ) 2 Es ist y i = y j für alle Kanten, die nicht zum Schnitt der Partitionen V 1, V 2 gehören. Für die Schnittkanten gilt: y i y j = 2 und somit: Ly, y = Insgesamt erhalten wir also: {v i,v j } E (y i y j ) 2 = {v i,v j } Ext(V 1,V 2 ) 2 2 = 4 σ(g). λ 2 Ly, y y, y = 4 σ(g) n = σ(g) λ 2 n Random Walks als Analysewerkzeug Folgt Bildsegmentierung mit spektraler Clusteranalyse Eine sehr anschauliche Anwendung des Graphclusterings ist die Segmentierung von Bildern. Hierbei besteht die Aufgabe darin, ein Bild in inhaltlich zusammenhängende, homogene Bereiche zu zerlegen. Die graphbasierte Bildsegmentierung ist nur eine von vielen Algorithmenklassen, die zur Lösung dieses weitverbreiteten Problems in der Bildverarbeitung verwendet wird. Die Wahl des richtigen Algorithmus ist dabei stark anwendungsabhängig. In diesem Abschnitt wollen wir am Beispiel der Bildsegmentierung die spektrale Clusteranalyse kennenlernen.

62 52 3. Clusteranalyse von Graphen Abbildung : Minimaler Schnitt einer schlechten Clusterung Graphrepräsentation von Bildern Zunächst müssen wir definieren, wie ein Bild als Graph repräsentiert werden kann. Die Idee dabei ist, jeden Pixel (i, j) des Bildes durch einen Knoten darzustellen. Kanten existieren dann von jedem Knoten zu seiner lokalen Nachbarschaft im Bild. Oft wird dabei die 8-Nachbarschaft jedes Pixels gewählt, es können aber auch noch größere Nachbarschaften definiert werden. Die Kantengewichte berücksichtigen dabei die Distanz des jeweiligen Pixels zu seinem Nachbarn sowie den Farbunterschied. Definition Wir definieren das Kantengewicht einer Kante (u, v) des Bildgraphen G = (V, E) wie folgt: w(u, v) := exp F (u) F (v) 2 2 σ 2 I { exp d(u,v) 2 σ 2 X 0 sonst falls v in Nachbarschaft von u wobei F : V [0, 255] 3 den RGB-Farbwert eines Pixels und d(u, v) die Distanz von Pixel u zu Pixel v angibt. Mit Hilfe der beiden Konstanten σ I und σ X können die beiden Faktoren zusätzlich gewichtet werden. Für F sind auch andere Funktionen wie beispielsweise die Helligkeit eines Pixels denkbar, dies ist selbstverständlich anwendungsabhängig. Damit repräsentiert das Kantengewicht w(u, v) die Wahrscheinlichkeit, dass Pixel u zum selben Objekt wie Pixel v gehört. Die Aufgabe eines Clusteringalgorithmus besteht nun darin, eine geeignete Partitionierung der Knotenmenge zu finden, sodass die Objekte eines Bildes jeweils eine Partition bilden Optimierungsproblem Nach der Definition der Kantengewichtsfunktion sollten in einer Partitionierung möglichst wenige schwere Kanten, d.h. Kanten mit hohem Gewicht, geschnitten werden. Dies entspricht dem Finden eines minimalen Schnitts zwischen den Partitionen. Allerdings schneidet der Algorithmus mit dieser Zielfunktion bevorzugt kleine Mengen isolierter Knoten. Abbildung zeigt ein Beispiel, in dem im Falle einer Bisektionierung stets ein einzelner isolierter Knoten der rechten Hälfte einen kleineren minimalen Schnitt ergibt, als der eigentlich für ein Clustering bessere Schnitt, der hier gestrichelt gekennzeichnet ist. Dieses Verhalten wollen wir bei der Bildsegmentierung vermeiden, denn sehr kleine Cluster decken meist einzelne Objekte eines Bildes nicht vollständig ab. Um diese Bedingungen zu berücksichtigen, definieren wir den normalisierten Kantenschnitt N cut (A, B) nach Shi und Malik [SM00] wie folgt:

63 3.4. Bildsegmentierung mit spektraler Clusteranalyse 53 Definition (Normalisierter Kantenschnitt) Sei vol(x) := u X,v V der gewichteten Knotengrade der Knoten in X. Dann ist w(u, v) die Summe N cut (A, B) := cut(a, B) vol(a) + cut(a, B) vol(b). Wir wollen nun mit Hilfe von spektralem Clustering auf dem Bildgraphen G = (V, E) Partitionen A und B finden, für die V = A B und A B = gilt, sodass die Funktion N cut (A, B) annähernd minimal ist. Definition Sei n = V und x { 1, 1} n der Indikatorvektor, für den x i = 1 gilt, wenn Knoten i in A enthalten ist und analog x i = 1 gilt, wenn Knoten i in B liegt. Weiter sei 1 der n 1 dimensionale Einsvektor und b R, sowie y {1, b} n ein weiterer Indikatorvektor. Sei außerdem D die Gradmatrix von G und L die Laplacematrix, also L = D W, wobei W die gewichtete Adjazenzmatrix ist. Lemma (Minimaler, normalisierter Kantenschnitt in algebraischer Form) Unter der Bedingung y T D1 = 0 gilt für den minimalen, normalisierten Kantenschnitt: min x N cut (x) = min y y T Ly y T Dy (3.4.1) Die Herleitung dieses Ergebnisses kann in der Publikation von Shi und Malik nachgelesen werden [SM00]. Man beachte, dass der Quotient in dem Rayleigh-Quotienten entspricht Relaxiertes Optimierungsproblem Die Lösung des Optimierungsproblems aus unter den Bedingungen b R, y {1, b} n (diskret!) und y T D1 = 0 ist NP-schwer. Deshalb nehmen wir eine Relaxierung des Problems vor, indem wir y [ b, 1] n erlauben. Dies führt mit Hilfe des Courant-Fischer-Theorems auf das verallgemeinerte Eigenwertproblem: Ly = λdy. Dieses Problem kann mit Hilfe eines Eigenlösers wie zum Beispiel dem Lanczos-Verfahren approximativ gelöst werden. Da wir in diesem Fall meist nur am Vorzeichen der Einträge in den Eigenvektoren interessiert sind, muss die benötigte Präzision des Eigenlösers nicht sonderlich hoch sein [SM00]. Algorithmus 22 zeigt den kompletten NCut-Algorithmus nach Shi und Malik Laufzeit des NCut-Algorithmus Die Laufzeit wird vom Lösen des Eigenwertproblems dominiert. Das Lösen mit einem Standardverfahren wie beispielsweise dem QR-Verfahren benötigt O(n 3 ) Operationen. Allerdings berechnet dieses Verfahren alle Eigenvektoren, was wir im NCut-Algorithmus nicht benötigen wir sind lediglich an einem Eigenvektor interessiert. Zudem spielt die Genauigkeit nur eine untergeordnete Rolle. Hinzu kommt, dass die Bildgraphen aufgrund der Konstruktion meist dünn besetzt sind. Darum bietet sich das bereits erwähnte Lanczos-Verfahren an, das eine Laufzeit von O(tn + t M V M ult(n)) besitzt. Hierbei bezeichnet t die maximale Anzahl benötigter Matrix- Vektor-Multiplikationen (t O( n)) und MV Mult die dabei anfallenden Kosten pro Aufruf (= O(n)). Demnach beträgt die Gesamtlaufzeit typischerweise O(n 1.5 ).

64 54 3. Clusteranalyse von Graphen Algorithmus 22 : NCut-Algorithmus nach Shi und Malik [SM00] Input : G = (V, E, w) : ungerichteter Graph mit w ij 0 Output : C : Clusterung von G 1 D DegreeMatrix(G) 2 L LaplacianMatrix(G) 3 v 2 SolveEigenProblem(L, D) // Eigenvektor v 2 zum zweitkleinsten EW 4 p FindSplitPoint(v 2 ) // Finde guten Splitting-Punkt 5 foreach i in V do 6 if v 2 (i) p then 7 C 1 C 1 {i} 8 else 9 C 2 C 2 {i} 10 if recursivepartition then // Falls nötig, partitioniere rekursiv weiter 11 else 12 C C C 1 C 2 13 return C Verallgemeinerung auf k Segmente Im vorangegangenen Abschnitt haben wir den NCut-Algorithmus kennen gelernt, der mit Hilfe von spektralem Clustering rekursiv 2-Partitionierungen eines Graphen berechnet, der aus einem Bild generiert wird. Der Nachteil des rekursiven Vorgehens ist, dass er sehr rechenaufwändig ist. Zudem enthalten die nächsten Eigenvektoren nach dem zweitkleinsten ebenfalls hilfreiche Partitionierungsinformationen, die ungenutzt bleiben. In diesem Abschnitt möchten wir dieses Verfahren deshalb auf eine k-partitionierung verallgemeinern, indem nicht nur ein Eigenvektor, sondern k Eigenvektoren verwendet werden. Um für jedes Pixel zu entscheiden, welcher der k Eigenvektoren als Indikator für dieses Pixel dienen soll, wird im Raum der Eigenvektoren ein geometrisches Clustering angewandt. Shi und Malik verwenden dafür den k-means-algorithmus, der auch als Lloyds Algorithmus bekannt ist k-means Algorithmus von Lloyd Die Idee des k-means-algorithmus ist die folgende: Gegeben eine Menge von Beobachtungspunkten (p 1,..., p n ), wobei jeder der Punkte d-dimensional ist, teilt der k-means Algorithmus die n Punkte in k Cluster C = {C 1,..., C k } ein, wobei die Summe der quadratischen Abstände zum Zentrum innerhalb eines Clusters minimiert wird: min C k i=1 p j C i p j µ i 2, wobei µ i das Zentrum bzw. der Schwerpunkt der Punkte in C i ist. Der Algorithmus wird dazu mit einer initialen Belegung der Zentren µ i aufgerufen. Diese kann zufällig gewählt werden, es existieren aber auch bessere Methoden. Anschließend werden folgende Schritte iterativ ausgeführt: Zuweisung jedes Punktes p i zu einem der Cluster C j, bei dem der quadratische Abstand zum Zentrum µ i des Clusters ( p j µ i 2 ) minimiert wird. Dieser Schritt entspricht der Par-

65 3.5. Weiterführende Literatur 55 titionierung der Punkte anhand des Voronoi-Diagramms, das von den Zentren der Cluster induziert wird. Neuberechnung der Zentren als Schwerpunkt jedes einzelnen Clusters anhand der Punkte, die im vorigen Schritt in jedes Cluster eingeteilt wurden. Abbildung veranschaulicht die Schritte des Algorithmus. Die Iteration wird beendet, sobald sich keine neuen Änderungen mehr ergeben. Der Algorithmus konvergiert, da in jedem Schritt die Zielfunktion optimiert wird und es nur eine endliche Anzahl solcher Partitionen gibt. Es ist allerdings nicht sichergestellt, dass der Algorithmus in ein globales Optimum konvergiert. Abbildung : Schematische Darstellung des k-means Algorithmus von Lloyd Algorithmus 23 zeigt den KWay-NCut-Algorithmus. Algorithmus 23 : KWay-NCut-Algorithmus Input : G = (V, E, w) : ungerichteter Graph mit w ij 0 Output : C : Clusterung von G 1 D DegreeMatrix(G) 2 L LaplacianMatrix(G) // Berechne generalisierte Eigenvektoren v 2,..., v k+1 3 {v 2,..., v k+1 } SolveEigenProblem(L, D) 4 U (v 2 v 3... v k+1 ) // Fasse Eigenvektoren als Spalten v. U auf // Interpretiere Zeilen v. U als k-dim. Punkte und wende geom. Algorithmus an // Übertrage das Ergebnis auf Knoten des Graphen 5 C k-means(u(1, :),..., U(n, :)) 6 return C 3.5. Weiterführende Literatur Der Abschnitt zur Bildsegmentierung basiert auf einem Paper von Shi und Malik [SM00]. Mehr folgt.

66

67 57 4. Visualisierung von Graphen In diesem Kapitel möchten wir nun für einen Graphen ohne Koordinateninformationen eine gute visuelle Repräsentation finden, durch die die Struktur des Graphen für einen Menschen schnell ersichtlich wird. Die Visualisierung soll also übersichtlich sein und je nach Anwendungsfall bspw. wenige Überschneidungen oder wenige Knicke besitzen. Typische Anwendungsgebiete sind U- Bahn-Pläne und technische Zeichnungen, aber auch die Darstellung von Datenrelationen, wie z.b. von sozialen Netzwerken oder das Debugging von Graphenalgorithmen. In jedem Fall suchen wir somit für jeden Knoten i V eine Koordinate x i im R 2 oder R 3, sodass die davon induzierte Zeichnung die gewünschten Eigenschaften besitzt. Welcher Algorithmus zur Visualisierung eingesetzt werden sollte, hängt stark von der Klasse des Eingabegraphen ab. So lassen sich Graphen mit einem geringen Durchmesser oft schlecht darstellen. Für sehr große Graphen hingegen benötigt man eine hierarchische Auflösung, da eine sinnvolle Zeichnung des kompletten Graphen viel zu viel Platz einnehmen würde. Der Facebook- Freundschaftsgraph würde auf normalen Bildschirmen mehrere zehntausend Kanten pro Pixel benötigen! 4.1. Spektrales Zeichnen In diesem Abschnitt stellen wir eine Methode vor, die mit dem spektralen Clustering des letzten Kapitels verwandt ist. Grundidee ist hierbei eine Erkenntnis von Hall: Es lassen sich viele Abfolge- und Platzierungsprobleme durch Minimierung der quadrierten Distanzen zwischen den Koordinaten charakterisieren. Sei L G die gewichtete Laplace-Matrix des Graphen G. Dann ist in unserem Szenario das Minimierungsproblem gegeben durch unter der Nebenbedingung min x R n (i,j) E w(i, j) x i x j 2 = min x R n xt L G x n x 2 l = 1. l=1 Die Nebenbedingung impliziert hierbei x 0. Dies ist wichtig, da in der trivialen Lösung alle Knoten auf den gleichen Punkt abgebildet würden. Nach dem letzten Kapitel müssen wir somit diejenigen Eigenvektoren als Koordinaten verwenden, die zu den zwei kleinsten positiven Eigenwerten gehören. Bezeichnen wir diese mit v 1 und v 2, so setzen wir also x i = ((v 1 ) i, (v 2 ) i ). Wir betrachten nun allgemein, warum die Eigenvektoren der betragsmäßig größten Eigenwerte besonders nützlich sind. Sei A R n n eine symmetrische Matrix mit den Eigenwerten α 1 α 2... α n und (v 1,..., v n ) eine Orthonormalbasis aus dazugehörigen Eigenvektoren. Dann lässt sich A darstellen durch seine spektrale Zerlegung: A = n α i v i vi T. i=1 Wir möchten nun mit Hilfe der Eigenwerte eine möglichst gute Approximation B von A erstellen,

68 58 4. Visualisierung von Graphen für die die Operatornorm A B bzw. die Frobeniusnorm A B F klein ist. Dabei sind die Normen gegeben durch Mx M = max M F = M x R n ij 2 x. Als Hilfsmittel dient uns dabei das Courant-Fischer-Theorem, das wir hier nicht beweisen: Theorem 4.1. Sei A eine symmetrische Matrix mit Eigenwerten α 1 α 2... α n. Dann gilt: x T Ax α k = max min S R n,dim(s)=k x S,x 0 x T x x T Ax = min max T R n,dim(t )=n k+1 x T,x 0 x T x Da wir nur nichttriviale Lösungen betrachten wollen, werden wir die Forderung x 0 nicht mehr explizit erwähnen. Nach dem Courant-Fischer-Theorem gilt somit für die extremen Eigenwerte α 1 und α n : α 1 = max x R n x T Ax x T x i,j α n = min x R n x T Ax x T x Als für uns wichtige Folgerung aus dem Courant-Fischer-Theorem erhalten wir, dass die beste Approximation von A durch eine Matrix mit Rang k gerade A (k) := k i=1 α iv i vi T ist. Der Beweis dieser Folgerung sei dem Leser als Selbstübung überlassen. Der Approximationsfehler A A (k) ist daher so klein wie möglich und dies erklärt, warum die k betragsmäßig größten Eigenwerte und ihre Eigenvektoren bereits sehr viel Information über A enthalten Kräftegesteuertes Zeichnen In diesem Abschnitt werden wir für das Zeichnen eines großen ungerichteten Graphen G = (V, E) einen weiteren Ansatz vorstellen. Wir modellieren dazu G als ein physikalisches System, auf das bestimmte Kräfte wirken und für das wir einen stabilen Gleichgewichtszustand (Äquilibrium) finden möchten. Wir gehen dazu wie folgt vor: 1. Berechnung von Kräften, die auf die Knoten wirken. 2. Bewegung der Knoten entlang der Richtung der Kräfte. 3. Wiederholung der beiden Operationen, bis ein Äquilibrium erreicht ist. Zur Modellierung der Kräfte benutzen wir das Feder-elektrische Modell. Dabei stellen wir uns die Knoten als elektrisch geladen vor sowie die Kanten als Federn, durch die die Endknoten einer Kante gegenseitig angezogen werden. Gleichzeitig wirken die elektrischen Kräfte auf jedes Paar von Knoten, gleichgültig ob durch eine Kante verbunden oder nicht, voneinander abstoßend. Die anziehende Kraft F a zwischen Nachbarn i und j soll hierbei proportional zur quadratischen Distanz zwischen i und j sein. Wir setzen daher F a (i, j) = x i x j 2 K x i x j x i x j, wobei K ein Skalierungsparameter ist, abhängig von der gewünschten Größe der endgültigen Zeichnung. Die abstoßende Kraft F r (r für engl. repulsive) zwischen allen Knotenpaaren (i, j)

69 4.2. Kräftegesteuertes Zeichnen 59 soll hingegen invers proportional zur Distanz zwischen i und j sein, sodass wir F r (i, j) = K 2 x i x j x i x j x i x j setzen. Hierbei ist K erneut der eingeführte Skalierungsparameter. Die Energie E in unserem Feder-elektrischen Modell ist gegeben durch: E(x) = x i x j 3 /3K K 2 ln( x i x j ) i j ij E Beispiel 4.2. Sei x i = (5; 1) die Koordinate von Knoten i und x j = (2; 5) die Koordinate von Knoten j. Als Skalierungsparameter wählen wir K = 10. Wir möchten nun die auf das Tupel (i, j) wirkenden Kräfte berechnen. Es ergibt sich: F a (i, j) = 25 (3, 4) = ( 1.5, 2) 10 5 F r (i, j) = (3, 4) 5 = (12, 16) Die anziehende Kraft F a (i, j) entspricht somit einer Translation um 1.5 in x-richtung und 2 in y-richtung, während F r (i, j) einer Translation um 12 in x-richtung und 16 in y-richtung entspricht. Für unseren Algorithmus können wir grundsätzlich ein beliebiges initiales Layout der Knoten wählen, z.b. eine zufällige Platzierung der Knoten in der Ebene. Dann werden wiederholt die verschiedenen Kräfte berechnet und eine Verschiebung durchgeführt, bis der Algorithmus konvergiert. Die Verschiebung wird dabei durch eine abnehmende Schrittlänge skaliert. Zusammengefasst ergibt sich Algorithmus 24. Algorithmus 24 : Algorithmus ForceDirected Input : Graph G = (V, E), Skalierungsparameter K, iniatiales Layout x, Toleranz tol Output : Kräftebasiertes Layout x 1 converged f alse 2 step initialsteplength 3 while converged true do 4 x (0) x 5 for i V do 6 f 0 // berechne Kraftvektor f 7 foreach j N(i) do 8 f f + F a (i, j) 9 for j i, j V do 10 f f + F r (i, j) 11 x i x i + step (f/ f ) // Normalisierung wird nur einmal ausgeführt! 12 step updatesteplength(step, x, x 0 ) 13 if x x (0) < tol K then 14 converged true Der angegebene Algorithmus funktioniert auf kleineren Graphen recht gut. Eine mögliche Verbesserung wäre die adaptive Aktualisierung der Schrittgröße. Für große Graphen ergeben sich

70 60 4. Visualisierung von Graphen Abbildung : Beispiel für einen Quadtree, a7/quadtree.png dann allerdings noch immer einige Probleme: Zum einen können viele lokale Minima auftreten. Der Algorithmus läuft dann häufig in ein schlechtes lokales Minimum. Dies könnte mit einem Multilevel-Ansatz umgangen werden, dessen Prinzip wir in Abschnitt vorstellen werden. Zum anderen tritt bei der Berechnung von F r quadratische Zeitkomplexität auf. Um dies zu umgehen, werden wir nachfolgend eine geometrische Datenstruktur zur Approximation von F r benutzen. Für weit entfernte Knoten berechnen wir dann nur einen Näherungswert. Die Laufzeit kann dann auf O(n log n + m) gedrückt werden Quadtree-Datenstruktur Wie bereits erwähnt, besitzt die Berechnung von F r eine quadratische Laufzeit. Dies kommt daher, dass Algorithmus 24 eine verschachtelte Schleife ist, bei der außen über jeden Knoten iteriert wird und im Inneren für F r über alle anderen Knoten iteriert wird. Ähnlich dem n- Körper-Problem in der Physik verwenden wir zur Approximation den Ansatz, dass wir weit entfernte Knoten in der gleichen Region als einen Superknoten auffassen. Wir realisieren dies mit Hilfe eines Quadtrees im zweidimensionalen bzw. mit einem Octree im dreidimensionalen Fall. Ein Quadtree ist eine rekursive Baum-Datenstruktur, die wie folgt aufgebaut wird: Der Wurzelknoten repräsentiert die gesamte Ebene (bzw. den gesamten zu betrachtenden Ausschnitt). Falls das zum aktuellen Knoten gehörende Rechteck zu viele Punkte (Schwellwert als Parameter) enthält, dann teile die zu einem Knoten v im Baum gehörige Fläche wird in vier gleich große Rechtecke, die jeweils einem der vier Kinder von v zugeordnet werden. Verfahre rekursiv so lange weiter, bis die gewünschte Auflösung erreicht ist, also z.b. die Anzahl der Punkte pro Rechteck unter dem Schwellwert liegt. In Abbildung ist beispielhaft die Aufteilung eines Rechtecks und der dazugehörige Quadtree dargestellt. Falls ein Knoten j in unserem Ausgangsgraphen G weit weg ist für die Kraftberechnung F r (i, j), so genügt zur Approximation schon ein innerer Baumknoten des Quadtrees, es muss kein Blatt oder j selbst sein. Ein innerer Baumknoten repräsentiert dabei eine Menge S von Knoten des Graphen G am Schwerpunkt x S = j S x j/ S von S. Die abstoßende Kraft von Knoten i zum Superknoten S ist dann F r (i, S) = K 2 x i x S x i x S x i x S. Eine Möglichkeit, um das Kriterium weit weg zu formalisieren, besteht in dem Barnes-Hut- Kriterium: Ein Superknoten S ist weit weg von Knoten i, wenn die Breite d s des Rechtecks, das

71 4.2. Kräftegesteuertes Zeichnen 61 zu S gehört, klein ist im Vergleich zum Abstand von x S und x i. Dies bedeutet, es gibt ein θ 0, sodass gilt d S / x i x S θ. Je kleiner dabei θ gewählt wird, umso genauer ist die Näherung. In der Praxis haben sich hierfür die Werte θ = 1 und θ = 2 bewährt. Betrachten wir nun, wie sich die Verwendung eines Quadtrees in Algorithmus 24 auf die Berechnung der abstoßenden Kraft F r auswirkt. Dabei nehmen wir an, dass die Punkte im Quadtree geeignet verteilt sind. Die Konstruktion des Quadtrees benötigt O(n log n) Zeit. Die Bestimmung aller Superknoten für einen Knoten im Ausgangsgraphen G kann in O(log n) durchgeführt werden. Die Laufzeit der Bestimmung der abstoßenden Kraft reduziert sich somit von O(n 2 ) auf O(n log n). Weitere Verbesserungen sind sogar noch möglich, wenn wir nicht nur zwischen einem Blatt und einem Superknoten approximieren, sondern jeweils zwischen Paaren von Superknoten. Mit Hilfe der Datenstruktur des Quadtrees haben wir somit das Problem der quadratischen Zeitkomplexität pro Iteration umgangen. Allerdings können noch immer viele lokale Minima der Energiefunktion existieren. Hierfür werden wir im nächsten Abschnitt den Multilevel-Ansatz kennenlernen Multilevel-Verfahren für kräftegesteuertes Zeichnen Ein Mehrebenen- oder Multilevel-Verfahren besteht aus drei Phasen. In einem ersten Schritt wird der Eingabegraph G rekursiv vergröbert, d. h. es entsteht eine Hierarchie von Graphen G = G 0, G 1,..., G k, den k + 1 Ebenen des Verfahrens. Je höher der Index einer Ebene, desto weniger Knoten und Kanten soll der zugehörige Graph besitzen. Trotz Vergröberung soll dabei die Struktur des Eingabegraphen weitgehend erhalten bleiben. Auf der stärksten Vergröberungsstufe G k wird dann eine initiale Lösung berechnet. Abschließend wird durch Interpolation der initialen Lösung und lokaler Optimierung auf jeder Ebene eine Lösung für den Eingabegraphen errechnet. In unserem Szenario laufen die drei Phasen folgendermaßen ab: 1. Rekursive Vergröberung: Zur Vergröberung des ungerichteten Graphen G i existieren verschiedene Möglichkeiten. Oft wird dazu ein nicht erweiterbares Matching benutzt. Die Kanten des Matchings und deren Endknoten werden dabei zu einem neuen Knoten verschmolzen. Sei e = uv eine solche Kante. Wir bilden dann einen neuen Superknoten x in G i+1 mit w(x) = w(u) + w(v) und entfernen die Kante e. Kanten von einem Knoten y / {u, v, x} zu u oder v werden in G i+1 auf den Superknoten x umgebogen. Dabei verschmelzen wir parallele Kanten und addieren ihre Gewichte: w(yx) = w(yu) + w(yv). Eine alternative Möglichkeit zur Vergröberung besteht in der Berechnung einer unabhängigen Knotenmenge U mit geeignet gewichteten Kanten zwischen den Knoten in U. 2. Initiales Layout: Durch die Vergröberung in Phase 1 ist der resultierende Graph G k sehr klein. Es kann somit ein beliebiger Algorithmus zur Berechnung eines initialen Layouts gewählt werden. Der im vorherigen Abschnitt vorgestellte ForceDirected-Algorithmus bietet sich hierfür an, da er auf kleinen Graphen gute Lösungen erreicht. Wegen der kleinen Größe von G k ist die Wahrscheinlichkeit groß, dass der Algorithmus das globale Optimum für G k erreicht. 3. Interpolation und Verbesserung: In dieser Phase wird die Rekursion aus Phase 1 wieder rückabgewickelt. Im Graphen G i expandieren wir die in G i+1 verschmolzene Kante e = uv wieder, indem die alte Adjazenzinformation wiederhergestellt wird. Die beiden Endknoten u und v erhalten im Layout für

72 62 4. Visualisierung von Graphen G i zunächst die Position ihres Superknotens. Lokale Verbesserungen können nun, z.b. mit dem ForceDirected-Algorithmus, durchgeführt werden. Bei letzterem Algorithmus muss beachtet werden, dass sich die relative Position von u und v zueinander nicht mehr ändert, falls die Nachbarschaften der beiden Knoten gleich sind. In diesem Fall sollten alternative Platzierungen bei der Expansion von e erwogen werden. Verwenden wir den Algorithmus ForceDirected in einem Multilevel-Verfahren, so können wir durch die lokalen Verfeinerungen in Phase 3 auch weitgehend das Problem umgehen, dass viele lokale Minima im Graphen auftreten können. Das Multilevel-Verfahren bietet somit sowohl eine globale Sicht (durch Phase 2), als auch eine lokale Sicht (durch Phase 3) auf das Problem. Nichtsdestotrotz bleibt es eine Heuristik, die nicht garantiert, dass wir die global optimale Lösung finden. Für viele kombinatorische Optimierungsprobleme sind Multilevel-Verfahren jedoch sehr effektiv Weiterführende Literatur Eine ausführlichere Darstellung des spektralen Zeichnens und zu spektralen Methoden findet sich im Kapitel Spectral Graph Theory von Spielman im Buch Combinatorial Scientific Computing [NS12] von Naumann und Schenk (Hrsg.). Weitere Erklärungen zum DirectedForce-Algorithmus und Vergleiche mit anderen Visualisierungsalgorithmen sind ebenfalls im Buch Combinatorial Scientific Computing, im Kapitel Algorithms for Visualizing Large Networks von Hu zu finden.

73 63 5. Lastbalancierung paralleler Berechnungen 5.1. Parallelität Abschnitt folgt Dynamische Balancierung unabhängiger Lasten Gegeben sei ein Rechnernetz mit vielen Prozessoren. Jeder Prozessor hat gewisse Arbeitsaufgaben, die abzuarbeiten sind und die wir in der Folge als Last bezeichnen. Bis zur gemeinsamen Lösung eines Problems muss man immer auf den am längsten rechnenden Prozessor warten. Daher ist es für eine effiziente Nutzung eines Parallelrechners entscheidend, dass alle Prozessoren gleich stark ausgelastet sind. Algorithmisch stellen wir uns daher die Frage, wie eine möglichst schnelle Balancierung der Lasten erreicht werden kann. Unsere Modellannahme in diesem Abschnitt bezüglich des parallelen Systems und der Arbeitsaufträge ist, dass die Prozessoren in jedem Schritt nur ihre eigene Last und die ihrer Nachbarn kennen und mit ihnen in einer Runde Last austauschen können. Dies geschieht ohne zentrale Steuerung und nur über die Kommunikationskanäle, die Prozessoren direkt miteinander verbinden. Weiterhin sind die Lasten beliebig aufteilbar (also durch reelle Zahlen repräsentierbar). Ein entsprechendes Rechnersystem repräsentieren wir durch einen ungerichteten Graphen, in dem die Knoten die Prozessoren darstellen und die Kanten Kommunikationskanäle zwischen den Prozessoren Das Diffusionsverfahren erster Ordnung (FOS) Gegeben sei ein Graph G = (V, E) mit n Knoten und m Kanten und seiner Adjazenzmatrix A. Sei w der Vektor (w 1,..., w n ) T, der die Arbeitslasten der Prozessoren (= Knoten) beschreibt, d. h., 1 w i bezeichnet die Last des Knotens v i V. Setze den Diffusionsparameter α (0, max i deg(i) ). Weiter sei w (k) der Lastvektor nach k Iterationsschritten und sei y (k) ij der Fluss entlang der Kante (v i, v j ) im Schritt k. Dann führt das Diffusionsverfahren erster Ordnung (engl.: first order diffusion scheme, FOS) in Iteration k + 1 folgende Operationen aus: In Matrixform: y (k+1) ij w (k+1) i = α(w (k) i = w (k) i w (k) j ) = w j N(i) j N(i) y (k+1) ij α(w (k) i w (k) j ) = (1 d i α)w (k) i + αw (k) j j N(i)

74 64 5. Lastbalancierung paralleler Berechnungen Abbildung : 3 3-Torus aus Beispiel 5.2 (links) mit initialer Lastverteilung und dem Fluss, der durch das Diffusionsverfahren entsteht (rechts). w (k+1) 1 w (k+1) 2. w (k+1) n = 1 d 1 α 0 α α 0 α 0 1 d 2 α 0 0 α 0 0 α.. } α α 0 0 {{ α d n α } n n-matrix M w (k) 1 w (k) 2. w (k) n Bemerkung 5.1. Es gilt also w (k+1) = Mw (k), wobei M R n n mit M = I αl und w (k) R n. Es folgt w (k+1) = M k+1 w (0). Weiterhin besitzt M nur reelle Eigenwerte und es gibt n aufeinander stehende Eigenvektoren z 1,..., z n, die eine Orthonormalbasis im R n bilden. Beispiel 5.2. Der Graph in Abbildung links ist ein 3 3-Torus. Die initiale Lastverteilung w (0) der Knoten sei in der Abbildung rechts dargestellt. Dann liefert das Diffusionsverfahren denjenigen Fluss, der auf den Kanten dargestellt ist. Lemma 5.3. Sei w (0) n die initiale Lastverteilung in einem Graphen G = (V, E) und sei w = n j=1 w j (1,..., 1) n die zugehörige balancierte Lastsituation. Sei w (0) = n j=1 β jz j, dann gilt: w = β 1 z 1. Beweis. Es gilt λ 1 = 1 > λ 2 (falls G zusammenhängend), und z 1 = a (1,..., 1), wobei a R.

75 5.2. Dynamische Balancierung unabhängiger Lasten 65 Dann gilt: w (0), w = = = = n β j z j, w j=1 n β j z j, j=1 β 1 z 1, n j=1 n j=1 w j (1,..., 1) n w j (1,..., 1) n (da (1,..., 1)zu allen Eigenvektoren außer z 1 senkrecht steht) n w j β 1 a(1,..., 1), (1,..., 1) n j=1 Nehmen wir nun die Gleichheit w (0), w = 1 w, w b an, wobei w = b β 1 z 1. Dann folgt: w (0), w = = w, w = j=1 (w 1,..., w n ), w j (1,..., 1) n n n j=1 w j w j = ( n j=1 w j) 2 n n j=1 j=1 w j j=1 (1,..., 1), w j (1,..., 1) = i=1 b = 1 Insgesamt gilt also w = β 1 z 1. n ( j=1 w j n n ) 2 = n ( n j=1 w j) 2 Seien µ 1 µ 2... µ n die Eigenwerte von M und λ 1 λ 2... λ n die Eigenwerte der Laplace-Matrix L. Sei z i der Eigenvektor der Matrix L zum Eigenwert λ i. Dann folgt: M z i = (I αl)z i = Iz i αlz i = z i αλ i z i = (1 αλ i )z i. Der Vektor z i ist daher auch Eigenvektor von M zum Eigenwert 1 αλ i. Da die Eigenwerte von L alle nicht-negativ sind, ist L positiv semidefinit. Wie bereits festgestellt, gilt λ 1 = 0 und der zugehörige Eigenwert ist z 1 = (1,..., 1). Wir haben bereits im Zusammenhang mit spektraler Clusteranalyse gezeigt, dass 0 ein einfacher (d.h. einfach vorkommender) Eigenwert von 0 genau dann ist, wenn G zusammenhängend ist. Definition 5.4. Sei ɛ (k) = w (k) w der Fehler nach k Iterationsschritten. Lemma 5.5. Sei G = (V, E) ein Graph und sei w (0) die initiale Lastsituation in G. Seien β 1,..., β n R: w (0) = n i=1 β iz i. Dann gilt: ɛ (0) = n β i z i. i=2 n 2

76 66 5. Lastbalancierung paralleler Berechnungen Beweis. Es gilt: ɛ (0) = w (0) w = n β i z i w = i=1 n β i z i β 1 z 1 ɛ (k) = w (k) w = M k w (0) M k w = M k (w (0) w) = M k ɛ (0) Theorem 5.6. Sei G = (V, E) ein Graph, sei w (0) die initiale Lastsituation und führe Diffusion mittels der Diffusionsmatrix M durch. Dann gilt: i=1 ɛ (k) 2 max{ µ 2, µ n } k ɛ (0) 2 Beweis. Zunächst gilt M w = w, da mit Lemma 5.3 folgt M w = Mβ 1 z 1 = β 1 z 1 = w. Setze γ := max { µ 2, µ n }. Nach Definition von ɛ (k) gilt ɛ (k) 2 = w (k) w 2 = M k w (0) w 2 = M k w (0) M k w 2 Weiterhin gelten die Zusammenhänge = M k (w (0) w) 2 = M k ɛ (0) 2 Mɛ (0) = M( M k ɛ (0) = M k ( Insgesamt folgt somit die Behauptung durch ɛ (k) 2 = n β j µ k j z j 2 j=2 n β j γ k z j 2 = γ k j=2 n β j z j ) = j=2 n β j z j ) = j=2 n β j µ j z j j=2 n β j µ k j z j j=2 n β j z j 2 = γ k ɛ (0) 2 = γ k ɛ (k) 2 j=1 Definition 5.7. Ein Fluss-Vektor y heißt l 2 -minimal, wenn y 2 = min{ x 2 x balanciert die Last in G mit initialem Lastvektor w (0) }. Theorem 5.8. Das Diffusionsverfahren FOS berechnet einen l 2 -minimalen Fluss y R m. Bemerkung 5.9. Das Diffusionsverfahren kann durch Berücksichtigung der vorletzten Iteration auf einfache Weise so abgewandelt werden, dass die Lastsituation bereits nach O( log(1/ɛ) 1 γ ) Schritten ɛ-balanciert ist. Darüber hinaus gibt es weitere Diffusionsverfahren mit noch deutlich besserem Konvergenzverhalten. Dazu benötigt man unter anderem die Eigenwerte der Laplace-Matrix des Graphen Weitere Verfahren zur dynamischen Lastbalancierung Es gibt eine Reihe weiterer Verfahren für das oben beschriebene Szenario (beispielsweise Dimension Exchange oder Work Stealing), auf die hier (zunächst) nicht genauer eingegangen werden soll.

77 5.3. Balancierung abhängiger Lasten mittels Graphpartitionierung 67 Abbildung : Veranschaulichung zur Balancierung abhängiger Lasten und ihre Entsprechung bei der Partitionierung eines Graphen Balancierung abhängiger Lasten mittels Graphpartitionierung Im vorigen Abschnitt sind wir davon ausgegangen, dass die Arbeitslasten des parallelen Systems unabhängig voneinander waren. Nun ändern wir das Szenario in dieser Hinsicht. Die Arbeitslasten und deren Abhängigkeiten repräsentieren wir dabei als Graphen, dessen Knoten (Lasten) durch eine Kante verbunden sind, wenn zwischen ihnen eine Abhängigkeit besteht. Eine typische Anwendung sind iterative Algorithmen, die bei der Berechnung des Wertes an einem Knoten v in Iteration i auf die Werte der Nachbarn von v in Iteration i 1 zurückgreifen muss. Will man diese Algorithmen parallelisieren, muss man sich im Allgemeinen überlegen, wie man die Daten auf die verschiedenen Prozessoren aufteilt, um möglichst wenig zwischen Prozessoren kommunizieren zu müssen. Dies führt uns zum Graphpartitionierungsproblem. Bei der Partitionierung eines Graphen G = (V, E) soll die Knotenmenge V in fast gleich große, zusammenhängende Teilmengen aufgeteilt werden. Typische Anwendungsbereiche sind Teile-und- Herrsche-Algorithmen oder auch Lastbalancierung für verteilte parallele Graphenalgoirthmen, wie z.b. beim wissenschaftlichen Rechnen oder der Analyse riesiger Netzwerke. In Abbildung Mitte ist ein Graph dargestellt, der die Abhhänigkeiten in einem System repräsentieren soll. Die Werte in den Knoten sind dabei die initialen Lasten. Der auf den Kanten aufgeführte Fluss (Werte gerundet) balanciert das System so, dass jeder Knoten genau 92 Einheiten Last erhält. Interessant dabei ist, dass der Knoten links unten als initiale Last 67 < 92 besitzt und für den balancierten Fluss dennoch Last abgeben muss. Der Fluss könnte mittels Diffusion ausgerechnet werden. Allerdings ist dies auch durch Partitrionierungen möglich, die dem Lastproblem entsprechen: In Abbildung links ist die dem initialen Zustand entsprechende Partitionierung dargestellt und rechts die Partitionierung, die den balancierten Zustand induziert. Definition Eine Abbildung Π: V {1,..., k} induziert eine disjunkte Aufteilung V = π 1 π 2... π k mit π i = {v V Π(v) = i}. Eine solche Abbildung Π nennen wir Partitionierung und die π Blöcke von Π. Sie heißt ɛ-balancierte Partitionierung, wenn π i (1 + ɛ) V /k gilt. Definition Der Kantenschnitt cut(π) einer Partitionierung Π eines ungerichteten Graphen G = (V, E, ω) ist definiert als: cut(π) := {u,v} E: π(u) π(v) ω({u, v}). Der Kantenschnitt cut(π) einer Partitionierung Π ist beispielhaft in Abbildung dargestellt.

78 68 5. Lastbalancierung paralleler Berechnungen π 1 π 2 π 3 Abbildung : Ein Graph mit Partitionierung Π = π 1 π 2 π 3. Wir nehmen an, dass alle Kantengewichte 1 sind. Dann gilt für den von Π induzierten Kantenschnitt: cut(π) = 7. Die Kanten, die dabei gezählt werden, sind rot dargestellt. Problem Das Graphpartitionierungsproblem besteht in der Berechnung einer ɛ-balancierten Partitionierung mit minimalem Kantenschnitt. Bemerkung Wird ein dynamischer Graph betrachtet, bei dem sich die Struktur über die Zeit ändert, so sprechen wir von einem Repartionierungsproblem. In diesem Fall möchten wir bei Eingabe von G und Π 1 das Problem 5.12 lösen und Π 2 berechnen. Dabei fordern wir zusätzlich, dass die Migrationskosten zwischen Π 1 und Π 2 minimiert werden sollen. Diese ergeben sich üblicherweise aus der Zahl der Knoten, die in Π 2 einem anderen Block zugewiesen sind als in Π 1. Im Allgemeinen sind beide Probleme N P-schwer, sodass in der Praxis Heuristiken eingesetzt werden. Die Schwierigkeit des Optimierungsproblems liegt interessanterweise nicht in der Zielfunktion des minimalen Schnitts, sondern in der Nebenbedingung der Balancierung der Blöcke. Falls diese Nebenbedingung entfällt, können wir das bekannte MaxFlow-MinCut-Theorem anwenden und mit effizienten Flusslösern eine (im Allgemeinen natürlich unbalancierte) Lösung mit minimalem Schnitt in Polynomialzeit berechnen Bubble-Framework Eine Partitonierungsidee, die wir nachfolgend benutzen wollen, basiert auf der Idee von Lloyds k- means Algorithmus: Gegeben sei eine Punktmenge in der Ebene. Wir wollen diese in k Bereiche zerlegen und für jeden Bereich ein Zentrum bestimmen, sodass die Summe über den quadratischen Abstand zu den Zentren minimal wird. Initial werden dabei k Zentren beliebig, z.b. zufällig, gewählt. Dann wird jeder Punkt dem nächstgelegenen Zentrum zugeordnet. Anschließend wird der jeweilige geometrische Schwerpunkt der entstandenen Bereiche neues Zentrum und ein weiterer Iterationsschritt beginnt. Dieses Verfahren ist schematisch in Abbildung links dargestellt. Das Bubble-Framework überträgt diese Idee nun auf Graphen, indem der Abstand durch ein geeignetes Distanz- bzw. Ähnlichkeitsmaß ersetzt wird (siehe Abbildung rechts). Dieses Ähnlichkeitsmaß soll zum Ausdruck bringen, wie gut zwei Knoten (oder allgemeiner: zwei Regionen) im Graphen miteinander verbunden sind. Gut verbunden wird hier nicht streng definiert, in der Literatur gibt es dazu verschiedene Ansätze. Im Allgemeinen versteht man darunter, dass zwischen den Knoten eine Vielzahl kurzer Pfade existieren. Letztlich nutzen wir hier wie bereits im Abschnitt zu MCL (Abschnitt 3.2) aus, dass geeignete Techniken auf Basis von Random Walks

79 5.3. Balancierung abhängiger Lasten mittels Graphpartitionierung 69 Abbildung : Schematische Darstellung des k-means Algorithmus von Lloyd (links) und seine Übertragung auf Graphen durch das Bubble-Framework (rechts). Abbildung : Schematische Darstellung des Abflusses bei der gestörten Diffusion. (oder auf Diffusion als speziellem Random Walk) in der Lage sind, dichte Gebiete in Graphen von dünnen zu unterscheiden. Das Bubble-Framework besteht aus der anfänglichen Prozedur DetermineInitialCenters und den beiden Prozeduren AssignPartition und ComputeCenters, die in jedem Iterationsschritt ausgeführt werden. Diese folgen, wie an den Namen zu erkennen ist, der generischen Struktur des k-means-algorithmus. Bevor wir seine Details anschauen, führen wir zunächst das verwendete Distanz- bzw. Ähnlichkeitsmaß ein Gestörte Diffusion (FOS/C) In diesem Abschnitt ändern wir das FOS-Verfahren so ab, dass ein balancierter Zustand bei Konvergenz vermieden wird. Dazu fließt in jeder FOS-Iteration von jedem Knoten δ > 0 Last ab und anschließend wird der Gesamtabfluss auf die Menge der Quellknoten gleichmäßig verteilt, wie in Abbildung dargestellt ist. Dabei geht keine Last im Graphen verloren, da sie nur umverteilt wird! Dieses Verfahren nennen wir gestörte Diffusion oder kurz FOS/C (engl.: f irst order diffusion scheme with constant drain). Definition (Abflussvektor) Sei S V die Quellmenge. Dann ist der Abflussvektor d gegeben durch: { δ, falls i / S d i = n δ S δ, falls i S Definition (Gestörte Diffusion FOS/C) Gegeben seien G = (V, E), eine Quellmenge S V von Knoten sowie der Diffusionsparameter 0 < α < max deg(g) 1. Seien der Abfluss-

80 70 5. Lastbalancierung paralleler Berechnungen vektor d wie in Def sowie der initiale Lastvektor w (0) definiert durch: { w (0) 0, falls i / S i = n S, falls i S Das gestörte Diffusionsverfahren FOS/C führt dann in Iteration k (i 1) die Berechnung w (k) = Mw (k 1) + d aus. Hierbeit ist M = I αl die bereits bekannte Diffusionsmatrix und L die Laplace-Matrix von G. Wie FOS konvergiert das FOS/C-Verfahren ebenfalls, sogar unabhängig vom (aus anderen Gründen) oben gewählten initialen Lastvektor. Allerdings erreicht es dabei im Unterschied zu FOS wie gewünscht keinen balancierten Zustand. Theorem Sei G = (V, E) ein zusammenhängender, schlichter und ungerichteter Graph. Das FOS/C-Verfahren konvergiert auf G für jeden initialen Vektor w (0). Betrachten wir die beiden ersten Iterationen: w (1) = Mw (0) + d w (2) = Mw (1) + d = M 2 w (0) + Md + d = M 2 w (0) + M(I + d). Wenn wir dies iterativ fortführen, so ergibt sich w (k) = Mw (0) + (M k M + I)d und somit durch die geometrische Reihe für Matrizen w ( ) = M w (0) + (I M) d = w + (αl) d. Im obigen Beweis ist L die Pseudoinverse der Laplace-Matrix und w der stationäre Zustand, also der balancierte Lastvektor, von FOS. Wäre L regulär, könnte man dort die echte Inverse einsetzen. Statt mit der oben dargestellten und im Beweis genutzten Form der Iteration kann der stationäre Zustand w ( ) folglich auch durch das Lösen eines linearen Gleichungssystems Lw = d mit w = αw ( ) bestimmt werden. Löser für lineare Gleichungssysteme wie CG (konjugierte Gradienten) konvergieren meist deutlich schneller als das iterative FOS/C-Verfahren. Letzteres ist daher eher als Mittel zum Verständnis und zur Analyse zu sehen, nicht als Basis einer effizienten Implementierung von FOS/C Bubble-FOS/C Wir werden nun das FOS/C-Verfahren mit dem Bubble-Framework verbinden, um mit dieser Kombination namens Bubble-FOS/C Graphen zu partitionieren. Wir betrachten zunächst, wie wir die einzelnen Methoden des Bubble-Frameworks mit Hilfe von FOS/C-Prozeduren implementieren. Unter einer FOS/C-Prozedur verstehen wir dabei den Lösungsvektor w im stationären Zustand eines konkreten FOS/C-Systems mit einer bestimmten Quellmenge S. Dabei sei C[i] das Zentrum von Block i. Wir führen zusätzlich zu AssignPartition und ComputeCenters die optionale Methode Consolidation ein, die in gewisser Weise die beiden vorigen Methoden kombiniert und oft zu einer besseren Balancierung und einer höheren Qualität der Partitionierung führt. 1. DetermineInitialCenters: Wir wählen k verschiedene, beliebige Knoten v 1,..., v k aus und setzen C[i] v i für

81 5.3. Balancierung abhängiger Lasten mittels Graphpartitionierung 71 i = 1,..., k. Alternativ kann auch ein anderes Verfahren gewählt werden, das k verschiedene Zentren bestimmt. Man kann bspw. nur ein Zentrum zufällig wählen und die übrigen Zentren möglichst weit weg von den bisherigen Zentren wählen. Möglichst weit weg gilt dabei in Bezug auf das Ähnlichkeitsmaß FOS/C. 2. AssignPartition: Zur Zuweisung eines Knotens an das nächstgelegene Zentrum lösen wir k FOS/C-Prozeduren. Die Quellmenge für Verfahren i ist dabei {C[i]}. Ein Knoten wird dem Zentrum zugeordnet, dessen System die meiste Last sendet. Algorithmisch wird dabei ausgeführt: Löse das Gleichungssystem Lw i = d i für i = 1,..., k Π(v) argmax i w i (v) 3. ComputeCenters: Die Berechnung neuer Zentren aus der bisheriger Partitionierung wird ebenfalls durch Lösen von k FOS/C-Prozeduren erreicht. Dabei ist die Quellmenge für Verfahren i der gesamte Block i. Neues Zentrum des Blocks i wird der Knoten mit höchster Last in System i. Algorithmisch bedeutet dies: Löse das Gleichungssystem Lw i = d i für i = 1,..., k. (nun andere Abflussvektoren!) C[i] argmax v w i (v) 4. Consolidation (optional): Diese Prozedur wird verwendet, um aus einer bestehenden Partitonierung eine neue zu berechnen. Dazu werden erneut k FOS/C-Verfahren berechnet. Die Quellmenge in System i ist der gesamte Block i. Ein Knoten wird zu dem Zentrum hinzugefügt, dessen Partition die meiste Last sendet. Diese Prozedur ist somit ein Mischung aus den Prozeduren AssignPartition und ComputeCenters. Um die Balancierung weiter zu verbessern, können zusätzliche Balancierungsschritte eingeführt werden. Beim ScaleBalance wird Last aus Systemen mit zu großen Partitionen entfernt und im Gegenzug Last zu Systemen mit zu kleinen Partitionen hinzugefügt. Dabei wird ein passender Skalierungsfakor β i berechnet, der die Menge der Last im System geeignet skaliert. Eine andere Möglichkeit ist FlowBalance. Hierbei wird mittels Diffusion ein balancierender Fluss bestimmt, der berechnet, wie viele Knoten von Block i nach Block j (1 i j k) müssen, um die Balancebedingung einzuhalten. Unklar ist hingegen zunächst weiterhin, welche Knoten dies genau sind. Hierfür können jedoch die Lasten aus der Prozedur AssignPartition benutzt werden. Letzlich werden diejenigen Knoten verschoben, die die höchste Affinität zum Zielblock besitzen. Nachfolgend ist der Algorithmus Bubble-FOS/C dargestellt, der die oben beschriebenen Methoden benutzt. Passend dazu kann Konsolidierung oder Balancierung eingebaut werden. Dabei wird die Konsolodierung üblicherweise als letzte Methode in der Schleife integriert, die Balancierungs-Methoden noch dahinter in der Schleife oder um Zeit zu sparen nur hinter der Schleife Theoretische Ergebnisse zu Bubble-FOS/C In diesem Abschnitt zeigen wir zunächst, dass Bubble-FOS/C auf zusammenhängenden ungerichteten Graphen konvergiert. Der Beweis basiert auf Lastsymmetrie und einer Potentialfunktion, die es erlaubt, die Lösung des Algorithmus zu charakterisieren. Mit Hilfe dieser Charakterisierung können wir dann zeigen, dass Bubble-FOS/C den Kantenschnitt auf relaxierte Weise global optimiert.

82 72 5. Lastbalancierung paralleler Berechnungen Algorithmus 25 : Bubble-FOS/C Input : Graph G, Zahl der Partitionen k Output : Partitionierung Π 1 C DetermineInitialCenters(G, k) 2 Π AssignP artition(g, C, k) 3 for τ = 1 until convergence 4 C ComputeCenters(G, Π, k) 5 Π AssignP artition(g, C, k) 6 return Π Definition Die Potentialfunktion F (Π, Z, τ) zum Zeitpunkt τ ist wie folgt definiert: F (Π, Z, τ) := k [w] zc(τ) v, c=1 v π c(τ) wobei π c (τ) die c-te Partition und z c (τ) das Zentrum der Partition in Iteration π ist. Wir wollen nun F maximieren. Es ist offensichtlich, dass F eine endliche obere Schranke besitzt, wenn der Graph endlich ist. Daher genügt es zeigen, dass die Operationen AssignPartition und ComputeCenters den Wert von F bezüglich der Eingabe maximieren. Für die Operation AssignPartition ist dies leicht einzusehen, da die Knoten jeweils der Partition zugeteilt werden, die die meiste Last sendet. Für ComputeCenters ist dies hingegen nicht offensichtlich, sodass wir zunächst folgendes Resultat beweisen werden: Lemma Sei G = (V, E) ein Graph und u, v V zwei beliebige Knoten. Dann gilt: [w] u v = [w] v u. Beweis. Wir betrachten die FOS/C-Prozedur mit Quelle u. Dann ist der Flussvektor d definiert als d = ( δ,..., δ, δ(n 1), δ,..., δ) T, wobei δ(n 1) der Eintrag in Zeile u ist. Die Iteration von FOS/C zum Zeitpunkt t + 1 für den Knoten v und Quelle u kann folgendermaßen dargestellt werden: [w (t+1) ] u v = [M t+1 w (0) ] u v + [(I + M M t )d] u v = [M t+1 w (0) ] u v + nδ t l=0 Ml v,u (t + 1)δ. Wir haben in Abschnitt gelernt, dass M t+1 w (0) gegen w = (1,..., 1) T, die balancierte Lastverteilung, konvergiert. Dies gilt sogar, wenn die Kanten des Graphen gewichtet sind. Somit erhalten wir: ( [w] v u [w] u t ) v = nδ l=0 Ml u,v M l v,u. Da M und somit auch alle Potenzen von M symmetrisch sind, verschwinden alle Summanden auf der rechten Seite und wir erhalten die Aussage des Lemmas. Obiges Resultat ist in seiner Allgemeinheit überraschend, da man keine Lastsymmetrie in einem beliebigen Graphen ohne Symmetrie vermuten würde. Es ist daher beim gestörten Diffusionsschema FOS/C von besonderem Interesse. In unserem Fall hilft es uns dabei, das nächste wichtige Lemma zu beweisen.

83 5.3. Balancierung abhängiger Lasten mittels Graphpartitionierung 73 Lemma Die Operation ComputeCenters maximiert den Wert der Potentialfunktion F für eine gegebene k-partitionierung Π. Beweis. Sei Π die aktuelle Partitionierung. ComputeCenters berechnet für jede Partition π c, c {1,..., k}, eine FOS/C-Prozedur mit mehreren Quellen, wobei die gesamte Partition als Quellmenge fungiert. Betrachte die Partition π c und die dazugehörige Multi-Quellen-FOS/C-Prozedur, die w durch Lw = d berechnet. Dabei ist d der zugehörige Flussvektor. Wir wollen nun diese Prozedur in Teilprozeduren aufteilen, die jeweils Lw i = d i, i π c, berechnen mit i π c d i = d. Solch eine Aufteilung L(w 1 + w w πc ) = d 1 + d d πc existiert. Beachten Sie dazu, dass jede Teilprozedur Lw i = d i einer FOS/C-Prozedur mit einzelner Quelle entspricht, bei dem der Abflussvektor mit 1 π c skaliert wurde: [d i ] v = { δn π δ c π, c v π c, v Quelle in Teilverfahren i δ π, c sonst Es ist einfach zu zeigen, dass i π c d i = d und d i (1,..., 1) T gilt, sodass jede Teilprozedur eine Lösung besitzt. Zusammen mit der Linearität von L erhalten wir i π c w i = w. Das neue Zentrum von Partition π c ist nun der Knoten mit der größten Last im System der Multi-Quellen- FOS/C-Prozedur. Mit den obigen Überlegungen folgt, dass dies der Knoten u sein muss, für den [w] u = i π c [w] i u maximal ist. Nach Lemma 5.18 gilt dann i π c [w] i u = i π c [w] u i, sodass das neue Zentrum z c derjenige Knoten u ist, für den die meiste Last in einer FOS/C-Prozedur mit einer Quelle in der Partition π c verbleibt. Folglich wird der Beitrag v π c [w] zc v für jede Partition π c in F maximiert. Theorem Sei w der Lastvektor im stationären Zustand von FOS/C. Dann gehört die größte Last in w zur Quellmenge S. Nachdem k paarweise disjunkte Zentren initial gewählt wurden, existieren stets k verschiedene Zentren und genau k Partitionen während der Ausführung von Bubble-FOS/C. Beweis. Der stationäre Zustand in FOS/C ist äquivalent zu einem l 2 -minimalem Fluss-Problem, bei dem die Quellen Last an die verbliebenen Knoten senden und somit eine höhere Last besitzen. Somit ist die erste Aussage klar. Für die zweite Aussage ist die Beziehung " " offensichtlich, sodass wir noch zeigen müssen, dass mindestens k verschiedene Zentren und Partitionen in jedem Iterationsschritt existieren. Beim initialen Festlegen der Zentren können wir einfach gewährleisten, dass k verschiedene Knoten ausgewählt werden. In jedem Fall gehören die Zentren, die von ComputeCenters ausgewählt werden, zu einer eigenen Partition und müssen somit verschieden sein. Weiterhin belässt AssignPartition jedes Zentrum in seiner aktuellen Position. Seien nun z i and z j zwei beliebige, aber verschiedene Zentren. Nach Lemma 5.18 wissen wir bereits, dass [w] z j z i [w] z i z i > [w] z i z j gilt, erhalten wir [w] z i z i > [w] z j z i und damit die gewünschte Aussage. = [w] z i z j gilt. Da Mit obigen Resultaten folgt nun direkt das Haupttheorem und damit die Konvergenz des Algorithmus. Theorem Der Algorithmus Bubble-FOS/C konvergiert und berechnet eine k-partitionierung. Diese Partitionierung ist lokal optimal bezüglich der Potentialfunktion F. Theorem Bubble-FOS/C berechnet relaxierten Kantenschnitt. Der vollständige Beweis zu Theorem 5.22 findet sich im Artikel Beyond Good Partition Shapes: An Analysis of Diffusive Graph Partitioning von Meyerhenke und Sauerwald [MS12].

84 74 5. Lastbalancierung paralleler Berechnungen DibaP Folgt Weiterführende Literatur Folgt. [MMS09b] [MMS09a]

85 75 6. Ausdünnung von Graphen und Laplace-Löser Eine ganze Reihe von Graphenalgorithmen erwarten als Eingabegraphen einen dünnen 1 Graphen. Dies liegt oft daran, dass für dünne Graphen gute Lösungen einfacher zu finden sind. Aus praktischer Sicht sind Software-Werkzeuge meist auf Anwendungsfälle mit dünnen Graphen optimiert, weil diese die üblichen Eingaben aus der Praxis darstellen. Doch was passiert, wenn der Eingabegraph dicht ist? Neben dem Speicherverbrauch steigt normalerweise die Rechenzeit stark an. Noch problematischer ist es allerdings, wenn die eingesetzten Algorithmen und Werkzeuge keine guten Lösungen mehr berechnen, weil sie für dünne Graphen optimiert sind. Wir möchten dann den Graphen geeignet ausdünnen, ohne dass dabei die wesentlichen Informationen des ursprünglichen Graphen verloren gehen. Schematisch ist dies in Abbildung dargestellt. Abbildung : Schematische Darstellung zur Ausdünnung eines Graphen Schnitterhaltende Ausdünnung von Graphen Eine Ausdünnung wird nicht in jedem Fall jede Eigenschaft eines Graphen erhalten können. In der Folge beschäftigen wir uns zunächst mit einem Ausdünnungs-Verfahren, das die Gewichte aller Schnitte eines Graphen approximativ erhält zumindest mit einer gewissen Wahrscheinlichkeit Definitionen Die Bestimmung von minimalen Schnitten in einem Graphen besitzt vielfältige Anwendungsszenarien, wie wir bereits bei einigen vorher behandelten Themen angemerkt haben. Zu nennen sind z.b. Clusteranalyse, wissenschaftliches Rechnen oder Bioinformatik. Wir formalisieren die Problemstellung wie folgt: Definition 6.1. Sei G = (V, E, ω) ein ungerichteter Graph mit positiver Kantengewichtsfunktion u: E R +. Für S V sei δ G (S) = { e = {u, v} E u S, v S } 1 Die Definition von dünn ist sehr problemabhängig. Häufig versteht man darunter, dass m = O(n) gilt. In diesem Kapitel bezeichnen wir aber auch Graphen mit m = O(n polylog(n)) als dünn.

86 76 6. Ausdünnung von Graphen und Laplace-Löser e Abbildung : Beispiel für einen ungewichteten Graphen, bei dem Random Sampling kein geeignetes Ausdünnungsverfahren ist. der durch S induzierte Schnitt und w(δ G (S)) = w(e) e δ G (S) das Gewicht des durch S induzierten Schnitts in G. Definition 6.2. Sei G = (V, E, w G ) ein Graph mit positiver Kantengewichtsfunktion w G : E R +. Als Ausdünnung von G mit approximativer Schnitterhaltung bezeichnen wir einen Graphen H = (V, F, w H ) mit F E und F E sowie Gewichtsfunktion w H : F R +, falls für alle S V gilt. w H (δ H (S)) = (1 ± ɛ) ω G (δ G (S)) Also bleibt nach dieser Art der Ausdünnung der Wert eines Schnitts δ(s) in G auch in H approximativ erhalten. Einen ausgedünnten Graphen H = (V, F, w H ) können wir alternativ auch durch eine nicht-negative Gewichtsfunktion w H : E R 0 beschreiben, indem genau die Kanten entfernt werden, für die das Gewicht 0 ist. Den Graphen H, der durch Ausdünnung eines Graphen G entstanden ist, werden wir nachfolgend auch als H = S(G) schreiben. Ist ein (exakter) Algorithmus A auf G zu langsam, der Ausdünnungsalgorithmus S aber deutlich schneller, so bietet es sich an, den Algorithmus A auf den ausgedünnten Graphen S(G) anzuwenden. Wir erhalten somit einen Approximationsalgorithmus A(S(G)). (Die Approximationseigenschaft setzt natürlich voraus, dass A keine wesentlichen Informationen außer den Schnittgewichten verwendet.) Wir erarbeiten nun, wie sich die Ausdünnung S(G) berechnen lässt Der Sampling-Prozess Ein erster Ansatz wäre es, jeder Kante e E mit der gleichen Wahrscheinlichkeit (random sampling) zu entfernen und dies so lange zu betreiben, bis die Anzahl der verbliebenen Kanten klein genug ist. Dies führt jedoch schnell dazu, dass die wesentliche Struktur eines Graphen verloren geht, wie Abbildung zeigt. Entfernen wir hier die Kante e, so zerfällt der Graph in zwei Komponenten. Wir müssen somit die Wichtigkeit einer Kante bezüglich Schnittbildung definieren und dürfen wichtige Kanten nicht einfach entfernen. Definition 6.3. Sei G = (V, E, w) ein Graph. Die Konnektivität k e einer Kante e E ist das minimale Gewichts eines Schnitts S V, der e enthält, d. h. es gilt k e = min w(δ G(S)). S V,e δ G (S) Mit dem Max-Flow-Min-Cut-Theorem folgt direkt, dass k e der Wert eines maximalen Flusses in einem geeigneten Flussproblem ist. Für e = {u, v} wählen wir hierfür als Quelle s = u,

87 6.1. Schnitterhaltende Ausdünnung von Graphen 77 als Senke t = v und ersetzen die ungerichteten Kanten durch jeweils zwei gerichtete Kanten mit Kapazität w e. Somit kann k e für jede Kante e effizient berechnet werden. Kanten mit großer Konnektivität kommen in Schnitten mit vielen anderen Kanten vor, so dass diese weniger wichtig sind. In unserem Beispiel hat die Kante e eine Konnektivität von 1 und ist somit wichtiger als die restlichen Kanten. Nachfolgend betrachten wir zur einfacheren Darstellung den Fall, dass alle Kanten e E Gewicht 1 besitzen, d. h. es gilt w(f ) = F für F E. Der allgemeine Fall lässt sich durch analoge Überlegungen nachvollziehen. Aufbauend auf der Definition der Kantenkonnektivität, erhalten wir den folgenden Algorithmus: Algorithmus 26 : Iteratives randomisiertes Sampling Input : Ungewichteter Graph G = (V, E), Anzahl der Runden ρ Output : Ausgedünnter Graph H = (V, F, w) 1 w 0 2 foreach e E do 3 Berechne k e 4 for i = 1 to ρ do 5 foreach e E do 6 Mit Wahrscheinlichkeit 1/k e, erhöhe w e um k e /ρ Ein Vorteil des vorgestellten Sampling-Prozesses ist, dass die Kantengewichte im Erwartungswert erhalten bleiben: Lemma 6.4. Für jede Kanten e E gilt: E [w e ] = 1. Beweis. Der erwartete Zuwachs für w e in Iteration i beträgt (1/k e ) (k e /ρ) = 1/ρ. Da der Erwartungswert linear ist und insgesamt ρ Iterationen durchgeführt werden, gilt somit: E(w e ) = ρ 1 ρ = 1. Algorithmus 26 ist somit erwartungstreu hinsichtlich der Kantengewichte. Durch die Linearität des Erwartungswerts ergibt sich somit auch direkt das nachfolgende Resultat: Lemma 6.5. Sei F E. Dann gilt: E [w(f )] = F. Das Gewicht eines Schnittes bleibt somit ebenfalls im Erwartungswert erhalten. Allerdings ist dieses Resultat noch zu schwach für unsere Zwecke. Wir möchten vielmehr, dass mit hoher Wahrscheinlichkeit das Gewicht eines Schnittes erhalten bleibt, d. h. dass w(f ) mit hoher Wahrscheinlichkeit nahe bei F = E [w(f )] liegt. Anders ausgedrückt, muss eine Konzentration von w(f ) um seinen Erwartungswert vorliegen Konzentration um den Erwartungswert Zunächst erinnern wir an die Chernov-Schranken aus der Wahrscheinlichkeitstheorie: Theorem 6.6. (Chernov-Schranken) Seien X 1,..., X n Zufallsvariablen von n unabhängigen Bernoulli-Experimenten mit Erfolgswahrscheinlichkeit p, d. h. X i Bin(1, p). Dann gilt: E [Anzahl der Erfolge] = E [ n i=1 X i] = pn

88 78 6. Ausdünnung von Graphen und Laplace-Löser Für jedes δ > 0 gilt: [ n ] min {δ, δ 2} P r X i (1 + δ) pn exp pn 3 i=1 Für δ [0, 1] gilt: [ n ] P r X i (1 δ) pn i=1 ) exp ( δ2 2 pn Betrachten wir einen beliebigen Schnitt δ(s) in G. Sei X i,e die Bernoulli-Zufallsvariable, die angibt, ob Kante e in Iteration i ausgewählt wurde, i = 1,..., ρ und e δ(s). Dann ist das Gewicht w(δ(s)) des Schnitts δ(s) im Ausgabegraphen H gegeben durch die Zufallsvariable X mit ρ k e X = ρ X i,e. i=1 e δ(s) Da die Zufallsvariablen X i,e unabhängig sind, können wir die Chernov-Schranken anwenden, um eine Konzentration von X um den Erwartungswert E [X] zu beweisen. Allerdings müssen für eine beidseitige Abschätzung die Zufallsvariablen (k e /ρ) X i,e in [0, 1] liegen. Da die Koeffizienten k e sehr groß und, was entscheidend ist, sehr unterschiedlich werden können, ist eine direkte Anwendung nicht möglich. Betrachten wir dazu das nachfolgende Beispiel: Beispiel 6.7. Sei X = n i=1 n X i gegeben, wobei die X i unabhängige Bernoulli-Zufallsvariablen sind. Obwohl der Koeffizient n groß ist, können wir dennoch die beiden Chernov-Schranken anwenden. Die Zufallsvariable X ist gerade n n i=1 X i und für n i=1 X i sind die Koeffizienten jeweils 1. Betrachten wir hingegen die Zufallsvariable Y = n Y 0 + n i=1 Y i und Y 0,..., Y n seien Bernoulli- Zufallsvariablen mit Trefferwahrscheinlichkeit p = 1 n. Dann ist E(Y ) = 2 und P r(y n) 1 n. Die Chernov-Schranken können folglich nicht angewendet werden. Um eine Konzentration dennoch zeigen zu können, werden wir die Kanten in Gruppen einteilen, deren Konnektivität ungefähr gleich ist. Sei dazu E i = { e E 2 i 1 k e < 2 i}, wodurch wir eine Partition E = E 1 E 2... E log(n) der Kantenmenge erhalten. Anstatt eine Konzentration von w(δ(s)) um E [w(δ(s))] direkt zu bestimmen, werden wir die Chernov-Schranken jeweils auf w(δ(s) E i ) anwenden. Für e δ(s) E i sind nach Konstruktion die Koeffizienten ke ρ ungefähr gleich. Eine Kantenmenge F der Form F = δ(s) E i nennen wir nachfolgend eine schnittinduzierte Menge. Es könnte allerdings eine Knotenmenge S V geben mit F = δ(s) E i = δ(s ) E i. Wir betrachten daher jeweils den Schnitt mit kleinster Kardinalität, da der Stichprobenfehler w(f ) klein gegenüber δ(s) sein soll und dies am schwierigsten ist, wenn δ(s) kleinstmöglich gewählt wird. Wir definieren weiterhin: q(f ) = min { δ(s) S V, δ(s) E i = F }. Mit Hilfe der Chernov-Schranken erhalten wir dann das nachfolgende Lemma für die Menge F : Lemma 6.8. Sei F E i eine schnittinduzierte Menge. Dann gilt für ɛ > 0: [ P r w(f ) E [w(f )] > ɛ q(f ) ] ( ) 2 exp ɛ2 ρ q(f ) log n 3 2 i log 2. n Der Beweis dieses Lemmas bleibt dem Leser als Selbstübung durch Anwendung der Chernov- Schranke überlassen.

89 6.1. Schnitterhaltende Ausdünnung von Graphen Das Hauptresultat Wir möchten nun das Haupttheorem dieses Abschnitts beweisen, nämlich dass Algorithmus 26 tatsächlich eine approximativ schnitterhaltende Ausdünnung des Eingabegraphen berechnet: Theorem 6.9. Sei G = (V, E) ein ungerichteter Graph mit n Knoten. Dann produziert Algorithmus 26 mit Wahrscheinlichkeit 1 2 eine Gewichtsfunktion w : E R 0, die den Wert aller Schnitte in G approximativ, d. h. bis auf den Faktor 1 ± ɛ, erhält und nur O(n log 3 (n) /ɛ 2 ) Nichtnulleinträge erzeugt. Durch eine weitergehende, kompliziertere Analyse lässt sich der Faktor log 3 (n) auf log 2 (n) reduzieren bzw. durch eine andere Herangehensweise sogar ganz eliminieren. Nachfolgend beschränken wir uns jedoch auf das oben genannte Resultat. Anzahl der Nichtnulleinträge. Die Anzahl der Nichtnulleinträge von w ist leicht zu analysieren. Wir setzen zunächst ρ = 100 log 3 (n/ɛ 2 ). Sei X i,e erneut die Indikator-Zufallsvariable, die angibt, ob die Kante e in Iteration i ausgewählt wurde. Dann ist E [X i,e ] = 1/k e. Die Anzahl der Nichtnulleinträge in w ist höchstens ρ i=1 e E X i,e und somit gilt E [Anzahl Nichtnulleinträge] = ρ e E 1 k e = O(n log 3 (n)/ɛ 2 ), da e E 1/k e n 1 für jeden Graphen mit V = n gilt. Wir erinnern an die Markov- Ungleichung aus der Wahrscheinlichkeitstheorie: Lemma Sei X eine Zufallsvariable mit Werten in [0, ]. Dann gilt für beliebiges r > 0 die Abschätzung: P r (X r E [X]) 1 r. Mit der Markov-Ungleichung folgt für r = 4 direkt, dass die Anzahl Nichtnulleinträge mit Wahrscheinlichkeit 3/4 kleiner als 4 O(n log 3 (n)/ɛ 2 ) ist. Konzentration um den Erwartungswert. Für den Beweis der Konzentration um den Erwartungswert, werden wir zeigen, dass für jede schnittinduzierte Menge F mit hoher Wahrscheinlichkeit w(f ) F ɛq(f ) (6.1.1) log(n) gilt. Dann erhalten wir für jeden Schnitt C = δ(s) die folgenden Beziehungen: w(c) C log n i=1 log n i=1 log n i=1 w(c E i ) C E i ɛq(c E i ) log n ɛ C log n = ɛ C. Dabei gilt die erste Ungleichung nach der Dreieckunsgleichung, die zweite folgt aus Formel und die dritte Ungleichung aus der Tatsache, dass q(c E i ) das Gewicht des kleinsten Schnitts ist, der C E i induziert. Es gilt daher die gewünschte Eigenschaft, dass das Gewicht eines Schnittes

90 80 6. Ausdünnung von Graphen und Laplace-Löser durch die Ausdünnung approximativ erhalten bleibt. Es bleibt somit zu zeigen, dass Formel tatsächlich gilt. Sei nachfolgend i {1,..., log n} fest. Seien ferner F 1, F 2,... die durch E i schnittinduzierten Mengen. Ordne diese derart, dass q(f 1 ) q(f 2 )... gilt. Ferner definieren wir p j durch ( p j := P r w(f j ) E [ w(f j ) ] > ɛq(f j ) ( ) 2 exp ɛ2 ρ q(f j ) ) log n 3 2 i log 2, (6.1.2) (n) wobei die Ungleichung nach Lemma 6.8 gilt. Mit der Bonferroni-Ungleichung (engl. union bound ) P r ( i A i) i P r(a i) für Ereignisse A i und der Definition der p j erhalten wir P r(schnittinduzierte Teilmenge F E i erfüllt nicht 6.1.1) j p j. Wir können nun jedoch nicht direkt Lemma 6.8 anwenden, da es exponentiell viele Mengen F j geben kann. Betrachten wir zunächst nur die ersten n 2 schnittinduzierten Mengen F 1,..., F n2. Da jede Kante e F j auch zu E i gehört, gilt folglich k e 2 i 1. Somit hat jeder Schnitt, der die Kante e enthält, mindestens Größe 2 i 1 und damit q(f j ) 2 i 1. Setzen wir dies nun in Ungleichung ein, so ergibt sich für unser gewähltes ρ = 100 log 3 (n)/ɛ 2 : p j 2 exp ( ɛ2 (100 log 3 (n)/ɛ 2 ) 2 i 1 ) 3 2 i log 2 2 exp ( 16 log n) 2n 16. (n) Es gilt also: n 2 j=1 p j 2n 14. Für die restlichen F j mit j > n 2 benötigen wir das nachfolgende Hilfslemma: Lemma Sei G = (V, E) ein Graph. Sei fener B E und K min {k e e B}. Dann gilt für jede reelle Zahl α > 1: {δ(s) B : S V δ(s) α K} < n 2α. Anders ausgedrückt ist die Anzahl der Schnittmengen eines Schnitts δ(s), dessen Größe durch α K beschränkt ist, mit einer beliebigen Kantenteilmenge B kleiner als n 2α. Setzen wir in diesem Lemma B = E i und K = 2 i 1, dann gilt für jedes α 1: { schnittiniduzierte Menge F E i mit q(f ) α 2 i 1} < n 2α. Also ist für α 1 die Anzahl der F j mit q(f j ) α 2 i 1 kleiner als n 2α. Setzen wir nun α = ln j/(2 ln n) in Ungleichung ein, so ergibt sich: p j 2 exp ( ɛ2 (100 log 3 (n)/ɛ 2 ) ln(j) 2 i 1 ) 6 2 i log 2 < j 8. (n) ln(n) Durch Summation über j > n 2 erhalten wir nun j>n 2 p j < j>n 2 j 8 ˆ n 2 j 8 dj = ] [ j 7 7 j=n 2 < n 14.

91 6.2. Spektrale Approximation 81 Insgesamt ergibt sich also: n 2 p j = p j + p j < 2n 14 + n 14 < n 2. j j=1 j>n 2 Wenn wir jetzt die Bonferroni-Ungleichung auf alle E 1,..., E log n anwenden, dann erhalten wir < P r(schnittinduzierte Teilmenge F erfüllt nicht 6.1.1) log n i=1 log n i=1 log n i=1 P r(schnittinduzierte Teilmenge F E i erfüllt nicht 6.1.1) j p j n 2 < 1 n. Die Ungleichung gilt somit mit Wahrscheinlichkeit 1 1/n und damit ist auch unser Haupttheorem bewiesen Spektrale Approximation Definitionen In diesem Abschnitt möchten wir ein Ausdünnungsverfahren kennenlernen, bei dem der ausgedünnte Graph H eine spektrale Approximation des Eingabegraphen G darstellt. Formalisieren lässt sich dies wie folgt: Definition Sei G = (V, E, w G ) ein Graph mit positiver Kantengewichtsfunktion w : E R + und Laplace-Matrix L G. Als (1 + ɛ)-spektrale Ausdünnung von G bezeichnen wir einen Graphen H = (V, F, w H ) mit F E, F E und Laplace-Matrix L H und Gewichtsfunktion w H : F R +, falls für alle x R n gilt ɛ xt L G x x T L H x (1 + ɛ)x T L G x Beachten Sie, dass eine spektrale Ausdünnung automatisch auch eine Ausdünnung mit approximativer Schnitterhaltung ist. Die Umkehrung gilt im allgemeinen Fall nicht. Beide Aussagen werden dem Leser als einfache Übungsaufgabe empfohlen. Spektrale Approximation findet in verschiedenen Approximationsalgorithmen für Graphenprobleme Verwendung, z. B. zur Partitionierung oder zur Berechnung maximaler Flüsse. Es ist möglich, eine spektrale Ausdünnung H mit O(n/ɛ) Kanten in Laufzeit O(m) zu berechnen. In diesem Abschnitt begnügen wir uns jedoch mit einem etwas schwächeren Resultat, das das Haupttheorem dieses Abschnitts bildet. Theorem Sei G = (V, E) ein Graph mit V = n und E = m. Ferner sei ɛ > 0. Dann existiert ein randomisierter Algorithmus, der mit Wahrscheinlichkeit 1 1/n eine spektrale Approximation von G mit O(n log(n)/ɛ 2 ) Nichtnulleinträgen berechnet. Bevor wir einen Algorithmus angeben können, der das obige Theorem erfüllt, benötigen wir noch einige Einsichten, wie Graphen und elektrische Netzwerke zusammenhängen.

92 82 6. Ausdünnung von Graphen und Laplace-Löser Abbildung : Beispiel für ein elektrisches Netzwerk Graphen und elektrische Netzwerke Sei G = (V, E) ein gerichteter Graph mit Gewichtsfunktion w. Wir können G wie folgt als elektrisches Netzwerk auffassen: Jeder Kante e E ordnen wir einen Widerstand r e = 1/w e zu. Jeder Knoten i ist eine Stromquelle, die dem System d i Ampere Strom zuführt. Einer der Knoten ist geerdet und über ihn verlässt Strom das System (für diesen Knoten ist d i somit negativ). Jeder Knoten besitzt ein Potential z i, mit dem der Stromfluss auf der Kante e = (i, j) genau (z i z j )w ij beträgt. Beispielhaft ist ein solches elektrisches Netzwerk in Abbildung dargestellt. Der Potentialvektor z lässt sich durch Lösen des linearen Gleichungssystem Lz = d berechnen, wobei L die Laplace-Matrix von G und d = (d 1,..., d n ) der Vektor ist, der die Stromzu- und abflüsse (ins bzw. aus dem System) darstellt. Nach dem Kirchhoffschen Potentialgesetz ist für jeden Zyklus im Graphen G die Summe der Stromflüsse auf den Kanten des Zyklus gerade 0. Ferner heben sich die Zu- und Abflüsse auf einem Knoten nach dem Kirchhoffschen Flussgesetz auf, wenn man den Zu- und Abfluss aus dem Stromnetzwerk mit berücksichtigt. Dies ist ein Analogon zur Lastbalancierung mit Diffusion, die wir im letzten Kapitel erarbeitet hatten. Hier gibt ein Knoten, der zu viel Last hat, diesen Zufluss komplett ins Netzwerk ab. Der Abfluss aus dem Netzwerk am Knoten kommt in einen Knoten vom restlichen Netzwerk, der zu wenig Last hat. Für das weitere Kapitel ist die Größe des effektiven Widerstands einer Kante eine zentrale Größe, die wir effizient berechnen möchten. Diese werden wir für den randomisierten Algorithmus zur spektralen Approximation benötigen. Definition Sei G = (V, E) ein gerichteter Graph und e = (u, v) E eine Kante. Sei z der Potentialvektor des Gleichungsysteme Lz = d, wobei der Stromflussvekor d gegeben ist durch: 1, falls x = u d x = 1, falls x = v 0 sonst Dann ist der effektive Widerstand R e der Kante e = (u, v) definiert durch R (u,v) = (z u z v )w (u,v).

93 6.2. Spektrale Approximation 83 Das Stromflussproblem in obiger Definition entspricht der Lösung von zwei FOS/C-Prozeduren, wobei u das Zentrum der ersten Prozedur und v das Zentrum der zweiten Prozedur ist. Seien d 1 der Vektor, der an der Stelle u den Wert 1 hat und sonst nur aus 0 besteht, und d 2 der Vektor, der an der Stelle v den Wert 1 hat und ansonsten nur 0. Dann entspricht die erste Prozedur dem Gleichungssystem Lz 1 = d 1 und die zweite dem Gleichungssystem Lz 2 = d 2. Es gilt somit d = d 1 d 2 und der in obiger Definition gesuchte Potentialvektor ergibt sich durch z = z 1 z 2. Der effektive Widerstand R e entspricht folglich einer Potentialdifferenz in z, so dass eine hohe Potentialdifferenz für einen Flaschenhals im System spricht. Wir möchten nun erarbeiten, wie wir den effektiven Widerstand alternativ berechnen können. Sei hierfür B { 1, 0, 1} m n die Knoten-Kanten-Inzidenzmatrix 2, d. h. es gilt 1, falls v Endknoten von e B e,v = 1, falls v Startknoten von e 0, sonst Für e = (u, v) kann der effektive Widerstand R e berechnet werden durch R e = (e u e v ) T L (e u e v ), wobei L die Pseudo-Inverse der Laplace-Matrix und e i der i-te Einheitsvektor ist. Setzen wir nun Π := BL B T, dann gilt somit R e = Π e,e, da (e u e v ) T gerade die Zeile von Π ist, die zur Kante e = (u, v) gehört. Die Matrix Π hat dabei einige interessante Eigenschaften, die wir (ohne Beweis) im nächsten Lemma zusammenstellen: Lemma Sei Π = BL B T. Dann gilt: 1. Π ist symmetrisch. 2. Π 2 = Π 3. Die Eigenwerte von Π sind 0 oder P r (e ist Kante in zufälligem Spannbaum) = R e Algorithmus und Beweis des Haupttheorems Mit den erarbeiteten Definition des effektiven Widerstands R e einer Kante e können wir nun einen iterativen Algorithmus zur Berechnung der spektralen Approximation angeben (Algorithmus 27). Beachten Sie dabei, dass die Summe über alle R e genau n 1 ist. Der Algorithmus erinnert vom Aufbau an den Algorithmus aus dem letzten Abschnitt über schnitterhaltende Ausdünnung. Da wir die effektiven Widerstände R e über die Matrix Π berechnen möchten, benötigen wir für den Beweis des Haupttheorems noch eine Chernov-Schranke für Matrizen : Theorem Sei ɛ > 0 hinreichend klein und M R m m eine zufällige, symmetrische, positiv semidefinite Matrix mit E [M] = I m. Seien ferner ρ := sup M M und M 1,..., M S stochastisch unabhänige Kopien von M. Dann gilt: [ ] P r 1 S ) M i I m > ɛ 2m exp ( Sɛ2 S 2ρ i=1 2 Beachten Sie, dass wir auf den Folien zu Kapitel 3 die Matrix B als B T (und umgekehrt) definiert hatten. Die Definition im Skript ist allerdings konsistent.

94 84 6. Ausdünnung von Graphen und Laplace-Löser Algorithmus 27 : Iteratives randomisiertes Sampling Input : Graph G = (V, E), Anzahl der Runden ρ Output : (1 + ɛ)-spektrale Approximation von G 1 w 0 2 foreach e E do 3 Berechne R e 4 for i = 1 to ρ do 5 foreach e E do 6 Mit Wahrscheinlichkeit R e /(n 1), erhöhe w e um R e /ρ Mit den getätigten Vorarbeiten können wir nun Theorem 6.13 beweisen: Beweis. (Prüfungsrelevant ist die Beweisstruktur, die konkreten Inhalte der Formeln sind es nicht. Sie sollten aber das grundsätzliche Vorgehen und die dabei beteiligen Matrizen sowie deren Zweck und Aufbau kennen.) Sei G = (V, E) der Graph, für den eine spektrale Approximation berechnet werden soll. Wir wählen eine Orientierung für jede Kante e E und B sei die dazugehörige Knoten-Kanten- Inzidenzmatrix. Weiter sei Π = BL B T wie im vorherigen Abschnitt und Π e die Spalte von Π, die zur Kante e gehört. Sei Y eine Zufallsvariable mit P r (Y = e) = p e, wobei p e = R e /(n 1) die Wahrscheinlichkeit aus Algorithmus 27 ist. Setze v e = Π e / p e und sei v Y der durch Y induzierte Zufallsvektor, d. h. P r (v Y = v e ) = p e. Wir definieren weiter eine Zufallsmatrix M = v Y v T Y ; ferner seien M i = v Yi v T Y i stochastisch unabhänige Kopien von M, für i = 1,..., S. Dann gilt für die Matrix M: E[M] = E[v e v T e ] = e E Π e Π T e = Π Nach Lemma 6.15, Eigenschaften 1 bis 3, ist die Matrix Π eine Projektionsmatrix und somit äquivalent zu einer Diagonalmatrix d j=1 e je T j für ein d m, hierbei ist d die Vielfachheit des Eigenwerts 1. Die Chernov-Schranken für Matrizen gelten ebenfalls, wenn E [M] = d j=1 e je T j für ein d m gilt und sogar auch, wenn E [M] äquivalent zu einer Diagonalmatrix der Form d j=1 e je T j mit d m ist. Da außerdem R e = Π e 2 gilt, folgt direkt v e 2 = Π e 2 p e = R e p e = n 1 und somit M i n 1 für alle i. Wir können daher die Chernov-Schranke für Matrizen aus Theorem 6.16 anwenden. Wir erhalten die Abschätzung ) P r( Π Π > ɛ) 2(n 1) exp ( Sɛ2, (6.2.1) 2(n 1) wobei die Matrix Π durch Π = 1 S S i=1 M i = 1 S S i=1 v Y i v T Y i gegeben ist. Setzen wir S als Ω(n logn/ɛ 2 ), so erhalten wir eine Fehlerwahrscheinlichkeit von n Ω(1). Wir möchten dieses nun auf die Laplace-Matrix L H des ausgedünnten Graphen H anwenden. Aus Π = BL G BT folgt für eine Kante e E v e = Π e pe = BL G b e pe = BL G u e,

95 6.2. Spektrale Approximation 85 wobei b e die Zeile von B ist, die zur Kante e gehört, und u e = b e / p e ist. Damit ergeben sich zusammen mit der Definition der Laplace-Matrix von H L H = 1 S S i=1 b Yi b T Y i p Yi = 1 S S u Yi u T Y i i=1 die Zusammhänge Π = 1 S S v Yi vy T i = 1 S i=1 = BL G L HL G BT S BL G u Y i u T Y i L G BT i=1 Π = BL G BT BL G L GL G BT Es gilt damit Π Π = sup x 0 xt ( Π Π)x x T x = sup x 0 xt BL G (L H L G )L G BT x x T. x Ist z ein Vektor mit Bz = 0, so muss z parallel zum Vektor 1 = (1,..., 1) T sein, da der Graph G zusammenhängend ist. Somit gilt für z 0, dass aus z, 1 = 0 direkt Bz 0 folgt. Wir können somit in der obigen Gleichung den Vektor y durch Bz substituieren. Da für solch einen Vektor z die Eigenschaft L G L Gz = z gilt, erhalten wir: Π Π sup zt B T BL G (L H L G )L G BT Bz z 0, z,1 =0 z T B T Bz = sup zt L G L G (L H L G )L G L Gz z 0, z,1 =0 z T L G z = sup zt (L H L G )z z 0, z,1 =0 z T L G z Zusammen mit dem Resultat aus Formel erhalten wir die gewünschte Eigenschaft P r ( sup z 0, z,1 =0 ) zt (L H L G )z ( ) z T > ɛ P r Π Π > ɛ = n Ω(1). L G z Dies entspricht genau der Definition der (1+ɛ)-spektralen Approximation und unser Algorithmus berechnet eine solche mit Wahrscheinlichkeit 1 1/n. Der vorgestellte Algorithmus zur spektralen Approximation hat bei effizienter Implementierung eine Laufzeit von O(m log(1/ɛ)). Um die effektiven Widerstände R e für die Kanten effizient mittels der Matrix Π = BL B T berechnen zu können, benötigen wir somit eine effiziente Berechnung der Matrix L, der Pseudoinversen der Laplace-Matrix. Diese ist jedoch im Allgemeinen eine dichte Matrix! Die Zeitkomplexität entspricht somit einer Inversion einer Matrix und die Raumkomplexität ist O(n 2 ). Alternativ zur Inversion kann es daher sinnvoll sein, die R e zu berechnen, indem wir Gleichungssysteme der Form Lz = d lösen. Einen schnellen Löser für solche Gleichungssysteme stellen wir im nächsten Abschnitt vor.

96 86 6. Ausdünnung von Graphen und Laplace-Löser Eine alternative Herangehensweise besteht darin, die R e durch einen Algorithmus mit konstanter relativer Güte approximieren zu lassen. Dieser soll eine Laufzeit von O(m log r) besitzen mit r = w max /w min. Hierbei gilt folgendes Resultat, das wir ohne Beweis benutzen. Theorem Sei G = (V, E, w) ein gewichteter Graph und ɛ > 0. Dann gibt es einen Algorithmus mit Laufzeit O(m log r/2), der eine Matrix Z der Dimension (24 log(n/2)) n derart berechnet, dass für jedes Knotenpaar (u, v) mit Wahrscheinlichkeit 1 1/n gilt: (1 ɛ)r (u,v) Z(e u e v ) 2 (1 + ɛ)r (u,v) Kombinatorische Löser für Laplace-Systeme Grundidee In diesem Abschnitt wollen wir erarbeiten, wie man ein Gleichungssystem der Form Lv = d effizient lösen kann, wobei L eine symmetrische, positiv semidefinite Matrix und d ein Vektor ist, dessen Einträge in der Summe 0 ergeben. Dazu stellen wir den kombinatorischen Löser KOSZ von Kelner, Orecchia, Sidford und Zhu vor, der nahezu lineare Laufzeit besitzt. Wir beschränken uns dabei sogar auf Systeme der Form Lv = e s e t, wobei e i ein Vektor ist, der an der Stelle i eine 1 enthält und sonst nur aus Nullen besteht. Andere rechte Seiten lassen sich stets darauf reduzieren. Im Abschnitt zu Graphen und elektrischen Netzen haben wir bereits erarbeitet, dass die Lösung des obigen Gleichungssystem einem Potentialvektor in einem elektrischen Netzwerk entspricht. Potentialdifferenzen induzieren dabei einen balancierenden Fluss, der in unserem Fall gesucht ist. Denn der balancierende Fluss ist dual zum Potentialvektor v, der Lösunge des linearen Gleichungssystems. Wir werden daher einen Approximaionsalgorithmus entwickeln, der diesen Fluss berechnet und so auch das entsprechende Gleichungssystem löst. Nach dem Kirchhoffschen Potentialgesetz ist die Summe der Flüsse auf einem Zyklus gerade 0. Wir können daher den folgenden Ansatz wählen: Starte mit einem zulässigen Fluss f zwischen den Knoten s und t. Bestimme einen Zyklus C zufällig bezüglich einer gegebenen Wahrscheinlichkeitsverteilung. Falls erforderlich, passe f auf C so an, dass die Summe des Flusses auf C gleich 0 ist. Führe weitere Iterationen durch, bis eine Fehlerschranke erreicht ist. Wir werden nun das KOSZ-Verfahren erarbeiten, das diesen Ansatz verfolgt Flüsse, Energie und Baumzyklen Sei G = (V, E, w) ein gerichteter Graph mit V = n und E = m. Ferner setzen wir den Widerstand r e = 1/w e für jede Kante e E. Beachten Sie den Unterschied zwischen Widerstand (Kehrwert des Kantengewichts) und dem effektiven Widerstand (Stromfluss auf der Kante). Einen Fluss f auf den Kanten interpretieren wir als Vektor aus R m. Es gilt dabei für alle e = (a, b) E, dass die Flussrichtung sich aus dem Vorzeichen ergibt und somit f(a, b) = f(b, a). Sei B die Kanten-Knoten-Inzidenzmatrix, L die Laplace-Matrix von G und R = (r ij ) R m m eine Diagonalmatrix definiert durch { r e, falls i = j = e r ij = 0, sonst Dann gelten die folgenden Zusammenhänge:

97 6.3. Kombinatorische Löser für Laplace-Systeme 87 Lemma Sei f ein Fluss, x R n, a V und (a, b) E. Dann gilt: 1. [B T f] a = (b,a) E f(b, a) (a,b) E f(a, b) 2. L = B T R 1 B 3. [Bx] (a,b) = x a x b 4. x T Lx = (a,b) E (x a x b ) 2 r (a,b) Falls ein Graph ungewichtet ist, folgt somit aus Unterpunkt 2 die vereinfachte Gleichung L = B T B. Wir benötigen zunächst noch weitere Definitionen für spezielle Flüsse: Definition Sei G = (V, E, w) wie oben und B die Kanten-Knoten-Inzidenzmatrix. Ein Fluss f heißt Zirkulation, falls B T f = 0. Die Energie E r (f) eines Flusses f ist definiert als E r (f) = e E r e f(e) 2 = f T Rf = f 2 R Der Fluss f opt heißt elektrischer oder optimaler Fluss bezüglich des Bedarfsvektors d, falls gilt: f opt = argmin B T f=d E r (f) Ein Fluss f heißt ɛ-approximativer elektrischer Fluss bezüglich des Bedarfvektors d, falls B T f = d und E r (f) (1 + ɛ)e r (f opt ). Für einen Stromfluss f gilt nach dem Abschnitt über elektrische Netzwerke die Beziehung f(i, j) = (v i v j )w ij. Also gilt f(i, j)/w ij = v i v j und folglich f opt = R 1 Bv opt. Mit dem Kirchhoffschen Potentialgesetz können wir somit folgern: Lemma Ein Fluss f ist genau dann optimal, wenn f T Rc = 0 für alle Zirkulationen c gilt. Lemma 6.20 werden wir nachfolgend noch vereinfachen und anhand von bestimmten Zyklen formulieren. Sei dazu T ein Spannbaum von G. Wir definieren darauf aufbauend Baumpfade und Baumzyklen: Definition Seien a, b V. Der Baumpfad P (a,b) ist der eindeutige Pfad von a nach b, der nur Kanten von T benutzt. Der dazugehörige Fluss p (a,b) ist derjenige Fluss, der eine Flusseinheit von a nach b sendet und nur auf Kanten aus T von Null verschieden ist (also nur Kanten von T benutzt). Definition Sei (a, b) eine Kante, die nicht in T vorkommt. Dann ist der Baumzyklus C (a,b) = (a, b) P (b,a) der eindeutige Kreis, der aus der Kante (a, b) und dem Baumpfad P (b,a) besteht. Die dazugehörige Zirkulation c (b,a) ist diejenige Zirkulation, die eine Flusseinheit auf C (a,b) sendet. Die Menge aller Zirkulationen { c R m B T c = 0 } nennen wir Zyklenraum. Eine Basis des Zyklenraums bilden dabei die Zirkulationen {c e e E\T }, die durch einen Baumzyklus induziert werden. Wir erhalten somit folgende Charakterisierung.

98 88 6. Ausdünnung von Graphen und Laplace-Löser Abbildung : Graph aus Beispiel Die Kanten des Spannbaums sind rot gefärbt. Korollar Ein Fluss f ist genau dann optimal, wenn f T Rc e = 0 für alle von Baumzyklen induzierten Zirkulationen c e gilt. Korollar 6.23 ist zentral für den zu entwickelnden Algorithmus. Wie bereits oben skizziert, werden wir iterativ überprüfen, ob auf gewählten Baumzyklen von G die Summe der Flüsse Null ergibt. Jeden Baumzyklus C e können wir ferner als langen Widerstand ansehen, der aus in Serie geschalteten Einzelwiderständen besteht. Für diesen definieren wir: Definition Sei C e ein Baumzyklus. Der Widerstand R e von C e ist gegeben durch R e = e C e r e = c T e Rc e. Das durch einen Fluss f auf C e induzierte Potential ce (f) ist definiert als ce (f) = e C e f(e )r e = f T Rc e. Mit obiger Definition lässt sich die Charaktiersierung eines optimalen Flusses umformulieren zu: Ein Fluss f ist genau dann optimal, wenn ce (f) = 0 für alle von Baumzyklen induzierten Zirkulationen c e gilt. Beispiel Sei G = (V, E) gegeben wie in Abbildung und die roten Kanten seien die Kanten eines Spannbaums T. Der Fluss f verschickt eine Einheit vom Knoten 1 an den Knoten 4. Es gilt somit f(1, 2) = 1, f(2, 4) = 1 und f(e) = 0 für alle anderen Kanten. Der Einfachhheit halber seien alle Kantengewichte 1, es gilt also r e = 1 für alle Kanten e E. Die Kante (1, 5) ist eine Nichtbaumkanten und es gilt R (1,5) = e C (1,5) r e = r (1,5) + r (5,4) + r (4,2) + r (2,1) = 4. Analog folgt R (1,6) = 4 und R (3,4) = 3. Berechnen wir nun die induzierten Flusspotentiale: Hier gilt c(1,5) (f) = f(e )r e = f(1, 2) r (1,2) + f(2, 4) r (2,4) = 2 e C (1,5) und durch analoge Rechnung c(1,6) (f) = 1, sowie c(3,4) (f) = 1. Der Fluss f ist daher keinesfalls optimal. Im weiteren Verlauf möchten wir nur bestimmte Spannbäume von G betrachten, die niedrige Steckung gemäß der folgenden Definition besitzen.

99 6.3. Kombinatorische Löser für Laplace-Systeme 89 Definition Sei T ein Spannbaum vom Graphen G. Die Baum-Konditionszahl t(t ) ist definiert als t(t ) = e E\T (R e/r e ). Die Streckung st(e) einer Kante e E ist gegeben durch e st(e) = P e r e r e und die Streckung st(t ) eines Spannbaums T durch st(t ) = e E st(e). Bevor wir nun die algorithmische Idee hinter dem KOSZ-Verfahren weiter untersuchen, benötigen wir eine letzte Definition. Definition Sei T ein Spannbaum von G und f ein Fluss in G. Sei s V beliebig, aber fest. Dann ist die bauminduzierte Spannung v R V für a V definiert als v(a) = f(e) r e. e P (a,s) Beispiel Sei die Situation wie in Beispiel Für die Baumkonditionszahl von T gilt mit den bereits berechneten Werten aus Beispiel 6.25: t(t ) = (R e /r e ) = R e w e = = 11. e E\T e E\T Wir berechnen nun die Streckung st(e) einer Kante e E. Für e = (1, 5) gilt st(1, 5) = (1/r (1,5) ) e P (1,5) r e = r (1,2) + r (2,4) + r (4,5) = 3. Die anderen Werte können ebenso berechnet werden. Für die Streckung st(t ) des Spannbaums T ergibt sich dann st(t ) = e E st(e) = 13. Sei nun s = 1. Dann gilt für die bauminduzierte Spannung v(5) = f(e) r e = f (4,2) + f (2,1) = f (2,4) f (1,2) = 2. e P (5,1) Insgesamt ergibt sich der Vektor v = (0, 1, 1, 2, 2, 1) T. Setzen wir hingegen s = 3, dann gilt v(5) = f (4,2) = 1 und wir erhalten den Vektor v = (1, 0, 0, 1, 1, 0) T Der Algorithmus SimpleSolver Unser Ziel wird es nun sein, einen zu dem Gleichungssystem Lv = d gehörenden, (1 + ɛ)- approximativen elektrischen Fluss zu berechnen. Wir gehen dazu wie folgt vor: 1. Berechne zunächst einen Spannbaum mit niedriger Streckung. 2. Berechne damit einen initialen zulässigen Fluss. 3. Iterative Zyklenaktualisierung: Berechne einen neuen zulässigen Fluss, der die Energie senkt. Wähle eine Nichtbaumkante e mit Wahrscheinlichkeit R e /r e aus. Überprüfe, ob für den Baumzyklus C e die Eigenschaft f T Rc e = 0 gilt. Falls nein, ändere f entsprechend ab.

100 90 6. Ausdünnung von Graphen und Laplace-Löser 4. Gebe den Fluss f und die Bauminduzierte Spannung v zurück. Dieser Algorithmus heißt SimpleSolver. Sein Pseudocode ist in Algorithmus 28 dargestellt. Der Name rührt daher, dass die Autoren in ihrer Arbeit einen weiteren Löser mit noch etwas besseren Eigenschaften angeben. Auf dessen Präsentation wird hier allerdings verzichtet. Algorithmus 28 : SimpleSolver Input : Graph G = (V, E, r), Bedarfsvektor d, Toleranz ɛ Output : ɛ-approx. elektr. Fluss f, zugeh. Potentialvektor v 1 T Spannbaum von G mit niedriger Streckung 2 f 0 eindeutiger Fluss auf T mit B T f 0 = d für alle Nichtbaumkanten e 3 p e 1 t(t ) Re r e 4 K t(t ) log 5 for i = 1 to K do ( st(t ) t(t ) ɛ ) 6 Wähle zufällige Nichtbaumkante e i mit Wahrscheinlichkeit p ei 7 f i f i 1 ce i (f i 1) R ei c ei 8 return f K und zugeh. Potentialvektor v K Das Haupttheorem dieses Abschnitts besagt, dass SimpleSolver tatsächlich einen (1 + ɛ)- approximativen elektrischen Fluss berechnet. Theorem Die Ausgabe von SimpleSolver erfüllt E [E r (f)] (1 + ɛ)e f (f opt ) und E[ v L d L ] ɛ L d L. Der Algorithmus kann so implementiert werden, dass seine Laufzeit ist. O(m log 2 (n) log log n log(ɛ 1 n)) Um dieses Theorem zu beweisen, werden wir als ersten Schritt die Kovergenzgeschwindigkeit analysieren Konvergenz des Algorithmus In diesem Abschnitt werden wir zeigen, dass der Algorithmus SimpleSolver konvergiert und die Konvergenzgeschwindigkeit 1 1/t(T ) beträgt. Wir möchten daher folgendes Theorem beweisen: Theorem Jede Iteration von SimpleSolver berechnet einen zulässigen Fluss f i derart, dass E [E r (f i )] E r (f opt ) (1 1 t(t ) )i (E r (f 0 ) E r (f opt )). Jede Iteration von SimpleSolver verringert also die Energie des aktuellen Flusses im Erwartungswert um (1 1/t) von der Energiedistanz zum optimalen Wert. Für einen zulässigen Fluss f können wir den durch E r (f) gemachten Fehler senken, indem wir ein Vielfaches einer Zirkulation c zu f addieren. Das nachfolgende Lemma zeigt, wie wir die Energie bestmöglich erhöhen können.

101 6.3. Kombinatorische Löser für Laplace-Systeme 91 Abbildung : Initialer Fluss f 0 (links) und der daraus durch eine Iteration entstehende Fluss f 1 (rechts) in Beispiel Lemma Für einen Fluss f, eine Zirkulation c und α = f T Rc c T Rc R gilt: argmin α R E r (f + αc) = α und E r (f + α c) E r (f) = (f T Rc) 2 Beweis. Nach Definition der Energie gilt E r (f) = f T Rf. Für α R folgt somit E r (f + αc) = (f + αc) T R(f + αc) = f T Rf + 2αf T Rc + α 2 c T Rc c T Rc Wir bilden nun die partiellen Ableitungen bezüglich α und setzen diesen Ausdruck gleich 0. So erhalten wir 2f T Rc + 2α c T Rc = 0. Dann erfüllt α = α diese Gleichheit und minimiert folglich den Ausdruck E r (f + αc). Im Spezialfall eines Baumzyklus als Zirkulation, also c = c e für ein e E\T, entspricht obiges α gerade der Zyklusaktualisierung unseres Algorithmus, da in diesem Fall c T e Rc e = R e und f T Rc e = ce (f) gilt. Wir können somit direkt folgendes Lemma zur Zyklusaktualisierung folgern: Lemma Für einen zulässigen Fluss f und e E\T gilt: E r (f c e (f) R e c e ) E r (f) = c e (f) 2 R e Beispiel Wir führen Beispiel 6.25 weiter: Sei f 0 der initiale Fluss mit f 0 (1, 2) = 1, f 0 (2, 4) = 1 und f 0 (e) = 0 für die anderen Kanten. Für alle Kanten e E gelte erneut r e = 1. Nach einer Iteration im SimpleSolver-Algorithmus entstehe der Fluss f 1 wie in Abbildung dargestellt. Für die Energie der beiden Flüsse gilt dann: E r (f 0 ) = r e f 0 (e) 2 = f 0 (1, 2) 2 + f 0 (2, 4) 2 e E = = 2 E r (f 1 ) = e E r e f 1 (e) 2 = f 1 (1, 2) 2 + f 1 (2, 4) 2 + f 1 (1, 5) 2 + f 1 (5, 4) 2 = = 1 Die Energiedifferenz der beiden Flüssen beträgt daher E r (f 0 ) E r (f 1 ) = 2 1 = 1.