Quantum Computing Hartmut Klauck Universität Frankfurt WS 05/ /2.1.

Element Distinctness Problem: Gegeben n Zahlen von [1...10n] Sind die n Zahlen paarweise verschieden? Lösung zum Beispiel durch Sortieren (Counting Sort), lineare Zeit Schneller Quantenalgorithmus? Lösung in Zeit O(n 3/4 log n) Benutze Amplituden Amplifikation

Element Distinctness Problem: Gegeben Menge T von n Zahlen aus [1...10n] Sind die n Zahlen paarweise verschieden? Ziehe n 1/2 Elemente zufällig, lese sie und sortiere sie in Zeit O(n 1/2 ), Menge A Wenn zwei gleiche Elemente gefunden, Ausgabe Benutze Grover Algorithmus, um festzustellen, ob es in T-A ein Element gibt, dass auch in A liegt, Zeit O(n 1/2 log n), da A sortiert Prozedur findet zwei gleiche Elemente mit Wahrscheinlichkeit 1/n 1/2 wenn vorhanden Amplituden Amplifikation! Laufzeit O(n 1/2 log n ¢ n 1/4 )

Element Distinctness Wir haben Algorithmus mit O(n 3/4 log n) Zeit gesehen (und Speicherplatz O(n 1/2 log n)) Tatsächlich können wir mit weniger Speicher, aber mehr Zeit auskommen

Time-Space Tradeoff Speicherplatz für S Indizes sei erlaubt Problem: Gegeben Menge T von n Zahlen aus [1...10n] Sind die n Zahlen paarweise verschieden? Ziehe S<n 1/2 Elemente zufällig, lese sie und sortiere sie in Zeit O(S log S), Ergebnis Menge A Wenn zwei gleiche Elemente gefunden, Ausgabe Benutze Grover Algorithmus, um festzustellen, ob es in T-A ein Element gibt, das auch in A liegt, Zeit O(n 1/2 log S), da A sortiert Prozedur findet zwei gleiche Elemente mit Wahrscheinlichkeit s/n, wenn vorhanden Amplituden Amplifikation! Laufzeit also O(n 1/2 log S ¢ (n/S) 1/2 )=O(n log n/S 1/2 ) für beliebiges S < n 1/2

Graphalgorithmen mit Quantensuche

Minimale Spannbäume Ein ungerichteter Graph sei als Adjazenzmatrix/liste mit Gewichten gegeben Gesucht ist eine Menge von maximal vielen Kanten, die Bäume bilden, und minimales Gewicht haben (spannender Wald) Der Graph sei im Speicher abgelegt, d.h. keine Rechenzeit für das Lesen der Eingabe

Minimale Spannbäume Klassische Algorithmen: Boruvka, Prim, Kruskal O(|E| log |V|) im Adjazenzlistenmodell O(n 2 log n) im Adjazenzmatrixmodell Es gibt (fast) Linearzeit Algorithmen Wir verwenden Boruvka Algorithmus

Minimale Spannbäume Algorithmus von Boruvka Zu Beginn betrachte jeden Knoten als einen Baum Gegeben also Menge von Bäumen In jeder Iteration wähle für jeden Baum eine minimale adjazente Kante aus, (die den Baum verlässt) Verschmelze die Bäume entsprechend Anzahl der Phasen: jede Iteration halbiert die Anzahl der Bäume (mindestens), daher höchstens log n Phasen Laufzeit somit O(m log n)

Vorbereitungen Wir wollen die Minimum Algorithmus mit Laufzeit O(n 1/2 ) verwenden Der Algorithmus rechet mit beschränktem Fehler Zunächst versuchen wir nur die Anzahl Fragen zu minimieren Betrachte zusammenhängende Graphen

Algorithmus Zu Beginn ist jeder Knoten ein Baum Seien T 1,…,T k Bäume Wiederhole bis es nur noch einen Baum gibt Finde Kanten e 1,…,e k so dass e j minimal und T j verlassend Unterbreche, wenn mehr als O(n 3/2 log n) Fragen gestellt Füge Kanten ein und verschmelze Bäume Ausgabe T 1

Algorithmus Verwalte Bäume als Mengen von Spalten der Adjazenzmatrix k Bäume: Suche aus <n Nachbarn nicht im Baum ) k mal Minimum aus <n 2 Kanten Seien Anzahl der ausgehenden Kanten m 1,…,m k, dann ist m i <n 2 Kosten der k Minimum Suchen: m i 1/2 · (n 2 /k) 1/2 ¢ k Tatsächlich notwendig, Fehler auf z.B. 1/n 2 zu senken, Kosten: log n Faktor Weiterhin log n Iterationen, k=n maximal, also insgesamt O(n 3/2 log n), da erste Iteration geometrisch dominiert

Weitere Idee Modifikation von Boruvka Iteration l hat Fehler 1/2 l+2 Gesamtfehler dann ¼ Minimum Algorithmus hat Fehler 1/2 l+2, wenn Laufzeit O(l n 1/2 ) Iteration l einen Faktor von O(l) teurer, insgesamt vernachlässigbar

Verfeinerung des Algorithmus Zu Beginn ist jeder Knoten ein Baum l=0 Seien T 1,…,T k Bäume Wiederhole bis es nur noch einen Baum gibt Erhöhe l Finde Kanten e 1,…,e k so dass e j minimal und T j verlassend Unterbreche, wenn mehr als O((l+2)k 1/2 n) Fragen gestellt Füge Kanten ein und verschmelze Bäume Ausgabe T 1

Insgesamt O(n 3/2 ) Fragen an die Black Box und Fehler ¼ Zeit: Brauchen Datenstruktur, die es erlaubt, per Iteration alle zu einem Baum T i adjazenten Kanten zu identifizieren und eine Superposition über diese zu erstellen Dazu reicht es, Superposition über alle Knoten in einem Baum zu erstellen Zeit: O(n) per Iteration hierzu

Auf Adjazenzlisten Möglich, Zeit O((mn) 1/2 ) zu erreichen Modell: Array von Graden der Knoten Pro Knoten ein Array der Nachbarn mit Gewichten Funktion f bilde 1,…2m ab auf die Gewichte der Kanten, wenn in verschiedenem Baum Funktion g bilde 1,…,2m auf Baumindex ab Suchen d Elemente verschiedenen Typs mit minimalem Wert (bzgl. g und f)

Abstrahiertes Suchproblem Gegeben zwei Funktionen f,g Finde eine Menge I von d Positionen, so dass alle bzgl. g verschieden sind, und wenn es j nicht in I gibt und f(j)<f(i) für ein i aus I, dann gibt es k aus I mit f(k)<f(j) und g(k)=g(j) Es gibt Quantenalgorithmus, der dies in O((dn) 1/2 ) löst

Abstrahiertes Suchproblem Greedy Ansatz mit Quantensuche Ein Index j heisse gut für eine Menge I von Indizes, wenn g(i)=g(j) und f(j)<f(i) für ein i aus I ODER g(j) neu und f(j)<f(i) für ein i aus I Idee: Finde gutes j, und ersetze ein i durch j

Algorithmus Anfang: I={n+1,..,n+d}, fiktive Indizes Wiederhole: t sei die Anzahl der guten Indizes für I Suche einen guten Index j Wenn ein i 2 I existiert mit g(i)=g(j), dann ersetze i durch j, sonst ersetze das i mit f(i) grösstmöglich Breche ab nach O((dn) 1/2 ) Schritten

Analyse Lemma Sei I beliebig mit d Elementen, t Anzahl der guten Elemente, diese haben e verschiedene g-Werte. Dann sind nach erwartet O(min{d,e}) Iterationen nur noch ¾t gute Elemente vorhanden. Dann: Nach O(d (n/t) 1/2 ) Fragen ist die Anzahl der guten Elemente nur noch t/2. Zeit: Nach O((dn) 1/2 ) Schritten nur noch 2d gute Elemente übrig Restliche Laufzeit: (Finde alle)

Anwendung auf Spannbäume In jeder Iteration halbiert sich die Anzahl der Spannbäume n/2 l Bäume in Iteration l Mit Fehler Schranke Laufzeit jeweils O(l (m n/2 l ) 1/2 ) Summiert: