Quantenteleportation

Für dieses Qiskit-in-Classrooms-Modul benötigen die Studierenden eine funktionierende Python-Umgebung mit folgenden installierten Paketen:

• qiskit v2.1.0 oder neuer
• qiskit-ibm-runtime v0.40.1 oder neuer
• qiskit-aer v0.17.0 oder neuer
• qiskit.visualization
• numpy
• pylatexenc

Informationen zur Einrichtung und Installation der oben genannten Pakete findest du im Qiskit installieren-Leitfaden. Um Jobs auf echten Quantencomputern ausführen zu können, müssen die Studierenden ein Konto bei IBM Quantum® einrichten. Die dazu notwendigen Schritte sind im Leitfaden IBM Cloud-Konto einrichten beschrieben.

Dieses Modul wurde getestet und hat 14 Sekunden QPU-Zeit verbraucht. Dies ist nur eine Schätzung. Deine tatsächliche Nutzung kann abweichen.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-aer qiskit-ibm-runtime

# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

Schau dir unten die Modulführung von Dr. Katie McCormick an oder klicke hier, um sie auf YouTube anzusehen.

---

Einführung und Hintergrund

Quantenteleportation ist eine Technik der Quantenphysik, die die Übertragung von Quanteninformationen von einem Ort zu einem anderen ermöglicht, ohne dass Teilchen physisch bewegt werden. Anders als beim Science-Fiction-Konzept der Teleportation wird dabei keine Materie transportiert. Stattdessen beruht das Verfahren auf dem Prinzip der Quantenverschränkung, bei dem zwei Teilchen unabhängig von ihrer Entfernung miteinander verbunden werden. Durch eine Reihe präziser Messungen und klassischer Kommunikation kann der Quantenzustand eines Teilchens in einem anderen Teilchen an einem weit entfernten Ort neu erzeugt werden – die Quanteninformation wird damit praktisch „teleportiert". In diesem Modul werden wir sehen, wie dies mathematisch funktioniert, und anschließend die Quantenteleportation auf einem echten Quantencomputer implementieren. Die Einführung hier ist bewusst kurz gehalten. Für mehr Hintergrundwissen zur Quanteninformation und ausführlichere Erklärungen zur Teleportation empfehlen wir John Watrous' Kurs Grundlagen der Quanteninformation, insbesondere den Abschnitt über Teleportation.

Klassische Bits können die Zustände 0 oder 1 annehmen. Quantenbits (Qubits) können die Quantenzustände $|0\rangle$ und $|1\rangle$ sowie Linearkombinationen dieser Zustände einnehmen, sogenannte „Superpositionen", wie etwa $|\psi\rangle = \alpha_0|0\rangle +\alpha_1|1\rangle$, mit $\alpha_0,\alpha_1 \in \mathbb{C}$ und $|\alpha_0|^2+|\alpha_1|^2 = 1.$ Obwohl die Zustände in dieser Superposition existieren können, wird der Zustand durch eine Messung auf entweder $|0\rangle$ oder $|1\rangle$ „kollabiert". Die Parameter $a$ und $b$ sind gemäß folgender Gleichungen mit der Wahrscheinlichkeit des jeweiligen Messergebnisses verknüpft:

$$P_0 = |\alpha_0|^2$$ $$P_1 = |\alpha_1|^2$$

Daher gilt die Bedingung $|\alpha_0|^2+|\alpha_1|^2 = 1.$

Ein weiteres Schlüsselmerkmal ist, dass Quantenbits „verschränkt" sein können. Das bedeutet, dass die Messung eines Qubits das Ergebnis der Messung eines anderen, verschränkten Qubits beeinflussen kann. Es ist etwas knifflig zu verstehen, worin sich Verschränkung von einfachen klassischen Korrelationen unterscheidet. Zunächst zur Notation: Wir nennen zwei Qubits, die zu Freund 0 (Alice) und Freund 1 (Bob) gehören und sich jeweils im Zustand $|0\rangle$ befinden:

$$|0\rangle_B|0\rangle_A$$

oder

$$|0\rangle_1|0\rangle_0$$

was oft einfach zu

$$|00\rangle$$

abgekürzt wird.

Beachte, dass das am niedrigsten nummerierte (oder alphabetisch erste) Qubit ganz rechts steht. Diese Konvention wird als „Little-Endian"-Notation bezeichnet und durchgehend in Qiskit verwendet. Wenn der Zwei-Qubit-Zustand der Freunde $|00\rangle$ ist und sie den Zustand ihrer jeweiligen Qubits messen, werden beide eine 0 finden. Ebenso würde jede ihrer Messungen eine 1 ergeben, wenn sich die Qubits im Zustand $|11\rangle$ befänden. Das ist nicht anders als im klassischen Fall. In der Quantencomputerrechnung können wir dies jedoch mit Superposition kombinieren, um Zustände wie den folgenden zu erhalten:

$$\frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$$

In einem solchen Zustand ist noch nicht bekannt – nicht einmal von der Natur festgelegt –, ob die Qubits von Alice und Bob im Zustand 0 oder 1 sind. Und dennoch weiß man, dass sie beim Messen denselben Zustand feststellen werden. Misst Bob beispielsweise sein Qubit im Zustand $|0\rangle$, so kann das nur dadurch geschehen sein, dass die Messung den Zwei-Qubit-Zustand auf einen der beiden möglichen Zustände kollabiert hat, nämlich auf $|00\rangle.$ Damit befindet sich Alices Qubit ebenfalls im Zustand $|0\rangle$.

Diese Verschränkung von Qubits erfordert nicht, dass die Qubits physisch nahe beieinander bleiben. Mit anderen Worten: Wir könnten Qubits verschränken, sie dann über große Entfernungen trennen und ihre Verschränkung nutzen, um Informationen zu übertragen. Ein verschränkter Zustand wie der oben gezeigte ist eine Grundeinheit der Verschränkung und wird manchmal als „e-Bit" bezeichnet – ein einzelnes Bit der Verschränkung. Diese e-Bits können als Ressourcen in der Quantenkommunikation betrachtet werden, da jedes e-Bit, das zwischen weit entfernten Partnern geteilt wird, – wie hier beschrieben – genutzt werden kann, um Informationen von einem Ort zu einem anderen zu übertragen.

Der erste Gedanke vieler Menschen, die dies zum ersten Mal hören, dreht sich um den Verstoß gegen die Relativitätstheorie: Kann man damit Informationen schneller als das Licht senden? Behalte diese kritische Haltung gegenüber wissenschaftlichen Regeln ruhig bei, aber leider erlaubt dies keine Übertragung von Informationen schneller als Licht – aus Gründen, die im Verlauf dieses Moduls deutlich werden. Spoiler: Erstaunlicherweise liegt es NICHT an der Geschwindigkeit, mit der sich dieser Kollaps ausbreitet, die tatsächlich schneller als Licht zu geschehen scheint [1]. Wir beginnen mit zwei Beteiligten: Alice und Bob, die sich zunächst am gleichen Ort befinden und gemeinsam an denselben Qubits arbeiten können. Sie verschränken ihre Qubits miteinander. Dann trennen sie sich und begeben sich an zwei verschiedene geografische Orte, wobei jeder sein Qubit mitnimmt. Alice erhält dann Quanteninformation auf einem neuen Qubit Q. Wir machen keine Annahmen über die Information auf Q. Der Zustand von Q könnte ein Geheimnis sein, das Alice unbekannt ist; er könnte sogar für alle Menschen unbekannt sein. Alice hat jedoch die Aufgabe, die Information auf Q an Bob zu übertragen. Dies wird sie mithilfe der Quantenteleportation tun.

Um dies zu erreichen, müssen wir einige Quantenoperationen oder „Gates" kennen.

Quantenoperatoren (Gates)

Dieser Abschnitt kann übersprungen werden, wenn du mit Quantengattern bereits vertraut bist. Möchtest du diese Gates besser verstehen, schau dir Grundlagen der Quanteninformation an, insbesondere die ersten beiden Lektionen auf IBM Quantum Learning.

Für dieses Teleportationsprotokoll werden wir hauptsächlich zwei Typen von Quantengattern verwenden: das Hadamard-Gate und das CNOT-Gate. Einige weitere Gates spielen eine untergeordnete Rolle: das $X$-Gate, das $Z$-Gate und das SWAP-Gate.

Dieses Modul kann mit sehr begrenzten Vorkenntnissen in linearer Algebra abgeschlossen werden, aber es kann manchmal hilfreich sein, quantenmechanische Gates mithilfe von Matrizen und Vektoren zu visualisieren. Daher stellen wir hier auch die Matrix- und Vektorformen von Quantengattern und -zuständen vor.

Die bereits eingeführten Zustände sind (teils durch Konvention und teils durch Rahmenbedingungen) so gewählt, dass sie folgende Vektorformen haben:

$$|0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix}$$ $$|1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}$$

Damit lässt sich ein beliebiger Zustand $|\psi\rangle = a|0\rangle+b|1\rangle$ schreiben als:

$$|\psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}$$

Es gibt verschiedene Möglichkeiten, die Notation auf Mehr-Qubit-Zustände zu erweitern, aber die folgende Wahl ist weit verbreitet:

$$|00\rangle = \begin{pmatrix}1 \\ 0 \\ 0 \\ 0\end{pmatrix},|01\rangle = \begin{pmatrix}0 \\ 1 \\ 0 \\ 0\end{pmatrix}, |10\rangle = \begin{pmatrix}0 \\ 0 \\ 1 \\0\end{pmatrix},|11\rangle = \begin{pmatrix}0 \\ 0 \\ 0 \\ 1\end{pmatrix}.$$

Mit dieser Vektornotation im Hinterkopf können wir nun die benötigten Quantengatter, ihre Wirkung auf Quantenzustände und ihre Matrixformen vorstellen.

H Hadamard-Gate: Erzeugt einen Superpositionszustand. Einzel-Qubit-Gate.

$$H|0\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right),$$ $$H|1\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right)$$ $$H=\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}$$

Ein Circuit mit einem Hadamard-Gate wird wie folgt erstellt:

from qiskit import QuantumCircuit

qc = QuantumCircuit(1)
qc.h(0)
qc.draw("mpl")

CNOT Controlled-NOT-Gate: Dieses Gate verwendet zwei Qubits: ein Steuer-Qubit (Control) und ein Ziel-Qubit (Target). Es prüft den Zustand des Steuer-Qubits, das selbst unverändert bleibt. Befindet sich das Steuer-Qubit jedoch im Zustand $|1\rangle$, ändert das Gate den Zustand des Ziel-Qubits; befindet sich das Steuer-Qubit im Zustand $|0\rangle$, wird keine Änderung vorgenommen. In der folgenden Notation ist Qubit $A$ (das Qubit ganz rechts) das Steuer-Qubit und Qubit $B$ (das Qubit ganz links) das Ziel-Qubit. Die verwendete Notation lautet $CNOT(q_{control},q_{target})|BA\rangle.$

$$CNOT(A,B)|00\rangle = |00\rangle, \\ CNOT(A,B)|01\rangle = |11\rangle, \\ CNOT(A,B)|10\rangle = |10\rangle, \\ CNOT(A,B)|11\rangle = |01\rangle$$

Manchmal wird CNOT ohne explizite Angabe der Reihenfolge von Steuer- und Ziel-Qubit geschrieben. In Code oder Schaltkreisdiagrammen gibt es jedoch keine solche Mehrdeutigkeit.

$$CNOT=\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}$$

Ein CNOT-Gate sieht in einem Circuit etwas anders aus, da es zwei Qubits benötigt. So wird es implementiert:

qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.draw("mpl")

Verständnisfragen

Lies die folgende Frage, denke über deine Antwort nach und klicke dann auf das Dreieck, um die Lösung einzublenden.

Die meisten Gates haben in Qiskit dieselbe Matrixform wie anderswo. Das CNOT-Gate wirkt jedoch auf zwei Qubits, weshalb die Reihenfolge der Qubits plötzlich eine Rolle spielt. Fachbücher, die Qubits in der Reihenfolge $|q_0,q_1,...\rangle$ anordnen, zeigen eine andere Matrixform für ihre CNOT-Gates. Verifiziere durch explizite Matrixmultiplikation, dass die obige CNOT-Matrix die korrekte Wirkung auf den Zustand $|01\rangle$ hat.

Antwort:

$CNOT|01\rangle =\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}\begin{pmatrix}0 \\ 1 \\ 0 \\0\end{pmatrix} = \begin{pmatrix}0 \\ 0 \\ 0 \\1\end{pmatrix} = |11\rangle$

$X$-Gate: Entspricht einer NOT-Operation. Einzel-Qubit-Gate.

$$X|0\rangle = |1\rangle,\\X|1\rangle=|0\rangle$$ $$X=\begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}$$

In Qiskit sieht das Erstellen eines Circuits mit einem $X$-Gate so aus:

qc = QuantumCircuit(1)
qc.x(0)
qc.draw("mpl")

$Z$-Gate: Fügt einem Zustand eine „Phase" hinzu (einen Vorfaktor, der im Fall der $Z$-Eigenzustände $|0\rangle$ und $|1\rangle$ entweder 1 oder -1 ist). Einzel-Qubit-Gate.

$$Z|0\rangle = |0\rangle,\\Z|1\rangle=-|1\rangle$$ $$Z=\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$$

In Qiskit sieht das Erstellen eines Circuits mit einem $Z$-Gate so aus:

qc = QuantumCircuit(1)
qc.z(0)
qc.draw("mpl")

Theorie

Lass uns das Protokoll zur Quantenteleportation mathematisch herleiten. Im nächsten Abschnitt werden wir dieses Setup dann auf einem Quantencomputer realisieren.

Alice und Bob verschränken ihre Qubits: Anfangs befinden sich Alices Qubit und Bobs Qubit jeweils einzeln im Zustand $|0\rangle$ (eine vernünftige Annahme und zugleich die korrekte Initialisierung für IBM®-Quantencomputer). Wir können dies als $|0\rangle_B|0\rangle_A$ oder einfach als $|00\rangle$ schreiben. Berechnen wir, was geschieht, wenn Alice und Bob das Hadamard-Gate auf Alices Qubit und dann ein CNOT-Gate mit Alices Qubit als Steuer- und Bobs Qubit als Ziel-Qubit anwenden:

$$\begin{aligned} CNOT(A,B)H_A |0\rangle_B|0\rangle_A &= CNOT(A,B)|0\rangle_B\frac{1}{\sqrt{2}}\left(|0\rangle_A+|1\rangle_A\right)\\ &=\frac{1}{\sqrt{2}}\left(CNOT(A,B)|0\rangle_B|0\rangle_A+CNOT(A,B)|0\rangle_B|1\rangle_A\right)\\ &=\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right) \end{aligned}$$

Beachte, dass Alices und Bobs Qubits jetzt verschränkt sind. Obwohl es von der Natur noch nicht festgelegt ist, ob sich beide Qubits im Zustand $|0\rangle$ oder $|1\rangle$ befinden, ist bekannt, dass ihre Qubits im gleichen Zustand sind. Alice und Bob trennen sich: Die beiden Freunde bringen ihre Qubits an neue Orte, die möglicherweise sehr weit voneinander entfernt sind. Dies ist mit vielen Einschränkungen verbunden: Quanteninformation ohne Störung zu bewegen ist nicht trivial. Aber es ist möglich, und du wirst es in diesem Modul tun. Behalte dabei jedoch im Hinterkopf, dass beim Übertragen von Quanteninformation mit Fehlern zu rechnen ist.

Q wird eingeführt: Der geheime Zustand wird auf Qubit Q präpariert:

$$|\psi\rangle_Q = \alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q$$

Zu diesem Zeitpunkt befindet sich Q lediglich neben Alices Qubit (A). Es gibt noch keine Verschränkung, daher kann der Quantenzustand aller drei Qubits zusammen geschrieben werden als:

$$|\psi\rangle_{AB}|\psi\rangle_Q = \frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right).$$

Das Ziel ist es, die Information auf Q von Alices Standort zum Standort von Bob zu übertragen. Dabei werden zunächst keine Aussagen oder Anforderungen bezüglich Geheimhaltung oder Übertragungsgeschwindigkeit gemacht. Wir untersuchen lediglich, wie Information von Alice zu Bob gelangen kann. Da die Information zunächst auf Q liegt, nehmen wir an, dass Q die niedrigste Qubitnummer erhält, sodass Q in der Little-Endian-Notation das Qubit ganz rechts in der folgenden Mathematik ist.

Alice verschränkt die Qubits A und Q: Alice wendet nun ein CNOT-Gate mit ihrem eigenen Qubit als Steuer-Qubit und Q als Ziel-Qubit an und appliziert anschließend ein Hadamard-Gate auf Q. Berechnen wir den Drei-Qubit-Zustand nach dieser Operation:

$$\begin{aligned} H_Q CNOT(A,Q)|\psi\rangle_{AB}|\psi\rangle_Q &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right)\\ &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|0\rangle_A|1\rangle_Q\right)+\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|1\rangle_A|1\rangle_Q\right)\right)\\ &= H_Q \frac{1}{\sqrt{2}}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q+\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right)\\ &= \frac{1}{2}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_0 |0\rangle_B|0\rangle_A|1\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|0\rangle_Q-\alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q\right)\\ &+\frac{1}{2}\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_0 |1\rangle_B|1\rangle_A|1\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|0\rangle_Q - \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right) \end{aligned}$$

Da sich A und Q am selben Ort befinden, gruppieren wir die obigen Terme nach den möglichen Messergebnissen der Qubits A und Q:

$$\begin{aligned} |\psi\rangle = \frac{1}{2}\left((\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|0\rangle_A|0\rangle_Q + (\alpha_0 |0\rangle_B-\alpha_1 |1\rangle_B)|0\rangle_A|1\rangle_Q + (\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|0\rangle_Q+ (-\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|1\rangle_Q \right)\\ \end{aligned}$$

Verständnisfragen

Lies die folgende Frage, denke über deine Antwort nach und klicke dann auf das Dreieck, um die Lösung einzublenden.

Wie groß ist die Wahrscheinlichkeit, dass eine Messung der Qubits A und Q das Ergebnis $|0\rangle_A|0\rangle_Q$ liefert, wenn man den oben angegebenen Ausdruck für die Zustände aller drei Qubits zugrunde legt?

Antwort:

25 %. Um dies einzusehen, erinnere daran, dass Bobs Zustand normiert sein muss, also: $|_A \langle0|_Q\langle0| \frac{1}{2} |0\rangle_A|0\rangle_Q (\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}|(\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}$

Nun kann Alice die Qubits A und Q messen. Das Ergebnis dieser Messung kann sie nicht beeinflussen, da Quantenmessungen probabilistisch sind. Wenn sie also misst, gibt es 4 mögliche Ergebnisse, die alle gleich wahrscheinlich sind: $|0\rangle_A|0\rangle_Q,$ $|0\rangle_A|1\rangle_Q,$ $|1\rangle_A|0\rangle_Q$ und $|1\rangle_A|1\rangle_Q.$ Beachte, dass jedes Ergebnis andere Auswirkungen auf Bobs Qubit hat. Misst Alice beispielsweise $|0\rangle_A|0\rangle_Q$, kollabiert der gesamte Drei-Qubit-Zustand auf $(\alpha_0|0\rangle_B+\alpha_1|1\rangle_B)|0\rangle_A|0\rangle_Q.$ Andere Messergebnisse für Alice führen zu unterschiedlichen Zuständen für Bob. Diese sind in der folgenden Tabelle zusammengefasst.

Alices Messergebnis	Bobs Zustand	Anweisung an Bob	Ergebnis
$\vert 0\rangle_A \vert 0\rangle_Q$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$	Keine	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 0\rangle_A \vert 1\rangle_Q$	$\alpha_0\vert 0\rangle_B-\alpha_1\vert 1\rangle_B$	$Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 0\rangle_Q$	$\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 1\rangle_Q$	$-\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$ und dann $Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
Für alle möglichen Messergebnisse von Alices Qubits befindet sich Bobs Qubit in einem Zustand, der dem ursprünglichen Geheimzustand auf Q ähnelt. In dem Fall, dass Alice $	0\rangle_C	0\rangle_A$misst (erste Zeile der Tabelle), entspricht Bobs Qubit exakt dem Geheimzustand! In den anderen Fällen stimmt etwas nicht: Die Koeffizienten ($\alpha$s) sind vertauscht, oder es gibt ein „-"-Vorzeichen, wo ein „+"-Vorzeichen stehen sollte, oder beides. Um Bobs Qubit so zu modifizieren, dass es genau dem Geheimzustand entspricht, muss Alice Bob anrufen (klassische Kommunikation nutzen) und ihm mitteilen, welche zusätzlichen Operationen er an seinem Qubit vornehmen soll, wie in der Tabelle angegeben. In der dritten Zeile zum Beispiel sind die Koeffizienten vertauscht. Wenn Alice Bob anruft und ihm sagt, er soll ein$X$-Gate auf sein Qubit anwenden, wird$	0\rangle$in$

Damit wird klar, warum wir dieses Setup nicht nutzen können, um Informationen schneller als Licht zu senden. Wir könnten Glück haben und $|0\rangle_A|0\rangle_Q$ messen, was bedeuten würde, dass Bob sofort den Geheimzustand hat. Aber Bob weiß das erst, wenn wir ihn anrufen und ihm sagen: „Wir haben $|0\rangle_A|0\rangle_Q$ gemessen, du musst also nichts tun."

Im Gedankenexperiment werden die Qubits oft physisch getrennt und an neue Orte gebracht. IBM®-Quantencomputer verwenden Festkörper-Qubits auf einem Chip, die sich nicht trennen lassen. Anstatt Alice und Bob an verschiedene Orte zu versetzen, werden wir daher die Information auf dem Chip selbst durch sogenannte „Swap-Gates" von einem Qubit auf ein anderes verschieben.

Experiment 1: Grundlegende Teleportation

IBM Quantum empfiehlt, Quantencomputerprobleme mit einem Framework namens „Qiskit Patterns" anzugehen. Es besteht aus folgenden Schritten:

• Schritt 1: Problem auf einen Quantenschaltkreis abbilden
• Schritt 2: Schaltkreis für die Ausführung auf echter Quantenhardware optimieren
• Schritt 3: Job auf IBM-Quantencomputern mit Runtime Primitives ausführen
• Schritt 4: Ergebnisse nachverarbeiten

Schritt 1: Problem auf einen Quantenschaltkreis abbilden

Die gesamte Mathematik, die wir oben durchgeführt haben, beschreibt Schritt 1. Jetzt werden wir ihn implementieren und unseren Quantenschaltkreis mit Qiskit aufbauen! Wir beginnen mit einem Quantenschaltkreis aus drei Qubits und verschränken die beiden Qubits von Alice und Bob. Diese werden Qubits 1 und 2 sein; Qubit 0 reservieren wir für den Geheimzustand.

# Step 1: Map your problem to a quantum circuit

# Import some general packages
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np

# Define registers
secret = QuantumRegister(1, "Q")
Alice = QuantumRegister(1, "A")
Bob = QuantumRegister(1, "B")

cr = ClassicalRegister(3, "c")

qc = QuantumCircuit(secret, Alice, Bob, cr)

# We entangle Alice's and Bob's qubits as in our work above. We apply a Hadamard gate and then a CNOT gate.
# Note that the second argument in the CNOT gate is the target.
qc.h(Alice)
qc.cx(Alice, Bob)

# Inserting a barrier changes nothing about the logic. It just allows us to force gates to be positioned in "layers".
qc.barrier()

# Now we will use random variables to create the secret state. Don't worry about the "u" gate and the details.
np.random.seed(42)  # fixing seed for repeatability
theta = np.random.uniform(0.0, 1.0) * np.pi  # from 0 to pi
varphi = np.random.uniform(0.0, 2.0) * np.pi  # from 0 to 2*pi

# Assign the secret state to the qubit on the other side of Alice's (qubit 0), labeled Q
qc.u(theta, varphi, 0.0, secret)
qc.barrier()

# Now entangle Q and Alice's qubits as in the discussion above.
qc.cx(secret, Alice)
qc.h(secret)
qc.barrier()

# Now Alice measures her qubits, and stores the outcomes in the "classical registers" cr[]
qc.measure(Alice, cr[1])
qc.measure(secret, cr[0])

# Now we insert some conditional logic. If Alice measures Q in a "1" we need a Z gate, and if Alice measures A in a "1" we need an X gate (see the table).
with qc.if_test((cr[1], 1)):
    qc.x(Bob)
with qc.if_test((cr[0], 1)):
    qc.z(Bob)

qc.draw(output="mpl")

Das ist alles, was wir tun müssen, um Alices Zustand zu Bob zu teleportieren. Erinnere dich jedoch daran, dass beim Messen eines Quantenzustands $\alpha_0 |0\rangle+\alpha_1|1\rangle$ entweder $|0\rangle$ oder $|1\rangle$ gemessen wird. Am Ende dieses Prozesses hat Bob definitiv Alices Geheimzustand, aber wir können dies mit einer Messung nicht ohne Weiteres überprüfen. Damit eine Messung uns bestätigt, dass wir alles richtig gemacht haben, müssen wir einen Trick anwenden. Wir hatten einen Operator namens „U" für „unitär", mit dem wir Alices Geheimzustand vorbereitet haben. Wir können die Inverse von U am Ende unseres Circuits anwenden. Hat U Alices $|0\rangle$-Zustand in $\alpha_0 |0\rangle+\alpha_1|1\rangle$ überführt, so wird die Inverse von U Bobs $\alpha_0 |0\rangle+\alpha_1|1\rangle$ zurück in $|0\rangle$ abbilden. Dieser letzte Schritt würde eigentlich nicht gemacht werden, wenn das Ziel nur das Übertragen von Quanteninformation wäre. Er dient lediglich zur Überprüfung unseres Ergebnisses.

# Add the inverse of U and measure Bob's qubit.
qc.barrier()

qc.u(theta, varphi, 0.0, Bob).inverse()  # inverse of u(theta,varphi,0.0)
qc.measure(Bob, cr[2])  # add measurement gate

qc.draw(output="mpl")

Wenn wir alles richtig gemacht haben, sollte unsere Messung von Bobs Qubit den Zustand $|0\rangle$ ergeben. Diese Messungen sind natürlich probabilistisch. Selbst wenn die Wahrscheinlichkeit, Bobs Qubit im Zustand $|1\rangle$ zu messen, sehr klein ist, könnte eine einzelne Messung $|1\rangle$ ergeben. Wir müssten viele Messungen durchführen, um sicherzustellen, dass die Wahrscheinlichkeit für $|0\rangle$ hinreichend hoch ist.

Schritt 2: Problem für die Quantenausführung optimieren

Dieser Schritt übersetzt die gewünschten Operationen in die Funktionalität eines bestimmten Quantencomputers. Außerdem wird unser Problem auf das Layout des Quantencomputers abgebildet.

Wir beginnen damit, mehrere Pakete zu laden, die für die Kommunikation mit IBM-Quantencomputern benötigt werden. Außerdem müssen wir ein Backend auswählen, auf dem wir ausführen möchten. Wir können entweder das am wenigsten ausgelastete Backend wählen oder ein bestimmtes Backend mit bekannten Eigenschaften auswählen.

Im folgenden Code findest du Zeilen, um deine Anmeldeinformationen beim ersten Gebrauch zu speichern. Lösche diese Informationen unbedingt aus dem Notebook, nachdem du sie in deiner Umgebung gespeichert hast, damit deine Zugangsdaten beim Teilen des Notebooks nicht versehentlich weitergegeben werden. Weitere Informationen findest du unter IBM Cloud-Konto einrichten und Den Dienst in einer nicht vertrauenswürdigen Umgebung initialisieren.

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load the Qiskit Runtime service

# Syntax for first saving your token.  Delete these lines after saving your credentials.
# QiskitRuntimeService.save_account(channel='ibm_quantum_platform', instance = '<YOUR_IBM_INSTANCE_CRN>', token='<YOUR-API_KEY>', overwrite=True, set_as_default=True)
# service = QiskitRuntimeService(channel='ibm_quantum_platform')

# Load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_brisbane".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_brisbane")
print(backend.name)

ibm_sherbrooke

Wir aktivieren explizit die Logik für Messungen.

from qiskit.circuit import IfElseOp

backend.target.add_instruction(IfElseOp, name="if_else")

Nun müssen wir den Quantum Circuit „transpilieren". Dieser Vorgang umfasst viele Teilschritte und ist ein faszinierendes Thema für sich. Ein Beispiel für einen Teilschritt: Nicht alle Quantencomputer können alle logischen Gates in Qiskit direkt ausführen. Wir müssen die Gates unseres Circuits in Gates ausdrücken, die der Quantencomputer ausführen kann. Diesen und weitere Prozesse können wir mithilfe eines vordefinierten Pass Managers durchführen. Das Setzen von optimization = 3 (die höchste Optimierungsstufe) stellt sicher, dass die Abbildung unseres abstrakten Quantum Circuits auf die Anweisungen an den Quantencomputer so effizient wie möglich ist.

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

Ein „Sampler" ist ein Primitive, das mögliche Zustände eines Quantum Circuits abtastet, Statistiken darüber sammelt, welche Zustände gemessen werden könnten, und mit welcher Wahrscheinlichkeit. Wir importieren hier den Qiskit Runtime Sampler:

# Load the Runtime primitive and session
from qiskit_ibm_runtime import SamplerV2 as Sampler

sampler = Sampler(mode=backend)

Nicht alle Berechnungen auf einem Quantencomputer lassen sich sinnvoll auf klassischen Computern simulieren. Diese einfache Teleportation ist durchaus simulierbar – es ist auch nicht überraschend, dass wir Information klassisch an einem Ort oder einem anderen speichern können. Wir empfehlen jedoch nachdrücklich, diese Berechnungen auf einem echten IBM-Quantencomputer durchzuführen. Falls du dein kostenloses monatliches Kontingent aufgebraucht hast oder etwas im Unterricht abgeschlossen werden muss, ohne in der Warteschlange zu warten, kann dieses Modul auch mit einem Simulator abgeschlossen werden. Führe dazu einfach die untenstehende Zelle aus und hebe die Kommentierung der entsprechenden Zeilen in den „Ausführen"-Schritten auf.

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

# Load the Aer simulator and generate a noise model based on the currently-selected backend.
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel

noise_model = NoiseModel.from_backend(backend)

# Define a simulator using Aer, and use it in Sampler.
backend_sim = AerSimulator(noise_model=noise_model)
sampler_sim = BackendSamplerV2(backend=backend_sim)

# Alternatively, load a fake backend with generic properties and define a simulator.
# backend_gen = GenericBackendV2(num_qubits=18)
# sampler_gen = BackendSamplerV2(backend=backend_gen)

Schritt 3: Ausführen

Verwende den Sampler, um deinen Job mit dem Circuit als Argument auszuführen.

job = sampler.run([qc_isa])
# job = sampler_sim.run([qc_isa])
res = job.result()
counts = res[0].data.c.get_counts()

Schritt 4: Nachverarbeitung und Analyse

Lass uns die Ergebnisse visualisieren und interpretieren.

# This required 5 s to run on a Heron r2 processor on 10-28-24
from qiskit.visualization import plot_histogram

plot_histogram(counts)

Verständnisfragen

Lies die folgende Frage, überlege dir deine Antwort und klicke dann auf das Dreieck, um die Lösung anzuzeigen.

Welche der oben gezeigten Zustände deuten auf eine erfolgreiche Teleportation hin, und wie erkennst du das?

Antwort:

Die Zustände $|000\rangle,$ $|001\rangle,$ $|010\rangle,$ $|011\rangle$ sind alle mit einer erfolgreichen Teleportation vereinbar. Das liegt daran, dass wir ein Gate hinzugefügt haben, das die anfängliche Vorbereitung des geheimen Zustands rückgängig macht. Wurde der geheime Zustand erfolgreich auf Bobs Qubit teleportiert, sollte dieses zusätzliche Gate Bobs Qubit in den Zustand $|0\rangle$ zurückversetzen. Jeder Zustand oben, bei dem Bobs Qubit (Qubit 0, ebenfalls in der 0. Komponente des klassischen Registers gemessen, also ganz rechts/oben) den Wert $|0\rangle$ hat, zeigt somit Erfolg an.

Dieses Diagramm zeigt alle Messergebnisse für die drei Qubits über 5.000 Durchläufe (sogenannte „Shots"). Wir haben bereits darauf hingewiesen, dass Alice alle möglichen Zustände für Qubits A und Q mit gleicher Wahrscheinlichkeit messen würde. Wir haben die Qubits 0–2 im Circuit Q, A und B zugewiesen, in dieser Reihenfolge. In Little-Endian-Notation ist Bobs Qubit ganz links/niedrigst. Die vier Balken auf der linken Seite entsprechen also Bobs Qubit im Zustand $|0\rangle$, während die anderen beiden Qubits in allen möglichen Kombinationen mit ungefähr gleicher Wahrscheinlichkeit auftreten. Man beachte, dass fast alle (meist ~95 %) der Messungen Bobs Qubit im Zustand $|0\rangle$ ergeben, was bedeutet, dass unser Aufbau erfolgreich war! Ein kleiner Anteil der Shots (~5 %) ergab Bobs Qubit im Zustand $|1\rangle$. Das sollte logisch eigentlich nicht möglich sein. Allerdings sind alle modernen Quantencomputer deutlich stärker von Rauschen und Fehlern betroffen als klassische Computer – und die Quantenfehlerkorrektur ist noch ein aufstrebendes Forschungsfeld.

Experiment 2: Teleportation über einen Prozessor

Das wohl Faszinierendste an der Quantenteleportation ist, dass ein Quantenzustand über große Entfernungen augenblicklich teleportiert werden kann (auch wenn die klassische Kommunikation der zusätzlichen Gates nicht augenblicklich erfolgt). Wie bereits erwähnt, können wir keine Qubits vom Prozessor lösen und herumbewegen. Aber wir können die Information von einem Qubit auf ein anderes übertragen, bis die an der Teleportation beteiligten Qubits auf gegenüberliegenden Seiten des Prozessors liegen. Wiederholen wir nun die obigen Schritte, diesmal aber mit einem größeren Circuit mit genug Qubits, um den gesamten Prozessor zu überspannen.

Schritt 1: Problem auf einen Quantum Circuit abbilden

Diesmal werden sich die Qubits für Alice und Bob ändern. Wir werden daher kein einzelnes Qubit „A" und ein anderes „B" nennen. Stattdessen nummerieren wir die Qubits und verwenden Variablen, um die aktuelle Position der Information auf den Qubits von Alice und Bob darzustellen. Alle anderen Schritte außer den Swap Gates sind wie zuvor beschrieben.

# Step 1: Map

# Define registers
qr = QuantumRegister(13, "q")

qc = QuantumCircuit(qr, cr)

# Define registers
secret = QuantumRegister(1, "Q")
ebitsa = QuantumRegister(6, "A")
ebitsb = QuantumRegister(6, "B")
# q = ClassicalRegister(1, "q meas")
# a = ClassicalRegister(1, "a")
# b = ClassicalRegister(1, "b")
cr = ClassicalRegister(3, "c")
qc = QuantumCircuit(secret, ebitsa, ebitsb, cr)

# We'll start Alice in the middle of the circuit, then move information outward in both directions.
Alice = 5
Bob = 0
qc.h(ebitsa[Alice])
qc.cx(ebitsa[Alice], ebitsb[Bob])

# Starting with Bob and Alice in the center, we swap their information onto adjacent qubits, until the information is on distant qubits.

for n in range(Alice):
    qc.swap(ebitsb[Bob], ebitsb[Bob + 1])
    qc.swap(ebitsa[Alice], ebitsa[Alice - 1])
    Alice = Alice - 1
    Bob = Bob + 1

qc.barrier()

# Create a random state for Alice (qubit zero)
np.random.seed(42)  # fixing seed for repeatability
# theta = np.random.uniform(0.0, 1.0) * np.pi    #from 0 to pi
theta = 0.3
varphi = np.random.uniform(0.0, 2.0) * np.pi  # from 0 to 2*pi

qc.u(theta, varphi, 0.0, secret)

# Entangle Alice's two qubits
qc.cx(secret, ebitsa[Alice])
qc.h(secret)

qc.barrier()

# Make measurements of Alice's qubits and store the results in the classical register.
qc.measure(ebitsa[Alice], cr[1])
qc.measure(secret, cr[0])

# Send instructions to Bob's qubits based on the outcome of Alice's measurements.
with qc.if_test((cr[1], 1)):
    qc.x(ebitsb[Bob])
with qc.if_test((cr[0], 1)):
    qc.z(ebitsb[Bob])

qc.barrier()

# Invert the preparation we did for Carl's qubit so we can check whether we did this correctly.
qc.u(theta, varphi, 0.0, ebitsb[Bob]).inverse()  # inverse of u(theta,varphi,0.0)
qc.measure(ebitsb[Bob], cr[2])  # add measurement gate

qc.draw("mpl")

Im Circuit-Diagramm ist zu sehen, dass die logischen Schritte dieselben sind. Der einzige Unterschied besteht darin, dass wir Swap Gates verwendet haben, um den Zustand von Alices Qubit von Qubit 6 ($A_5$) bis Qubit 1 ($A_0$) zu verschieben, direkt neben Q. Außerdem haben wir Swap Gates verwendet, um Bobs Ausgangszustand von Qubit 7 ($B_0$) bis Qubit 12 ($B_5$) zu verschieben. Beachte, dass der Zustand auf Qubit 12 erst nach den Messungen auf den entfernten Qubits 0 und 1 mit Qs geheimem Zustand zusammenhängt – und Qubit 12 erst nach dem Anwenden der bedingten $X$- und $Z$-Gates gleich dem geheimen Zustand ist.

Schritt 2: Circuit optimieren

Normalerweise ist es sinnvoll, den Pass Manager mit optimization_level = 3 zu verwenden, da wir unsere Circuits so effizient wie möglich gestalten wollen. In diesem Fall gibt es jedoch keinen rechnerischen Grund für uns, Zustände von Qubits 6 und 7 auf Qubits 1 und 12 zu übertragen. Das haben wir nur getan, um die Teleportation über eine Distanz zu demonstrieren. Wenn wir den Pass Manager bitten, unseren Circuit zu optimieren, erkennt er, dass es keinen logischen Grund für diese Swap Gates gibt, und wird sie entfernen und die Gate-Operationen auf benachbarten Qubits ausführen. Für diesen Sonderfall verwenden wir daher optimization_level = 0.

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pmzero = generate_preset_pass_manager(target=target, optimization_level=0)

qc_isa_zero = pmzero.run(qc)

print(qc_isa_zero.depth())

105

Wir können mithilfe der Funktion plot_circuit_layout visualisieren, wo auf dem Quantenprozessor sich diese Qubits befinden.

Schritt 3: Ausführen

Wie zuvor empfehlen wir die Ausführung auf echten IBM-Quantencomputern. Falls dein monatliches kostenloses Kontingent erschöpft ist, kannst du gerne die Simulator-Zellen auskommentieren, um auf einem Simulator zu laufen.

# This required 5 s to run on a Heron r2 processor on 10-28-24
job = sampler.run([qc_isa_zero])
# job = sampler_sim.run([qc_isa_zero])
counts = job.result()[0].data.c.get_counts()

from qiskit.visualization import plot_histogram

plot_histogram(counts)

Schritt 4: Klassische Nachverarbeitung

Wieder sehen wir, dass die Wahrscheinlichkeiten für die möglichen Ergebnisse von Alices Qubits ziemlich gleichmäßig verteilt sind. Es gibt eine deutliche Tendenz, Bobs Qubit nach dem Invertieren des geheimen Codes im Zustand $|0\rangle$ zu finden, was bedeutet, dass der geheime Zustand mit hoher Wahrscheinlichkeit korrekt vom Prozessor von Q zu Bob (Qubits 0 bis 12) teleportiert wurde. Wir bemerken jedoch, dass nun eine höhere Chance besteht, $|0\rangle$ für Bob nicht zu messen. Das ist eine wichtige Lektion in der Quantenberechnung: Je mehr Gates – insbesondere Multi-Qubit-Gates wie Swap Gates – du hast, desto mehr Rauschen und Fehler treten auf.

Fragen

Lehrende können Versionen dieser Notebooks mit Lösungsschlüsseln und Hinweisen zur Einordnung in gängige Lehrpläne anfordern, indem sie diese kurze Umfrage darüber ausfüllen, wie die Notebooks eingesetzt werden.

Kernkonzepte

• Qubits können verschränkt sein, was bedeutet, dass die Messung eines Qubits den Zustand eines anderen Qubits beeinflusst oder sogar bestimmt.
• Verschränkung unterscheidet sich von klassischen Korrelationen; zum Beispiel könnten sich Qubits A und B in einer Superposition von Zuständen wie $\alpha_0|00\rangle+\alpha_1|11\rangle$ befinden. Der Zustand von A oder B könnte von der Natur her unbestimmt sein, und dennoch könnte garantiert sein, dass A und B im selben Zustand sind.
• Durch eine Kombination aus Verschränkungen und Messungen können wir einen Zustand (der Information speichern kann) von einem Qubit auf ein anderes übertragen. Diese Übertragung kann sogar über große Entfernungen erfolgen – das nennt man Quantenteleportation.
• Die Quantenteleportation beruht auf Quantenmessungen, die probabilistischer Natur sind. Daher kann klassische Kommunikation notwendig sein, um die teleportierten Zustände anzupassen. Das verhindert, dass Quantenteleportation Information schneller als das Licht überträgt. Quantenteleportation verletzt weder die Relativitätstheorie noch die Kausalität.
• Moderne Quantencomputer sind deutlich anfälliger für Rauschen und Fehler als klassische Computer. Rechne mit einigen Prozent Fehlerrate.
• Je mehr Gates du hintereinanderschalten (besonders 2-Qubit-Gates), desto mehr Fehler und Rauschen sind zu erwarten.

Wahr/Falsch-Fragen

1. W/F Quantenteleportation kann verwendet werden, um Information schneller als das Licht zu übertragen.
2. W/F Moderne Belege deuten darauf hin, dass der Kollaps eines Quantenzustands sich schneller als das Licht ausbreitet.
3. W/F In Qiskit sind Qubits in Zuständen so angeordnet, dass das niedrigst nummerierte Qubit rechts steht, also $|q_3,q_2,q_1, q_0\rangle$.

Multiple-Choice-Fragen

1. Qubits A und B sind verschränkt und dann durch eine große Distanz $d$ getrennt. Qubit A wird gemessen. Welche Aussage ist korrekt bezüglich der Geschwindigkeit, mit der der Zustand von Qubit B beeinflusst wird?

• a. Qubit B wird augenblicklich beeinflusst, innerhalb der experimentellen Toleranz, in bislang durchgeführten Experimenten.
• b. Qubit B wird nach einer Zeit $d/c$ beeinflusst, d. h. der Quantenzustand „kollabiert" annähernd mit Lichtgeschwindigkeit, innerhalb der experimentellen Toleranz.
• c. Qubit B wird erst nach klassischer Kommunikation beeinflusst, was bedeutet, dass es in einer Zeit länger als $d/c$ geschieht.
• d. Keine der obigen Antworten

2. Bedenke, dass die Messwahrscheinlichkeit mit den Amplituden von Quantenzuständen zusammenhängt. Wenn ein Qubit zum Beispiel anfänglich im Zustand $\alpha_0|0\rangle+\alpha_1 |1\rangle$ ist, beträgt die Wahrscheinlichkeit, den Zustand $|0\rangle$ zu messen, $|\alpha_0|^2.$ Nicht alle Messreihen stimmen exakt mit diesen Wahrscheinlichkeiten überein, da die Stichprobengröße endlich ist (so wie das Werfen einer Münze zweimal hintereinander Kopf ergeben kann). Welchem der folgenden Quantenzustände könnte das untenstehende Messhistogramm entsprechen? Wähle die beste Antwort.

• a. $|0\rangle$
• b. $\frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right)$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$
• d. $\frac{4}{5}|0\rangle+\frac{3}{5}|1\rangle$
• e. $\frac{3}{5}|0\rangle+\frac{4}{5}|1\rangle$

3. Welche der folgenden Zustände zeigen verschränkte Qubits A und B? Wähle alle zutreffenden Antworten.

• a. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)$
• b. $\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)$
• d. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|0\rangle_A\right)$
• e. $|0\rangle_B|0\rangle_A$

4. In diesem Modul haben wir einen verschränkten Zustand vorbereitet: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right).$ Es gibt jedoch viele andere verschränkte Zustände, die für ein ähnliches Protokoll genutzt werden könnten. Welcher der untenstehenden Zustände könnte ein 2-Qubit-Messhistogramm wie das folgende ergeben? Wähle die beste Antwort.

• a. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)$
• b. $\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)$
• d. $\frac{4}{5}|0\rangle_B|1\rangle_A+\frac{3}{5}|1\rangle_B|0\rangle_A$
• e. $|0\rangle_B|0\rangle_A$

Diskussionsfragen

1. Beschreibe das Quantenteleportationsprotokoll von Anfang bis Ende deinem Partner / deiner Gruppe. Schau, ob sie etwas hinzuzufügen haben oder Fragen haben.

2. Gibt es etwas Besonderes an dem anfänglichen verschränkten Zustand zwischen Alice und Bob: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)?$ Wenn ja, was ist daran besonders? Wenn nicht, welche anderen verschränkten Zustände hätten wir verwenden können?