Q16 Quanten und Qubits - Was man so liest

Von Bernhard Thomas und Ulrich Trottenberg

Quanten-Computing wird in den Medien, aber auch in Vorträgen und in der Fachliteratur mit einer Reihe von Aussagen charakterisiert, die als Sprachkonstrukte ziemlich exotisch klingen - nach einer anderen Welt, in der logisch Unmögliches möglich scheint. Wir wollen uns einige dieser Sprachfiguren ansehen und überlegen, was dahinter steckt.

Unsere bisherigen Blog-Abschnitte über Qubit-Algorithmen sollten ausreichen, hier ein klares Verständnis zu schaffen. Hier die Übersicht über die Aussagen.

"Quanten können 0 und 1 gleichzeitig sein"

"Mit n Qubits kann man 2**n Zahlen gleichzeitig darstellen"

"Für N Zahlen benötigt ein Quanten-Computer nur log(N) Qubits"

"Ein Quanten-Computer kann mehrere Berechnungen gleichzeitig durchführen (Quanten-Parallelismus)"

"Was auf herkömmlichen Rechner Jahre dauert, kann ein Quanten-Rechner in Sekunden erledigen (Exponentielle Beschleunigung)"

"Quanten-Rechner werden herkömmlichen Rechnern überlegen sein (Quanten-Supremacy)"

"Jedes zusätzlich Qubit verdoppelt die Leistungsfähigkeit des Systems"

 

"Quanten können 0 und 1 gleichzeitig sein"

Dieser Satz und Abwandlungen davon ziehen sich durch die Quanten-Computing-Literatur wie ein Mantra des QC. Auch wenn er gelegentlich nur als Metapher gesehen wird, suggeriert dieser Satz in der öffentlichen Diskussion eine mystische Eigenschaft der Quanten, nicht zuletzt illustriert durch das Bild von Schrödingers Katze, die "gleichzeitig tot und lebendig" ist.

Damit werden auch die informatischen Gegenstücke der Bits, die Qubits, charakterisiert. Im Gegensatz zu Bits, die nur "0 oder 1" sein können, können Qubits "0 und 1 gleichzeitig" sein.

Wie könnten wir das feststellen? Wir wissen, dass die Messung eines Qubits entweder 0 oder 1 ergeben kann, aber nicht beides. Wenn wir mehrfach messen, bekommen wir manchmal eine 0, manchmal eine 1 als Ergebnis, aber nie "gleichzeitig". Was kann also gemeint sein - wenn es überhaupt einen Sinn ergibt.

Es gibt Varianten dieser "Gleichzeitig"-Sprachfigur, die etwas tiefergehend klingen: "Quanten können verschiedene Zustände gleichzeitig einnehmen". Wir wissen, dass man Zustände von Systemen in Form von mathematisch eindeutigen Ausdrücken beschreiben kann - so auch Qubits und Qubit-Systeme. Ausgehend von einem Anfangszustand sahen wir, wie mittels Qubit-Operationen (oder Gates) ein Qubit-Zustand in einen nächsten überführt werden kann. Zu jedem Zeitpunkt ist der Zustand des Qubits daher eindeutig festgelegt. Wenn wir nicht unsere normale zweiwertige Logik (2 Wahrheitswerte: wahr, falsch - oder 0, 1) in Frage stellen, kann ein Qubit nicht zwei verschiedene Zustände gleichzeitig haben. Eine Zahl, ein mathematischer Ausdruck, der einben Zustand beschreibt, kann nicht gleichzeitig 0 und 1 sein: z = 0 = 1?

Manchmal findet man Texte, in denen das "Gleichzeitige" durch die "Superpostion" ergänzt wird: "Quanten können in einer Superosition von 0 und 1 gleichzeitig sein". Wir wissen, was eine Superpostion ist. Z.B. ist 1/√2 (|0>+|1>), die Hadamard-Operation auf den Basiszustand |0>, eine Superpostion (oder mathematisch: Linearkombination) der Qubit-Zustände |0> und |1>. Wir haben Qubit-Zustände meist in Form von x-y-Koordinaten eines Punktes auf dem Einheitskreis beschrieben - im Beispiel also (1/√2,1/√2). Somit können wir korrekt formulieren: Ein Qubitzustand hat zwei Koordinaten. Aber was heißt dann "gleichzeitig"? Wenn jemand in Ingolstadt ist, befindet er sich z.B. auf der Strecke von München nach Nürnberg - aber ist er (möglicherweise) in München und Nürnberg "gleichzeitig"?

Wenn auch die Redewendung "... kann 0 und 1 gleichzeitig sein" etwas Unsinniges suggeriert, können wir sie als solche akzeptieren, wenn man sie auf die Möglichkeit einer Superposition von zwei (Basis-)Zuständen eines Qubits zurückführt. Darin unterscheiden sich Qubits und Bits tatsächlich.

Und während ein Bit nur einen der beiden Zustände 0 oder 1 repräsentieren kann (siehe BIT-Box in Q3), kann ein Qubit einen Zustand aus einer unendlichen Menge von Superpositionszuständen annehmen. Wobei wir das "unendlich" im Sinne aller Punkte auf dem Einheitskreis verstehen, ohne zu fragen, ob wirklich unendlich viele Superpositionen realisierbar sind (technisch und quantenmechanisch).

Eine elegante und gleichzeitig korrekte, einfache Erklärung finden wir im Glossar der IBM (Übersetzung DeepL):

Ein Qubit (ausgesprochen "kju-bit" und kurz für Quantenbit) ist der physikalische Träger der Quanteninformation. Es ist die Quantenversion eines Bits, und sein Quantenzustand kann Werte von |0> , |1> oder die Linearkombination von beiden annehmen, was ein Phänomen ist, das als Superposition bekannt ist.

Mehr ist eigentlich nicht zu sagen.

"Mit n Qubits kann man 2**n Zahlen gleichzeitig darstellen"

Mit n Bits kann man zwar auch 2**n verschiedene Zahlen darstellen - gemeint sind Binärzahlen in Form von Bitketten - aber immer nur eine zu einem Zeitpunkt, z.B. im Speicher eines klassischen Computers.

Diese Aussage zusammen mit dem "Quantenparallelismus" (s.u.) soll die überragende Leistungsfähigkeit von Quanten-Computern deutlich machen. Man liest auch: "Mit jedem weiteren Qubit verdoppelt sich die Kapazität" und "Schon 300 Qubits können mehr Werte speichern, als das bekannte Universum Teilchen enthält".

Nun ja, wie soll man das verstehen? Zunächst zu den beiden letzten Versionen des "Kapazitätssatzes": Auch mit jedem weiteren Bit verdoppeln sich die möglichen Werte, die man speichern - und wieder lesen - kann. Immer einer zu einer Zeit (Schreib-Lese-Zyklus). Und mit 300 Bits kann man mehr als alle Teilchen des bekannten Universums abzählen, oder je eine Zahl zu einem Zeitpunkt im Bereich 0 bis 2**300-1 speichern. Bei Qubits liegt das Geheimnis offenbar wieder im "gleichzeitig". Wieder nur eine Metapher?

Ein System von n Qubits, z.B. n=3, befindet sich zu einem Zeitpunkt in einem Zustand (von prinzipiell unendlich vielen), der eine Linearkombination (Superposition) von nunmehr 2**n Basiszuständen ist, also 8 bei n=3. In der ket-Schreibweise tritt jede n-lange Bitkette als ein Basiszustand auf, bei n=3 also |000>, |001>, |010>, |011>, |100>, |101>, |110>, |111>. Bei n = 300 sind es halt ......

Denken wir an Koordinatensysteme, wie z.B. in Q11, dann haben wir ein 8-dimensionales Koordinatensystem und jeder 3-Qubit-Zustand  wird durch 8 Koordinaten beschrieben. "Gleichzeitig" - für einen Punkt braucht man 8 Koordinaten "gleichzeitig".

Kann man in einer Superposition von 2**n Basiszuständen das gleichzeitige Speichern von 2**n Zahlen sehen? Nehmen wir eine gleichmäßige (uniforme) Superposition, d.h. alle Basiszustände kommen mit dem gleichen Koeffizienten vor. Bei n=3 also mit 1/√8.

Speichern nützt nur dann etwas, wenn man  mit dem Gespeicherten etwas anfangen kann, z.B. weiter verarbeiten mittels Qubit-Operationen oder Lesen, d.h. Messen. Beim Weiterverabeiten zu einem neuen Zustand können tatsächlich alle Komponenten der Linearkombination in einer Operation berücksichtigt werden (Quantenparallelismus, s.u.). Beim Messen (gegen die Basiszustände) erhält man eine Häufigkeitsverteilung über alle Bitketten, die als Basiszustände in der aktuellen Superposition vertreten sind. Sind einige nicht vertreten, tauschen sie, bis auf Quantenfehler, auch nicht im Messergebnis auf.

Aber was machen wir damit? Welche Information ziehen wir daraus? Dass 2**n Bitketten beim Messen auftreten können, wussten wir schon vorher. Wir "lesen" also nichts Neues. Wenn wir 2**300 Teilchen mit unterschiedlichen Bitketten versehen wollten, konnten wir das auch schon ohne Quanten-Computer (QC).

Wo liegt also die Information, die wir durch die Quanten-Berechnung gewonnen haben? Wohl in der gemessenen Häufigkeitsverteilung:

  1. Wir schauen nur auf "vorhanden" und "nicht vorhanden" von gemessenen Bitketten. Eine häufige Form der Interpretation von QC-Ergebnissen, z.B. beim Herausfinden eines Orakels, wie im Bernstein-Vazirani Problem oder dem von Deutsch-Josza. Man kann sich das so vorstellen: Der Qubit-Algorithmus "rechnet" mit den 2**n Basiszuständen des n-Qubit Systems, der Ergebnis-Zustand enthält aber in nur einen Basiszustand, der dann bei der Messung eine ziemlich eindeutige Bitkette liefert. Eine solche Methode ist auch die sogenannte Amplituden-Verstärkung (amplitude amplification). Zum Auffinden einer bestimmten Bitkette beginnt man mit einer uniformen Superposition und verändert diesen Zustand Schritt für Schritt so, dass die Amplitude des Basiszustands mit der gesuchten Bitkette zunehmend "größer" wird. Die Iteration wird beendet, wenn man nahe genug an der gesuchten Bitkette ist, d.h. wenn beim Messen diese Bitkette eine überragende Wahrscheinlichkeit erreicht. Das Verfahren wird auch Grover-Iteration genannt.
  2.  Uns interessiert ein "numerisches" Ergebnis, z.B. eine Zahl oder eine Reihe von Zahlen (Vektor), die sich bei der Messung am Ende der Rechnung als Häufigkeiten bestimmter Bitketten ergeben. Als "numerisches" Ergebnis nimmt man dann die Liste dieser Häufigkeiten. Hier stoßen wir aber auf verschiedene Probleme. Eines davon ist, dass ein echter QC die Häufigkeiten nicht exakt misst. Um halbwegs brauchbare Werte abzuleiten, müssen wir das QC Programm wiederholt durchlaufen lassen. Wie oft? Für n=3 kann man das ja einmal ausprobieren mit dem IBM QC. Wie oft bei n=50 oder n=300?

"Für N Zahlen benötigt ein Quanten-Computer nur log(N) Qubits"

Dies ist eine Variante der vorigen Aussage und besagt: "Während man auf herkömmlichen Computern für N Zahlen auch N Speicherplätze benötigt, braucht ein Quanten-Computer nur log(N) Qubits". Man hat also, umgekehrt gesehen, einen exponentiellen Effekt. Und damit ist ein Quanten-Computer exponentiell leistungsfähiger als ein herkömmlicher. Wie auch immer das gemeint ist, es läuft darauf hinaus, dass man eine Überlagerung der N Basiszustände eines "log(N) großen"  Qubit-Systems herstellt, bei der die Koeffizienten (auch Amplituden genannt) gerade die gewünschten N Zahlen sind. Wenn man also weiß, wie, kann man einen solchen Superpositionszustand als "Input" herstellen, und einen Qubit-Algorithmus damit weiterrechnen lassen. Das ist das sog. Amplituden-Verfahren oder auch Amplituden Encoding.

Aber halt! Die N Amplituden müssen ja in der Summe der Quadrate 1 ergeben. Schränkt das nicht die freie Wählbarkeit der N Zahlen ein? Nicht wirklich - man muss nur vorher jede Zahl durch die Summe aller Quadrate teilen, genauer, durch die Quadratwurzel dieser Summe. Damit kann man dann "Quanten-Rechnen". Allerdings tritt bei der Ergebnis-Festellung wieder das Problem aus 2. auf.

Um die N Zahlen als Input verwenden zu können, muss man zu Beginn des Qubit-Algorithmus geeignete Qubit-Operationen (Gates) ausführen, so dass sie in einer Superposition zu Koeffizienten von Basiszuständen werden. Das kann trotz "Quantenparallelität" aufwendig sein. Hier ein Beispiel:

Angenommen, wir wollen die 4 Zahlen 1.0, 1.0, √2 = 1.414, 2.0 als Input in Form von Amplituden für ein 2-Qubit-System bereitstellen (N=4, n=2). Die Summe der Quandrate ist 1.0+1.0+2.0+4.0 = 8.0.  Die Wurzel daraus ist √8. Dadurch müssen wir die 4 Zahlen teilen, damit diese eine gültige 2-Qubit Superposition ermöglichen: 1/√8, 1/√8, 1/√4, 1/√2. Es ist damit z.B. der Zustand 1/√8 |00> + 1/√8 |01> + 1/√4 |10> + 1/√2 |11> durch einen Qubit-Circuit herstellbar. Wie geht das? Hier ist eine Lösung:

Codieren der 4 Zahlen mittels 2 Qubits
Amplituden der Superposition: 0.354, 0.354, 0.5, 0.707
Messergebnisse: Häufigkeiten1/8, 1/8, 1/4, 1/2 (idealisiert)

Das "Fine-Tuning" der Amplituden erfolgt hier mittels Drehungen (Ry). Der resultierende Zustand ist verschränkt, d.h. er kann nicht als Kombination der einzelnen Qubits hergestellt werden. Das kann man nach der Methode in Q9 nachprüfen. (Ergebnis eines Simulatorlaufs mit 1024 shots.)

"Ein Quanten-Computer kann mehrere Berechnungen gleichzeitig durchführen"

Diese Aussage wird häufig als Verdeutlichung des sog. Quanten-Parallelismus verwendet. Auch hier wird wieder das Mantra-Wort "gleichzeitig" verwendet, dieses Mal aber in einer sinnvollen Bedeutung, nämlich im Gegensatz zu "nacheinander" (sequentiell). Natürlich können auch herkömmliche Computer heutzutage mehrere Berechnungen zeitlich parallel ausführen. Der Unterschied ist aber technisch fundamental: Herkömmliche Parallelrechner (z.B. MIMD-Architekturen) führen mehrere, durchaus auch verschiedene, Computerbefehle (Instructions) zur gleichen Zeit aus und verwenden dabei u.U. unterschiedliche Daten als Input.

Quanten-Computer führen zu einem Zeitpunkt einen Befehl (in Form von Gates) auf einer Datenstruktur aus. Die Datenstruktur ist der aktuelle Zustand eines n-Qubit-Systems, also meist eine Superposition oder gar eine Verschränkung. Der Zustand eines n-Qubit-Systems kann aber, wie wir zuvor gesehen haben, bis zu N=2**n Zahlen (in Form von Amplituden) repräsentieren. Indem der Qubit-Befehl auf den Zustand wirkt, wirkt er simultan auf alle Basiszustände, die in der Superposition vorkommen. Als Ergebnis können sich damit simultan alle Amplituden der Basiszustände verändern. Bingo!

Mathematisch gesehen ist das überhaupt nichts Ungewöhnliches. Eine Matrix A "wirkt" bei Multiplikation mit einem Vektor x auf alle seine Komponenten "gleichzeitig": y= Ax (Lineare Algebra). Wird ein Punkt (x,y) mittels einer Funktion F verschoben, dann werden alle Koordinaten "gleichzeitig" verschoben: (u,v) = F(x.y). Und auch die Qubit-Operatoren (Gates) können mathematisch als Matrizen dargestellt und verwendet werden. Wenn es allerdings ans praktische Rechnen geht, etwa mit einem Algorithmus, der die Matrixmultiplikation explizit durchführt, dann geht es klassisch (auf einem herkömmlichen Rechner) wieder nur Schritt für Schritt: die Operation wird in viele Einzelschritte zerlegt, die nacheinander ausgeführt werden. Hier unterscheiden sich klassische und Quanten-Computer tatsächlich fundamental. Quanten-Computer, wie die von IBM, sind technisch so aufgebaut, dass sie eine komplette Superposition in einem, statt in vielen Schritten verarbeiten können.

Wie man sich das vorstellen kann, zeigen wir an einem einfachen Beispiel: Das exklusive Oder (XOR) von zwei Bits entspricht der einfachen Bit-Addition bis auf die Operation "1+1", die 0 ergibt  statt 2. (Dafür verwendet man auch das Symbol ⊕ statt +). Wir können die Bit-weise XOR-Berechnung auch als Qubit-Circuit durchführen. Das ergibt die 4 Auswertungen in der Abbildung, wobei jeweils q0 und q1 auf Zustand 0 bzw. 1 gesetzt werden und das Ergebnis den neuen Zustand von q1 ergibt.

Abb.: Vier Berechnungen von XOR als Qubit-Algorithmus

Quanten-Parallelismus ermöglicht aber Superpositionen statt einzelner Basiszustände als Input zu präparieren, typischerweise mit dem H-Gate (Hadamard-Gate). Damit muss die Berechnung nur einmal ausgeführt werden und wir erhalten alle 4 Ergebnisse auf einmal.

 

Abb.: XOR Berechnungen mit Quanten-Parallelismus

Um die Ergebnisse einfacher "lesen" zu können, haben wir hier das XOR Ergebnis  auf ein drittes Qubit q2 übertragen. So erhalten wir als Messergebnis genau die obige XOR Tabelle mit XOR -> q2 : 000, 101, 110, 011 (q2 steht hier wieder jeweils ganz links in der Bitkette).

 

"Was auf herkömmlichen Rechnern Jahre dauert, kann ein Quanten-Rechner in Sekunden erledigen"

Als Begründung liest man dabei oft, dass Quantenrechner "exponentiell schneller" rechnen können als herkommliche. Was bedeutet das?

Das heißt zum Beispiel folgendes: Wenn wenn wir zwei Methoden haben, die eine Aufgabe lösen, etwa eine Berechnung durchführen oder ein "Geheimnis" (Q15) zu finden, und die eine Methode benötigt N Zeiteinheiten oder Rechenschritte, die andere aber nur log(N) viele, dann stellt die zweite Methode eine exponentielle Verbesserung - oder Beschleunigung - gegenüber der ersten dar. (Denn, für k=log(N) ist  N=exp(k).)

Es gibt eine ganze Reihe von solchen "Beschleunigungsbeziehungen" zwischen Methoden zur Lösung gleicher Aufgaben. Der Grover Qubit-Algorithmus benötigt nur etwa √N Schritte gegenüber N Schritten bei der klassischen Methode. Hier haben wir also eine quadratische Beschleunigung. In Q15 hatten wir das am Beispiel des Bernstein-Vazirani-Algorithmus diskutiert.

Solche Beschleunigungen gibt es von je her auch im klassischen Computing als Effekt einer algorithmischen Verbesserung. So gibt es z.B. unterschiedliche Sortier-Algorithmen, die sich bezüglich ihres Rechenaufwands erheblich unterscheiden, oder auch Verfahren zur numerischen Simulation, bei denen sogenannte Mehrgitterverfahren große Beschleunigungsraten bringen.

Der tatsächliche Beschleunigungseffekt des Quanten-Computing gegenüber herkömmlichen Bit-Computing beruht auf einer Kombination von zwei Dingen: dem Quanten-Parallelismus der Hardware (s. voriger Abschnitt) und dem Algorithmus, der für Qubits konstruiert werden kann.

Ein Rechenbeispiel: Hätte man eine (hypothetische) Aufgabe, die auf einem gewöhnlichen Rechner mit dem schnellsten Algorithmus 10 Jahre dauern würde, dann würde eine exponentielle Beschleunigung auf einen Zeitaufwand von rund 20 Sekunden führen: log(10*360*24*60*60) = log(311040000) = 19,56. Diese Zahlen sind allerdings eher fiktiv, da wie keine konkrete Aufgabe vor Augen haben und Wiederholungen und anderen "Overhead" nicht berücksichtigen. Aber es zeigt, wie sich die Größenordnung ändern.

Hätten wir also eine Aufgabe, die herkömmlich Jahre dauern würde, und hätten wir dazu ein Quanten-Computer, der sie alternativ mit exponentieller Beschleunigung löst, könnten wir die Aussage so akzeptieren. Allerdings gibt es noch nicht viele Algorithmen für Quanten-Computer, die in dieser Form praktische verwendbar sind. Was nicht zuletzt auch an der Größe und "Sensibilität" heutiger QC liegt.

Ein relevantes Beispiel, das immer wieder als "Gefahr durch Quanten-Computer" zitiert wird, ist das Verfahren von Shor, mit dem man einen wichtigen Schritt beim "Knacken" von besten heutigen Verschlüsselungsverfahren in akzeptabler Zeit durchführen kann. Um das zu verstehen, braucht es aber schon mehr Einsicht in die zugrunde liegende Mathematik. Daher wird hier meist nur der (befürchtete) Effekt zitiert und auf Verständnis verzichtet.

"Quanten-Rechner werden herkömmlichen Rechnern überlegen sein"

Man spricht auch generell von Quanten-Überlegenheit (Quantum Supremacy). Trotz der beängstigent klingenden Bezeichnung handelt es sich hier um eine unspektakuläre Sache. Es bedeutet lediglich das Ereignis, dass es eine Berechnung gibt, die ein Quanten-Computer schneller als jeder herkömmliche Supercomputer durchführen kann. Dabei ist es erst einmal egal, ob diese Berechnung einen Sinn macht oder praktische Bedeutung hat. Wie man kürzlich lesen konnte, hat man (mit einem QC von Google) bereits eine solche Berechnung durchführen können, d.h. der Meilenstein Quantum Supremacy ist schon erreicht.

"Jedes zusätzlich Qubit verdoppelt die Leistungsfähigkeit des Systems"

Hier bleibt einerseits unklar, was mit Leistungsfähigkeit gemeint ist - Rechenleistung, Speicherleistung, Leistung eines Algorithmus, der ein Qubit mehr zur Verfügung hat? Auch wenn wir einen Bit-Speicher (Register) um ein Bit erweitern, also von n auf n+1 Bits, können wir damit 2**(n+1) = 2*2**n Werte speichern bzw. mehr oder längere Befehle ausführen. So hatte sich auch die Prozessorarchitektur von früheren 32 Bit auf 64 Bit bei herkömmlichen Computern verändert und dabei prinzipiell eine 32-fache Verdoppelung der Leistung ermöglicht.

Was macht nun ein Qubit mehr aus bei einem Quanten-Computer? Zum einen gibt es dann doppelt so viele Basiszustände. Z.B. von 8 bei einem 3-Qubit System auf 16 bei 4 Qubits. In Superposition können damit 16 statt nur 8 Koeffizienten (Amplituden) einen Zustand bestimmen. Diese Verdoppelung ist analog der Situation bei Bits und wir hatten das schon oben bei N vs log(N) erklärt.

Zum anderen wissen wir, dass - ganz ander als beim Bit-Computing - verschränkte Zustände eine wichtige Rolle im Qubit-Computing spielen. Man kann sich also fragen, was bringt ein zusätzliches Qubit für die möglichen Verschränkungen, oder allgemein für die möglichen "Konfigurationen" von Superpositionen. Anders ausgedrückt: wieviel mehr Möglichkeiten gibt es für Zustände, in denen nur ein Basiszustand vertreten ist, oder zwei, oder drei usw. - unabhängig von den Werten der Amplituden. Diese Zahl wächst offenbar kombinatorisch. Für n=2 sind die "Muster" noch überschaubar: 4 mal |x>, 6 mal |x>+|y>, 3 mal |x>+|y>+|z> und 1 mal |x>+|y>+|z>+|v>, wenn |x>,|y>,|z>,|v> die Basiszustände |00>, |01>,|10>,|11> durchlaufen.

In Q13 (Superdichte Codierung) haben wir einen anderen Verdopplungseffekt gesehen: die Kapazität, Bitketten in GHZ-verschränkten Qubits zu "speichern" bzw. zu übertragen. Hier brachte jedes weitere Qubit in einer solchen Verschränkung eine Verdoppelung der Anzahl übertragbarer Bitketten.

 

Zuletzt eine Anmerkung: Bei "Was man so liest" fragt man sich leicht, wo man das gelesen hat. Die konkreten Aussagen in den Überschriften sind keine echten Zitate, obwohl sie so oder in Variationen der Wortwahl tatsächlich vorkommen. Wir wollen hier aber kein "Bashing" anzetteln, sondern nur kostruktiv klären, was dahinter steckt oder wo man leicht fehlgeleitet wird. Daher verzichten wir auf Quellenangaben.

 


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"

 

 


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

 


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.


Q4 ZBIT - unterwegs zum Qubit-Modell

Im vorausgegangenen Teil haben wir ein sog. Automaten-Modell für die BIT-Box entwickelt. Ein Automat, genauer, ein endlicher Automat (im Englischen Finite State Machine), ist ein einfaches Konstrukt, das aus folgenden Teilen besteht: Eingabe - innerer Zustand - Ausgabe, eine Methode zur Änderung des Zustands und eine, die den Output festlegt. Endlich heißt der Automat, weil die Möglichkeiten zur Eingabe, die Zustände und die Ausgaben nur einen endlichen Umfang haben.

Das BIT-Box-Modell hat, so gesehen, Null Eingabe-Möglichkeiten (ja, auch das geht!), 2 Zustände und 2 Output-Möglichkeiten. Die Zustandsveränderungen sind durch die beiden kleinen Tabellen für R und X festgelegt und die Output-Methode ist das Messen, M, das auch durch eine Tabelle festgelegt ist. Das BIT-Box-Modell ist damit ein sehr einfacher endlicher Automat. Was dazu führt, dass man sich angewöhnt hat, die mögliche Struktur, die technische Konstruktion eines BITs zu ignorieren und einfach davon zu sprechen, dass ein Bit etwas ist, was "im Zustand 0 oder 1 sein kann". Mit dieser Definition kann man z.B. hervorragend Informatik betreiben, ohne sich um die Physik zu kümmern. Aber das führt hier zu weit - wir wollen ja zum Qubit-Modell.

Z B I T

Am Ende des letzten Abschnitts hatte uns der Große Experimentator mit einer blauen ZBIT-Box konfrontiert. Die wollen wir jetzt verstehen. Wir machen wieder allerlei Klappe-auf / Klappe-zu Experimente, berühren die Touch-Felder usw. Also los!

Als erstes wiederholen wir die für die BIT-Box. Klappe auf: Dunkel. Erst X, dann Klappe auf: Licht usw. Die Messergebnisse sind wie bei der BIT-Box. Jetzt beziehen wir das neue Touch-Feld H in die Experimente ein:

Ausgangspuntk ist immer "Klappe zu".
H und Klappe auf: Licht. Wiederholung: Klappe zu, H und Klappe auf: Dunkel. Nanu! Wiederholung: Dunkel, Wiederholung: Licht. Jetzt werden wir systematisch und wiederholen in einer Serie das Experiment 20 mal und notieren uns die Ergebnisse. Wir bekommen 12 mal Licht, 8 mal Dunkel. Wir wiederholen die Serie: 11 mal Dunkel, 9 mal Licht... Am Ende sind wir überzeugt:

H und M (Klappe auf) ergibt "zufällig" Licht oder Dunkel, im Schnitt jeweils in der Hälfte der Experimente einer Serie.

Jetzt wissen auch auch, warum der G.E. das Feld mit "H" bezeichnet hat: H wie Halbe, oder Hälfte, oder 1/2. Und warum die Box ZBIT heißt: Abkürzung für "Zufalls BIT Intelligence Tester".

Jetzt kommt uns eine weitere Idee: bisher war H berührt worden direkt nach dem  Ausgangspunkt (Klappe zu). Was wäre, wenn wir vorher noch das X  berühren? Machen wir also die Serien noch mal, aber in der Abfolge: Ausgangspunkt, X, H und dann M. Wir stellen fest: bis auf zufällige Abweichungen das gleiche Verhalten wie vorher, ohne X. Halb Licht, halb Dunkel.

Und was ist, wenn wir H zweimal hintereinander berühren, nachdem die Klappe geschlossen wurde? Wir bekommen, auch in Serie, immer Dunkel. Wenn wir vorher noch X berühren, immer Licht. Doppeltes Berühren von  H hebt sich also auf.

Das ZBIT-Modell

Bevor wir weiter experimentieren, versuchen wir uns ein Modell zu machen in der Art wie bei der BIT-Box, quasi als Erweiterung. Wir sehen zunächst, ob das klappt, und überprüfen es dann mit verschiedenen Experimenten.

  1. Wir nehmen für das ZBIT-Modell 3 interen Zustände und und kennzeichen diese Zustände mit [0],  [1] und - neu - [1/2]. Die Zahlen haben wieder keine Bedeutung; wir könnten die Zustände auch Alice, Charly und Bob nennen.
  2. Wir setzen [0] als den Startzustand
  3. Die bekannten Outputs sind wieder D und L, für Dunkel und Licht. Neu ist der in der Serie variable Output, den wir mit P kennzeichnen.
  4. Die beiden Operationen X und R hatten wir schon eingeführt, für Touch-Feld X Berühren bzw. Klappe zu.
  5. Neu hinzugekommen ist das Touch-Feld H. Dafür führen wir den Operator H im Modell ein.
  6. Die  Wirkung von R, X, H auf die ZBIT-Zustände ist wie folgt:

R:  [0] -> [0] und [1] -> [0]  (Reset)
X:  [0] -> [1] und [1] -> [0]  (Switch)
H: [0] -> [1/2] und [1] -> [1/2] (Halbe-Halbe)

Das Messen des ZBIT-Zustands (Klappe auf und schauen) kürzen wir mit M ab. Messen des Zustands ergibt
M: [0] -> D  und  [1] -> L und [1/2] -> P

Da fehlt doch was! Wie wirken die Operationen R, X und H auf den neuen Zustand [1/2]? Wir machen dazu eine zunächst mal plausible Erweiterung der drei kleinen Tabellen und prüfen dann, ob das in sich stimmig wird.

R: [1/2] -> [0] ist plausibel, da "Klappe zu" den Ausgangszustand herstellen soll
X: [1/2] -> [1/2] ist ebenfalls plausibel, denn das Touch-Feld X vertauscht die Zustände nur. Und [1/2] ist der einzige Zustand, der beim "Vertauschen" von  [1/2] mittels X entstehen könnte.
H: [1/2] -> ? Hier müssen wir kurz nachdenken. Wenn der Zustand [1/2] die Bedeutung hätte, in der Hälfte der Fälle eigentlich [0] zu sein und in der anderen Hälfte [1], dann würde H in der einen Hälfte auf [0] wirken und [1/2] ergeben, in der anderen Hälfte auf [1] und ebenfalls [1/2] ergeben. Also scheint es plausibel zu setzen:
H: [1/2] -> [1/2]

Hier noch mal  gesamte Tabelle der Zustandsübergänge als Übersicht:

Zustand | Neuer Zustand bei
        |    R      X       H
[0]     |   [0]    [1]     [1/2]
[1]     |   [0]    [0]     [1/2]
[1/2]   |   [0]    [1/2]   [1/2]

Wir wollen nun einige Experimente (Algorithmen) mit diesen Operationen durchführen und damit überprüfen, ob das ZBIT-Modell mit der ZBIT-Box übereinstimmt.

R ---- X ---- H ---- M -> 1:1 liefert die ZBIT-Box in Serie
[0] -> [1] -> [1/2] -> P       liefert das Modell. Das passt.

R ---- H ------- X ---- M -> 1:1  ZBIT-Box Experimente (in Serie)
[0] -> [1/2] -> [1/2] -> P         ZBIT-Modell Output

Soweit stimmen Modell und die ZBIT-Box des G.E. überein.

Wir haben beim Experimentieren oben gesehen, dass sich zweimal Touch-Feld H hintereinander aufheben. Wir prüfen, ob das mit dem Modell übereinstimmt. Offenbar nicht! 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. Und wie wir der Tabelle entnehmen, hatten wir sinnvollerweise auch HH[0] = HH[1] = H[1/2] = [1/2] gesetzt.

Diese Herleitung ist gleichzeitg ein schönes Beispiel dafür, wie man mit den Automaten-Symbolen rechnen kann! Vielleicht etwas ungewöhnlich, aber verständlich.

Wir müssen also offenbar unser schönes ZBIT-Modell verwerfen, da es mit der Beobachtung an der ZBIT-Box im Widerspruch steht. Ein ganz normales wissenschaftliches Vorgehen.

Können wir ein verbessertes ZBIT-Modell entwerfen, das diesen Widerspruch auflöst? Das besprechen wir im nächsten Blog. Denn auch wenn wir den "Zufalls BIT Intelligenz Test" noch nicht bestanden haben, brauchen wir erst mal eine Pause. Danach geht es dann einen großen Schritt weiter in Richtung Qubit.

 


Q3 Vom Bit- zum Qubit-Modell

Um herauszufinden, was das Hello Qubit World eigentlich macht, müssen wir uns doch erst mal ein Bild davon machen, was ein Qubit sein soll - im Vergleich zu einem Bit. Wir entwickeln dazu ein verständliches Modell eines Qubits, das wir verstehen können ohne die physikalische Quantentheorie verstehen zu müssen.

B I T

Stellen wir uns vor, der Große Experimentator stellt uns einen schwarzen, würfelförmigen Kasten hin, auf dem oben die Buchstaben "B I T" stehen. Der Kasten hat vorne rechts eine Klappe, die man nach unten öffnen kann. Und ein Touch-Feld  markiert mit einem "X"  links daneben.

Was machen wir? Was zuerst? Die Klappe auf oder das Feld berühren? Egal - wir öffnen die Klappe und sehen ... nichts, es ist dunkel in der Box. Wir schließen die Klappe und öffnen sie wieder. Keine Änderung. Wir berühren das Touch-Feld: es tut sich nichts. Wir schließen die Klappe, berühren das Feld, machen die Klappe auf: Licht. Aha! Klappe zu, Klappe auf: wieder Dunkel. Aha! Es kristallisiert sich eine Vermutung heraus. Und jetzt werden wir systematisch:

  1. Ausgangspunkt: Klappe zu
  2. Klappe auf: Dunkel
  3. Wiederholung: es bleibt Dunkel
  4. Ausgangspunkt: Klappe zu
  5. X berühren, Klappe auf: Licht
  6. Wie 4. und 5., aber zweimal hintereinander X berühren: Dunkel
  7. Wiederholungen 1.-3. bzw. 4. und 5. bzw. 7. zur statistischen Absicherung.

Das lässt uns folgende empirische Regel vermuten:

Macht man nur die Klappe auf, ist es dunkel. Berührt man vorher das Touch-Feld, sieht man Licht. Berührt man es mehrmals hintereinander, heben sich jeweils zwei X gegeneinander auf.

(Jetzt wissen wir auch, warum der Große Experimentator den Kasten mit BIT beschriftet hat: Abkürzung für "BIT Intelligence Tester". War aber ziemlich einfach.)

Wie die BIT-Box das macht, wie sie konstruiert ist, können wir leider nicht wissen. Selbst wenn wir sie zerschlagen würden, hätten wir nur ein paar unverständliche Brocken. Wir können aber ein Modell davon machen, zunächst auf Papier.

Das BIT-Modell

Wir legen fest, BIT hat eine interne Zustandsvariable. Die kann zwei Werte (Zustände) annehmen. Mit der gültigen Operation X , das entspricht dem Touch-Feld-Berühren bei der Box,  lässt sich der Modellzustand wechseln. Die Operation R, das dem Schließen der Klappe entspricht, stellt einen festgelegten Anfangszustand von BIT her (Reset). BIT gibt uns je nach Zustand ein Signal als Output, das "Licht" oder "Dunkel" entspricht. Dazu müssen wir aber etwas tun: bei der Box die Klappe öffnen und nachschauen. Wir können das als Messen (M) des BIT-Zustands auffassen. Die Operation X kann nur "bei geschlossener Klappe" ausgelöst werden, d.h. wir können die Wirkung der Operation nicht unmittelbar beobachten, ebenso wenig wie die internen Zustände. Wir erschließen beides aufgrund des Outputs, den wir durch M (Klappe auf) bekommen.

Nach dieser Modellbeschreibung können wir leicht eine weiße Box konstruieren und bauen. Das einfachste ist eine kleine Lichtanlage mit einem (inneren) Schalter, der durch "Knopfdruck" X geschaltet wird - aber nur wenn die Beobachtungsklappe geschlossen ist.

Wir können es aber etwas "mathematischer" beschreiben, so dass wir im Prinzip das BIT-Modell "berechnen" können.

  1. Wir kennzeichen die beiden Zustände mit [0] und [1]. Die Ziffern haben keine Bedeutung; wir könnten die Zustände auch Paul und Paula nennen.
  2. Wir setzen [0] als den Startzustand
  3. Die Outputs des Modells werden als D und L abgekürzt, für Dunkel und Licht
  4. Die beiden Operationen X und R hatten wir schon eingeführt: Touch-Feld Berühren bzw. Klappe zu.  Ihre Wirkung auf den BIT-Zustand ist wie folgt:

R:  [0] -> [0] und [1] -> [0]  (Reset)
X:  [0] -> [1] und [1] -> [0]  (Switch)

Das Messen des BIT-Zustands (Klappe auf und schauen) kürzen wir mit M ab. Messen des Zustands ergibt
M: [0] -> D  und  [1] -> L

Ein Experiment mit diesem Modell kann dann z.B. so beschrieben werden: R--X--X--M .  Was bedeutet das? Im Modell können wir die Zustandsfolge und den Output nun "berechnen":

R -----X-----X-----M
[0] -> [1] -> [0] -> D

Der Output nach M ist - D.  Beim entsprechende Experiment mit der black box  können wir davon nur Dunkel beobachten. das entspricht dem D als Output. Die Operationen können wir auslösen, aber ihren Effekt nur erschließen, z.B. aus
R----M -> D
R----X----M -> L

Was ergibt folgender Algorithmus?
R----X----X----R----M
Nichts - diese Abfolge ist offenbar nicht zulässig. Solange die Klappe zu ist kann sie nicht wieder geschlossen werden. Es gibt also gewisse Regeln zu beachten in der Aufeinanderfolge von Operationen. Nicht alles ist möglich, bzw, "wohldefiniert".

R----X----M----R----M ist dagegen möglich. Der Output ist D - klar?

Nicht von ungefähr erinnern diese Operations-Linien schon an die Diagramme von einfachen Qubit-Algorithmen im letzten Abschnitt.

Algorithmen

Wir können mit dem BIT-Modell bereits kleine Algorithmen formulieren und - gedanklich - mit der BIT-Box manuell durchführen. Ein Beispiel:

R---X---M---R---M---R---X---M   liefert an den Messpunkten (M): L D L

oder Beeb Bib Beeb, den Morse-Code für den Buchstaben 'K'.

Als kleine Übungen kann man versuchen, BIT-Modell Algorithmen aufzuschreiben, die z.B. 'GE' oder 'Hello World' ausgeben - in Morse Code oder ASCII. Wer Lust hat, kann Ergebnise, Fragen oder Diskussionsbeiträge in das Kommentarfeld zum Blog eintragen.

Offenbar haben wir damit die BIT-Box verstanden. Gemeinerweise hat der Grosse Experimentator aber noch eine ganze Reihe von anderen BIT Boxen auf Lager. So finden wir jetzt eine Box in Blau vor, die im Wesentlichen so aussieht wie die BIT-Box. Allerdings hat sie ein weiteres Touch-Feld H, so dass wir links neben der Klappe jetzt die Berühr-Felder X und H finden. Und oben steht jetzt, Weiß auf Blau, "ZBIT".

 

Bevor wir uns aber daran machen, die ZBIT-Box zu analysieren, brauchen wir eine kleine Pause. Daher geht es im nächsten Teil weiter mit der ZBIT-Box.

 


Q1 Etwas ist anders! - Qubit-Algorithmen

Muss ich Quantenphysik kennen, oder verstehen, wie Quantencomputer funktionieren, um mich mit  sog. Quanten-Algorithmen zu beschäftigen?

Sicher nicht! Lass uns deshalb lieber von Qubit-Algorithmen, oder kurz Q-Algorithmen sprechen.  Die Idee der Qubit-Algorithmen gab es schon, bevor die ersten Quantencomputer nutzbar wurden.

Nicht anders als bei den Bit-Algorithmen, den herkömmlichen Algorithmen, die für "normale" Computer programmiert werden. Auch hier verstehen die Wenigsten die zugrunde liegende Physik und viele auch nicht, wie normale Computer funktionieren. Hauptsache, man kann spielen, chatten, Musik hören - ja, und manchmal sogar programmieren.

Allerdings - etwas ist anders bei Q-Algorithmen. Was darauf zurückzuführen ist, dass irgendwo doch die Quantenphysik schon im Hinterkopf war, als  Qubits und Qubit-Algorithmen "erfunden" wurden. Das wollen wir hier heraus finden.

Und es ist echt spannend, dass man heute reale, programmierbare Quantencomputer im Internet (als Cloud Service) frei verwenden kann, z.B. von IBM oder Google. Es ist schon ein etwas anderes Gefühl, ein eigenes kleines Q-Programm auf einem realen Q-Computer laufen zu lassen. Einfacher geht es übrigens mit Q-Computer-Simulatoren, also "Modellen" von Quantencomputern, die auf normalen Computern laufen und so tun, als wären sie QCs. Zum Ausprobieren von Q-Algorithmen perfekt.

Es wird heutzutage in den Medien viel Wunderliches über QCs und Qubit-Algorithmen geschrieben. Wie super-schnell sie sind - genauer, in Zukunft sein werden, welche geheimnisvollen Objekte Qubits sind, die gleichzeitig verschiedene Zustände haben können. Dann ist da von "Schrödingers Katze" die Rede, die gleichzeitig tot und lebendig sein soll - also wohl ein Zombie? (Jedenfalls solange, bis man nachschaut - dann ist sie entweder tot oder lebendig!) Und dass ein Quantencomputer daher doppelt so schnell Lösungen errechnet, wenn man nur ein Qubit hinzufügt. Es ist von der  "Supremacy" von Quantencomputern die Rede, ein Wort, das ausdrücken soll, dass wir bald QCs haben werden, die - bei bestimmten Rechnungen - schneller sein werden als der schnellste Supercomputer.  Und damit z.B. die stärksten heute verwendeten Verschlüsselungen im Nu knacken können.

Wenn wir uns mit Bits und Qubits und Qubit-Algorithmen näher beschäftigen, werden wir sehen, was davon zu halten ist und was dahinter steckt. Wenn man es selbst ausprobiert hat, wird man den Zauber schon verstehen. Wenn man die Katze streichelt, merkt man schon, wie lebendig sie ist.

Als nächstes wollen wir sehen, was ein Qubit bedeutet - oder wir schauen uns erst einmal ein einfaches Beispiel eines Q-Algorithmus an, um einen Eindruck zu bekommen, aber ohne es schon verstehen zu müssen. Am liebsten beides gleichzeitig? Mal sehen, wie die Entscheidung ausfällt.

Fortsetzung folgt - Stay tuned

Übrigens, wer Lust hat, kann Fragen, Ideen, Kommentare oder Diskussionen direkt ins Kommentarfeld unter dem Blog schreiben.

Und hier geht's weiter.