Q13 Superdichte Codierung und Quanten-Kommunikation
Auf verschränkten Qubits lassen sich eine Reihe interessanter Effekte aufbauen - mit noch interessanteren Namen: Superdense Coding, Quanten-Kommunikation und Quanten-Teleportation sind sicher die spektakulärsten.
Superdense Coding bedeutet, dass man 2 Bit Information in einem Qubit "speichern" kann. Quanten-Kommunikation ermöglicht sichere Übertragung von 2 Bits durch ein Qubit und Quanten-Teleportation umgekehrt die Übertragung eines Qubit-Zustands durch 2 Bits. Wie das Qubit-algorithmisch geht und was das bedeutet, untersuchen wir in diesem Abschnitt. Falls der zu lang wird, lagern wir die Quanten-Teleportation auf den nächsten Blog aus.
Superdense Coding - Naiver Versuch und Bit-controlled Qubits
Wir werden die Idee des Superdense Coding zunächst auf einem Weg angehen, der naheliegend scheint, sich aber als Irrweg herausstellen wird. Wir können dabei jedoch eine interessante Möglichkeit der Qubit-Algorithmik kennen lernen: Das Zusammenspiel von klassischen Bits und Qubits: Bit-controlled Gates, manchmal auch Dependent Gates genannt.
Wir haben bereits kennen gelernt, wie man über den Zustand eines Qubit den eines anderen "steuern" kann: Controlled Gates. Es gibt bei Qubit-Algorithmen auch die Möglichkeit, Qubit Zustände durch klassiche Bits zu beeinflussen. Dabei wird, analog zum Controlled Gate, ein Qubit-Gate durch eine Bedingung gesteuert, in die die Bits eines Messergebnisses einbezogen werden. Wir nennen das hier Bit-controlled Gates.
Mit dem Composer wird ein Bit-controlled Gate dadurch erzeugt, dass das Gate auf einer Qubit-Linie mit dem If-Operator kombiniert wird. Das If-Symbol wird dazu einfach auf das Gate gezogen (Drag&Drop). Anschließend kann man das Gate editieren, d.h. die If-Bedingung nach Bedarf festlegen. Die If-Bedinung kann nur als Vergleich der gemessenen Bit-Kette (auf der c-Linie) mit einem Zahlenwert formuliert werden. Dabei werden die Bits der Messung als Binärzahl gewertet. (Mit der Qiskit-Bibliothek für Python sind das natürlich einfache If-Konstrukte, die sich auf die Mess-Bits beziehen.)
Hier ein Beispiel.
Die Qubits q0, q1, q2 werden in die Zustände |1>, |0> bzw |1> versetzt und gemessen (1 shot) . Das ergibt die 3-Bit-Kette 00101, die Binärzahl für 5. Für Qubit q3 wird das Hadamard-Gate H angewendet, wenn das Messergebnis 5 ist. Wenn es 3 ist, wird dagegen X angewendet - also nicht im vorliegenden Fall. Bei allen anderen Messergebnissen passiert nichts mit q3.
Das Beispiel zeigt auch gleich einen einfachen Weg wie man Bits "von außen" in einen Circuit hineinbringen kann.
Die naheliegende Idee, zwei Bits in einem Qubit zu speichern, wäre, für die vier möglichen Kombinationen 00, 01, 10, 11 vier Superpositionen eines Qubit zu definieren, die durch Bit-gesteuerte Gatter erzeugt werden. Wir können zum Beispiel die Zwei-Bit-Ausdrücke durch die vier Zustände (1,0), (√2/3,√1/3), (√1/3,√2/3), (0,1) abbilden. (Das Wurzelzeichen bezieht sich auf den ganzen Bruch.) Diese liegen auf dem Einheitskreis im ersten Quadranten in Schritten von 30° Winkeln.
Das zu codierende Bit-Paar bringen wir wie beschrieben in den Circuit. Die dann anzusetzenden Bit-controlled Gates zeigt die Tabelle.
Bit-Paar | 00 | 01 | 10 | 11 |
Binär-Bedingung | 0 | 1 | 2 | 3 |
Gate | ID | Ry(π/3) | Ry(2π/3) | X |
Qubit-Zustand | (1,0) | (√2,√1)/√3 | (√1,√2)/√3 | (0,1) |
Für jedes vorgegebene Bit-Paar ergibt sich ein Mess-Ergebnis als Binärzahl, welche die Bedingung definiert, unter der das jeweilige Gate auf das "Speicher-Qubit" anzuwenden ist. Mit dem Composer lässt sich der Algorithmus wie folgt darstellen (Bit-Paar 11 ist als Input vorgegeben).
Der erste Teil der "Partitur" setzt das zu codierende Bit-Paar als Zustand von q0 und q1. Der mittlere Teil versetzt je nach Wert der gemessenen klassischen Bits auf der c5-Linie das Qubit q3 in den entsprechenden Zustand.
Wir haben damit 2 Bits in einem Qubit codiert.
Wenn wir es recht überlegen, können wir auf diese Weise eigentlich auch 4, 8 oder beliebig viele Bits in einem Qubit codieren, denn es lassen sich mit Bit-controlled Ry-Gates (cRy) beliebig viele Qubit-Zustände herstellen. Das kling gut - zu gut, um wahr zu sein.
Das ist richtig für den Zustand des Qubits. Und solange wir mit dem Zustand weiter arbeiten im Qubit-Algorithmus, bleibt die Codierung auch erhalten. Wenn wir aber die Codierung rückgewinnen wollen - durch das Auslesen eines Speichers per Messung - bekommen wir lediglich eine 0 oder eine 1! Die Unterscheidung der 4 Zustände in Form von unterschiedlichen Häufigkeiten bekommen wir dagegen nur durch Wiederholungen, etwa 1024 shots. Die unterschiedlichen Zustände des Qubits präsentieren sich nur als Wahrscheinlichkeiten, und die kann man nur verifizieren durch viele Wiederholungen.
Das war der Irrweg. Besser geht's auf Basis von Verschränkung.
Superdichte Codierung - Verschränkung und Umkehrbarkeit
Der Irrweg war nicht ganz nutzlos. Wir müssen nur das manipulierte Qubit als Teil eines verschränkten Paares sehen. Statt den Algorithmus einfach aus Wikipedia abzuschreiben (wenn man es dort überhaupt versteht), versuchen wir mittels der uns schon bekannten algorithmischen Bausteine den Algorithmus selbst zu konstruieren. Wer keine Lust dazu hat, kann diesen Teil überspringen und gleich mit der Zusammenfassung des Superdense Coding Verfahrens weiter machen.
Eine wichtige Eigenschaft von Qubit-Gates ist noch gesondert hervorzuheben, obwohl sie uns in vielen Beispielen seit der ZBIT-Box schon begegnet ist: Die Reversibilität oder Umkehrbarkeit von Gates und Gate-Kombinationen. In der Qubit-Welt sind außer der Messung, bzw außer Interaktionen mit klassischen Bits, die Operationen umkehrbar. Für jedes Gate und jede Gate-Folge gibt es die Möglichkeit, den Ausgangszustand wieder herzustellen.
Wir wissen z.B. schon, dass zur Umkehrung von X und H die Gates selbst verwendet werden können. Anders ausgedrückt: X---X und H---H ergeben das Gleiche wie das ID-Gate, das den Qubit-Zustand erst gar nicht verändert. Für Drehungen mit Ry gibt es für jeden Drehwinkel einen komplementären Winkel, so dass z.B. Ry(2π/3) durch Ry(-2π/3) wieder aufgehoben wird. Wer Lust hat, kann sich alle bisher erwähnten 1-Qubit Gates noch einmal daraufhin anschauen - auch an Hand der Berechnungsformeln (s. Q10) - oder mit Hilfe von Composer-Tests. Auch Gate-Abfolgen mit controlled Gates wie CNOT (cX) und Tofoli (ccX) lassen sich umkehren. Darunter fällt auch unsere Standard-Verschänkung, Circuit 7 aus Q10, die aus H und CNOT gebildet wird. Die Umkehrung besteht aus beiden Gates in umgekehrter Reihenfolge und löst die Verschränkung wieder auf.
Nun zur Codierung: Wir brauchen ein verschränktes Qubit Paar, statt nur ein Qubit wie oben. Wir erzeugen das mittels H und CNOT aus den Standard-Ausgangszuständen von q0 und q1. Wenn wir nun die 2-Bit Information 00 "codieren" wollten, müssen wir erreichen, dass sich am Ende bei der Messung auch immer (zu 100%) 00 ergbit. Dieses Ergebnis 00 erfolgt aus der Messung von zwei Qubits im Ausgangszustand. D.h. wir codieren 00, indem wir nach der Verschränkung diese wieder umkehren, also dem H---CNOT ein CNOT---H folgen lassen. Wenn wir wollen, können wir zwischen diesen beiden Circuit-Teilen ein ID-Gate auf die q0-Linie setzen. Damit kann man sagen, das ID-Gate codiert die zwei Bits 00.
Damit hat man die algorithmische Idee für die Codierung von 2 Bits: wir prüfen, welche 2 Bits "am Ende herauskommen", wenn wir statt ID andere Gates auf die q0-Linie setzen. Das kann man ausprobieren, oder auch errechnen, wie wir es in Q10 getan haben. Tatsächlich finden wir heraus, dass Z, X und die Kombination X---Z die drei anderen 2-Bit-Ergebnisse liefern.
Der Algorithmus in Worten zusammengefasst:
- Es wird ein Qubit Paar in den verschränkten Zustand 1/√2(|00>+|11>) versetzt.
- Ein Qubit wird für die vorgegbenen 2 Bits mit einem passenden Gate "codiert", das andere Qubit bleibt unberührt.
- Um die codierte 2-Bit Information wieder abzurufen, erfolgt eine Gate-Kombination, die unabhängig ist von der in dem einen Qubit "gespeicherten" Information. Danach werden beide Qubits gemessen (1 shot).
Im Composer sieht der Algorithmus so aus: (Wir lassen den Teil der Bit-Paar-Bereitstellung weg. Der wäre wie oben davor zu schalten.)
Im ersten Teil wird der schon aus Q9 bekannte verschränkte Zustand zwischen q0 und q1 hergestellt. Im mittleren Teil erfolgt die Codierung auf q0. Dabei steht für jedes der vier 2-Bit Paare eine bestimmte Gate-Kombination (s. folgende Tabelle). Damit ist das Bit-Paar in q0 codiert, ähnlich wie beim ersten Versuch.
Da q0 Teil eines verschränkten Systems ist, kann mit den Gates und Messungen im rechten Teil die Information bei Bedarf wieder ausgelesen werden. Wie schon erklärt, ist die Gate-Kombination die Umkehrung der Gates im Verschränkungsteil.
Mit 1-shot Durchläufen auf dem QC-Simulator können wir diesen Qubit-Algorithmus überprüfen. Im Beispiel ist das Bitpaar 01 codiert. Zur Codierung der 4 möglichen 2-Bit Paare verwendet man im Composer folgende Gates auf q0:
Bit-Paar | 00 | 01 | 10 | 11 |
Gates auf q0 | ID | Z | X | X --- Z |
Dabei bedeutet X --- Z, dass hier X und Z nacheinander angewendet werden. Natürlich kann man den Effekt auch "rechnerisch" mittels der Zustansabfolge nachweisen.
Wer Lust hat, kann versuchen, diesen Circuit so zu erweitern, dass man, wie im ersten Versuch, den "Bit-Input" über zwei zusätzliche Qubits und Bit-controlled Gates implementiert. Entweder als Skizze oder im Composer, wenn der Zugang zu IBM Q Experience besteht.
Wenn man diesen Qubit-Algorithmus zum Speichern (und wieder Auslesen) von 2 Bit kritisch betrachtet, wird klar, das eigentlich nicht viel gewonnen ist. Man benötigt zwei Qubits, in verschränktem Zustand, um eine 2-Bit Information "abzulegen" und gelegentlich wieder auszulesen. Um weitere 2 Bit zu speichern, benötigt man wieder zwei verschränkte Qubits. Der subtile Unterschied liegt lediglich darin, dass nur das eine Qubit die 2 Bit Information per Gates "aufgeprägt" bekommt, das andere in der Verschränkung unberührt bleibt. Trotzdem gibt es bei der Messung "seinen Anteil" der 2-Bit Information determiniert aus, hat sich also ggf. verändert. (Mit der Mehr-Qubit GHZ-Verschränkung sieht der Effekt aber schon wieder anders aus. Darauf kommen wir am Ende des Abschnitts Qubit-Kommunikation zurück.)
Plausibler wird der Superdense-Effekt allerdings bei einem anderen Einsatz des Algorithmus, nämlich zur Kommunikation.
Superdichte Codierung - Qubit-Kommunikation
Superdense Coding kann man einsetzen, um z.B. 2 Bit Information mittels eines Qubits zu übertragen, d.h. den Übertragungsaufwand gegenüber bit-weiser Kommunikation zu halbieren.
Auch wenn wir in dieser Blog-Serie die physikalischen Hintergründe vermeiden, muss man sich für das Folgende klar machen, dass es dem Großen Experimentator tatsächlich gelungen ist, verschränkte Qubits einzeln und über getrennte Wege an verschiedene Empfangsstellen zu schicken. Ähnlich, oder sogar mit den gleichen Mitteln, wie wir die klassische Datenübertragung (Internet) kennen. Das geht inzwischen über Hunderte von Kilometern. Wenn also von Qubit Senden die Rede ist, ist das nicht nur eine Fiktion, sondern praktisch realisierbar.
Die Interpretation des Superdense Coding Algorithmus, oben, als Kommunikationsmethode zwischen zwei Teilnehmern, üblicherweise Alice und Bob, ist wie folgt: Alice möchte Bob eine Nachricht (2 Bit) schicken,
- Bob erzeugt eine Verschränkung von zwei Qubits im Ausgangszustand.
- Eines der Qubits schickt er an Alice, das andere behält er.
- ------ Erste Trennlinie ------
- Alice möchte 2 Bits an Bob übermitteln. Dazu codiert sie mittels der passenden Gates (s.o.) die 2 Bits in ihr Qubit.
- Anschließend sendet sie ihr codiertes Qubit an Bob.
- ------ Zweite Trennlinie ------
- Bob wendet die Gates CNOT und H auf die Verschränkung an
- und misst Alice's und sein Qubit.
- Bob erhält damit die Nachricht von Alice.
Obwohl hier auch zwei Qubits im Spiel sind, wird nur das eine für die Kommunikation gebraucht. Alice "codiert" ihre Nachricht an Bob durch Anwendung von Gates auf dieses eine Qubit und schickt es zurück. Das andere Qubit tut nichts. Es ist lediglich Basis für die Verschränkung. Man kann das ganze wiederholen für eine beliebige binär codierte Nachricht, jeweils 2 Bit auf einmal, z.B. zur Übermittlung eines geheimen Schlüssels.
Ohne das hier näher zu erörtern, weist die Qubit-Kommunikation auch gewisse Sicherheitsmerkmale auf. Zum einen kann Alice's Information nicht gelesen werden ohne das zweite Qubit der Verschränkung. Zum anderen kann die Nachricht nicht "abgefangen" werden, ohne dass der Verschränkungszustand gestört wird.
Qubit-Kommunikation mit Mehr-Qubit GHZ Verschränkung
Das Kommunikationsverfahren mit zwei verschränkten Qubits lässt sich auf mehrere Qubit-Systeme erweitern. Wir kennen bereits aus Q11 die GHZ-Verschränkung, die eine konsistente Erweiterung unserer 2-Qubit-Verschränkung auf 3 und mehr Qubits ermöglicht. Damit können wir das Verfahren der 2-Bit Übertragung auf mehrere Bit ausdehnen. D.h. wir könnten statt 4 Zwei-Bit-Kombinationen mit einem verschränkten Qubit-Paar mehr Information übertragen, indem Alice z.B. alle außer einem Qubit bekommt und codiert zurück sendet. Wie die Tabelle zeigt,
GHZ Qubits | 2 | 3 | 4 | 5 |
# Alice's Qubits | 1 | 2 | 3 | 4 |
# Bit-Ketten | 4 | 8 | 16 | 32 |
kann Alice auf zwei Qubits die 8 Bitketten 000, ... 111 unterbringen. Die Gate-Kombinationen auf den beiden Qubit-Linien sind allerdings nicht so einfach wie oben. Wir haben 4*4 Gate-Kombinationen, also 16 Möglichkeiten, die 8 3-Bit-Ketten zu codieren. Die Tabelle zeigt, wie das geht (Ergebnisse der 16 Circuits).
ID | Z | X | X---Z | q0 | |
ID | 000 | 001 | 010 | 011 | |
Z | 001 | 000 | 011 | 010 | |
X | 110 | 111 | 100 | 101 | |
X---Z | 111 | 110 | 101 | 100 | |
q1 |
Die Composer-Grafik zeigt als Beispiel einen Qubit-Circuit mit 2 Qubits, die Alice mit q0: Z und q1: XZ codiert hat. Bob bekommt damit die 110.
Wie man an der Tabelle sieht, gibt es immer zwei Gate-Kombinationen, die die gleiche 3-Bit-Kette codieren. Alice kann aber alle bereits dadurch abdecken, dass sie für q0 die gleichen 4 Gate-Kombinationen wie oben wählt und für q1 entweder ID oder X.
Der Verdichtungsfaktor, das Verhältnis Bit-Information zur Anzahl zu codierender Qubits, vergrößert sich mit zunehmender Qubit-Zahl nicht-linear: bei 1 und 2 Qubits ist er 4, bei 3 bereits 16/3 und bei 4 immerhin schon 8.
Hier noch zwei Beispiele für eine 16-zu-3 Codierung: X auf q0, q1, q2 codiert 1000; mit Z statt X auf q1 wird 1111 codiert. Wer Lust hat, kann das mit dem Composer und der 4-Qubit-Verschränkung überprüfen.
Von dieser Stelle aus lassen sich vielfältige Ideen, Experimente und Untersuchungen entwickeln. Zum Beispiel könnten die Qubits an verschiedene Empfänger geschickt werden. Es sei dem eigenem Interesse überlassen, Szenarien hierzu zu überlegen.
Wir legen hier wieder eine Pause ein und vertagen das Thema Quanten-Teleportation auf den nächsten Blog. Eine Kaffepause und etwas Bewegung tun jetzt gut.
Und hier geht es weiter - stay tuned!
Neue Begriffe in diesem Abschnitt:
Begriff englisch | Begriff deutsch | Bedeutung |
Superdense Coding | Superdichte Codierung | Codierung von 2-Bit Information in einem Qubit |
Quantum Communication | Quanten-Kommunikation | Übertragung von (superdichter) Bit-Information durch ein Quantensystem |
Quantum Teleportation | Quanten-Teleportation | Übertragung eines Qubit-Zustands auf ein anderes Qubit |
Dependent Gate | Bit-controlled Gatter | Gate, das abhängig von klassichen Bits auf den Qubit-Zustand wirkt |
If Operator | If-Operator | |
Reversibility | Reversibilität | Grundsätzliche Umkehrbarkeit von Qubit-Operationen |
Compression Factor | Verdichtungsfaktor | Verhältnis von Bit-Information zur Anzahl verwendeter Qubits. Z.B. 2 Qubits für 8 3-Bit-Ketten: Faktor 4 |
Q12 Ein echter Quanten-Würfel in 3 Qubits
Ein normaler Spiel-Würfel hat sechs Flächen mit Punkten (Augen) von 1 bis 6. Bei Games oder Simulation von Zufallsvorgängen werden Würfel, oder allgemein Zufallszahlen, durch trickige mathematische Verfahren imitiert. Pseudo-Zufallszahlen heißen sie deshalb, weil sie nicht echt zufällig sind, sondern das Ergebnis einer festgelegten Berechnungsformel. Die ist für uns nur so kompliziert, dass wir das Ergebnis nicht wirklich "verstehen" oder vorhersagen können. Also akzeptieren wir das als "Zufall", obwohl es genau berechnet ist.
Der Spiel-Würfel ist echt. Da gibt es keine Funktion, nach der wir das Ergebnis eines Wurfs berechnen könnten. Wirklich nicht? Nun ja, prinzipiell doch, denn er gehorcht ja klaren physikalischen Gesetzen in dem, wie er sich dreht, wie er fällt, wie er rollt, wie er kippt. Aber auch diese alle zusammen sind wieder so kompliziert, dass wir gut darauf vertrauen können, dass er ein "neutrales" Zufallsergebnis liefert.
Der Quanten-Würfel ist nicht nur echt, sondern es ist sogar prinzipiell nicht möglich das Ergebnis voraus zu berechnen. Prinzipiell heißt hier, nach den Prinzipien der Quantenphysik. Zugegeben, es ist schwer, das zu glauben - aber man kann das sogar beweisen, d.h. die Physiker können das.
Wenn wir also einen Qubit-Algorithmus entwerfen können, der Würfelergebnisse durch Messung liefert, und wenn wir den auf einem echten Quantencomputer laufen lassen würden, hätten wir einen wirklich echten Würfel.
Ein Würfel-Qubit-Algorithmus
Einen einfachen Zufallsgenerator, der wie beim Münzwurf 0 oder 1 liefert, kennen wir schon: Wir versetzen ein Qubit in den Zustand |+> = H|0> und messen. Das ergibt ein Bit. Wir können das dreimal tun und erhalten ein 3-Bit-Ergebnis, von 000 bis 111. Das sind allerdings 8 mögliche Ergebnisse, für den Würfel brauchen wir genau 6 mit gleicher Wahrscheinlichkeit 1/6.
In der Zahl sechs liegt hier unser kleines Problem. Mit 2 Qubits können wir bis zu 4 verschiedene 2-Qubit-Messergebnisse erzielen. Wir kennen bereits Circuits, die ein, zwei, oder vier 2-Bit Ergebnisse liefern. Wir werden sehen, dass man auch Circuits konstruieren kann, die drei davon liefern mit gleicher Wahrscheinlichkeit. Aber auch das ist schon nicht so einfach.
Wir benötigen sechs, also brauchen wir 3 Qubits. Es ist einfach damit 1, 2, 4 oder 8 3-Bit Messergebnisse mit Häufigkeit größer Null zu erzielen. Aber sechs?
Wir versuchen folgende Methode:
Wir zerlegen das Problem in zwei Teilprobleme 6 = 3*2 : (a) die Konstruktion eines Circuits, der drei gleichwahrscheinliche Messergebnisse liefert, (b) eine Erweiterung, die den Endzustand von (a) noch in zwei gleichwahrscheinliche aufteilt.
Während (b), gefühlt, einfach erscheint - wir kennen ja die Wirkung von H - ist (a) etwas komplizierter. Aber auch hier teilen wir wieder auf: Wir brauchen einen Cicruit, der zwei Ergebnisse im Verhältnis 1/3 : 2/3 liefert, und versuchen dann, die 2/3 wieder in zwei gleichwahrscheinliche Ergebnisse "aufzuteilen".
Klingt, als könnte das gehen - aber wie? Zwei Ergebnisse mit unterscheidlichen Häufigkeiten hatten wir schon in Q8 für 1 Qubit erzeugt, durch Drehung mit Ry. (Das Schöne an den Qubit-Algorithmen ist, dass wir unsere Ideen - auch schrittweise - immer gleich überprüfen können mit dem IBM Composer und qasm-Simulator!) Also probieren wir mal:
Der Zustand auf dem Einheitskreis mit den Koordinaten (1/√3, 2/√3) liefert das gewünschte Ergebnis: (1,0) mit 1/3 und (0,1) mit 2/3 Wahrscheinlichkeit. Wie kommen wir vom Ausgangszustand (1,0) dahin? Es gibt verschiedene Wege. Der einfachste ist mittels einer Drehung um den passenden Winkel. Hier muss man den Taschenrechner bemühen und z.B. die arccos-Funktion mit 1/√3 aufrufen. Der Drehwinkel ist damit 0.955317. Wenn wir diesen mit Ry realisieren wollen, müssen wir wieder daran denken, dass der Ry-Winkel immer als das Doppelte vom Winkel im Koordinatensystem genommen werden muß (s. Q8). Wir komponieren also
|0> ---> Ry(2*0.955317) ---> M (Messung) ---> 000 und 001 zu 1/3 bzw 2/3
Der Simulationslauf bestätigt das!
Nun müssten wir 001 noch "aufteilen" in zwei Ergebnisse mit je 1/2 Wahrscheinlichkeit. Das wird trickig. Die 2/3 kommen aus der Komponente |1> des q0-Zustands. Die können wir mit einem geeigneten controlled Gate auf ein zweites Qubit "übertragen" werden. Sie müssen aber auf die Zustände |0> und |1> von q1 1:1 aufgeteilt werden. Damit würde der |1>-Anteil von q0 kombiniert werden mit den beiden Basiszuständen von q1. Gleichzeitig darf aber der |0>-Anteil von q0 nicht mit einem |1>-Anteil von q1 kombiniert werden, denn sonst hätten wir wieder 4 Ergebnisse. Was bietet sich an? Das controlled Hadamard-Gate! Das lässt zum Teil den q1 Ausgangszustand |0> unberührt und zum anderen Teil "dreht" es diesen auf 1/√2(|0>+|1>). Hier ist das Composer-Diagramm dazu.
Die Läufe auf dem Simulator liefern das gewünschte Ergebnis: 00, 01 und 11 mit Häufigkeiten z.B. 31.25%, 34.18% und 34.57%. Wie oben erwähnt haben wir hiermit auch ein Beispiel für ein 2-Qubit-System, das 3 der vier möglichen Messergebnisse aufweist.
Wir wollten aber einen Würfel konstruieren. Für Schritt (b) brauchen wir nur ein weiteres Qubit in eine 1:1 Superposition zu bringen. Dann bekommen die 3 2-Qubit Ergebnisse von (a) jeweils eine 0 oder 1 "dazugeschaltet". Das geht am einfachsten mit dem Hadamard-Gate. Das Composer-Diagramm und ein Ergebnis-Histogramm von 1024 Shots:

Das Ergebnis-Histogramm zeigt die 6 "Würfel-Ergebnisse" mit etwa gleicher Häufigkeit. Natürlich sind die Bit-Ketten unter den Säulen nicht als Binärzahlen zu nehmen. Eine Interpretation als Augenzahl ist allerdings simpel. (Wir werden an anderer Stelle ein Würfelspiel in Form eines Python Programms unter Verwendung des IBM QC-Package Qiskit zeigen.) Wir können z.B. folgende Übersetzung festlegen
Qubit-Ergebnis | 00000 | 00001 | 00011 | 00100 | 00101 | 00111 |
Augenzahl | 2 | 1 | 3 | 4 | 5 | 6 |
Dann sind immerhin die mittleren vier Augenzahlen in den Bitketten als Binärzahl repräsentiert.
Die W-State Verschränkung
Die Idee für den obigen, letztlich doch recht einfachen Qubit-Algorithmus für einen Würfel, geht auf einen Artikel zurück, in dem P. Decoodt in einem GitHub Beitrag von 2019 (Link) die Erzeugung sog. verschränkter W-Zustände beschreibt.
W-Zustände können beliebig viele Qubits in der Weise verschränken, dass jedes darin nur einmal mit ihrem Basiszustand |1> vertreten sind. Also etwa
1/√2(|01>+|10>) für n=2 Qubits
1/√3(|001>+|010>+|100> für n=3, und
1/√n(|00...01>+|00...10>+....+|10...00>) allgemein.
Für n=3 sieht man, dass der W-Zustand bei Messung genau 3 Ergebnisse mit gleicher Wahrscheinlichkeit liefert. Daher ist er ein guter Kandidat für den Schritt (a) eines Würfel-Algorithmus. Es gibt in dem erwähnten Beitrag einen sehr eleganten Algorithmus, bzw. ein algorithmisches Schema, nach dem die W-Zustände für n Qubits generiert werden können. Für n=3 und in Composer-Darstellung übersetzt, sieht das wie folgt aus:

(Die ID Gates kann man sich weg denken. Sie stehen dort nur, damit die elegante Struktur des Algorithmus deutlich wird. Der Composer schiebt ansonsten alles zusammen, was die Ausführungsabfolge nicht beeinträchtigt.) Was man hier an der Grafik nicht erkennt, ist, dass die cZ-Gates in diesem Algorithus "von unten nach oben" weisen. D.h. die Control-Qubits sind q2 und q1, die Target-Qubits q1 bzw q0. Die "Richtung" lässt sich im cZ-Gate editieren.
Der Algorithmus liefert drei mögliche Messergebnisse: 001, 010 und 100. Und die zusätzliche Idee für einen echten Würfel besteht damit nur noch darin, diese drei zu gleichen Anteilen "aufzuspalten". Da kommt das Hadamard-Gate gerade recht, das am Ende der q2-Lebenslinie hinzugefügt wird. In der Abbildung also nach dem ID-Gate und vor den Messoperatoren.
Insgesamt ist der W-Zustand Algorithmus als Teil des Würfel-Algorithmus aber recht komplex, daher lohnt es, sich die einzelnen Schritte des genauer anzusehen. Zunächst stellt man fest, dass die beiden CNOT Gates nicht nötig sind, um auf genau drei verschiedene Messergebnisse zu kommen. Auch hier ist es gute Praxis, die Messpunkte im Composer einfach zu verschieben, um zu überprüfen, was der bis zu einer bestimmten Stelle im Algorithmus entwickelte Zustand ergibt. Setzt man die Messpunkte z.B. hinter das zweite Ry-Gate auf der q0-Linie, bekommt man zwei Messergebnisse im Häufigkeitsverhältnis 1/3 : 2/3. (Allerdings nicht den W-Zustand. Der ist aber auch für den Würfel unerheblich.)
Die nächste Vereinfachnung ergibt sich, wenn man bedenkt, dass das X anfangs der q2-Linie nur den q2-Zustand so umstellt, dass das controlled Z (cZ, senkrechte Linie mit zwei Punkten) immer greift. Man kann also das X und das cZ weglassen, wenn man dafür ein Z an diese Stelle auf der q1-Linie platziert. Das bedeutet aber, dass sich der Zustand von q1 zunächst unabhängig entwickelt: Eine Drehung in negative Richtung um einen bestimmten Winkel θ, eine Spiegelung an der x-Achse (Wirkung des Z-Gates), was insgesamt einer Drehung des Ausgangszustands um θ in positiver Richtung (in den 1. Quadranten des Koordinatensystems) entspricht. Anschließend erfolgt eine Drehung noch einmal um θ, so dass wir insgesamt bei einem Winkel von 2*θ ankommen. Daher kann man das ganze Geschehen auch abkürzen, indem man statt dessen für q1 nur eine Drehung (Ry) um 2*θ in positiver Richtung als Gate ansetzt. Nun muss man θ so festlegen, dass der Zustand die zwei Messergebnisse im Verhältnis 1/3 : 2/3 liefert. Dieser Winkel ist im W-Algorithmus bereits bestimmt (0.955317 oder arccos(1/√3) ), man kann ihn also übernehmen. Mit dem Composer kann man das Ergebnis unmittelbar überprüfen.
Es bleibt die Überlegung für das Zusammenspiel zwischen q1 und q0. Der Zustand von q0 wird zunächst ebenfalls (per Drehung) verändert. Dann greift das cZ: die Wirkung des Z-Gates beschränkt sich auf den |1> Anteil des q1-Zustands. Mit diesem Anteil wird der q0-Zustand gespiegelt und anschließend noch einmal um φ in positiver Richtung gedreht. Dieser "Anteil" ist damit in einem Zustand, der im Koordinatensystem mit dem Winkel 2*φ auf dem Einheitskreis liegt. Der andere Anteil des q0-Zustands wird lediglich wieder "zurück gedreht" auf den Ausgangszustand |0>. Der Winkel φ muss so bestimmt werden, dass der zugehörige Zustand zur Hälfte aus |0> und zur Hälfte aus |1> besteht. Das kann man aber insgesamt auch erreichen, indem man die Drehungen mit dem Ry-Gate und das cZ ersetzt durch ein einfaches controlled H (cH) "von q1 nach q0". Genau das haben wir oben getan, was uns zu dem schlichten Würfel-Algorithmus oben geführt hat. (Allerdings haben wir dort q0 und q1 vertauscht.)
Wir lernen daraus auch eine Methode des Qubit-algorithmischen Denkens: Effekte von Gates zu verstehen und parallel mit Hilfe des einfachen grafischen Composer Tools zu überprüfen, indem man systematisch Messpunkte setzt bzw. verschiebt. Verschieben eignet sich insbesondere für die Analyse von Qubit-Algorithmen, das systematische Setzen beim Entwurf von Qubit-Algorithmen.
Die Erläuterung der Wirkung von cZ oder auch des cH zwischen q1 und q0 macht auch deutlich, warum man zu der Deutung neigt, dass ein Qubit "in zwei Zuständen gleichzeitig" sein kann - vereinfacht zu: "Ein Qubit kann gleichzeitig 0 und 1 sein". Mittels controlled Gates kann ein Zustand, der eine Superposition (i.e. Linearkombination) darstellt, eingesetzt werden, um ein anderes Qubit auf zwei unterschiedlichen "Wegen" weiter zu entwickeln. Es ist, als würde man gleichzeitig zwei "Schicksale" des gleichen Qubit verfolgen. Von da aus ist es nicht weit bis zu der phantastischen Vorstellung von gleichzeitig existierenden Parallelwelten. Wir kommen darauf in einem späteren Blog noch einmal zurück.
Der rekursive W-State Algorithmus hat interessantes Potenzial über die Würfel-Implementierung hinaus. Wir können damit im Prinzip jede Anzahl von Messergebnissen realisieren. Z.B. mit n=5 Verteilungen über 5 Bitketten der Länge 5. Und mit "Aufspaltungen" wie oben in Schritt (b) bei n=3 auch gerade Vielfache davon.
Im nächsten Abschnitt versuchen wir uns am Super Dense Coding, bei dem man mit n Qubits 2n Bits an Information übertragen kann. Ebenfalls eine Quelle vieler Mythen.
Vorher aber eine Spiel-Pause - mit dem Quantenwürfel. Stay tuned!
Tabllen-Ergänzung
Begriff englisch | Begriff deutsch | Bedeutung |
Pseudo random numbers | Pseudo-Zufallszahlen | Mit einer determinierten Rechenvorschrift erzeugte Zahlen, die uns "zufällig" erscheinen |
Histogram | Histogramm | Säulen-Darstellung von Zahlenwerten, z.B. Häufigkeiten von Ereignissen |
W State | W-Zustand | Verschränkter n-Qubit Zustand besonderer Struktur |
Target Qubit | Ziel-Qubit | Andere Bezeichnung für das Controlled Qubit bei einem Controlled Gate |
Algorithmic schema | Algorithmisches Schema | Allgemeine Struktur von Algorithmen, die mehreren Algorithmen zugrunde liegen kann. |
ID Gates | ID-Gatter | Wirkungsloses Gatter, das i.w. zu besseren Strukturierung von Composer Grafiken verwendet werden kann. Auch für zeitliche Taktung. |
Qubit Algorithmic Thinking | Qubit-algorithmisches Denken | Verstehen, Analysieren und Entwerfen von Qubit-Algorithmen als speziellem Algorithmus-Typ |
Q11 3-Qubit Circus
So sieht ein Circuit mit 3 Qubits im IBM Q Composer aus.
3-Qubit Zustände
Wir haben hier auch gleich einmal das Swap-Gate zwischen q0 und q1 eingesetzt und das ID-Gate.
Was wird das Messergebnis sein? Klar, q0 liefert 0, q1 liefert 1, beides jeweils zu 100%. Aber H (mit oder ohne ID) liefert für q2 je 50% 0 und 1. D.h. als 3-Qubit Messergebnis können wir 010 und 110 zu je 50% erwarten. (Der Lauf auf dem Simulator bestätigt die Erwartung.)
Erstaunlich - dies ist die Analyse eines Mini-Qubit-Algorithmus mit immerhin 3 Qubits, die wir allein aus der Interpretation der Gates abgeleitet haben. Das war übrigens auch schon bei den vergangenen Circuit-Beispielen der Fall. Andererseits kann man den Algorithmus auch "formelmäßig berechnen", indem man, ausgehend vom Anfangszustand der Qubtis, die Abfolge der Zustände über die Gate-Formeln berechnet. Das haben wir ernsthaft schon in Q10 begonnen.
Nun zu den 3-Qubit-Zuständen. Mit dem allgemeinden Zustand (r,s) für q2 rechnen wir analog zum 2-Qubit-Zustand:
(r,s) ⊗ ((u,v)⊗(x,y)) = (r,s) ⊗ (ux, uy, vx, vy) = (rux, ruy, rvx, rvy, sux, suy, svx, svy)
Das Resultat ist ein 8-dimensionalen "Punkt". Wieder ist die Summe der Quadrate der Koordinaten =1. Und alle 8-Koordinaten-Punkte, die diese Bedingung erfüllen sind wieder zulässige 3-Qubit-Zustände. Die Berechnung des 3-Qubit-Zustands aus den Zuständen der einzelnen Qubits ist assoziativ aber nicht kommutativ. D.h. es ist zwar egal, ob erst (r,s)⊗(u,v) gerechnet wird oder erst (u,v)⊗(x,y), aber es ist nicht egal, ob man die Reihenfolge der Qubit-Zustände vertauscht: (r,s)⊗(u,v) ist nicht das Gleiche wie (u,v)⊗(r,s). Nur zur Warnung!
Verfolgen wir die Zustände im obigen Beispiel:
q0 (1,0) ---> X ---> (0,1) ---> Swap ----> (1,0) = (x,y)
q1 (1,0) ---------------------> Swap ----> (0,1) = (u,v)
q3 (1,0) ---> H ---> 1/√2(1,1) ---> ID --->1/√2(1,1) = (r,s)
Damit wird der 3-Qubit-Zustand zum Zeitpunkt der Messung
1/√2(1,1) ⊗ (0,1) ⊗ (1,0) = (0, 0, 1/√2, 0, 0, 0, 1/√2, 0)
Man macht sich hier zunutze, dass der 3-Qubit-Zustand separabel ist; denn er wird ja aus drei 1-Qubit-Zuständen zusammen gesetzt.
Messung und Kets
Wie passt das zur Messung? Dazu müssen wir den M-Operator auf 3-Qubit-Zustände erweitern. Ein solcher Zustand (a0, a1, a2, a3, a4, a5, a6, a7) lässt sich mit 3-Kets schreiben als a0|000>+a1|001>+a2|010>+a3|011>+a4|100>+a5|101>+a6|110>+a7|111>
Dabei sind die 3-Kets wieder die Abkürzungen für |0>⊗|0>⊗|0> = |000> usw. Allgemein gilt die Schreibweise |ijk> = |i>⊗|j>⊗|k>.
Und da wir gerade dabei sind, stellen wir fest, dass die 0-1-Folgen in den 3-Kets genau die Dezimalzahlen 0, 1, 2, ..., 7 ergeben, wenn man sie als Binärzahlen interpretiert. Und wenn wir die Koordinaten a0, ... a7 so durchnummerieren wie in der Ket-Summe, dann passen die gerade zu den Kets als Dezimalzahlen.
Damit kann man nun den Operator M so festlegen - und das gilt für beliebige Anzahlen von Qubits:
M(a0, a1, a2, a3, a4, a5, a6, a7) = (|a0|², |a1|², |a2|², |a3|², |a4|², |a5²|, |a6|², |a7|²)
und dabei bedeutet z.B. |a5|² die Wahrscheinlichkeit dafür, dass wir als Messergebnis 101, die Binärzahl für 5, bekommen. Und ja, man schreibt dann natürlich auch manchmal den Ket mit der Dezimalzahl statt der Bitkette: |101> = |5>. Allgemein:
|i>⊗|j>⊗|k>=|ijk>=|d>, wobei d=i*2²+j*2¹+k*2°
Dabei den Durchblick zu behalten, ist schon eine ziemliche Herausforderung. Aber es musste mal gesagt werden - auch wenn wir möglichst bei der Koordinatendarstellung von Zuständen bleiben.
Zurück zur Messung im Beispiel oben: der M-Operator angewendet auf den 3-Qubit-Zustand
1/√2(1,1) ⊗ (0,1) ⊗ (1,0) = (0, 0, 1/√2, 0, 0, 0, 1/√2, 0)
ergibt die Wahrscheinlichkeiten (0,0,1/2,0,0,0,1/2,0). D.h. nur 010 und 110 kommen bei Messungen vor.
Man muss darauf achten, dass man Zustände in Koordinatenschreibweise und Messwahrscheinlichkeiten sachlich und sprachlich voneinender unterscheidet. Insofern ist die Ket-Schreibweise wiederum hilfreich, weil sid ganz anders "aussieht" als die Liste der Wahrscheinlichkeiten, die M liefert.
Tofoli Gate
Das Tofoli-Gate ist ein CCNOT Gate, d.h. q0 und q1 steuern q2: wenn beide im Zustand (0,1) sind (also |1> als Ket), wird der Zustand von q2 umgedreht, sonst bleibt er unverändert. Mit (x,y), (u,v) und (r,s) als Zustände von q0, q1 bzw. q2, überführt das Tofoli-Gate den 3-Qubit-Zustand
(r,s) ⊗ (u,v)⊗(x,y) = (rux, ruy, rvx, rvy, sux, suy, svx, svy)
---> CCNOT
---> (rux, ruy, rvx, svy, sux, suy, svx, rvy)
d.h. die 4. und 8. Koordinate werden vertauscht. Das ist einfach zu verstehen: v und y sind die Anteile von (0,1) (oder |1>) in den beiden Control-Qubits q0 und q1. Kommen beide zusammen in einer Koordinate des 3-Qubit-Zustands vor, wechselt q2 die Zustandskoordinaten. Damit wird in der 4. Koordinate rvy zu svy und umgekehrt in der 8. Koordinate.
Ein Beispiel-Circuit mit Tofoli-Gate (CCNOT). Es liefert 010 und 111 mit Wahrscheinlichkeit 1/2. Eine gute Übung, das Ergebnis über die Zustandsentwicklung nachzuvollziehen.
Logische Gates
Wenn wir das Tofoli-Gate (auch CCNOT oder ccX genannt) mit den Controlled Gates in den 2-Qubit-Circuits vergleichen, etwa cX (CNOT) oder cH, dann ist das Tofoli-Gate eine Erweiterung des CNOT auf zwei "kontollierende" Qubits. Entsprechend kann man auch andere 1-Qubit Gates-Gates über kontrollierende Qubits beeinflussen.
Bei 3-Qubit gibt es auch die Möglichkeit, ein controlling Qubit auf die zwei anderen Qubits wirken zu lassen. Ein Beispiel ist das cSWAP, auch Fredkin-Gate genannt. Es "swappt" die Zustände von q1 und q2 in Abhängikeit von q0.
Nicht alle Möglichkeiten für controlled Gates sind als Symbole im Circuit Composer vordefiniert. Man kann sie aber in der Regel alle aus vorhandenen Gates "konstruieren".
Die logischen Qubit Gates sind zu vergleichen mit einfachen "wenn ... dann" Konstrukten in herkömmlichen Algorithmen. Während dabei aber die Bedingung hinter "wenn" stets entweder wahr oder falsch ergibt, oder als Bits 1 oder 0, kann bei Qubits die Bedingung "anteilweise" erfüllt sein. Etwa, wenn das Control-Qubit den Zustand 1/√2(1,1) hat. Die Wirkung nach dem "dann" bezieht sich immer auf ein anderes Qubit (das controlled Qubit), während bei herkömmlichen Algorithmen die "dann"-Aktion mehrere Schritte mit mehreren Variablen haben kann - die in der "wenn"-Bedingung vorkommenden eingeschlossen.
3-Qubit-Verschränkungen
Natürlich gibt Verschränkung auch in 3-Qubit (oder Mehr-Qubit) Systemen. Der Circuit sieht aus wie ien Erweiterung unseres Circuit 7 für 2 Qubits. Tatsächlich ist auch das Messergebnis ähnlich: Es liefert 000 und 111 mit jeweils etwa 50%. Das lässt sich auch anhand der Zustandsabfolge nachvollziehen (mit ein bisschen Probieren):
(1,0)⊗(1,0)⊗(1/√2,1/√2) = (1/√2, 1/√2, 0, 0, 0, 0, 0, 0)
---> CNOT-q0-q1 ---> (1/√2, 0, 0, 1/√2, 0, 0, 0, 0)
---> CNOT-q1-q2 ---> (1/√2, 0, 0, 0, 0, 0, 0, 1/√2)
Verschränkte 2- und Mehr-Qubit-Zustände spielen eine wichtige Rolle in Qubit-Algorithmen. Wir werden das in den nächsten Blogs demonstrieren.
Man kann nun untersuchen, was passiert, wenn man dem q1 und / oder dem q2 ein X-Gate voranstellt, d.h. nicht mit dem Anfangszustand (1,0) sondern mit (0,1) startet. Das Einfachste, wenn man den Zugang zum IBM Q Experience Circuit Composer hat, ist Ausprobieren. Andererseits kann man das auch erschließen. Z.B. hat ein X auf der q1-Linie den Effekt, als Messergebnis 001 und 110 zu liefern, also gegenüber 000 und 111 eine Umkehrung des (rechten) Ergebnis-Bit aus dem Zustand von q0. In jedem Fall bekommen wir eine Verschränkung der 3 Qubits.
Diese Zustandsverschränkung wird als GHZ-Verschränkung bezeichnet - wie überhaupt in der Qubit-Welt viele Objekte mit Namen von Forschern bezeichnet oder abgekürzt werden. Damit wollen wir uns hier aber nicht belasten. Ganz am Ende der Blogserie gibt es dann noch mal eine Tabelle dafür. Ein weiterer wichtiger Verschränkungszustand heißt "W-Zustand". Den werden wir im nächsten Blog kennen lernen. Und unterwegs werden wir einen ersten "richtigen" Qubit-Algorithmus konstruieren, der etwas Reales tut: "Würfeln". Klingt simpel? Ist es aber nicht.
Kleine Pause, dann geht's hier weiter. Stay tuned!
Tabellen-Ergänzung
Begriff englisch | Begriff deutsch | Bedeutung |
Swap Gate | Swap Gate | Vertauscht die Zustände zweier Qubits |
3-Qubit State | 3-Qubit-Zustand | (r,s)⊗(u,v)⊗(x,y) in Koordinatenschreibweise |
|ijk> | |ijk> | 3-Qubit-Zustand in Ket-Schreibweise: |ijk> = |i>⊗|j>⊗|k> |
associative | assoziativ | Reihenfolge der Ausführung der Operation ist beliebig z.B. (a+b)+c = a+(b+c). |
commutative | kommutativ | Reihenfolge der Operanden ist beliebig, z.B. a+b=b+a. Aber nicht a-b = b-a! |
Tofoli-Gate | Tofoli-Gatter | ccX: Switch q3, wenn q0 und q2 im Zustand (0,1) |
Fredkin-Gate | Fredkin-Gatter | cSwap: Swappt Zustände von q2 und q3, wenn q0 in (0,1) |
GHZ | GHZ | Ein verschränkter 3-Qubit-Zustand |
W state | W-Zustand | Ein anderer 3-Qubit verschränkter Zustand |