Q14 Quanten-Teleportation

Die geheimnisvolle Kunst des Teleportierens kennt man - je nach Alter - aus Raumschiff Enterprise ("Beam' mich hoch, Scotty!") oder als Zauber aus Harry Potter (Disapparieren und Apparieren). Hier wie da verschwindet etwas oder jemand und taucht an anderer Stelle wieder auf. Der "3D-Druck" tut im Effekt etwas Ähnliches, nur verschwindet das Original nicht, wenn eine Kopie des Objekts an anderer Stelle "erscheint". Lediglich die (geometrischen) Daten des Original-Objekts werden an die Empfangsstelle übertragen. Quanten-Teleportation ist beides - oder beides nicht: das Original-Qubit verschwindet und taucht an anderer Stelle als neues Qubit-Objekt auf. Dazwischen wird Information übertragen.

Etwas ernsthafter: Als Quanten-Teleportation bezeichnet man die Übertragung eines Qubit-Zustands mittels klassicher Bit-Information, um ein anderes Qubit in den Zustand des Originals zu versetzen. Dabei geht der Original-Zustand verloren. Und da Qubits keine "Individualität" haben, hat man vorher und nachher das gleiche Qubit, nur an einem anderen Ort. Teleportation eben.  Das funktioniert tatsächlich auch technisch und wurde schon über viele Kilometer hinweg realisiert wie ein Blick ins Wikipedia zeigt.

Die Quanten-Teleportation ist das Gegenstück zur Quanten-Kommunikation (s. Q13):  Die Quanten-Kommunikation übermittelt zwei Bit Information mittels eines Qubit-Zustands, die Quanten-Teleportation übermittelt einen Qubit-Zustand mittels zweier Bits. Und in beidem spielt die Verschränkung eine entscheidende Rolle.

Das Teleportationsverfahren schrittweise von der Ausgangssituation her zu entwicklen, wird leicht mühselig, auch für den Leser. Daher schlagen wir dieses Mal den umgekehrten Weg ein: Wir stellen den Algorithmus vor, experimentieren damit ein wenig und liefern die Erklärung weiter unten nach, als systematische Darstellung der Zustandsabfolge.

Teleportation - der Algorithmus

Der Ablauf ist schnell erzählt: Alice möchte Bob den Zustand ihres Qubit (q0) übermitteln. Bob erzeugt dazu ein Qubit-Paar (q1, q2) mit der üblichen Verschränkung (siehe Circuit 7) und schickt das eine davon (q1) an Alice. Das andere verbleibt bei Bob.  Alice wendet auf ihre beiden Qubits (q0, q1) zwei Gates an, ein CNOT von q0 zu q1 und danach ein H-Gate auf q0.Anschließend misst sie die Zustände der beiden Qubits. Die beiden Bits aus der Messung schickt sie auf dem klassichen Übertragungsweg an Bob. Der steuert damit ein X- und ein Z-Gate, die auf den Zustand seines Qubits (q2) wirken. Als Ergebnis erhält er q2 in dem Zustand, in dem q0 zuvor war. Wie man das nachprüft, sehen wir anschließend.

Im Composer sieht die Teleportation wie folgt aus:

Dieses Composer-Bild hat drei 1-Bit Linien, für jede Qubit-Messung eine. Bisher hatten wir die Messbits von Multi-Qubit-Systemen immer auf einer "Schiene". Der Vorteil hier ist, dass wir die Messbits unabhängig voneinander zur Steuerung einsetzen können, statt über die 3-Bit Binärzahl-Werte zu steuern. Man sieht das an den bedingten X- und Z-Gates.

Die Barrieren (gestrichelte Linien) dienen hier nur zur grafischen Gliederung: Links definiert Alice den Zustand von q0, der teleportiert werden soll. Hier (0,1). Im zweiten Abschnitt erzeugt Bob ein verschränktes Qubit-Paar, wovon er q1 an Alice schickt. Im mittleren Abschnitt wendet Alice auf ihre Qubits ein CNOT und ein Hadamard-Gate an und misst das Ergebnis. Das Ergebnis von q0 wird auf das Bit c1 übertragen, das von q1 auf d1. Alice sendet diese klassichen Bits an Bob. der wendet Bit-controlled Operationen (X, Z) auf sein Qubit an. Wenn der Zustand von q1 als 1 gemessen wird, wird das X-Gate auf q2 angewendet. Wird für q0 eine 1 gemessen, wird das Z-Gate angewendet. Sind beide Messbits 1, dann wirken beide Gates.  Abschließend wird q2 gemessen. Wenn alles gut gegangen ist, müsste q2 nun im Zustand (0,1) sein.

Wir starten  den Algorithmus und bekommen als Ergebnis z.B. 110 bei einem Durchlauf. Ok, für q2 wird eine 1 gemessen. Die Logik: Wenn q2 nach Teleportation im Zustand (0,1) ist, darf eine Messung keine 0 ergeben. Mit 1024 shots bekommen wir dieses Histogramm:

Alle Messergebnisse liefern eine 1 für q2. Interessant ist auch zu bemerken, dass q0 sowohl 1 als auch 0 liefert. D.h. q0 hat seinen ursprünglichen Zustand verloren, der nur das Messergebnis 1 hatte.

Wenn Alice q0 im Zustand (1,0) teleportieren will, entfällt das X-Gate am Anfang. Das Ergebnis-Histogramm zeigt, wie zu erwarten, dann nur 3-Bit-Ketten, die links eine 0 haben. Klar!

Damit haben wir die Basiszustände teleportiert.

Teleportation allgemeiner Qubit-Zustände

Wenn wir einen beliebigen Qubit-Zustand als Superposition der Basiszustände (1,0) und (0.1) teleportieren wollen, können wir eigentlich davon ausgehen, dass, wenn diese korrekt teleportiert werden, auch ihre Kombination korrekt in q2 übertragen wird. Wir probieren das gleich mal aus.

Dabei machen wir uns die Darstellung des Messergebnisses von q2 etwas einfacher, indem wir nach der Teleportation q0 und q1 in den Standard-Anfangszustand versetzen und erneut messen. Etwas so:

Wir setzen statt X das Rotationsgate Ry mit dem Drehwinkel 30° an den Anfang von q0. Eine direkte Messung des Qubits in diesem Zustand ergibt, idealisiert, zu 75% Bit 0 und zu 25% Bit 1. Wir wollen sehen, ob nach Durchlauf des Circuits auch q2 diese Eregbnis liefert.

Mit der "Neutralisierung" von q0 und q1 am Ende des Circuits bekommen wir ein Histogram mit zwei Säulen, die sich nur im Messwert für q2 unterscheiden.

Und wir finden tatsächlich insgesamt etwa 75% der Ergebnisse mit 0 und 25% mit 1 für das linke Bit. Also genau wie erwartet!

Qubit Zustände und Messergebnisse

Wir machen das gleiche mit dem Zustand 1/√2(|0>-|1>), der entsteht, wenn wir X --- H hintereinander auf |0> anwenden. Wie erwartet, ergibt die direkte Zustandsmessung von q0 das gleiche wie die Messung von q2 nach Durchlauf der Teleportation. Scheint also unsere Vermutung zu bestätigen. Scheint! Wir wollen aber nicht Messergebnisse teleportieren, sondern Qubit-Zustände. Können wir hier aus dem Ergebnis der q2-Messung schließen, dass tatsächlich der Zustand von q0 korrekt auf q2 übertragen wurde? Nein! Ein einfacher Versuch: mit dem Zustand H|0> =1/√2(|0>+|1>) (plus!) bekommen wir die gleichen Messergebnisse. Man kann also nicht sagen, ob die q2-Messung von dem ersten oder dem zweiten Teleportationsbeispiel stammt.

An dieser Stelle müssen wir uns noch einmal klarmachen, dass man zwar immer vom Zustand eines Qubit-Systems auf das Messergebnis schließen kann, aber aus einem Messergebnis nicht  eindeutig auf den Zustand zurück schließen kann. Man sagt, die übereinstimmenden Messergebnisse sind eine notwendige Bedingung für die korrekte Teleportation, aber keine hinreichende. Wie können wir hier eine Unterscheidung herbei führen und festellen, ob die Teleportation gelungen ist?

Zwei Möglichkeiten stehen uns zur Verfügung. Erstens, die Abfolge der Zustandsänderungen dieses 3-Qubit-Systems Schritt für Schritt mittels der Formeln nachzuvollziehen und am Ende den tatsächlichen Zustand von q2 mit q0 zu vergleichen. Das "üben" wir am Ende des Blogs.

Als zweite Möglichkeit nutzen wir die grundsätzliche Umkehrbarkeit von Qubit-Operationen. Wenn wir nach der Teleportation erst noch ein Gate auf q2 anwenden, das das H-Gate umkehrt, und die Teleportation korrekt funktioniert hat, müssten wir im ersten Fall (X --- H) immer 1 als das linke Messbit bekommen, im anderen Fall 0. Im Beispiel-Fall ist H selbst ein komplementäres Gate, das wir direkt hinter der letzten Barriere eingefügt haben. (Alternativ könnte man auch Ry(3π/2) verwenden. Mal ausprobieren!) Aus diesen Messergebnissen können wir dann schließen, dass wir in q2 den Zustad |1> bzw. |0> vorliegen haben, und damit der mit H veränderte Zustand korrekt übertragen wurde. Das Umkehr-Verfahren komplementiert also das Messverfahren bei der Bestimmung von Zuständen.

Tatsächlich bekommen wir hier zu 100% die 1 für q2.

Anm.: Natürlich können auch die Basiszustände mit einem Minuszeichen versehen sein, z.B. per 180° Drehung und dabei 0 bzw. 1 als Messergebnis liefern. Dieser Faktor -1 macht aber nichts aus, denn die  beiden Zustände im Beispiel unterscheiden sich ja schon über die Messergebnisse.

Teleportieren, Klonen, Kopieren, Übertragen

Warum das doch recht aufwändige Teleportieren, um ein "anderes" Qubit in den Zustand von q0 zu bringen? Kann man den Zustand nicht einfach kopieren wie bei "gewöhnlichen" Algorithmen? Beispiel: a = 5, b=a , dann haben wir zwei Variablen mit dem Wert 5 (wie auch immer dies in einer Programmiersprache umgesetzt wird).

Kopieren bedeutet eine Kopie herstellen, d.h. das Original bleibt erhalten, die Kopie ist etwas anderes als das Original. Klonen bedeutet, das Original noch einmal herstellen. Wenn wir den Zustand eines Qubits auf ein zweites Qubit kopieren wollten, würde wir es automatische klonen, denn es gibt nichts, was zwei Qubits voneinander unterscheiden könnte als der Zustand.

Nun gibt es in der Theorie der Qubits ein Theorem, das besagt, dass man Qubits nicht klonen kann, das sog. No-Cloning-Theorem (s. Wikipedia). Das ist nicht zu schwer zu beweisen, überschreitet aber den mathematischen Rahmen, in dem wir uns hier bewegen wollen. Wir müssen also akzeptieren, dass man nicht aus dem (beliebigen, unbekannten) Zustand eines Qubits ein zweites herstellen kann, ohne z.B. das Original zu zerstören. Natürlich kann man, wenn man den Zustand eines Qubits kennt und weiß, wie er "hergestellt" wurde, ein zweites Qubit mit Hilfe von Gates so präparieren, dass es den gleichen Zustand hat. Dazu muss man aber den Zustand des Originals explizit kennen!

Man kann aber den Zustand eines Qubits übertragen. Teleportation ist eine Methode. Eine ganz einfache Methode ist das Swap-Gate: es vertauscht die Zustände von zwei Qubits in einem Circuit. Man kann das so sehen, dass der Zustand von einem Qubit auf das andere übertragen wird und umgekehrt. In herkömmlichen Algorithmen sieht ein Variablen-Swap zwischen a und b so aus: s = a, a = b, b = s (nicht etwa: a=b, b=a !). Im Effekt haben wir aber nur die Qubit-Variablen getauscht.

Eine echte Übertragungsmethode ist eine Art lokale Version der Teleportation. Lokal deshalb, weil hierbei keine Übertragung im Sinne eines Transports zwischen entfernten Orten (Alice und Bob) stattfindet. Der Composer-Circuit dazu sieht so aus:

Das Ergebnis Histogramm entspricht dem ersten oben, d.h. q2 liefert nur 1, die beiden anderen - insbesondere q0 - jeweils 0 und 1.

Statt Bit-controlled Gates wie bei der Teleportation haben wir hier ein CNOT (auch cX genannt) und ein cZ. Damit "kürzen" wir den Umweg über die Messwerte ab. Statt zu messen, ob q0 bzw. q1 eine 1 oder 0 liefern, und danach die Gates X und Z für q2 zu steuern, nehmen wir gleich die Zustände von q0 und q1, um die Gates zu steuern. Man beachte, dass dabei stillschweigend unterstellt wird, das z.B. Zustand |1> und Messung 1 äquivalent sind.

Der Unterschied zwischen Teleportation und lokaler Übertragung liegt in der "Anwendung" der Algorithmen. Bei der Teleporation werden Qubits an unterschiedlichen Orten behandelt und die Zustandsübertragung mittels klassicher Bits - und damit klassischer Übertragungsmedien - durchgeführt. Alice kann damit den Zustand eines Qubits, das sich bei ihr befindet, auf ein Qubit von Bob übertragen. Dagegen ist die lokale Übertragung - eben lokal.

Das Zustandsprotokoll

Wenn wir den Teleportationsalgorithmus schon nicht entworfen haben, wollen wir ihn wenigstens verstehen. Dazu versuchen wir die Entwicklung der Zustände des 3-Qubit Systems Schritt für Schritt anhand eines Zustandsprotokolls nachzuvollziehen. Dazu konstruieren wir uns eine Tabelle, die im Wesentlichen die 8 Koordinaten  eines 3-Qubit als Spalten hat. Jede Zeile steht für einen Schritt im Algorithmus. Der jeweilige Schritt wird in der Zeile links symbolisch dargestellt. Rechts ist noch Platz für eventuelle Erläuterungen oder Hinweise. Die Zustandskoordinaten der Qubits q2, q1 und q0 werden mit (r,s), (u,v) bzw. (x,y) benannt. Wir wollen das erste Beispiel oben nachvollziehen, beginnen also mit dem X-Gate auf q0.

(r,s)⊗(u,v)⊗(x,y) rux ruy rvx rvy sux suy svx svy Koordinaten (q2,q1,q0)
Ket- / Messbits 000 001 010 011 100 101 110 111 Kets / Messwerte (f1, d1, c1)
Dezimal 0 1 2 3 4 5 6 7 Binär-Werte
q0: X(1,0)=(0,1) 1 q1, q2 sind (1,0)
q1: H(1,0) 1/√2 1/√2 Hadamard q1 ->1/√2(1,1)
CNOT q1->q2 1/√2 1/√2
CNOT q0->q1 1/√2 1/√2
q0: H 1/2 -1/2 1/2 -1/2 Hadamard q0 ->1/√2(1,-1)
Messung (und Transfer) 010 011 100 101 Häufigkeit ca 25%
q2: If d1==1 X 1/2 -1/2 1/2 -1/2 Bedingtes X-Gate
q2: If c1==1 Z 1/2 1/2 1/2 1/2 Bedingtes Z-Gate
Messung 100 101 110 111 q2 liefert immer 1

(Die leeren Felder stehen für 0, bzw. 0 Häufigkeit bei Messungszeilen.)

Wir haben damit am Ende nicht nur die konsistenten Messergebnisse, sondern auch den separierbaren 3-Qubit Zustand (0,1)⊗(1/√2,1/√2)⊗(1/√2,1/√2) mit q2 im Zustand (0,1). Auf ähnliche Weise kann man auch die Teleportation anderer q0-Zustände entwicklen.

Im nächsten Abschnitt werden wir uns mit einem Orakel beschäftigen und einem Algorithmus, der exemplarisch für den Beschleunigungseffekt des "Quanten-Parallelismus" steht. Doch zunächst die Ergänzung der Begriffstabelle und eine Pause.

Hier geht's dann weiter - stay tuned!

Begriff englisch Begriff deutsch Bedeutung
Barrier Barriere Senkrechte, gestrichelte Linie in Composer-Circuit zur Abtrennung von Optimierungsbereichen. Hier nur als Strukturierung verwendet
Necessary condition Notwendige Bedinung In "wenn A, dann B":  B ist notwendig für A. Zwangsläufige Folge
Sufficient condition Hinreichende Bedingung In "wenn A, dann B": A ist hinreichend für B
Reversibility method Umkehr-Verfahren Methode, das Vorliegen eines Qubit-Zustands zu prüfen unter Verwendung der prinzipiellen Umkehrbarkeit von Qubit-Operationen
No-Cloning Theorem No-Cloning Theorem Generelles Prinzip, dass Qubits nicht geklont werden können
State protocol Zustandsprotokoll Schematische Darstellung der Zustandsabfolge eines Qubit-Algorithmus
Quantum parallelism Quanten-Parallelität Bei Superpositionen wirkt ein Gate auf alle Komponenten der Basis-Zustände "parallel"

 

 


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:

Der "Quanten-Würfel" und ein Ergebnis 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:

3-Qubit-Verschränkung: W-Zustand Algorithmus für n=3 - Composer-Darstellung

(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

 


Q10 Qubit-Algorithmen - Hinter die Kulissen geschaut

"Hinter die Kulissen schauen" - das heißt, die Effekte der Zwei- und Mehr-Qubit Algorithmen durch Zustandsübergänge zu erklären. Das ist, zugegeben, nicht ganz so einfach wie bei herkömmlichen Algorithmen, bei denen wir die Variablen - als Pendant zu den Qubits - einfach setzen, verrechnen und zu jeder Zeit "ansehen" können (print).

In Q9 hatten wir die Darstellung von Qubit-Zuständen für 2-Qubit Systeme eingeführt - in Form von Vierer-Koordinaten und, alternativ, in Ket-Schreibweise. Damit können wir nun einige elementare Qubit-algorithmische Komponenten nachvollziehen. In Q9 hatten wir eine Reihe von Circuit-Beispielen grafisch erstellt und vom IBM Qubit-Simulator ausführen lassen. Einige davon wollen wir anhand der Zustandsübergänge untersuchen und so erklären, wie es zu den Messergebnissen kommt. Besonders interessiert uns natürlich das Phänomen der Verschränkung und, was es mit dem Kick-back auf sich hat.

Zwei-Qubit-Zustände können durch vier Koordinaten (w, x, y, z) dargestellt werden, die   |w|²+|x²|+|y|²+|z|²=1 erfüllen. Also Punkte auf einer Art 4-dimensionalem Einheitskreis.

Wenn der Zustand aus einer Kombination von zwei Qubit-Zuständen, sagen wir (u,v) und (x,y), entsteht, dann sind die vier Koordinaten durch (u,v)⊗(x,y) = (ux, uy, vx, vy) bestimmt. Die Reihenfolge ist übrigens nicht vertauschbar! Und wir hatten per Circuit-Simulation und Nachrechnen schon gesehen, dass nicht jeder 2-Qubit-Zustand sich aus zwe 1-Qubit-Zuständen zusammensetzt (Verschränkung).

Zustände und Gates

Wir hatten schon in Q7 gesehen, dass man die 1-Qubit-Gates X und H durch die Koordinaten (x,y) eines Zustands ausdrücken kann:

X(x,y) = (y,x)  und  H(x,y) = 1/√2(x+y,x-y)

Ry hat einen Parameter, θ, der einen Drehwinkel beschreibt. Daher ist nicht Ry ein Gate sondern Ry(θ). Angewendet auf den Zustand (x,y), den man auch mittels seines Winkels auf dem Einheitskreis als (cos(α),sin(α)) ausdrücken kann, wirkt Ry(θ) auf (x,y) als "Bewegung" auf dem Einheitskreis um θ/2. Als Formel also

Ry(θ)(x,y) = (cos(α+θ/2),sin(α+θ/2))

(Das θ/2 ist wieder nötig, weil der Ry-Paramter eine andere Bedeutung hat als der Drehwinkel auf unserem Einheitskreis.) Man kann das immer überprüfen durch Tests mit einfachen Composer-Circuits.

Aber was ist mit dem CNOT Gate, dass ja zwei Qubit-Zustände "verknüpft"? Nehmen wir wieder (u,v)⊗(x,y) = (ux, uy, vx, vy) als generelles Beispiel. Dann ist

CNOT angewendet auf (u,v)⊗(x,y) = (ux, vy, vx, uy)

d.h. die 2. und 4. Koordinate werden vertauscht. Aber wie können wir das begründen? Und welcher von beiden ist der "controlling" (steuernde) Qubit-Zustand und welcher der "controlled" (gesteuerte)? Wir überprüfen das mit dem Effekt auf die Basiszustände in Koordinatendarstellung. Wir erinnern uns dennoch, dass (1,0) dem Ket |0> entspricht und (0,1) dem Ket |1>.

(0,1)⊗(1,0) = (0, 0, 1, 0) ---> CNOT ---> (0, 0, 1, 0) = (0,1)⊗(1,0)  gleich
(0,1)⊗(0,1) = (0, 0, 0, 1) ---> CNOT ---> (0, 1, 0, 0) = (1,0)⊗(0,1)  ungleich

(1,0)⊗(1,0) = (1, 0, 0, 0) ---> CNOT ---> (1, 0, 0, 0) = (1,0)⊗(1,0) gleich
(1,0)⊗(0,1) = (0. 1, 0, 0) ---> CNOT ---> (0, 0, 0, 1) = (0,1)⊗(0,1) ungleich

Die Zustände der beiden Qubits bleiben nach CNOT gleich, wenn der zweite Zustand (rechts) (1,0) ist. Das entspricht dem Ket |0>. Der linke Zustand ändert sich, wenn der rechte (0,1) ist, was dem Ket |1> entspricht. Der rechts vom ⊗ stehende Zustand verändert sich in keinem Fall. Damit ist klar, dass der Zustand von q0 im Circuit 7 (Control Qubit) in der Formel rechts stehen muss, und der von q1 (Controlled Qubit) links im ⊗-Ausdruck. Merkregel: Das passt zu den Bit-Ketten, die beim Messen der Circuits geliefert werden: von q0 ganz rechts bis q4 ganz links.

Nur zur Übung hier die vierte Zeile "übersetzt" in die Ket-Schreibweise.

|0>⊗|1> = |01> = 0*|00>+1*|01>+0*|10>+0*|11>
---> CNOT
---> 0*|00>+0*|01>+0*|10>+1*|11> =|11> = |1>⊗|1>
das q1 hat seinen Zustand von |0> auf |1> geändert, da q0 den Zustand |1> hat.

Wer Lust hat, kann die anderen CNOT-Transformationen ebenfalls in Ket-Schreibweise versuchen. (Die Kommentare unten werden gelesen!)

Verschränkte Qubits

Hier noch einmal der Circuit 7, der uns eine Verschränkung der Qubits q0 (obere Leitung) und q1 (untere Leitung) bescherte. Bisher konnten wir nur die Messergebnisse interpretieren. Mit den Formeln für H und CNOT können wir den verschränkten 2-Qubit Zustand bestimmen.

Die Ausgangszustände der beiden Qubits sind (1,0). Wenn H auf q0 angewendet wird, bekommen wir 1/√2(1,1) nach der Formel oben. Das CNOT müssen wir daher mit diesem Zustand als Control auf den Zustand von q1 anwenden, d.h. (1,0) steht links vom ⊗:

(1,0)⊗(1/√2,1/√2) = (1/√2, 1/√2, 0, 0) ---> CNOT ---> (1/√2, 0, 0, 1/√2)  = ???

Das Ergebnis von CNOT ist 1/√2(1,0,0,1) und das ist, wie wir in Q9 gesehen haben, nicht separabel, d.h. in zwei einzelne Qubit-Zustände zerlegbar.

Im Beispiel 2 des vorigen Blogs (Q9) hatten wir die Variante mit einem X-Gate auf der q1-Linie, vor dem CNOT, diskutiert. In der vorausgegangenen Rechnung würde daher ganz links ein (0,1) stehen, statt (1,0). Was wäre dann hier der Zustand bei Messung? Und ist der separabel oder verschränkt?

Kick-back Qubit 0

Im Blog Q9 hatten wir mit Beispiel 6 einen überraschenden Effekt, der als Kick-back bezeichnet wird. Der Algorithmus im Composer-Format sah so aus:

Die Messungen ergeben 01 und 11 zu je etwa 50%.

Wir versuchen das mittels der Abfolge der Zustände, die wir ja theoretisch berechnen können, zu verstehen. Wir verwenden dazu die Koordinaten-Darstellung der Zustände.

Qubit q0 beginnt im Zustand (1,0) und wird per H in (x,y) = 1/√2*(1,1) überführt. Qubit q1 beginnt im Zustand (1,0) und wird von X in (0,1) überführt. Darauf wird H angewendet, das nach der Formel oben den Zustand von q1 in (u,v) = 1/√2*(1,-1) überführt. Das 2-Qubit System hat damit den zusammengesetzten Zustand

(u,v)⊗(x,y) = (ux, uy, vx, vy) = 1/2*(1, 1, -1, -1)
---> CNOT   (Vertauschen der zweiten und vierten Koordinate)
---> 1/2*(1, -1, -1 ,1) = 1/√2*(1,-1)⊗1/√2*(1,-1)

Nun überführt H, auf q0 im Zustand 1/√2*(1,-1) angewendet, q0 in (0,1). Qubit q1 bleibt in 1/√2*(1,-1). Wir stellen damit fest:

  • Der 2-Qubit Zustand ist nicht verschränkt. Beide Qubits sind separat messbar.
  • Messung von q0 liefert immer 1, Messung von q1 liefert 0 und 1 zu 50%. Damit erwarten wir die 2-Qubit Zustände 01 und 11 zu 50%.

Das controlled Qubit hat damit eine Rückwirkung (Kick-back) auf das q0. Es kehrt den Zustand von q0 zu (0,1) um, obwohl HH(1,0) = (1,0) zu erwarten wäre. Wir werden das Kick-back später in einem komplexeren Algorithmus geschickt einsetzen. (Zur Übung lohnt es sich, diese Rechnung auch in Ket-Form durchzuführen.)

Mehr Gates, mehr Qubits

Bisher haben wir folgende Gates und ihre Formeln für die Zustandsüberführung kennen gelernt: Das X, H und Ry für 1-Qubit Zustände, sowie ein "Reset"-Gate, das im Composer schlicht als |0> gekennzeichnet wird.  Damit kann man im Verlauf der Zustandsentwicklung ein Qubit auf den Ausgangszustand zurücksetzten.

Das Instrumentarium der Qubit-Algorithmik enthält noch eine Reihe von weiteren Gates, die auch in einem Circuit eingesetzt werden können. Einige davon, die wir in unseren Blogs gebrauchen können, sind hier kurz erklärt. Wer Lust hat kann deren Wirkung unmittelbar in einfachen Circuits einmal ausprobieren - dabei ist aber zu beachten, dass verschiedene Zustände durchaus das gleiche Messergebnis liefern können.

  • Y-Gate: Hat für unsere Zwecke die gleiche Wirkung wie X.
  • Z-Gate: Überführt 1/√2*(1,1) in einem Schritt in 1/√2*(1,-1), und umgekehrt. Für diese beiden Zustände gibt es übrigens ein besonderes Ket-Symbol: |+> und |->. Es ist offensichtlich, welches Ket welchen Zustand kennzeichnet. Das Z-Gate überführt also |+> in |->. Klingt etwas exotisch, ist aber oft eine ganz praktische "Abkürzung". Beide Zustände liefern natürlich das gleiche Messergebnis, daher kann man die Wirkung von Z nicht unmittelbar an der Messung ablesen.
  • ID-Gate: Typisch Mathematik bzw. Informatik, es gibt immer auch eine Operation, die nichts verändert.
  • Zwei-Qubit Gates:
    • Swap-Gate, symbolisiert durch die zwei X, die übereinander stehen und mit einer senkrechten Linie verbunden sind: Vertauscht die Zustände der beiden betroffenen Qubits
    • cH, controlled H-Gate: Analog zum CNOT führt es H für das controlled Qubit aus, wenn das controlling Qubit im Zustand |1> ist.
    • Controlled Z-Gate, symbolisiert durch die zwei mit einem senkrechten Linie verbundene Punkte:  Analog zum CNOT führt es Z für das controlled Qubit aus, wenn das controlling Qubit im Zustand |1> ist.
  • Das Tofoli-Gate ist ein 3-Qubit Gate. Um das zu verstehen müssen wir zunächst unsere Zustandsbeschreibungen auf 3-Qubit Zustände erweitern.

Das machen wir gleich im Anschluß, ohne große Pause. Wir holen uns nur schnell einen Kaffe oder ein stilles Wasser. Dann gehts hier weiter.

Hier noch ein paar neue Begriffe aus diesem Anschnitt in Fortführung der tabellarischen Übersicht.

Begriff englisch Begriff deutsch Bedeutung
CNOT-Gate CNOT-Gatter Controlled NOT - CNOT verknüpft zwei Qubits. In Abhängigkeit vom Zustand des einen Qubits ändert sich der des anderen.
Control Control Qubit, dessen Zustand beim CNOT Gate den des anderen "steuert"
Controlled Controlled Qubit, dessen Zustand beim CNOT Gate durch den des anderen "gesteuert" wird.
Y, Z, ID Y, Z, ID Weitere 1-Qubit Gates
2-Qubit Gates 2-Qubit Gates Gates, die sich über zwei Qubits erstrecken
Swap-Gate Swap-Gatter 2-Qubit Gatter, vertauscht die Zustände zweier Qubits
cH-Gate cH-Gatter Controlled H-Gate, analog CNOT für H
cZ-Gate cZ-Gatter Controlled Z-Gate, analog CNOT für Z
Tofoli-Gate Tofoli-Gatter Ein controlled 3-Qubit Gate. Eine Art Erweiterung des CNOT auf 2 steuernde Qubits.
|+>, |-> |+>, |-> Ket-Bezeichnung für 1/√2(1,1) bzw. 1/√2(1,-1)

 


Q9 Verschränkung und andere 2-Qubit Phänomene

Der Einsatz des CNOT Gates in Q8, Beispiel 7 (Circuit 7), führte zu einem überraschenden Ergebnis im Vergleich zu den vorausgehenden 2-Qubit Circuits. Es gibt von den sonst möglichen vier 2-Bit Messergebnissen nur die Ergebnisse 00 und 11 aus. Die beiden Qubits sind scheinbar "gleichgeschaltet". Man bezeichnet dieses Phänomen in der Qubit-Welt auch als Verschränkung (entanglement). Warum, das wird weiter unten noch genauer erklärt.

Es drängen sich eine ganze Reihe von Experimenten mit Varianten von Circuit 7 auf, von denen wir uns einige ansehen wollen. Wir werden dabei nicht immer die Composer-Grafik dazu einfügen. Wer Lust hat, kann sich das Bild dazu aufmalen. Noch besser und spannender wäre es, die 2-Qubit Circuits nicht nur zu diskutieren, sondern selbst mit dem IBM Q Experience Simulator auszuprobieren. Der Zugang ist, wie gesagt einfach und in einem eigenen Blog kurz beschrieben, und das Erstellen und Testen im Composer ist ebenfalls "Drag&Drop"-leicht.

2-Qubit Circuits

Circuit 7 (Beispiel 7 in Q8)

Hier zunächst noch einmal die Ausgangsgrafik des "Circuit 7", der 00 und 11 mit der Häufigkeit 0.5 liefert.

1. Was würde passieren, wenn wir vor das H-Gate noch ein X einfügen würden? Einfache Überlegung: Der Startzustand |0> von q0 würde zunächst in |1> verändert. H angewendet auf |1> ergibt 1/√2 (|0>- |1>) (s. Q8, Beispiel 6). Der Unterschied zu Circuit 7 ist also das Minus-Zeichen. Nach CNOT mit q1 macht das aber keinen Unterschied im Messergebnis, denn die Häufigkeiten von 0 und 1 entsprechen dem Quadrat der Koeffizienten. Und (-1/√2)² ist das Gleiche wie (1/√2)². Damit erwarten wir das gleiche Ergebnis wie bei Circuit 7. Das Simulationsergebnis bestätigt dies.

2.  Was wäre, wenn X auf q1 vor CNOT angewendet würde? Dann ist q1 vor CNOT im Zustand |1>. Für q0 im Zustand |1> ändert sich dann q1 zu |0>, sonst bleibt es |1>. Wie demnach zu erwarten, liefert die Messung nun 01 und 10 zu je rund 50%. Wir haben hier also einen Circuit der "Ungleichschaltung". Wenn wir bei einem Qubit z.B. eine 0 messen, wissen wir, dass das andere 1 ergeben muß. Und umgekehrt. Wir haben hier also auch eine Form der Verschränkung.

3. Was ist ausschlaggebend für das Verschränkungsphänomen? Ist es das H-Gate? Was ein X-Gate zusätzlich bewirkt, bei q0 oder q1, haben wir schon gesehen. Versuchen wir es mal mit anderen Gates und testen das mit dem Simulator. Bleiben wir zunächst bei Qubit 0 und ersetzen das H durch X bzw. durch unsere Rotation Ry.

Ersetzen wir H durch X, können wir das Ergebnis einfach vorhersagen: X verkehrt den Ausgangszustand, also ist q0 bei CNOT im Zustand |1>, damit wird q1 umgekehrt, also |1>. Wir bekommen determiniert das Ergebnis 11 bei 100% der Messungen.

Ersetzen wir H durch Ry mit dem Gate-Parameter π/3, dann wird der Startzustand von q0 im x-y-Koordinatensystem um 30º gedreht.

 

Als Simulatorergebnis (1024 shots) bekommen wir: 74% 0000,   26% 0011.

D.h. wir finden wieder eine "Gleichschaltung" der Zustände wie in Circuit 7, allerdings mit einer anderen Häufigkeitsverteilung. Die entspricht der Häufigkeitsverteilung bei einer 1-Qubit Anwendung von Ry(π/3)  in Q8, Beispiel 3b. Offenbar ist das Vorliegen einer Superposition für q0 ausschlaggebend für Verschränkung. Wir werden später sehen, ob die Vermutung stimmt.

4. Nun zu q1. Was passiert, wenn wir q1 in eine Superposition versetzen, z.B. mittels H.

Als Simulationsergebnis bekommen wir hier eine Häufigkeitsverteilung über alle 4 Möglichkeiten. Z.B.:

Bit-Ergebnis H Ry(π/3)
0000 26% 36%
0001 25% 11%
0010 23% 13%
0011 26% 40%

Setzen wir statt H die Rotation Ry(π/3) ein, ergibt sich das enstprechende Bild (rechte Spalte) zu rund 3/8, 1/8, 1/8, 3/8.

Die beiden Beispiele zeigen offenbar keine Verschränkung, sondern eine  Verteilung über alle 4 möglichen Messergebnisse. Wenn wir aufgrund der Experimente mit den Varianten eine Vermutung anstellen wollten, dann die, dass CNOT eine Verschränkung (ob gleich oder ungleich geschaltet) nur dann liefert, wenn eines der Qubits  in einem Basiszustand ist. Wir werden diese Vermutung weiter unten "rechnerisch"  untersuchen.

5. Bisher haben wir zusätzliche Gates immer vor das CNOT geschaltet. Was ist, wenn wir das im verschränkten Zustand tun?  Die einfachste Variante ist, ein X-Gate nach dem CNOT auf die q1-Leitung zu setzen. Also so:

Was würde man erwarten? Vor dem X-Gate ist der Zustand des 2-Qubit-Systems verschränkt bzgl. 00 und 11. Danach findet man als Messergebnis die "Umkehrung", 01 und 10. Das gleiche finden wir, wenn wir das X-Gate auf q0 setzen. Schalten wir dagegen für beide Qubits ein X-Gate nach, bleibt das Ergebnis 00 und 11 zu je 50%.  Macht man die gleichen Tests mit dem H-Gate anstelle des X-Gate, bekommt man - und das ist nicht mehr ganz so überraschend - bei einem H-Gate jeweils eine Verteilung über alle 4 Möglichkeiten, bei H auf beiden Wires wiederum das Ergebnis 00 und 11 zu je 50%.

Es sei betont, dass wir immer nur die Messergebnisse sehen. Was mit den Zuständen passiert, können wir erst untersuchen, wenn wir ein formale Beschreibung für Systeme aus zwei oder mehr Qubits haben.

6. Ein algorithmisches Beispiel kann uns aber doch noch überraschen. Es ist gleichzeitig ein ziemlich wichtiger Baustein für Qubit-Algorithmen. Das Schaltbild dazu ist

Das Ergebnis ist - 01 und 11 zu je 50%! Das scheint zu keinem der bisherigen Ergebnisse zu passen. Ohne das nachgeschaltete H-Gate für q0  bekommen wir, wie zu erwarten, das Ergebnis von Beispiel 4, also alle vier Ergebnismöglichkeiten zu 25%. Abgesehen davon, wissen wir, dass H, zweimal hinternander auf |0> angewandt, wieder |0> ergbit.

Es würde uns jetzt nicht wundern, wenn es auch eine Circuit-Variante gibt, die 00 und 10 liefert. Richtig, ohne das X-Gate, also die initiale Umkehrung des Startzustands von q1! Wenn wir beides zusammen betrachten, sieht es so aus, als ob das Ergebnis von Qubit q0, das rechte der zwei Bits, durch q1 umgeschaltet. Durch das CNOT sollte aber doch eigentlich q0  das q1 beeinflusst. Trotzdem, dieser Effekt ist korrekt und hat den schönen Namen (phase) kickback - das von q0 gesteuerte q1 "schlägt zurück". (Wir werden davon in Q15 interessanten Gebrauch machen.)

Es gibt noch zwei weitere Ergebnisse ähnlicher Art, nämlich 00 und 01 zu 50% und 10 und 11 mit je 50%. Es ist interessant zu versuchen, 2-Qubit Circuits zu konstruieren, die diese Ergebnisse liefern. Wer Lust hat, möge das mit dem IBM Composer ausprobieren.

2-Qubit Zustände

Um das zu verstehen, müssen wir uns mit den "Formeln" für Zwei- und Mehr-Qubit-Systeme befassen. Zunächst mal für 2-Qubit-Systeme,  auch 2-Qubit-Register genannt, in Anlehnung an das Bit-Register, der zentralen Komponente eines herkömmlichen (Bit-)Prozessors.

Wir erinnern uns, dass wir Qubit-Zustände als Punkte auf dem Einheitskreis im x-y-Koordinatensystems beschreiben können. Also z.B. (x,y) = (1/√2, -1/√2). Eine etwas andere Schreibweise, die häufig verwendet wird aber das Gleiche bedeutet, ist die, einen Qubit-Zustand als Kombination der Basis-Zustände (1,0) und (0,1) zu schreiben, für die außerdem  die (aus der Quantenphysik stammenden) Symbole |0> und |1> verwendet werden. Das mag verwirren; es ist aber manchmal leichter einen Qubit-Zustands-Sachverhalt mal in der einen oder der anderen Form zu beschreiben. Man mache sich klar, dass (x,y) und x*(1,0)+y*(0,1) und x*|0>+y*|1> das Gleiche ausdrücken. Aus historischen Gründen nennt man diese Schreibweise die Ket-Schreibweise - statt z.B. "Rechts-Spitzklammer"-Schreibweise - und nennt ein Symbol |a> für einen Qubit-Zustand ein ket, bzw. ket-a.

Was ist nun der Zustand eines 2-Qubit-Systems? Eigentlich nur die Kombination von zwei Qubit-Zuständen nach der Methode "jeder mit jedem". (Wem das zu unmathematisch klingt, kann sagen, es ist das Tensorprodukt der beiden.) Haben wir also ein Qubit q0 im Zustand (u,v) und q1 im Zustand (x,y), so ist der Zustand des 2-Qubit-Systems (ux, uy, vx, vy). Er besteht also aus 4 Koordinaten, die sich aus der Multiplikation der Koordinaten der beiden Qubit-Zustände ergibt. Hier sind einige übliche Schreibweisen, an die man sich wohl gewöhnen muß - es steckt aber immer das Gleiche dahinter:

(u,v)⊗(x,y) = (ux, uy, vx, vy)

oder, wenn wir in der Ket-Schreibweise den Zustand  von q0 mit |a> und den von q1 mit |b> symbolisieren

|a>⊗|b> = (ux, uy, vx, vy), wenn wir |a>=u*|0>+v*|1> und |b>=x*|0>+y*|1> für die Zustände von q0 und q1 schreiben.

Wenn man den 2-Qubit-Zustand so beschreibt, stellt man fest, dass erfreulicherweise die 4 Koodinaten wieder auf einem 4-dimensionalen "Einheitkreis" liegen. Das ist schwer vorzustellen, aber einfach als Formel auszudrücken:

|ux|²+|uy|²+|vx|²+|vy|² = 1

Da die Einzel-Zustände auf dem "normalen" Einheitskreis liegen, also |u|²+|v|²=1 und |x|²+|y|²=1, ergibt sich das einfach durch Ausrechnen von (|u|²+|v|²)* (|x|²+|y|²).

Wir konstruieren uns einige Beispiele und zeigen sie in der Tabelle in Koordinatenform. In der rechten Spalte ist das jeweilige 2-Zustands-Messergebnis dargestellt, also das, was wir z.B. bei den Messungen entsprechender 2-Qubit Circuits erwarten können.

Koordinaten Koordinaten Messung
q0 q1 2-Qubit-Zustand 2-Bit Ergebnis : Häufigkeit
(1,0) (1,0) (1,0,0,0) 00: 1.0
(1,0) (0,1) (0,1,0,0) 01: 1.0
(0,1) 1/√2*(1,1) 1/√2*(0,0,1,1) 10: 0.5  11: 0.5
(u,v) (x,y) (ux,uy,vx,vy) 00: |ux|²  01: |uy|²  10: |vx|²  11: |vy|²

Zum Vergleich - und zur Gewöhnung - schreiben wir die Tabelle noch einmal in Ket-Schreibweise. (Die Messergebnisse sind die gleichen.)

q0 - Ket q1 - Ket 2-Qubit-Zustand - Ket
|0> |0> 1*|00>
|0> |1> 1*|01>
|1> 1/√2*(|0>+|1>) 1/√2*(|10>+|11>)
u|0>+v|1> x|0>+y|1> ux|00>+ uy|01>+ vx|10> + vy|11>

Etwas fällt vielleicht noch auf: die Kets mit zwei Ziffern, etwa |01>. Das ist einfach wieder eine abkürzende Schreibweise für |0>⊗|1>, also die Kombination von zwei Qubit-Zuständen (in Ket-Schreibweise) zu einem 2-Zustands-Ket.

Die Ket-Schreibweise erleichtert bei Zwei- und Mehr-Qubit-Zuständen die Sicht auf die Messergebnisse. Der Operator M, auf einen allgemeinen 2-Qubit-Zustand (w, x, y, z) angewendet liefert die Wahrscheinlichkeiten |w|², |x|², |y|², |z|². Aber was ist was? Man kann sich merken, dass |w|² für Bitfolge 00 der Messung, |x|² für 01 usw. gilt. Schreibt man den Zustand in Ket-Form, dann sieht man es sofort. Denn (w,x,y,z) = w|00> + x|01> + y|10> + z|11>. Damit ist, bei 2-Qubit-Zuständen,

M(w,x,y,z) = ( |w|², |x|², |y|², |z|²)

eine "theoretische Formel" für den Messvorgang. Gemessen wird der Zustand, das Ergebnis (rechts) sind Wahrscheinlichkeiten für die 2-Bit-Folgen. Man hat hiermit also eine Verknüpfung zwischen Qubits und klassichen Bits.

Um Verwirrung zu vermeiden, werden wir allerdings im Weiteren vorzugsweise die Koordinaten-Schreibweise verwenden.

Verschränkte 2-Qubit-Zustände

Im Prinzip kann man alle Punkte im 4-dim Koordinatensystem, die als Summe ihrer Quadrate 1 ergeben, als 2-Qubit-Zustände betrachten. Bei Messungen ergäben sich aus solchen Zuständen die Quadrate der Koordinaten als Häufigkeitsverteilung über die vier möglichen (Bit-) Messergebnisse 00, 01, 10, 11. D.h. beliebige 4 Zahlen (w, x, y, z) mit |w|²+|x²|+|y|²+|z|²=1 ergeben einen zulässigen 2-Qubit-Zustand.

Allerdings, nicht jeder Zustand in dieser Form lässt sich - wie oben - aus den Zuständen von zwei Qubits herstellen! Das ist verblüffend, aber lässt sich leicht überprüfen.

Circuit 7, oben, lieferte als Messung 00 und 11 mit Häufigkeit 0.5, und 01 bzw 10 mit Häufigkeit 0. Wenn der (unbekannte) 2-Quibt-Zustand, der zu dieser Messung führt, eine Kombination (u,v)⊗(x,y) = (ux, uy, vx, vy) von zwei Qubits wäre, müssten |ux|² = |vy|² = 0,5 sein und gleichzeitig |uy|² = |vx|² = 0. D.h. einerseits müssen u,x,v und y ungleich Null sein, andererseits müssen u oder y, sowie v oder x Null sein. Das ist offensichtlich ein Widerspruch.

Der Zustand, der in Circuit 7 gemessen wird, ist damit ein zulässiger und herstellbarer 2-Qubit-Zustand. Er kann aber nicht aus zwei Qubits zusammengesetzt werden, oder, anders ausgedrückt, er ist nicht separierbar. Das System aus zwei Qubits, das in einen nicht-separierbaren 2-Qubit-Zustand überführt wird, ist verschränkt. Das ist es, was dahinter steckt! Man mag nun selber überprüfen, welche der Circuits oben ebenfalls verschränkte Zustände liefern. (Wer Lust hat - der Kommentar-Bereich steht offen.)

Eine Konsequenz der Verschränkung ist, dass man nicht von den Zuständen der beiden Qubits sprechen kann. Im eigentlichen Sinne haben sie keinen Zustand. Allein das Gesamtsystem hat einen Zustand. Insofern kann man auch nur das Gesamtsystem messen, nicht die "involvierten" Qubits.

Die Wirkung von Gates

Mit Hilfe der Zustandsbeschreibungen können wir nun auch die Wirkung von Gates "berechenbar" machen. D.h., obwohl wir sie nicht per Messung verfolgen können, lässt sich die Abfolge der Zustände rechnerisch darstellen.

Das machen wir im nächsten Blog-Beitrag; denn jetzt haben wir uns spätestens eine Pause verdient, bei der wir entspannt noch mal über alles nachdenken können.

Hier geht's dann anschließend weiter.

Stay tuned!

Hier noch ein paar neue Begriffe aus diesem Anschnitt in Fortführung der tabellarischen Übersicht.

Begriff englisch Begriff deutsch Bedeutung
Entanglement Verschränkung Nicht separierbarer Gesamtzustand eines 2-Qubit Systems
Separable Separierbar 2-Qubit-Zustand, der sich aus zwei Qubit-Zuständen zusammensetzem lässt.
Register Register System von zwei oder mehr Qubits auf dem algorithmische Operationen ausgeführt werden
Ket Ket Zweite Silbe von Bra-cket. Schreibweise für Qubit-Zustände
Symbol ⊗ Symbol ⊗ Symbolisiert die Kombination von zwei Qubit-Zuständen zu einem Gesamtzustand.
|00>, |01> etc |00>, |01> etc Kurzschreibweise für |0>⊗|0>, |0>⊗|1>usw.
(Phase) Kickback (Phase) Kickback Spezielle Rückwirkung zwischen CNOT verbundenen Qubits

 

 


Q8 Fingerübungen - Einfache Qubit Algorithmen ausprobiert

Wir wissen nun, was ein Qubit ist. Genauer, wie man ein Qubit modellieren kann - aber wir wollen uns ein wenig sprachliche Vereinfachung zugestehen, solange wir uns darüber im Klaren sind. Fassen wir noch einmal zusammen:

Ein Qubit ist ein Konstrukt, das einen Zustand hat, der durch Operatoren  beeinflusst wird, und der über ein Messverfahren einen binären Wert liefert (Bit). Der Zustand ist aus einer kontinuierlichen (unendlichen) Menge.  Wiederholte Messungen bei gleichem Zustand liefern eine Häufigkeitsverteilung über die binären Werte, die man als Wahrscheinlichkeitsverteilung dem Zustand zuordnen kann.

Wir legen fest, dass die Operatoren den Zustand determiniert beeinflussen, mathematisch also eine Abbildung darstellen. D.h. gleicher Operator angewendet auf gleichen Zustand liefert gleiches Ergebnis (neuer Zustand). Für das Messverfahren gilt das natürlich nicht. Wohl aber für die Zuordnung der Wahrscheinlichkeitsverteilung zu einem Zustand.

In diesem Sinne ist ein klassisches Bit auch ein Sonderfall eines Qubits. Wieso?

Für die konkrete Beschreibung von Qubits verwenden wir (einfache) mathematische Ausdrücke: Die Zustände beschreiben wir durch die Koordinaten (x,y) eines Punktes auf dem Einheitskreis in der x-y-Ebene. Die binären Messwerte bezeichnen wir mit 0 und 1. Für die Punkte, die einen Zustand repräsentieren, verwenden wir gelegentlich "Namen" anstelle der Koordinaten; das macht manchmal das Lesen einfacher. Insbesondere sind folgende Bezeichnungen in der Qubit-Welt üblich: |0> für (1,0), |1> für (0,1) - also für die Punkte des Einheitskreises, die auf den positiven Koordinatenachsen liegen. (Diese Zustände hatten wir beim ZBIT-Modell mit [00] und [11] bezeichnet. Die etwas ungewöhnliche | >-Schreibweise erklären wir später. ) Damit kann man einen Zustand (x,y) auch als Kombination von |0> und |1> schreiben:  x|0> + y|1>.

Ein typischer Sprachgebrauch in der Qubit-Welt ist z.B. "das Qubit |1>" an Stelle von  "das Qubit im Zustand |1>".  Kein Problem, wenn klar ist, was gemeint ist. "Namen" für die Qubits sind wie herkömmliche Variablen-Namen zu verstehen und werden in den Composer-Grafiken links vor die zugehörige Linie gestellt. Sie sind der Einfachheit halber durchnummeriert. Entweder als q0, q1, usw. oder im Stile von Python-Listen als q[0], q[1] usw., also mit eckigen Klammern.

Ein weiterer häufig anzutreffender Begriff für die x-y-Kombination der beiden Basiszustände ist "Superposition", übersetzt als "Überlagerung", von |0> und |1>. Ein leicht mysteriös klingender Begriff für die Kombination der beiden Zustände. Der stammt aus der Physik und wird in der Mathematik übrigens Linearkombination genannt.

Wie wir in Q7 gesehen haben, ist für x|0> + y|1> dann |y|²  die Wahrscheinlichkeit p(1) für den binären Wert 1 bzw. |x|²=1-|y|² die für 0 bei der Messung des Qubits in diesem Zustand.

Man kann damit den Messvorgang, genauer, den wiederholten Messvorgang, auch als einen Operator darstellen, der Zustände (x,y) in Häufigkeiten von Bits überführt:

M(x,y) = M(x|0> + y|1>) = ( |x|², |y|²).

Bei Mehr-Qubit-Zuständen wird das, wie wir sehen werden, eine hilfreiche Darstellung. Wir bezeichnen M nicht als Gate, weil wir Gates für Übergänge von Zustand zu Zustand reservieren wollen, ( |x|², |y|²) aber kein Qubit-Zustand ist, sondern Wahrscheinlichkeiten für Bit-Ergebnisse.

Woher wissen wir, in welchem Zustand sich ein Qubit befindet? Man wählt |0> als Ausgangszustand, herstellbar durch die Operation R. Wenn wir anschließend weitere Operatoren anwenden, liefert jeder einen determinierten Folgezustand. Wenn wir die Wirkung der Operatoren berechnen können, wie in Q7 für X, H usw., können wir die Zustände nachverfolgen, wissen also bei der Messung, welcher Zustand vorliegt - auch wenn die Messung selbst nur ein Bit (0 oder 1) liefert. Dies ist ein wichtiges Prinzip, um Algorithmen für Qubits formulieren zu können.

1-Qubit Beispiele

Das wollen wir im Folgenden für einige erste kleine Beispiele mit einem bzw. zwei Qubit(s) tun und diese gleich auch auf einem Qubit-Computer realisieren.

Für einen Qubit Computer (physikalisch oder als Simulator) müssen wir fordern, dass wir die physikalischen Entsprechungen der Qubit-Operatoren so konstruieren können, dass sie - in wiederholten Messungen -  Häufigkeiten eines binären Ergebnisses liefern, die der Wahrscheinlichkeit von 0 und 1 in dem Operator-generierten Zustand entprechen. Klingt kompliziert, ist es auch. Aber wir machen nichts falsch, wenn wir darauf vertrauen, dass die Quantencomputer-Konstrukteure dafür gesorgt haben.

In Q7 u.a. hatten wir schon einige 1-Qubit Algorithmen in der Form R --- X --- H --- M oder ähnlich formuliert. Diese Schreibweise kommt der grafischen Darstellung im "Composer" (Komponisten) der IBM Q Experience Umgebung schon sehr nahe. Wir probieren es einfach und lassen die "Partitur" vom Simulator ausführen. (Wie man Zugang zur IBM Quantencomputing-Umgebung bekommt, wird in diesem Blog beschrieben. Besser noch, man findet es selbst heraus. Hier ist der Link zum IBM Q Login.) Es ist wirklich zu empfehlen, diese Erfahrung "in echt" zu machen (s. Q2). Statt des Simulators kann man zur Ausführung auch einen der verfügbaren echten Quantencomputer auswählen!

1. R--- X --- H --- M

Algorithmus im Composer-Format
Ergebnis einer Serie von 1024 "Shots"

Das Ergebnis zeigt die Häufigkeiten von 0 und 1 (interpretiert als klassische Bits) bei einer Serie von 1024 Durchläufen.  Die Legende der State-Achse ist für die gleichzeitige Messung von 5 Qubits ausgelegt, daher die 5-stelligen Bit-Ketten. Das Bit rechts kommt aus der Messung des Qubit Nr. 0, dem obersten im Composer, wenn wir mehrere Qubits haben. Dass die Achse mit "state" (Zustand) bezeichnet wird, ist etwas verwirrend. Gemeint ist bestenfalls der "Ausgabezustand".

Nicht ganz zufällig gibt es die hier schon verwendeten Operatoren X und H auch beim Qubit-Composer. Im Qubit-Sprachgebrauch werden die Operatoren Gates genannt, zu deutsch Gatter. Die Gates werden auf Wires (Leitungen) positioniert. Und die "Partitur" wird  in der Qubit-Welt Circuit (Schaltung) genannt. Am Anfang eines Qubit-Wire ist das Qubit auf den Ausgangszustand |0> gesetzt. Das Symbol (Gate) dafür im Composer ist nicht R sondern einfach |0>. Die beiden Gates auf dem Wire von Qubit q[0] heißen X-Gate oder NOT-Gate, weil es den Qubit-Zustand umkehrt,  und Hadamard-Gate (H-Gate), benannt nach dem französichen Mathematiker J. Hadamard. Die Wirkung hatten wir in Q7 bereits formelmäßig definiert.

Als ein anderes Beispiel nehmen wir aus Q7 "Vorhersagen und Erklärungen" die Nummer 8.

2. R ---- G60 ---- H ---- H ---- M

Composer-Bild für Beispiel 8 in Q7
Ergebnis bei 1024 Wiederholungen. Vgl. Q7/8.

Es fällt auf, dass wir bei der QBIT-Box das Dreh-Feld mit G bezeichnet haben, im Composer aber ein neues Gate Ry(2*pi/3) verwendet haben. Mit G hatten wir in Q7 den Dreh-Operator vereinfacht. So wie wir G definiert hatten, entspricht dem das Rotations-Gate Ry mit dem Paramterwert θ=2*pi/3. Man sieht in der Tabelle am Ende von Q7, dass dieses θ dem Winkel w=60º entspricht. (Die Gates in den Composer- bzw. Programmier-Umgebungen orientieren sich an einer anderen Zustandsbeschreibung, die dazu führt, dass der Winkel, den wir für Drehungen auf dem x-y-Einheitskreis definieren, in der Composer-Beschreibung verdopplet werden muss.)

3. R --- G30 --- X --- M vergleichen wir mit R --- G30 --- M, um die Wirkung von X zu verifizieren. Hier müssen wir, wie eben erklärt, für G30 das Gate Ry mit pi/3 parametrisieren. Wir verzichten dabei auf die Histogramme und notieren stattdessen nur die Häufikeiten der Messergebnisse.

a) 30 Grad Drehung und X: 23.633% 0, 76.367% 1
b) 30 Grad Drehung ohne X-Gate: 75.00% 0, 25.00% 1

Man sieht also sehr schön den Effekt eines X-Gates aus der wiederholten Messung: Es vertauscht die Zustandskoordinaten. Für die Basis-Zustände ergibt sich daraus: X: |0> -> |1>, d.h. (1,0) -> (0,1), und umgekehrt. Wir merken an, dass wir hier wieder von den Messergebnissen (Bits) auf den Zustand (Qubit) nach Anwendung der Gates schließen. Die Messergebnisse sind nicht der Zustand!

4. R --- Gw --- M. Das Diagramm der QBIT-Box Experimente in Q7 (blaue Punkte) ist natürlich auf diese Weise (3b) entstanden! Das w durchlief alle Werte von 0º bis 360º (das entspricht θ=2*pi) in 15º-Schritten. Für jedes w wurde ein Cirquit der Form 3b) erzeugt, der jeweils 50 Mal durchlaufen wurde. Die Häufigkeiten von 1 (das entspricht dem L) wurden in die Grafik eingetragen. Das Ganze wurde natürlich in Form eines kleinen (Python-)Programms durchgeführt. Im Kern einer Schleife über die verschiedenen Winkel steht dabei das Python-Pendant zum Composer Circuit:

## Circuit definieren 
q_box = QuantumCircuit(q, c) 
rot = k*2*pi/m 
q_box.ry(rot,q) 
q_box.measure(q[0], c)

Etwas ausführlicher wird das Programm in einem Kommentar zu diesem Blog gezeigt.

2-Qubit Beispiele

Bevor wir uns theoretisch mit Zwei- und Mehr-Qubit Kombinationen befassen, probieren wir einfach einmal ein paar Beispiele mit dem Composer praktisch aus. Wir müßten dazu natürlich auch unsere einfache Schreibweise für Qubit-Algorithmen erweitern, etwa zwei Zeilen untereinander. Das stimmt aber ziemlich genau mit den Composer Grafiken überein, die wir bereits in Abschnitt Q2 erkundet hatten. Daher formulieren wir die kleinen Algorithmen gleich als Circuit.

5. Probieren wir es mal mit

und versuchen zu verstehen, was wohl als kombiniertes Messergebnis herauskommen wird. Der Ausgangszustand von Qubit 0 (q0-Wire) wird mit X zu |1> und dann gemessen. Qubit 1 (q1-Wire) wird sofort gemessen, bleibt also im Zustand |0>. Grundsätzlich gibt es 4 mögliche Messergebnisse, nämlich die vier 2-Bit Kombinationen 00, 01, 10, 11. Das Ergebnis hier ist natürlich 100% 01.

Zur Erinnerung (an Abschnitt Q2): Auf der c-Linie kommen die Messergebnisse an - in Form von klassischen Bits (c für classical). Die 5 deutet an, dass die c-Linie die Ergebnisse von bis zu 5 Qubits aufnimmt (s. Histogram nächstes Beispiel), auch wenn wir hier nur 2 Qubits verwenden.

6. Etwas schwieriger:

Hier wird q0 zunächst geswitcht und dann mit dem Hadamard-Gate transformiert. D.h. |0> wird zu 1/√2 (|0> - y|1>), oder in Koordinaten wie in Q7 zu 1/√2(1,1). Die Wahrscheinlichkeiten für 0 und 1 als Messergebnis sind damit 1/2. Für q1 wird nach H der Zustand 1/√2 (|0>+y|1>) gemessen, was die gleichen Wahrscheinlichkeiten für Qubit 1 ergibt. Was ist also das Gesamtergebnis (1024 "shots")?

 

 

 

 

Hier zählen nur die zwei rechten Bits, so dass also die experimentellen Häufigkeiten um den zu erwartenden Wert 0.25 schwanken. (Die Konvention ist, das Bit-Ergebnis von q0 immer ganz rechts zu schreiben.)

7. Das Hello Qubit World Beispiel aus Q2 sah als "Partitur" so aus:

Hier finden wir nach dem H ein neues Gate, das offenbar zwei Qubits miteinander in Beziehung bringt. Das ist das Controlled-Not-Gate, auch als CNOT oder CX bezeichnet. Es beeinflußt q1 - da, wo das + im Kreis steht - in Abhängigkeit vom Zustand des Qubit q0. Genauer: wenn q0 im Zustand |1> ist, kehrt sich q1 um - hier also von |0> nach |1>. Ansonsten bleibt der Zustand von q1 unverändert, also hier |0>.

Schauen wir uns das Ergebnis an (1024 shots).

Das Histogramm zeigt nur positive Werte für die 2-Bit Messergebnisse 00 und 11, zu jeweils ziemlich genau 50%. Die beiden anderen, 01 und 10, kommen bei Messungen nicht vor.  Das hat verschiedene Konsequenzen, auf die wir später noch eingehen werden. Hier stellen wir erst einmal fest, dass das CNOT-Gate offenbar die beiden Qubits "gleichschaltet". Aber Achtung - nur bezüglich der Messergebnisse! Beide sind nach diesem Circuit entweder 0 oder 1, und was, das bestimmt q0. Um über die Zustände zu sprechen, müssen wir wieder unser Modell bemühen.

Damit können wir das Ergebnis noch besser verstehen: durch das Hadamard-Gate geht der q0-Zustand in die Kombination von |0> und |1> über, jeweils mit Anteil 1/√2. Daher ergibt sich der neue Zustand von q1 nach der CNOT-Regel als Kombination von |0> (unverändert) und |1> (verändert) mit den entsprechenden Anteilen von 1/√2. Und q1 kann nur 0 ergeben, wenn sein Zustand sich nicht geändert hat, also wenn q0 das Ergebnis 0 liefert. Andernfalls hätte sich q1 umgekehrt und würde 1 liefern. Das erklärt - in Worten - warum 01 und 10 nicht als Messergebnis auftreten können. Im nächsten Blog werden wir das "nachrechnen".

Die "Gleichschaltung" der beiden Qubits durch diesen Circuit bedeutet u.a., dass wir wissen können, welchen Messwert das andere Qubit hat, wenn wir nur das eine gemessen haben. Wir können aus einer Messung das Ergebnis beider Messungen erschließen! Das wirkt zunächst einmal ungewöhnlich und führt zu teilweise "geheimnisvollen" Deutungen. Doch davon später.

Ein kleiner Ausflug: Die Wires sind so etwas wie die "Lebenslinien" der beiden Qubit-Variablen q0 und q1. Sie beginnen beide in einem Anfangszustand und "enden" durch Messung. Mit etwas Phantasie kann man auch klassische Algorithmen als Composer Diagramm darstellen.

Pythogoras-Algorithmus in Compser-Form

Zum Beispiel kann man die Berechnung der Hypothenusenlänge nach dem Satz des Pythagoras a²+b²=c² so in Composer-Form darstellen. Dabei sind a,b,c die Variablen, 3 ,4, 0 die Anfangszustände, Q ist die Quadrat-Operation, W die Wurzel, und das Konstrukt in der Mitte mit dem S auf dem c-Wire ist die Summenbildung der Variablen auf den beiden oberen Wires im aktuellen Zustand. Die Messoperation ist hier P, für print. Auch hier "beobachtet" man nur die Anfangszustände und die print-Ausgaben. Noch enger ist die Analogie, wenn man sich das P "destruktiv" vorstellt,  d.h. die Variablen werden nach Ausgabe "gelöscht" oder auf Null gesetzt. Insgesamt also eine schöne Algorithmen-Analogie zum Verständnis der Composer-Diagramme.

An dieser Stelle ist erst einmal wieder eine Pause fällig. Wir haben Beispiele für kleine 1- und 2-Qubit Algorithmen untersucht und mittels Quantencomputer-Simulator praktisch ausprobiert. Außerdem haben wir zwei neue Gates kennen gelernt: als Entsprechung für unser G (Dreh-Feld) bei der QBIT-Box das Ry-Gate und das CNOT, das zwei Qubits verbindet. Und eine ganze Reihe neuer Begriffe, die im Sprachgebrauch der Qubit-Algorithmik verwendet werden. Es ist wieder hilfreich, sich eine tabellarische Übersicht zu machen und im weiteren Verlauf zu ergänzen. Der Anfang sei hier gemacht.

Begriff englisch Begriff deutsch Bedeutung
Composer Composer Tool bzw. Form zur grafischen Darstellung von Qubit-Algorithmen
Circuit Schaltkreis Qubit-Algorithmus
Wire Wire (Leitungen) Algorithmische "Lebenslinie" eines Qubits
Gate Gatter Qubit-Operator in einem Algorithmus
Paramter Parameter Gates wie Ry können eine Parameter haben, z.B. einen Drehwinkel.
|0>, |1>, |a> |0>, |1>, |a> Schreibweise für Qubit-Zustände, alternativ zu Koordinaten
Basis Basiszustand Hier |0> oder |1>
Superposition Überlagerung (Linear-)Kombination von Qubit-Zuständen, meist von |0> und |1>
Hadamard-Gate H-Gatter Spezieller Superpositionsoperator
M Operator M Operator Mess-Operator, berechnet aus Qubit-Zuständen Wahrscheinlichkeiten von Bit-Ergebnissen
Classical Bit Klassisches Bit Messergebnisse werden als Bits / Bit-Ketten ausgegeben
c-Wire c-Wire Wire, das die Messergebnisse aufnimmt (Bit-Ketten)
Initial State Anfangszustand Jedes Qubit beginnt im Zustand |0>
Ry-Gate Ry-Gatter Eine bestimmte Art der Drehung, vergleichbar mit dem G im ZBIT-Modell
shots shots Anzahl Durchläufe eines Algorithmus für Ergebnis-Statistik

 

Bevor es nun weiter geht mit  Mehr-Qubit Registern, werden wir noch einige verblüffende Besonderheiten des Circuits aus Beipiel 7 untersuchen.

Stay tuned! Hier geht's weiter.



Q7 Qubit - Ein Modell für Qubit-Algorithmen

Die gute Nachricht: Das ZBIT-Modell in der x-y-Koordinatendarstellung ist bereits das QBIT-Modell. Allerdings beschränkt auf 8 Zustände. R, X, H und M sind mit ihren Formeln dazu passend definiert. Mehr noch, man kann jeden Punkt (x,y) auf dem Einheitskreis als Zustand gelten lassen und die Operatoren liefern wieder einen gültigen Zustand. Und auch die Doppelt-Anwendung von X und H auf ein (x,y) liefert diesen Zustand wieder. (Wer Lust hat, kann regelrecht nachrechnen, dass HH(x,y) = (x,y) liefert und das gerne ins Kommentarfeld eintragen).

Eine ganze Reihe von Qubit-Algorithmen kann man bereits mit diesem ZBIT-Modell formulieren. Wer daher keine Lust hat, sich mit der Erforschung einer weiteren Box des Großen Experimentators zu befassen, kann daher auch zu Q8 über Qubit-Sprachgebrauch und Multi-Qubit-Modelle übergehen. Die nicht so gute Nachricht: Man verpasst dann die Möglichkeit, (x,y)-Zustände außer den 8 ZBIT-Zuständen zu entdecken. Mit dem ZBIT-Modell können wir keine Zustandsüberführung durchführen, die aus dem 8er-Set herausführt.

QBIT-Box

QBIT-Box bei Zimmertemperatur

Dieses Mal konfrontiert uns der Große Experimentator mit einer ganz mysteriösen Box. Schwarz wie die Nacht (ohne Mond und Sterne) mit nichts auf den Flächen. Keine Touch-Felder, keine Klappe, keine Aufschrift ist zu erkennnen. Was sollen wir mit dieser Box anfangen, wie sie erforschen, wie damit experimentieren?

 

 

Nach längerem Überlegen und Probieren kommen wir auf die Idee, die Box mal ins Gefrierfach zu legen und zu kühlen. Nach kurzer Zeit hat sie sich tatsächlich verändert und sieht so aus:

QBIT-Box gekühlt

Die Box ist nun grau und zeigt die Aufschrift QBIT, hat die üblichen beiden Touchfelder X und H und zusätzlich eine Art Touch-Drehrad mit der Kennzeichung G, einer Skala und einer Markierung am Rand. Es gibt keine Klappe, die man auf und zumachen könnte. Dafür aber ein umrahmtes quadratisches Feld mit zwei Touch-Feldern M und R darunter. Wir vermuten gleich, dass das M für "Messen" steht, also dem früheren "Klappe auf", und R für "Reset", das offenbar "Klappe zu" ersetzt. Was das Drehfeld bedeutet, müssen wir wohl experimentell herausfinden.

Nach einiger Zeit in Zimmertemperatur verschwinden die Strukturen auf den Flächen wieder und die Box sieht aus wie vor der Kühlung. Da hat sich der Große Experimentator wohl eine besondere Schikane ausgedacht? Wir müssen also vor jedem Experiment die Box hinreichend tief kühlen, das erschwert Untersuchung und die Überprüfung unseres Modell-Ansatzes. Egal, da müssen wir durch. Vielleicht hilft ja eine Cool-Box ein wenig.

 

QBIT-Box Experimente

Wir überprüfen zunächst das Naheliegende - immer im gekühlten Zustand. Die Touch-Felder R, X, H und M bewirken das Entsprechende wie bei der ZBIT-Box:

R ---- M -> Dunkel, d.h. das quadratische Anzeigefeld wird schwarz
R ---- X ---- M -> Licht, das Anzeigefeld wird hell.
R ---- H ---- M -> Dunkel und Licht jeweils mit der Häufigkeit ungefähr 1/2
Kombinationen, wie X---H und H---H zeigen ebenfalls die von der ZBIT-Box bekannten Ergebnisse.

Neu ist  das Touch-Drehrad G. Wir machen ein paar Versuche in Serie bei gleicher Einstellung. Dazu hilft die Skala am Rand. Wenn wir genau hinsehen, unterteilt die Skala den gesamten Kreis so ähnlich wie ein Ziffernblatt der Uhr. Allerdings haben die 12 Teilstriche noch Punkte jeweils auf der Mitte dazwischen. Ein Viertel des Umfangs hat damit 6 Markierungen, die analog zu einer Halbstunden-Skala sind. Im 360º Kreis entspricht das 15º. Wir bemerken, dass der "Zeiger" immer auf "3 Uhr" zurückspringt, wenn wir R betätigen, also scheint "3 Uhr" so etwas wie die Ausgangsposition des Dreh-Feldes zu sein.

Wir drehen den Zeiger auf "12 Uhr" bzw. 90° gegen den Uhrzeiger-Sinn (also mathematisch positiv) und berühren anschließend das "G" in der Mitte des Drehfeldes. Als Messergebnis leuchtet das Anzeigefeld hell. Wir wiederholen diese Operation mehrfach:

R ---- G90 ---- M -> L

und bekommen immer L. Nun liegt nahe, was wir, mehr oder wenniger systematisch, ausprobieren - immer mit ein paar Wiederholungen. Wir finden:

R ---- G45 ---- M -> Dunkel und Hell, vermutlich jeweils mit der Häufigkeit ungefähr 1/2
R ---- G00 ---- M -> Dunkel - das wußten wie schon, denn das ist genau das RM-Experiment von oben.
R ---- G30 ---- M -> D und L, mit einem Weiß/Schwarz-Häufigkeitsverhältnis von etwa 1:3.
R ---- G135 --- M -> D/L im Verhältnis etwa 1:1, also gleiches Ergebnis wie mit G45.
R ---- G180 --- M -> Dunkel für die Stellung "9 Uhr", also genau gegenüber der Ausgangsposition.

Mühselig, wie es sein mag, die Box muss systematisch erforscht werden. Wir machen die Experimente mit G für jeden der 12 Drehfeld-Teilstriche in Serie, 50 mal, und notieren die Häufigkeiten von Hell und Dunkel für jede Position. Die Grafik zeigt die Häufigkeit von Hell als Punkte über die 12 Teilstriche von "3 Uhr" bis "3 Uhr".

Häufigkeit von "hell" über 12 Stellung des Dreh-Feldes

Ein gewisses Muster ist zu erkennen, wenn auch spärlich. Machen wir das Ganze noch einmal für die Zwischenpunkte und tragen die in eine Gesamt-Grafik mit 24 Positionen ein.

Häufigkeit von L über 24 Einstellungen von G

Man erkennt, dass die Punkte, die die Häufigkeit von L im Experiment zeigen, über die verschiedenen Dreh-Feld Einstellungen periodisch sind. Bei 12, d.h. "9 Uhr"-Stellung, ist die Häufigkeit wieder 0, bei 2 und 18 sind die Werte 1. Soweit man die trigonometrischen Funktionen kennt (sin, cos), kann man hier eine Art sin-Funktion erkennen. Da die Werte aber immer zwischen 0 und 1 liegen,  sieht es eher nach sin² aus über 0 bis 360º, in 24 Schritten.

Bevor wir weitere Experimente machen, wollen wir versuchen, das Bisherige zu verstehen, d.h. uns ein passendes QBIT-Modell zu machen, das auch die Operation von G berücksichtigt.

Ein QBIT-Modell

Wir hatten in Q6 für das ZBIT bereits ein konsistentes Modell entwickelt und eine Darstellung gefunden, die uns Zustandsübergänge und die Zustand-Output Beziehung "rechnerisch", d.h. durch Formeln, zu formulieren ermöglichten. Die Zustände liegen dabei auf einem Einheitskreis in der x-y-Ebene.

Das einfache Qubit-Modell in x-y-Koordinaten mit Drehwinkel w

Für das QBIT-Modell müssen wir die Dreh-Operationen berücksichtigen. Die Einstellungen von "3 Uhr" (entspricht 0º) bis "12 Uhr" (entspricht 90º)  liefern Ergebnisse für die Häufigkeit von L, die sich aufsteigend von 0 bis 1 verteilen. Von 90º bis 180º (9 Uhr) geht es umgekehrt von 1 nach 0. Und bei Einstellungfen von 180º bis 360º wiederholt sich das Geschehen. Wenn wir uns die p(L) Linie in der ZBIT-Modell Grafik ansehen, heißt das eigentlich nur, dass die experimentellen Ergebnisse auf der p(L)-Linie von der Mitte nach oben, dann nach ganz unten und zurück zur Mitte bewegen. Jeder Punkt auf der p(L)-Linie hat aber eine Entsprechung auf dem Einheitskreis - genauer, sogar zwei! (Mit zwei Ausnahmen.) Wir können daher als die Zustände eines QBIT-Modells alle Punkte auf dem Einheitskreis  nehmen. Das umfasst natürlich auch automatische die 8 Zustände aus dem ZBIT-Modell.

Damit bekommen wir als QBIT-Modell-Beschreibung eine Erweiterung des ZBIT-Modells:

  • Die Zustände sind alle Punkte auf dem Einheitskreis, d.h. alle (x,y), für die x² + y² = 1 gilt.
  • Die Output-Werte bilden das Intervall [0,1], interpretiert als Wahrscheinlichkeiten p(L) für das Messergebnis L.
  • Ein Zustand (x,y) ergibt als Output M(x,y) = |y|² = p(L) (wobei hier die das Betrags-Symbol |  | unnötig ist). p(D) ist entsprechend x² = 1-y².
  • R(x,y) = (1,0) und liefert p(L) = 0
  • X(x,y) = (y,x). Wir leiten daraus ab, dass der Output M nach Anwendung von X p(L) = |x|² ergibt.
  • H(x,y) = 1/√2(x+y,x-y). Was ist der Output p(L) direkt nach Anwendung von H auf (x,y)? (Wer Lust hat, usw.)

Wie beschreiben wir die Dreh-Feld Operation G? G "dreht" den Ausgangszustand (1,0) auf dem Einheitskreis entsprechend dem"Dreh-Winkel" (G für Gyro). Dazu müssen wir etwas mathematisch ausholen. Ein Zustand auf dem Einheitskreis (x,y) kann auch durch den Winkel w zum Ausgangspunkt beschrieben werden. Nämlich - da der Radius des Einheitskreises 1 ist - als x = cos(w) und y = sin(w). Damit hat der Modell-Zustand, der durch Drehen um den Winkel w ausgehend vom Zustand (1,0) erreicht wird die Koordinaten (x,y) = (cos(w),sin(w)). Die erfüllen die Gleichung für den Einheitskreis, klar, und das |y|² ist gleich sin(w)². Also setzen wir

  • G(w) = (cos(w),sin(w)), wobei w der Dreh-Winkel von (1,0) aus ist.

Wir können damit das Modell einfach berechnen und den Output, das p(L), für alle Drehfeld-Einstellungen von 0 bis 360 in die Grafik der experimentellen Ergebnisse einzeichnen. Die rote Linie repräsentiert die Funktion sin(w)² und passt (zumindest visuell) hervorragend zu den blauen Punkten. Wir haben damit eine "statistische Bestätigung" unseres Modells.

QBIT-Box Experiment und Modellberechnung von p(L)

Vorhersagen und Erklärungen

Was passiert, wenn wir zwei G hintereinander schalten?
1. R ---- G90 --- G45 ---- M -> 0.5  (Modell), 49:51 Experiment
2. R ---- G45 --- G90 ---- M -> 0.5  (Modell), 52:48 Experiment
3. R ---- G60 --- G45 ---- M -> 0.93 (Modell), 4:96 Experiment (D:L)
4. R ---- G105 --- M -> 0.93 (Modell), 9:91 Experiment (D:L)

Offenbar ist der Effekt zweier Drehungen der gleiche wie eine Drehung um die Summe der Winkel, in der Theorie wie - statistisch - im Experiment.

Wir wissen, dass X so wirkt, dass die Koordinaten vertauscht werden.
5. R ---- G60 ---- M -> 0.75 (Modell), 22:78 Experiment (D:L)
6. R ---- X ---- G60 ----M -> 0.25 (Modell), 74:26 Experiment (D:L)
7. R ---- G60 ---- X ----M -> 0.25 (Modell), 75:25 Experiment (D:L)

Das X vor oder nach der Drehung vertauscht die Koordinaten und damit die theoretischen Wahrscheinlichkeiten für D und L.

Nun noch ein paar Kombinationen mit H:

8. R ---- G60 ---- H ---- H ---- M -> 0.75 (Modell), 24:76 Experiment (D:L)
Das entspricht dem Ergebnis von Versuch 5. D.h. das doppelte H hebt sich auf - wie wir das ja schon aus dem ZBIT-Modell kennen. Aber was macht ein einzelnes H?

9. R ---- G60 ---- H ---- M -> 0.067 (Modell), 93:7 Experiment (D:L)
Vorhersage und Experiment passen recht gut zusammen. Wir können aber das Ergebnis aus dem Modell "errechnen", indem  wir die Formeln anwenden.

Die Drehung des Ausgangszustands (1,0) um 60º liefert den Punkt
(cos(w),sin(w)) mit w=60º
auf dem Einheitskreis. H bedeutet, darauf die Formel 1/√2(x+y,x-y) anzuwenden, also
H(cos(w),sin(w)) = 1√2(cos(w)+sin(w),cos(w)-sin(w)).
Dieser Zustand wird gemessen (in Serie von 100). Mit M bedeutet das
p(L)=|y|²=1/2*(cos(w)-sin(w))².
Das ergibt (berechnet z.B. mit Wolfram Alpha) p(L) = 0.0669. Die Modell-Zustände, -Übergänge und -Outputs kann man berechen - die Ergebnisse der QBIT-Box  dagegen NICHT!

10. R ---- H ---- G60 ---- M -> Liefert in Experiment-Serien Ergebnisse um 8:92 für (D:L). Das sieht aus wie das Ergebnis von 3., oben.
Ob das stimmt, können wir per Modell herausfinden. R setzt den Anfangszustand (1,0), H macht daraus 1/√2(x+y,x-y)=1/√2(1,1), das kennen wir schon. Dieser Punkt liegt auf dem Einheitskreis mit dem Winkel 45º, da die x- und y-Koordinate gleich sind. D.h. H macht mit (1,0) das Gleiche wie eine Drehung um w=45º. Anschließend "dreht" G60 weiter auf 45+60=105º. Und das ist genau das, was wir in Versuch 3. hatten. Damit ist das theoretische Ergebnis wieder p(L)=0.93, passend zum Experiment. Aber Achtung! H ist nicht generell mit G45 gleich zu setzen. H ist keine Drehung um einen festen Wert. Wo H(x,y) liegt, hängt von (x,y) ab. Wer Lust hat kann überlegen, was passiert, wenn wir nach R erst ein X einsetzen (und das in einen Kommentar schreiben).

Auf diese Weise kann man viele weitere 1-Qubit Algorithmen formulieren und per Modell untersuchen. Leider ist der Gegenstand unsere Experimente nur ein virtueller. Der G.E. hat uns keine Handhabe gegeben, Experimente anders als immer mit der gleichen Routine zu machen: Kühlen, Reset, Operationen anwenden, Messen und das Ergebnis im Hell/Dunkel-Feld beobachten. Protokollieren und Statistik machen. (Wer wissen will, wie die Ergebnisse der obigen Mess-Serien zustande gekommen sind, kann das im nächsten Blog-Abschnitt kennen lernen.)

Die Vielfalt der Bezeichnungen

Eines hat in der Abfolge der Modellierungsansätze vermutlich irritert: die offensichtliche Beliebigkeit der Darstellung und Bezeichnung der Modell-Zustände. Nun, das hatte einen guten Grund. Es sollte zeigen, dass es

(a) verschiedene Modell-Beschreibungen für die gleiche Sache gibt,
(b) keine davon per se die "Wahre" ist und
(c) es der "Sache" egal ist, welche Beschreibung wir wählen, sofern sie nicht im Widerspruch zu den Experimenten steht.

Wir können daher bei der Modellwahl auf andere Eigenschafte achten, z.B. ob die Begriffe leicht zu verstehen oder zu merken sind, ob man damit leicht operieren bzw. rechnen kann, oder ob uns eine der Möglichkeiten einfach mehr Spaß macht, besser "in der Hand liegt".

In der Qubit-Algorithmik findet man daher mindestens 3 Standard-Beschreibungsansätze für Qubits. Wir werden darauf später teilweise noch eingehen können.

Zunächst wollen wir aber mal in unserem eigenen Zoo von Modellen Klarheit schaffen, vom BIT bis zu  QBIT. Dazu zeigt folgende Tabelle, welche Zustandsbezeichnungen in den verschiedenen Ansätzen sich entsprechen.

Uhr Grad π π/2 x-y-KoS p(L) ZBIT BIT Alice Qubit
3:00 0 0 (1,0) 0 [00] [0] Alice |0>
2:00 30º 1/6 1/3 (√3/2,1/2) 1/4 -- -- --
1:30 45º 1/4 1/2 (1/√2,1/√2) 1/2 [01] -- Charly |+>
1:00 60º 1/3 2/3 (1/2,√3/2) 3/4 -- -- --
12:00 90º 1/2 1 (0,1) 1 [11] [1] Debbie |1>
9:00 180º 1 2 (-1,0) 0 -- -- --
6:00 270º 3/2 3 (0,-1) 1 -- -- --
4:30 315º 7/4 7/2 (1/√2,-1/√2) 1/2 [10] -- Bob |->
hh:mm φ θ (x,y) |y|² -- -- --  x|0>+y|1>

Jede Spalte entspricht einer der Beschreibungsmöglichkeiten, die Einträge in einer Zeile entsprechen einander. Die erste Spalte zeigt Werte unseres Uhren-Bildes, mit dem Ausgangszustand auf 3 Uhr. Die zweite Spalte zeigt die entsprechenden Werte in Grad, gegen den Uhrzeigersinn. Statt Grad-Angaben kann man auch den Kreis mit Winkelangaben in π kennzeichnen. Die Spalte x-y-KoS gibt die entprechenden Koordinaten wieder, p(L) die zugehörige Wahrscheinlichkeit für L. Im ZBIT- und BIT-Modell hatten wir nur 4 bzw. 2 Zustände gekennzeichnet. Für das ZBIT die Zustände sogar mal mit Namen gekennzeichnet. Die letzte Spalte und die Spalte π/2 sind Zustandsschreibweisen, die wir noch kennen lernen werden. Sie gehören zu den erwähnten Standard-Beschreibungen für Qubits. Wenn man mal nicht weiß, was was ist, hat man hier eine Tabelle zum Nachschlagen.

Die letzte Zeile stellt die verwendeten Symbole für einen allgemeinen Zustand in der jeweiligen Schreibweise dar. Es fällt auf, dass es für das ZBIT- und BIT-Modell keinen "allgemeinen" Zustand gibt. Es sind stets die 4 bzw. 2 Zustände und nichts "dazwischen".

Wir sind jetzt in der Qubit-Welt angekommen, zumindest in einer der Qubit-Welten. Mit einem Qubit kann man algorithmisch recht wenig anfangen, vergleichbar einem Programm mit nur einer Variablen. Interessanter werden Qubit-Algorithmen, die mehrere Qubits umfassen - in einem sog. Qubit-Register. Das werden wir - nach einer kleinen Pause natürlich - im nächsten Abschnitt kennen lernen. Und zwar durch kleine praktische Beispiele von der Art "Hello Qubit World" in Q2, ausgeführt auf dem IBM Q Experience Quantencomputer (bzw. dem Simulator).

Hier geht's weiter.

Ach ja, wofür steht wohl QBIT auf der Box? Vorschläge gerne in den Kommentarfelden.


Q6 Zwischenspiel - ZBIT-Spielereien

Hier wollen wir mit dem verbesserten ZBIT-Modell aus Q5 ein wenig rumspielen, um mit dem Modell und den Definitionen ein wenig vertrauter zu werden. Um so leichter fällt dann der letzte (kleine) Schritt zum Qubit. Wegen des letzten Abschnitts ist dieser Blog etwas länger geraten. Dafür führt er uns aber zu einer Modell-Darstellung, die schon die für das Qubit-Modell sein wird. Wer keine Lust hat zum Spielen, kann auch einfach nur einen Kaffee trinken und gleich mit dem nächsten Blog weitermachen.

Wir hatten schon festgestellt, dass die inneren Zustände eigentlich beliebig wählbar sind, vorausgesetzt, die Maschinen-Tabellen (Output und Zustandsübergänge) sind konstistent.

1. Alice, Bob, Charly und Debbie

Statt [00] usw. können wir z.B. Namen nehmen:

Alice, Bob, Charly und Debbie statt [00], [10], [01], [11]. Wenn wir die vier dann als Ecken eines Quadrats aufstellen, etwa in der Sporthalle, können wir das Modell als Ballspiel beschreiben:

  1. Jede Runde beginnt bei Alice, sie hat den Ball (Operation R)
  2. Jeder spielt den Ball entsprechend den Regeln von X und H.
  3. Jeder ist dabei frei, welche der Regel sie oder er "werfen" will
  4. Irgendwann pfeift der Referee ab (M)

Die Grafik illustriert das Set-up. Die Pfeile zeigen, wie X und H gespielt werden dürfen. Da die Personen formal Zustände sind, zeigt die Grafik ein sog. Zustandsüberführungs-Diagramm, ein Wort, das man üben muss.

Wir haben noch nicht gesagt, was D, L und P sein sollen. Da wir die inneren Zustände und Übergänge beim Ballspiel beobachten, könnten wir trivialerweise festlegen: D, wenn der Ball bei Abpfiff bei Alice ist, L, wenn er bei Debbie ist und P, wenn er bei einem der beiden anderen ist. Das ist nicht beonders interessant.

Wie wäre es, wenn bei Abpfiff der Ball in einen Basketball-Korb geworfen werden muss? Das ganze Spiel findet hinter einem Vorhang statt, sodass wir es nicht sehen können. Allein den Wurf auf den Korb können wir sehen. Dabei bedeutet D, dass der Ball niemals versenkt wird (Alice), L, dass er mit Sicherheit reingeht (Debbie), und P, dass er manchmal trifft und manchmal nicht, im Verhältnis 1:1.

Fragen: Können wir herausfinden, wer den Ball zum Korb wirft? Wie wäre es, wenn wir dem Team bzw. dem Referee Spielpläne vorgeben würden (Algorithmen)? Wie könnte ein "autonomes" Spiel aussehen? D.h. jeder Spieler entscheidet (zufällig) welchen der möglichen Würfe (R, X, H, M) er oder sie macht.

Wer Lust hat, kann Überlegungen oder Antworten als Kommentar einfügen.

Nun gut, lassen wir die vier weiter spielen und wenden uns einer Darstellung zu, mit der wir das ZBIT-Modell simulieren können.

2. Ein ZBIT-Box Simulationsmodell

Wir haben im Beitrag "Etwas ist anders - Hello Qubit World" die Partitur eines QuBit-Algorithmus gesehen - ohne zu wissen, worum es geht. Solche Partituren können, wenn sie fehlerfrei sind, von Quanten-Computern oder auch von QC-Simulatoren abgearbeitet werden. Es wäre doch interessant, wenn wir die ZBIT-Experimente in diese Form bringen könnten und sie dem Simulator vorlegen könnten.

Da die Experimente mit den ZBIT- und BIT-Modellen schon in Anlehnung an die "Partitur-Form" beschrieben wurden, sollte es uns tatsächlich leicht fallen.

Die Modell-Beschreibung für den QC-Simulator ändert sich kaum: X und H werden vom Simulator "verstanden", das R gibt es nicht explizit, sondern jede Partitur beginnt mit dem Ausgangszustand.  Der wird im Simulator mit |0> gekennzeichnet statt mit [00], aber die Namen der inneren Zustände sind ja unwesentlich. (Was |0> bedeutet, werden wir später sehen.) Das Anzeige-Symbol ("Tacho-Nadel") steht für die Operation M (Messen).

Anders als bei den bisherigen Modell-Beschreibungen können wir nichts über die inneren Zustände des Simulators wissen. Die Zeile der Zustandsübergänge in den bisherigen Experimenten ist nicht verfügbar - jedenfalls beim QC. Die Messergebnisse des Simulators können '0' oder '1' sein, das entspricht dem D und L im ZBIT-Modell. Was wir für P bekommen sehen wir im Experiment.

Wir nehmen das ZBIT-Vorhersage-Experiment aus dem vorausgehenden Blog:

R ------ H ----- X ----- H ---- H ----- M -> P

und bilden es ab auf den QC-Simulator (hier: IBM Q Experience Circuit Composer).

Mit dem QC-Simulator können wir dieses Experiment einmal durchführen und erhalten:
{'0': 1}. Wir wiederholen und bekommen wieder ein {'0': 1}, dann ein {'1': 1}. Das bedeutet, die ersten drei Experiment-Durchläufe resultierten jeweils in einer  '0', bzw. einer  '1'. Wir bekommen also D oder L als Output. Wie bei der ZBIT-Box machen wir jetzt Mehrfach-Experimente, z.B. eine Serie von 50 Durchläufen. Das Ergebnis:

also 28 mal L und 22 mal D in unserer ZBIT-Interpretation.

Das sieht schon recht spannend aus. Im Prinzip könnten wir alle bisherigen Experimente mit dem BIT-Modell und dem ZBIT-Modell in dieser Weise simulieren. Damit kommen wir dem Konzept von Qubit-Algorithmen schon sehr nahe.

Und wir gewinnen eine wichtige Erkenntnis: ZBIT (das verbesserte) und BIT sind Teilmodelle des - hier noch unbekannten - Qubit-Modells.

Wer Lust hat, kann nicht nur Fragen und Antworten als Kommentar unten anfügen, sondern auch unter IBM Q Experience sich registrieren und schon mal im Circuit Composer stöbern. Wir schauen uns das in einem späteren Blog noch mal näher an. Eine ähnliche Umgebung bietet auch Google an mit Cirq.

Nun wenden wir uns einer Darstellung zu, mit der wir das ZBIT-Modell  mit einfachen Formeln berechnen können.

3. Ein Modell mit Formeln

Wir wollen nun versuchen, die Zustände so zu definieren, dass man mit ihnen "rechnen" kann. Statt in den Automaten-Tabellen die Zustandsübergänge nachzusehen, wollen wir sie mit einfachen Formeln berechnen können. Das gleiche für die Outputs.

Eine naheliegende Idee wäre es, die Ziffern in den Zuständen [00] usw. tatsächlich als Zahlen aufzufassen und dazu auch die Output-Ergebnisse in Zahlen umzuwandeln:  D entspricht 0, L entpricht 1, und P dem Wert 1/2. Diese Werte können verstanden werden als Wahrscheinlichkeiten, dass wir Licht sehen, wenn wir die Klappe öffnen. Wir schreiben dafür p(L).

Allerdings hatten wir [00] usw. eigentlich nur als "Label" für die Zustände eingeführt und  nicht als arithmetische Größen. Daher wäre es ein erstaunlicher Zufall, wenn wir damit ein konsistentes arithmetisches Modell bilden könnten.

Tatsächlich geht das aber, bis zu einem gewissen Punkt. Wer sich davon überzeugen will: es gibt einen Annex zu Q6, in dem das dargestellt wird. Wenn wir allerdings das Modell erweitern wollen, z.B. um Zustände, die p(L) = 1/4 als Output liefern, gibt es Schwierigkeiten.

Wir geben uns daher etwas mehr Freiheit bei der Definition eines rechnerischen Modells, indem wir die Zustände ("Labels"), in ein x-y-Koordinatensystem einbetten. (Wir erinnern uns, dass wir mit den zwei-ziffrigen Zuständen in Q5 so etwas wie 2-dimensionale Zustände eingeführt hatten.) Die Zustände werden dann zu Punkten in der x-y-Ebene.

Wir halten die Bezeichnungen [00] bzw. Alice zunächst einmal bei. Sie benennen die Punkt, so wie man Punkte A, B und C eines Dreiecks in der Ebene benennt und mit Koordinaten versieht. Trotzdem können die 0-en und 1-en etwas verwirrend wirken. Die Punkte werden mit ihren Koordinaten in normalen Klammern geschrieben, also z.B. (1,0), die [00] in eckigen Klammern sind die Label der Punkte, ebenso wie die Namen Alice etc.

Das  Einfachste ist, die beiden Zustände [00] und [11] - die ja auch die BIT-Zustände repräsentieren - auf die Koordinaten-Achsen zu platzieren. [00] als Punkt auf der x-Achse bei 1: (x,y) = (0,1). Und [11] entsprechend auf der y-Achse: (x,y) = (1,0). Das Diagramm zeigt wie.

Wohin gehört Bob?

Wo würden wir dann die Zustände [10] und [01] positionieren? Nun, das können wir bereits "ausrechnen". Schauen wir uns dazu zunächst die passenden Formeln für die Wirkung der Operatoren R, X und H an.

R ist einfach: R(x,y) = (1,0). Das Reset überführt jeden Zustand in den Ausgangszustand, der jetzt die Koordinaten (0,1) hat.

Auch X ist nicht schwer: X(x,y) = (y,x). X als "Switch" vertauscht die Koordinaten. Das passt schon mal für die beiden vorgegeben Zustände (1,0) <-> (0,1).

Wir haben uns noch nicht um den Output gekümmert. Der Output von (1,0) (i.e. [00]) muss p(L) = 0 sein, der vom (0,1) (i.e. [11]) entspechend p(L) = 1. Es liegt daher nahe, die y-Koordinate als p(L) zu übernehmen. Die x-Koordinate wäre entsprechend als Wahrscheinlichkeit für D zu interpretieren: p(D).

Hieraus folgt direkt und zwingend: p(L) + p(D) = 1.

Damit bekommen wir folgende Bedingungen für die Zustände [10] und [01]:
(1) Sie müssen so positioniert werden, dass die Summe ihrer beiden Koordinaten 1 ergeben.
(2) Der zugehörige Output muß 1/2 ergeben;  die y-Koordinate muss also 1/2 sein.
(3) Wegen der Wirkung von HH, müssen H[00] = [01] und H[11] = [10] unterschiedliche Koordinaten haben.

Man sieht sofort, dass diese Bedingungen unvereinbar sind: [01] kann mit den Koordinaten (1/2,1/2) die Bedingung (1) und (2) erfüllen. Es gibt aber keinen weiteren Punkt, der (1) und (2) erfüllt.

Wir ändern daher die Output-Definition: M (x,y) = p(L) = |y|, d.h. die Wahrscheinlichkeit für L ist der Absolutbetrag von y. Die Bedingungen (1) und (2) werden dann zu
(1') Die Summe der Beträge der Koordinaten muss 1 sein: |x|+|y| = 1. Und
(2') Der Betrag der y-Koodinate muss 1/2 sein

Wenn wir dann [10] mit den Koordinaten (1/2,-1/2) versehen, werden alle drei Bedingungen erfüllt. (Siehe Grafik.)

Das ZBIT-Modell einem Koordinatensystem

Weiter stellen wir fest, dass aus der Anwendung X und H auf schon bekannte Zustände neue Punkte hervorgehen, die wir ebenfalls als Zustände zulassen müssen.  So muß z.B. mit (1/2,-1/2), den Koordinaten für [10],  auch X(1/2,-1/2) = (-1/2,1/2) = -(1/2,-1/2) ein zulässiger Zustand sein. Wenn H(1/2,-1/2) wieder (0,1) sein soll (doppelte H Anwendung auf [11]), dann muss H(-1/2,1/2) = (0,-1) zulässig sein. Und X(0,-1) = (-1,0) = -(1,0) ebenso. Das Diagramm zeigt die Zustände als Punkte, die Pfeile für die Operatoren sind wegen der Übersichtlichkeit nicht eingezeichnet. Man kann aber, wenn man Lust hat, selbst versuchen, diese Zustandsübergänge einzuzeichnen (gedanklich), soweit es geht.

Das ist zunächst einmal überraschend: Wenn wir die 4 Zustände des ZBIT-Modell durch Punkte im (x,y)-Koordinatensystem darstellen wollen, erweitert sich das Modell zwangsläufig auf 8 Zustände! In unserem ZBIT Ball Game oben, würden dann Alice, Bob, Charly und Debbie jeweils einen Zwilling bekommen, Twin-Alice usw. Eigentümlich - aber niemand zwingt uns, bei einem Modell für die ZBIT-Box mit nur 4 Zuständen auszukommen. Vier ist das Minimum, aber 8 geht auch. Im Diagramm sind die "Twins" als helle Punkte eingezeichnet. Frage: Welcher Punkt ist Twin von wem?

Damit haben wir für das Koordinaten-basierte Modell:

  • Die Zustandsmenge
  • Die Wirkung von R und X als Formel
  • Die Zustand -> Output Abbildung M mit der Interpretation als p(L), Wahrscheinlichkeit für L als Messergebnis

Was fehlt, ist die Formel für H. Wir hatten festgelegt, dass (1,0) (Label [00]) durch H in (1/2,1/2) überführt werden soll und (0,1) (Label [11]) in (1/2,-1/2). Eine naheliegende Formel für H wäre: H(x,y) = 1/2 (x+y, x-y). Sie liefert für (1,0) und (0,1) genau das, was sie soll. Aber wie sieht es mit (1/2,1/2) und (1/2,-1/2) aus. H auf diese Zustände angewandt müsste ja wieder (1,0) bzw. (0,1) ergeben.

Jedoch: H(1/2,1/2) = 1/2 (1/2+1/2, 1/2-1/2) = 1/2 (1,0). Den gleichen Widerspruch erhalten wir für (1/2,-1/2). Der Faktor 1/2 macht die Inkonsistenz aus. Wenn wir allerdings den Faktor 1/2 in der Definition von H weg lassen, bekommen wir für (1,0) und (0,1) schon gleich falsche Ergebnisse.

Was tun? Vielleicht etwas dazwischen - zwischen 1/2 und 1? Wie es die Mathematiker gerne machen, wenn man sich nicht entscheiden kann, setzt man anstelle von 1/2 eine Variable, sagen wir a, und versucht, dafür einen passenden Wert zu bestimmen. Das ist sehr elegant. Probieren wir also:  H(x,y) = a*(x+y,x-y).

H(1,0) ergibt dann nicht mehr (1/2,1/2) sondern (a,a), was immer a auch ist. Entsprechend H(0,1) = (a,-a). Wenn wir darauf wieder H anwenden, bekommen wir H(a,a) = a*(a+a,a-a) = a*(2a,0) und H(a,-a) = a*(a+(-a),a-(-a)) = a*(0,2a). Andererseits muss H(a,a) = (1,0) sein, also a*2a = 2a² = 1 oder a = 1/sqrt(2). Das klappt auch mit der zweiten Bedingung. Très chic !

Allerdings stehen wir damit wieder am Anfang. Wir müssen die drei Spiegelpunkte oben wieder neu festlegen. Aber dieses Mal lohnt sich die Spielerei; denn wir haben hiermit automatisch die grundlegenden Komponenten für ein Qubit-Modell in Q7 abgeleitet.

  • Die 8 Zustände sind (1,0), (0.1), (-1,0), (0-1) und (a,a), (-a,a), (-a,-a), (a,-a) mit a = Wurzel aus 1/2. Alle diese Zustände liegen auf einem Kreis mit Radius 1.0 im x,y-Koordinatensystem. Sie erfüllen die Bedingung x² + y² = 1, die Gleichung des Einheitskreises.
  • R und X sind genau wie zuvor definiert, und H als H(x,y) = a*(x+y,x-y).
  • Wie ist die Zustand-Output Beziehung? Jetzt ergibt M(x,y) = y² das p(L), die Wahrscheinlichkeit für L bei einer Messung. Und p(D) ist entsprechend x² = 1-y², was ja für alle Zustände auf dem Einheitskreis stimmt.

Das Diagramm zeigt das ZBIT-Modell mit diesen Festlegungen.

ZBIT-Modell mit konsistenten Zuständen im x-y-Koordinatensystem

Der letzte Abschnitt war sicher keine einfache Spielerei mehr. Aber wir haben es geschafft. Und, wie wir sehen werden, gleichzeitig DAS Werkzeug für Qubit-Algorithmen gefunden.

Frage: Wie würde das ZBIT Ball Game aussehen, wenn wir die vier neuen Spieler ins Feld bringen würden -  nennen wir sie Twin-Alice, Twin-Bob, Twin-Charly und Twin-Debbie? Wer Lust hat usw.

Im nächsten Blog, versprochen, kommen wir aber zum QuBit-Modell - zumindest in einer ersten Form.

Fortsetzung folgt - Stay tuned!

 


Q5 Ein verbessertes ZBIT-Modell

Können wir ein verbessertes ZBIT-Modell entwerfen, dass den Widerspruch bei der doppelten H Operation auflöst?  Wir erinnern uns:

Wir haben beim Experimentieren mit der ZBIT-Box gesehen, dass sich zweimal H hintereinander aufheben. Mit dem bisherigen ZBIT-Modell ließ sich dieses Ergebnis nicht herbeiführen. Denn H auf [0] angewendet ergibt [1/2], aber auch H auf [1] angewendet ergibt [1/2]. Damit kann nicht gleichzeitig HH[0] = H[1/2] = [0] und HH[1] = H[1/2] = [1] sein.

Ein verbessertes ZBIT-Modell

Wie können wir  ein verbessertes Modell für die ZBIT-Box entwerfen? Der Widerspruch entstand, als wir H auf den  einen neu eingeführten Zustand [1/2] anwendeten und erwarteten, dass daraus zwei verschiedene Ergebnisse hervorgehen. Das war zwar naheliegend (Occam's Razor Prinzip, mal bei Wikipedia nachschlagen), aber vielleicht hätten wir besser zwei neue Zustände eingeführt.

Das kann man einfach erreichen, indem man zu der ursprünglichen Zustandsvariablen mit zwei möglichen Werten eine weitere mit ebenfalls zwei Werten hinzufügt. D.h. der innere Zustand hat zwei Größen, sagen wir s1 und s2, die die Werte [0] und [1] haben können. Die Zahlen haben wieder keine Bedeutung; wir könnten die Zustände auch a und b nennen oder a1, b1 und a2, b2 nennen. Damit gibt es für  (s1, s2) genau vier mögliche Kombinationen!

Die Wahl von [0] und [1] erweist sich aber als ganz praktisch. So können wir uns z.B. einfach vorstellen, dass die inneren Zustände des neuen ZBIT-Modells die vier Ecken des Einheitsquadrats in der Ebene darstellen - weswegen wir auch sagen, dass der Zustand 2-dimensional ist.

Das neue ZBIT-Modell legen wir ähnlich wie oben fest:

  1. Wir nehmen für das neue Modell  zwei Zustandsvariablen (oder: einen zwei-dimensionalen Zustand)  und kennzeichen diese  [0][0], [0][1], [1][0] und [1][1].  Um uns die Klammerei zu erleichtern, "labeln" wir die Zustände stattdessen einfach mit [00], [01], [10] und [11].
  2. Wir setzen [00] als den Startzustand
  3. Die Outputs werden als D,  L und P abgekürzt, für Dunkel und Licht und den variablen Zufalls-Output.
  4. Die  Operationen sind wieder mit R, X und H bezeichnet und repräsentieren Klappe zu und das Berühren von Touch-Feld X bzw. H.
  5. Das Messen (M) des 2-dimensionalen ZBIT-Zustands (Klappe auf und schauen), d.h. die Zuordnung Output zu Zustand, kann nun vier Ergebnisse haben. Wir legen fest:
    M: [00] -> D, [01] -> P, [10] -> P und [11] -> L

Auch die Wirkung der Operatoren R, X und H müssen wir neu festlegen. Das geschieht am übersichtlichsten in eine vollständigen Tabelle, analog der vom ersten Versuch.

Zustand | Neuer Zustand bei
        |    R      X      H
[00]    |   [00]   [11]   [01]
[01]    |   [00]   [10]   [00]
[10]    |   [00]   [01]   [11]
[11]    |   [00]   [00]   [10]

Als technische Konstruktion des Modell können wir uns vorstellen, dass im Inneren zwei (!) Schalter sitzen, die durch die Touch-Felder bzw. "Klappe zu" betätigt werden. Wie, sagt die Tabelle. Und die Schalterstellung bestimmt, ob Dunkel, oder Licht oder zufällig zur Hälfte Licht und Dunkel zu sehen ist beim Öffnen der Klappe. Z.B. besagt die M-Tabelle, dass, wenn die Schalter "verschieden" gesetzt sind, der Zufallsoutput erfolgen muss. Wie man das baut - mal ausprobieren. Z.B. mit Roberta (IAIS).

An dieser Stelle ist noch einmal wichtigt zu bedenken, dass auch die technische Konstruktion ein Modell für die Blaue Box ist. Im Gegensatz zur Box haben wir aber vollständige Einsicht in unsere Modell-Box.

Wir müssen nun erneut prüfen, ob das Modell widerspruchsfrei ist, d.h. im Experiment das Verhalten der blauen ZBIT-Box zeigt. Für die Operationen R, X, H müssen wir in die Tabelle schauen, für M in die Output-Liste. Wir beschränken uns hier auf die Beispiele vom ersten Modell und die "Problemfälle" dort.

R ------ X ------ H ---- M -> 1:1 liefert die ZBIT-Box im Serienexperiment
[00] -> [11] -> [10]  -> P       liefert das neue Modell. Das passt wieder.

"1:1"  bedeutet Dunkel / Licht im Verhältnis 1:1.

R ------ H ------ X ---- M -> 1:1 ZBIT-Box Messreihe
[00] -> [01] -> [10]  -> P          ZBIT-Modell Output

Noch ein paar einfache Fälle, die wir schon aus dem BIT-Modell kennen:

R ----- M -> Dunkel          R ----- X -----M -> Licht
[00] -> D                          [00] -> [11] -> L

R ------ X ------ X ---- M -> Dunkel
[00] -> [11] -> [00] -> D

Passt also. Nun die Doppel-H Experimente:

R ------ H ----- H -----M -> Dunkel als ZBIT-Box Output
[00] -> [01] -> [00] -> D       Modell Output. Passt!

Für HH[11] müssen wir zunächst den Ausgangszustand [00] mit Hilfe von X zu [11] machen und dan HH anwenden.
R ------ X ------ H ----- H -----M ->  Licht in der Box
[00] -> [11] -> [10] -> [11]  -> L         "Licht" im Modell

Durch Hinzunahme einer zweiten Zustandsgröße konnten wir also den Widerspruch des ersten Versuchs auflösen. Das ist auch leicht zu verstehen: der Zustand nach dem ersten Anwenden von H würde bei Messung zwar immer P ergeben, er trägt aber noch die Information, "woher" er kommt, von [00] oder [11]. nämlich in der Reihenfolge von 0 und 1 im Zustand. (Genial! findet der G.E.)

ZBIT Vorhersagen

Natürlich können wir auch jetzt noch nicht ausschließen, dass das Modell nicht widerspruchsfrei ist. Dazu müssten wir alle möglichen Abfolgen von Operationen (Algorithmen) gegen die ZBIT-Box evaluieren - oder zumindest eine endliche Menge davon, auf die "alle möglichen" reduziert werden können.

Was wir weiterhin machen können, sind Vorhersagen. D.h. wir können eine noch nicht gesehene Abfolge von Operationen im Modell berechnen und das Ergebnis experimentell an der ZBIT-Box überprüfen. Ein Beispiel, das wir bei der Erforschung der Box oben noch nicht als Experiment durchgeführt hatten

R ------ H ----- X ----- H ---- H ----- M ergibt
[00] -> [01] -> [10] -> [11] -> [10] -> P

Das zugehörige Experiment: Klappe zu -> Touch H -> Touch X -> Touch H -> Touch H -> Klappe auf: Dunkel. Wir wissen, dass wir das gleiche Experiment vorsichtshalber in Serie durchführen müssen, um zwischen P und Licht oder Dunkel unterscheiden zu können. Wir tun das 20 Mal und sehen 11 Mal Dunkel und 9 Mal Licht, experimentell also eindeutig P bestätigt.

Fragen: Wie oft müssten wir das Experiment mindestens wiederholen, bis wir das Ergebnis P bestätigen können? Wie oft, um ein vorausgesagtes Ergebnis L zu bestätigen? Hier haben wir offenbar ein Problem. Wir können, da wir das "Innere" der Box nicht kennen können, nie sicher sein, ob nicht bei der nächsten Wiederholung ein D folgt. Wie immer müssen wir uns damit zufrieden geben, L als bestätigt zu sehen, wenn wir bei einer großen Anzahl von Wiederholungen immer L gesehen haben. Anders ausgedrückt, wir "bestätigen" das Ergebnis mit (einfachen) statistischen Methoden - aber das ist eine ganz andere Baustelle.

Aufgaben:

  1. Die 2-dim Zustandsdefinition erinnert an die üblichen vier 2-Bit Kombinationen. Könnte man die ZBIT-Box möglicherweise mittels zweier BIT-Modelle modellieren?
  2. Was wäre, wenn man beim Berühren von H nicht Licht und Dunkel im Verhältnis 1:1 beobachtet sondern z.B. 1:3 (Häufigkeit von D etwa 1/4)?
  3. Das dauernde Wiederholen eines Experiments, von dem man als Output P erwartet ist eigentlich lästig. Könnten wir uns eine technische Konstruktion ausdenken, die den Output P durch ein halb so helles Licht anzeigt?

Wer Lust hat, kann gerne die Fragen und die Aufgaben im Kommentarfeld unten diskutieren.

Vom ZBIT-Modell ist es nun nur noch ein kleiner Schritt zum Qubit-Modell. Aber erst mal wieder: Pause - also einen Kaffee trinken oder etwas spielen.

Hier geht's weiter.