Quantum Computing

Hartmut KlauckUniversität FrankfurtWS 05/0619.12./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(n3/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 n1/2 Elemente zufällig, lese sie und sortiere sie in Zeit O(n1/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(n1/2 log n), da A sortiert

Prozedur findet zwei gleiche Elemente mit Wahrscheinlichkeit 1/n1/2 wenn vorhanden

Amplituden Amplifikation! Laufzeit O(n1/2 log n¢ n1/4)

Element Distinctness

Wir haben Algorithmus mit O(n3/4 log n)Zeit gesehen (und SpeicherplatzO(n1/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<n1/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, ZeitO(n1/2 log S), da A sortiert

Prozedur findet zwei gleiche Elemente mit Wahrscheinlichkeit s/n, wenn vorhanden

Amplituden Amplifikation! Laufzeit also O(n1/2log S ¢ (n/S)1/2)=O(n log n/S1/2) für

beliebiges S < n1/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(n2 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(n1/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 T1,…,Tk Bäume Wiederhole bis es nur noch einen Baum gibt

Finde Kanten e1,…,ek so dass ej minimal und Tj verlassend

Unterbreche, wenn mehr als O(n3/2 log n) Fragen gestellt

Füge Kanten ein und verschmelze Bäume Ausgabe T1

Algorithmus

Verwalte Bäume als Mengen von Spalten der Adjazenzmatrix

k Bäume: Suche aus <n Nachbarn nicht im Baum) k mal Minimum aus <n2 Kanten

Seien Anzahl der ausgehenden Kanten m1,…,mk, dann ist mi<n2

Kosten der k Minimum Suchen: mi1/2 · (n2/k)1/2 ¢ k

Tatsächlich notwendig, Fehler auf z.B. 1/n2 zu senken, Kosten: log n Faktor

Weiterhin log n Iterationen, k=n maximal, also insgesamt O(n3/2log n), da erste Iteration geometrisch dominiert

Weitere Idee

Modifikation von Boruvka Iteration l hat Fehler 1/2l+2

Gesamtfehler dann ¼ Minimum Algorithmus hat Fehler 1/2l+2,

wenn Laufzeit O(l n1/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 T1,…,Tk Bäume Wiederhole bis es nur noch einen Baum gibt

Erhöhe l Finde Kanten e1,…,ek so dass ej minimal und Tj

verlassend Unterbreche, wenn mehr als O((l+2)k1/2n)

Fragen gestellt Füge Kanten ein und verschmelze Bäume

Ausgabe T1

Insgesamt

O(n3/2) Fragen an die Black Box und Fehler ¼

Zeit: Brauchen Datenstruktur, die es erlaubt, per Iteration alle zu einem Baum Ti 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 esj 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 i2I 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

LemmaSei 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/2l Bäume in Iteration l Mit Fehler Schranke Laufzeit jeweils

O(l (m n/2l)1/2) Summiert: