Quantenfehlerkorrektur

Transkript

1 korrektur korrektur 14. Juli 2005 Seminar: Quantencomputing

2 korrektur Einleitung Ideales (fehlerfreies) Quantencomputing liefert schnelle Algorithmen Ideales Quantencomputing ohne Bedeutung für die Praxis Ohne Fehlerkorrektur sind größer skalierte Quantencomputer nicht realisierbar Korrektur eines Zustandes, der bei seiner Messung zerstört wird überhaupt möglich? Bis 1995 keine Fehlerkorrektur-Algorithmen im Quantencomputing

3 korrektur Inhalt Fehlerkorrektur durch Wiederholung korrektur in Quantencomputern ist unmöglich Verschränkung mit der Umgebung Fehlerdarstellung durch Paulimatrizen korrektur Von der Unmöglichkeit der korrektur Das Prinzip der korrektur Der 5-qubit-code

4 korrektur Wiederholungscode Fehler in klassischen Computern Fehler in klassischen Computern: Bit-Flip Ohne Fehlerkorrektur liefern Berechnungen falsche Resultate Fehlerkorrektur bei klassischen Bits (cbits) relativ einfach

5 korrektur Wiederholungscode Einfacher Code: Der Wiederholungscode Kodiere cbits: 0 = = 111 Beispiel: Ein kodiertes cbit wird durch Bit-flip verfälscht: Zwei cbits im Zustand 0 Ein cbit im Zustand 1 Mehrheitsentscheidung führt zur Korrektur: 000

6 korrektur Wiederholungscode Wie gut ist der Wiederholungscode? (1) Beachte: Falsche Korrektur, falls 2 Bits geflippt werden Frage: Wie gross ist die Wahrscheinlichkeit, dass ein nicht richtig korrigierbarer Fehler auftritt? Annahmen: Bit sei im Zustand 0 = 000 Wahrscheinlichkeit für einen Bit-flip: p = 0.25 Wahrscheinlichkeit das Bit nicht geflippt wird: 1 p = 0.75 p 0(011) = = p 0(101) = = p 0(110) = = p 0(111) = (0.25) 3 =

7 korrektur Wiederholungscode Wie gut ist der Wiederholungscode? (2) Für die Wahrscheinlichkeit eines nicht korrigierbaren Fehlers gilt damit: Es ist: p = p 0(011) + p 0(101) + p 0(110) + p 0(111) = < 0.25 = p Die Kodierung liefert eine Verbesserung der Fehlerwahrscheinlichkeit. Allgemein gilt: p = 3 (1 p)p 2 + p 3

8 korrektur Wiederholungscode Das Versagen des Wiederholungscodes Frage: Bis zu welcher Wahrscheinlichkeit p eines Bit-flips funktioniert die Fehlerkorrektur? Berechne dazu: p p 3 (1 p)p 2 + p 3 p Beispiel: 1 2 p 1 Angenommen p = 0.7 Dann ist p = Wahrscheinlichkeit eines Bit-Flips ist mit Kodierung größer als ohne

9 korrektur Wiederholungscode Was bisher passiert ist Ein erster Rückblick Es gibt nur Bit-flip-Fehler in klassischen Computern Messung von cbits ist problemlos Fehlerkorrektur ist relativ einfach

10 korrektur klassisch korrigieren Dekohärenz Fehlerdarstellung durch Paulimatrizen Der Unterschied zwischen cbits und qubits cbits Technisch realisiert durch makroskopische Anzahl von Atomen Diskrete Zustände 0 und 1 qubits Technisch realisiert durch einzelne Atome Volle Auswirkung quantenmechanischer Effekte Allgemeiner Zustand eines qubits: Ψ = α 0 + β 1

11 korrektur klassisch korrigieren Dekohärenz Fehlerdarstellung durch Paulimatrizen korrektur in Quantencomputern? Frage: Was passiert bei der Messung? Zusammenbruch der Wellenfunktion Das System befindet sich anschließend in einem Eigenzustand Die Information die in der Überlagerung verschiedener Eigenzustände enthalten war, ist unwiederruflich verloren Problem: Prinzip der klassischen Fehlerkorrektur:

12 korrektur klassisch korrigieren Dekohärenz Fehlerdarstellung durch Paulimatrizen Schlussfolgerungen für Fehlerkorrektur in Quantencomputern: Tatsache ist: Der Zustand eines Quantensystems kann nicht gemessen werden, ohne die Superposition von Eigenzuständen zu zerstören korrektur ist nicht möglich Brauchen: 1. Die möglichen Fehler in Quantencomputern 2. Geeignete Fehlerdarstellung 3. Kodierung der Qubits, die Messung des Fehlers ermöglicht

13 korrektur klassisch korrigieren Dekohärenz Fehlerdarstellung durch Paulimatrizen Verschränkung mit der Umgebung entstehen durch Verschränkung eines qubits mit der Umgebung Zustand der Umgebung: e Verschränkung der Umgebung mit einem qubit: Dekohärenz e 0 e e 1 1 e 1 e e 3 1 Entspricht einer unitären Zeitentwicklung des Systems. Durch Einsetzen von x = 0, 1 lässt sich bestätigen: e x ( e 0 + e 3 2 wobei X = ( ) 1 + e 1 + e 2 2 Z = ( X + e 2 e 1 2 ) Y = ZX = Y + e 0 e 3 Z) x 2 ( )

14 korrektur klassisch korrigieren Dekohärenz Fehlerdarstellung durch Paulimatrizen Fehlerdarstellung mit Pauli-Matrizen Setze nun d = e 0 + e 3 2 Damit folgt schließlich a = e 1 + e 2 2 b = e 2 e 1 2 c = e 0 e 3 2 e x ( d 1 + a X + b Y + c Z) x Dies gilt auch für ein qubit in einem beliebigen Zustand Ψ (Linearität) e Ψ ( d 1 + a X + b Y + c Z) Ψ Dies ist die Fehlerdarstellung durch Pauli-Matrizen

15 korrektur klassisch korrigieren Dekohärenz Fehlerdarstellung durch Paulimatrizen Bedeutung der Pauli-Matrizen X(α 0 + β 1 ) = Z(α 0 + β 1 ) = Y(α 0 + β 1 ) = ( ) (α 0 + β 1 ) = α 1 + β 0 Bit-flip ( ) (α 0 + β 1 ) = (α 0 β 1 ) Phasenfehler ( ) (α 0 + β 1 ) = ( α 1 + β 0 ) Bit-flip und Phasenfehler

16 korrektur klassisch korrigieren Dekohärenz Fehlerdarstellung durch Paulimatrizen Erweiterung auf 2-qubit-Zustand Die Verschränkung für ein Qubit war e Ψ ( d 1 + a X + b Y + c Z) Ψ Betrachte ein System im Zustand Ψ 2 = (α β 1 1 )(α β 2 1 ) Verschränkung des Systems mit der Umgebung führt zu e Ψ 2 3 µ 1 =0 µ 2 =0 3 e µ1 µ 2 X (µ 1) X (µ 2) (α β 1 1 )(α β 2 1 ). wobei X (0) 1, X (1) X, X (2) Y und X (3) Z Es treten also Einfachfehler und Zweifachfehler auf. Beispiele für Fehler: e 10 (α β 1 0 )(α β 2 1 ) Einfachfehler e 13 (α β 1 0 )(α 2 0 β 2 1 ) Zweifachfehler e 22 ( α β 1 0 )( α β 2 0 ) Zweifachfehler

17 korrektur klassisch korrigieren Dekohärenz Fehlerdarstellung durch Paulimatrizen Vereinfachung des 2-Qubit-Zustands Annahme: Nur Einfachfehler Die Verschränkung 3 3 e Ψ 2 e µ1 µ 2 X (µ 1) X (µ 2) (α β 1 1 )(α β 2 1 ). µ 1 =0 µ 2 =0 vereinfacht sich durch die Annahme zu ( d 1 + e Ψ 2 ) 2 ( a i X i + b i Y i + c i Z i ) (α β 1 1 )(α β 2 1 ) i=1 Beachte: X 1 = X 1, X 2 = 1 X Beispiele: a 1 (α β 1 0 )(α β 2 1 ) b 2 (α β 1 1 )( α β 2 0 )

18 korrektur Wenn der Zustand bekannt wäre klassisch korrigieren Dekohärenz Fehlerdarstellung durch Paulimatrizen Annahme: System im Zustand Wende X 2 an: a 2 X 2 Ψ 2 a 2 X 2 X }{{} 2 Ψ 2 = a 2 Ψ 2 =1 Beachte: X 2 X 2 = ( ) ( ) = ( )

19 korrektur Was bisher passiert ist Ein zweiter Rückblick klassisch korrigieren Dekohärenz Fehlerdarstellung durch Paulimatrizen 1. Dekohärenz Verschränkung des qubits mit seiner Umgebung Fehlerzustand: e Ψ ( d 1 + a X + b Y + c Z) Ψ 2. Fehlerdarstellung durch Pauli-Matrizen: X Bit-Flip Z Phasenfehler Y Bit-Flip & Phasenfehler Nur Einfachfehler: e Ψ 2 d 1 P 2 + i=1 ( a i X i + b i Y i + c i Z i ) Ψ 2

20 korrektur Unmöglichkeit der korrektur Prinzip der Fehlerkorrektur 5-qubit-code Von der Unmöglichkeit der korrektur Bis 1995 kein Verfahren zur korrektur vorhanden. Klassische Korrekturcodes sind nicht anwendbar: Fehlerkorrektur mittels klassischer Verfahren erfordert Messung des Zustands Bei Messung des Systemzustands bricht die Wellenfunktion zusammen Aus superponierten Zustand wird ein einzelner Eigenzustand Information in Überlagerung ist verloren Vorteile des Quantencomputing wären nicht gleichzeitig mit Fehlerkorrektur nutzbar Quantencomputer haben eine hohe Fehleranfälligkeit. Ohne Fehlerkorrektur können Quantencomputer nicht sinnvoll genutzt werden. Problem: Der Fehler muss gefunden werden, ohne den Zustand des Systems zu messen

21 korrektur Unmöglichkeit der korrektur Prinzip der Fehlerkorrektur 5-qubit-code Was soll der Korrekturcode tun? Betrachte einen Speicher von qubits. Mit der Zeit tritt Dekohärenz auf Nun wird der Korrekturcode angewendet, der das System wieder in den ursprünglichen Zustand bringt. Solche Korrekturcodes heißen stabilisierende Codes Der erste stabilisierende Code ist 1995 von P.W. Shor gefunden worden.

22 korrektur Unmöglichkeit der korrektur Prinzip der Fehlerkorrektur 5-qubit-code Das Prinzip der korrektur 1. Wahl mehrerer paarweise kommutierender Observablen 2. Kodierung der qubits 0 und 1 3. System befinde sich nun im vereinfachten Fehlerzustand 4. Messung der komm. Observablen projiziert Zustand in einen Eigenraum 5. Kombination der Eigenwerte liefert den Fehler 6. Fehler kann nun korrigiert werden

23 korrektur Unmöglichkeit der korrektur Prinzip der Fehlerkorrektur 5-qubit-code Paarweise kommutierenden Operatoren Jedes qubit wird durch 5 qubits kodiert. Wähle M (1) = X 2 Z 3 Z 4 X 5 M (2) = X 3 Z 4 Z 5 X 1 M (3) = X 4 Z 5 Z 1 X 2 M (4) = X 5 Z 1 Z 2 X 3 Die Operatoren kommutieren und es gilt M 2 (i) = 1 Beachte: XY = YX XZ = ZX YZ = ZY oder anders ausgedrückt [X, Y] + = [X, Z] + = [X, Y] + = 0 [X, X] = [Y, Y] = [Z, Z] = 0

24 korrektur Unmöglichkeit der korrektur Prinzip der Fehlerkorrektur 5-qubit-code Kodierung der qubits Definiere 0 = 1 4 (1 + M (1))(1 + M (2) )(1 + M (3) )(1 + M (4) ) = 1 4 (1 + M (1))(1 + M (2) )(1 + M (3) )(1 + M (4) ) Jedes M (i) flipt genau 2 qubits Jeder Term von 0 hat eine ungerade Zahl von Nullen Jeder Term von 1 hat eine gerade Zahl von Nullen Damit folgt 0 1 Aus M 2 (i) = 1 folgt (1 + M (i)) 2 = 2(1 + M (i) ). Damit gilt also: 0 0 = = 1

25 korrektur Unmöglichkeit der korrektur Prinzip der Fehlerkorrektur 5-qubit-code Weitere Eigenschaften von 0 und 1 M (i) (1 + M (i) ) = (M (i) + M 2 (i) ) = 1 + M (i) M (i) 0 = 0 M (i) 1 = 1 Also ist der Zustand Ψ = α 0 + β 1 ein Eigenzustand der M (i) mit dem Eigenwert 1

26 korrektur Unmöglichkeit der korrektur Prinzip der Fehlerkorrektur 5-qubit-code Der Fehlerzustand Das System sei in dem vereinfachten Fehlerzustand ( ) 5 d 1 + ( a i X i + b i Y i + c i Z i ) Ψ i=1 16 zweidimensionale Fehlerzustände 2 5 = 32 Dimensionen um die Fehlerzustände in unterschiedlichen Eigenräumen unterzubringen Messung der M (i) projiziert das System in einen Eigenraum

27 korrektur Unmöglichkeit der korrektur Prinzip der Fehlerkorrektur 5-qubit-code Anwendung der Operatoren Erinnerung: M (1) = X 2 Z 3 Z 4 X 5 M (2) = X 3 Z 4 Z 5 X 1 M (3) = X 4 Z 5 Z 1 X 2 M (4) = X 5 Z 1 Z 2 X 3 M (i) Ψ = Ψ = α 0 + β 1 [X, Y] + = [X, Z] + = [Y, Z] + = 0 [X, X] = [Y, Y] = [Z, Z] = 0 Wende die M (i) auf X 1 an: M (1) X 1 Ψ = X 2 Z 3 Z 4 X 5 X 1 Ψ = X 1 X 2 Z 3 Z 4 X 5 Ψ = X 1 M (1) Ψ = X 1 Ψ M (2) X 1 Ψ = X 3 Z 4 Z 5 X 1 X 1 Ψ = X 1 X 3 Z 4 Z 5 X 1 Ψ = X 1 M (2) Ψ = X 1 Ψ M (3) X 1 Ψ = X 4 Z 5 Z 1 X 2 X 1 Ψ = X 1 X 4 Z 5 Z 1 X 2 Ψ = X 1 M (3) Ψ = X 1 Ψ M (4) X 1 Ψ = X 5 Z 1 Z 2 X 3 X 1 Ψ = X 1 X 5 Z 1 Z 2 X 3 Ψ = X 1 M (4) Ψ = X 1 Ψ

28 korrektur Unmöglichkeit der korrektur Prinzip der Fehlerkorrektur 5-qubit-code Anwendung der Operatoren Entweder kommutieren oder antikommutieren die M i mit den X i, Y i und Z i Führe die Berechnungen nun für alle X i, Y i und Z i durch Kommutiert M (i) mit einem der Fehleroperatoren, so ergibt die Messung den Eigenwert 1. Antikommutation ergibt den Eigenwert 1. Die 16 Eigenzustände sind eindeutig identifiziert: X 1 Y 1 Z 1 X 2 Y 2 Z 2 X 3 Y 3 Z 3 X 4 Y 4 Z 4 X 5 Y 5 Z 5 M (1) M (2) M (3) M (4) Wird viermal der Eigenwert 1 gemessen, so ist kein Fehleraufgetreten

29 korrektur Unmöglichkeit der korrektur Prinzip der Fehlerkorrektur 5-qubit-code Beispiel für Fehlerkorrektur X 1 Y 1 Z 1 X 2 Y 2 Z 2 X 3 Y 3 Z 3 X 4 Y 4 Z 4 X 5 Y 5 Z 5 M (1) M (2) M (3) M (4) P 5 1. Zustand des Systems: d 1 + i=1 ( a i X i + b i Y i + c i Z i ) Beispiel: 2. Messung der Operatoren M (1), M (2), M (3) und M (4) 3. Eigenwerte 1, 1,1 und 1 4. Zustand des Systems c 1 Z 1 Ψ 5. Wende Z 1 an: c 1 Z 2 1 }{{} Ψ = c 1 Ψ =1 6. Der Fehler ist korrigiert Ψ

30 korrektur Was bisher passiert ist Ein dritter Rückblick Unmöglichkeit der korrektur Prinzip der Fehlerkorrektur 5-qubit-code 1. korrektur unmöglich? 2. Stabilisierender 5-qubit-Code: Operatoren M(1), M (2), M (3), M (4) Kodierung der qubits: 0 = 1 4 (1 + M (1))(1 + M (2) )(1 + M (3) )(1 + M (4) ) = 1 4 (1 + M (1))(1 + M (2) )(1 + M (3) )(1 + M (4) ) Messung der M(i) projiziert den Fehlerzustand in einen Eigenraum Eigenwerte identifizieren den Fehler eindeutig Anwendung des Fehleroperators ergibt den ursprünglichen Zustand 3. korrektur ist möglich

31 korrektur 1. Nur Bit-flips Fehlerkorrektur durch Messung unproblematisch 2. Verschränkung mit Umgebung Fehlerdarstellung durch Paulimatrizen Dadurch Fehleranzahl diskretisiert und endlich 3. korrektur Kodierung der qubits Fehlererkennung durch Messung der M(i) und Projektion in einen Eigenraum Fehlerkorrektur durch Anwendung des gefundenen Fehleroperators X (i)