{
"cells": [
{
"cell_type": "markdown",
"id": "3e8391e9-be00-46b0-81a9-5474ae778663",
"metadata": {},
"source": [
"---\n",
"title: \"Quanten-Teleportation\"\n",
"description: \"Erforschen Sie, wie Quanten-Teleportation einen Quantenzustand mithilfe der Prinzipien der Quantenverschränkung von einem Ort zu einem anderen überträgt.\"\n",
"---\n",
"\n",
"\n",
"\n",
"# Quanten-Teleportation\n",
"\n",
"Für dieses Modul \"Qiskit im Klassenzimmer\" müssen die Schüler eine funktionierende Python Umgebung mit den folgenden Paketen installiert haben:\n",
"\n",
"* `qiskit` v2.1.0 oder neuer\n",
"* `qiskit-ibm-runtime` v0.40.1 oder neuer\n",
"* `qiskit-aer` v0.17.0 oder neuer\n",
"* `qiskit.visualization`\n",
"* `numpy`\n",
"* `pylatexenc`\n",
"\n",
"Um die oben genannten Pakete einzurichten und zu installieren, lesen Sie die Anleitung [Qiskit installieren](/docs/guides/install-qiskit).\n",
"Um Aufträge auf echten Quantencomputern ausführen zu können, müssen die Schüler ein Konto bei IBM Quantum® einrichten, indem sie die Schritte in der Anleitung zur [Einrichtung Ihres IBM Cloud Kontos](/docs/guides/cloud-setup) befolgen.\n",
"\n",
"Dieses Modul wurde getestet und verbrauchte 14 Sekunden QPU-Zeit. Dies ist nur eine Schätzung. Ihre tatsächliche Nutzung kann davon abweichen.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0df1108e-f1ac-4e75-96c2-3d8b5992504e",
"metadata": {},
"outputs": [],
"source": [
"# Uncomment and modify this line as needed to install dependencies\n",
"#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'"
]
},
{
"cell_type": "markdown",
"id": "404ed202-a761-4e82-a480-ce59d4b04adf",
"metadata": {},
"source": [
"Schauen Sie sich den Modul-Walkthrough von Dr. Katie McCormick unten an, oder klicken Sie [hier](https://youtu.be/jxqnzltpDdE?si=UVL58hFOOWe2Q9qI), um ihn auf YouTube zu sehen.\n",
"\n",
"***\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a200b899-0c56-4f69-a7ba-0ca4d83e47cd",
"metadata": {},
"source": [
"\n",
"\n",
"## Einführung und Hintergrund\n",
"\n",
"Die Quantenteleportation ist ein Verfahren der Quantenphysik, mit dem Quanteninformation von einem Ort zum anderen übertragen werden kann, ohne dass dabei Teilchen physikalisch bewegt werden müssen. Im Gegensatz zum Science-Fiction-Konzept der Teleportation wird bei diesem Verfahren keine Materie transportiert. Stattdessen basiert es auf dem Prinzip der Quantenverschränkung, bei dem zwei Teilchen unabhängig von der Entfernung miteinander verbunden werden. Durch eine Reihe präziser Messungen und klassischer Kommunikation lässt sich der Quantenzustand eines Teilchens in einem anderen Teilchen an einem entfernten Ort nachbilden, wodurch die Quanteninformation praktisch „teleportiert“ wird. In diesem Modul werden wir uns ansehen, wie das mathematisch funktioniert, und anschließend werden wir die Quantenteleportation auf einem echten Quantencomputer umsetzen. Die Einführung hier soll kurz ausfallen; für weitere Hintergrundinformationen zur Quanteninformation und eine ausführlichere Erläuterung des Themas Teleportation empfehlen wir den Kurs von John Watrous zu den [Grundlagen der Quanteninformation](/learning/courses/basics-of-quantum-information), insbesondere den Abschnitt über [Teleportation](/learning/courses/basics-of-quantum-information/entanglement-in-action/quantum-teleportation).\n",
"\n",
"Klassische Bits können die Zustände 0 oder 1 annehmen. Quantenbits (Qubits) können sich in Quantenzuständen befinden, die mit $|0\\rangle$ und $|1\\rangle$ bezeichnet werden, sowie in linearen Kombinationen dieser Zustände, sogenannten „Superpositionen“, wie beispielsweise $|\\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, führt eine Messung des Zustands zu einem „Zusammenbruch“ in entweder den Zustand $|0\\rangle$ oder den Zustand $|1\\rangle$. Die Parameter $a$ und $b$ beziehen sich auf die Wahrscheinlichkeit des jeweiligen Messergebnisses gemäß\n",
"\n",
"$$\n",
"P_0 = |\\alpha_0|^2\n",
"$$\n",
"\n",
"$$\n",
"P_1 = |\\alpha_1|^2\n",
"$$\n",
"\n",
"Daraus ergibt sich die Nebenbedingung, dass $|\\alpha_0|^2+|\\alpha_1|^2 = 1$ gilt.\n",
"\n",
"Ein weiteres wichtiges Merkmal ist, dass Quantenbits \"verschränkt\" sein können, was bedeutet, dass die Messung eines Qubits das Ergebnis der Messung eines anderen, verschränkten Qubits beeinflussen kann. Zu verstehen, wie sich die Verschränkung von einfachen klassischen Korrelationen unterscheidet, ist nicht ganz einfach. Erläutern wir zunächst unsere Notation. Nennen Sie zwei Qubits, die zu Freund 0 (Alice) und Freund 1 (Bob) gehören und sich jeweils im Zustand $|0\\rangle$ befinden\n",
"\n",
"$$\n",
"|0\\rangle_B|0\\rangle_A\n",
"$$\n",
"\n",
"oder\n",
"\n",
"$$\n",
"|0\\rangle_1|0\\rangle_0\n",
"$$\n",
"\n",
"manchmal abgekürzt zu einfach\n",
"\n",
"$$\n",
"|00\\rangle\n",
"$$\n",
"\n",
"Beachten Sie, dass sich das Qubit mit der niedrigsten Nummer (bzw. dem niedrigsten Buchstaben) ganz rechts befindet. Dies ist eine Konvention, die als „Little-Endian“-Notation bezeichnet wird und in Qiskit durchgängig verwendet wird.\n",
"Wenn der Zwei-Qubit-Zustand der Freunde „ $|00\\rangle$ “ lautet und sie den Zustand ihrer jeweiligen Qubits messen, erhalten sie jeweils eine 0. Ebenso würde jede ihrer Messungen eine 1 ergeben, wenn sich die Qubits im Zustand $|11\\rangle$ befänden. Das unterscheidet sich nicht vom klassischen Fall. In der Quanteninformatik können wir dies jedoch mit der Superposition kombinieren, um Zustände wie\n",
"\n",
"$$\n",
"\\frac{1}{\\sqrt{2}}(|00\\rangle+|11\\rangle)\n",
"$$\n",
"\n",
"In einem solchen Zustand ist noch nicht bekannt, ob sich die Qubits von Alice und Bob im Zustand 0 oder 1 befinden – dies ist noch nicht einmal von der Natur festgelegt –, und dennoch wissen wir, dass sie bei der Messung denselben Zustand für ihr Qubit feststellen werden. Wenn Bob beispielsweise misst, dass sich sein Qubit im Zustand $|0\\rangle$ befindet, kann dies nur geschehen, wenn die Messung den Zwei-Qubit-Zustand auf einen der beiden möglichen Zustände kollabiert hat, nämlich konkret auf $|00\\rangle$. Damit befindet sich auch Alices Qubit im Zustand $|0\\rangle$.\n",
"\n",
"Die Verschränkung von Qubits auf diese Weise erfordert nicht, dass die Qubits physisch nahe beieinander bleiben. Mit anderen Worten: Wir könnten Qubits verschränken, sie dann über eine große Entfernung voneinander trennen und ihre Verschränkung zur Übertragung von Informationen nutzen. Ein verschränkter Zustand wie der obige 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 entfernten Partnern ausgetauscht wird, wie hier beschrieben, verwendet werden kann, um Informationen von einem Ort zum anderen zu übertragen.\n",
"\n",
"Der erste Gedanke vieler Menschen, die zum ersten Mal davon hören, ist die Verletzung der Relativitätstheorie: Können wir damit Informationen schneller als das Licht senden? Hinterfragen Sie auf jeden Fall weiterhin die wissenschaftlichen Regeln, aber leider wird es uns nicht möglich sein, Informationen schneller als das Licht zu senden, aus Gründen, die im Laufe dieses Moduls deutlich werden. Spoiler: Erstaunlicherweise liegt es NICHT an der Geschwindigkeit, mit der sich dieser Kollaps ausbreitet, der schneller als das Licht zu sein scheint [\\[1\\]](https://www.nature.com/articles/nature15759).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "4ce474e6-cea7-4327-9742-9e1a7dd468b0",
"metadata": {},
"source": [
"Wir beginnen mit zwei Mitarbeitern, Alice und Bob, die sich zunächst am selben Ort befinden und gemeinsam an denselben Qubits arbeiten können. Diese Kollaborateure werden ihre Qubits verschränken. Dann werden sie sich an zwei verschiedene geografische Orte begeben und ihre jeweiligen Qubits mitbringen. Alice erhält dann Quanteninformationen über ein neues Q-Bit. Wir machen keine Annahmen über die Informationen zu Q. Der Zustand von Q könnte ein Geheimnis sein, das Alice nicht kennt; er könnte allen Menschen unbekannt sein. Alice erhält jedoch die Aufgabe, die Informationen über Q an Bob weiterzugeben. Sie wird dies mittels Quantenteleportation tun.\n",
"\n",
"Um dies zu erreichen, müssen wir einige Quantenoperationen oder \"Gates\" kennen.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "03fe38b1-66fe-4c50-8403-d8c64197b5c6",
"metadata": {},
"source": [
"\n",
"\n",
"## Quantenoperatoren (Gatter)\n",
"\n",
"Sie können diesen Abschnitt überspringen, wenn Sie bereits mit Quantengattern vertraut sind. Wenn Sie diese Gates besser verstehen wollen, lesen Sie die [Grundlagen der Quanteninformation](/learning/courses/basics-of-quantum-information), insbesondere die ersten beiden Lektionen, auf IBM Quantum Learning.\n",
"\n",
"Für dieses Teleportationsprotokoll werden wir hauptsächlich zwei Arten von Quantengattern verwenden: das Hadamard-Gatter und das CNOT-Gatter. Einige andere werden eine geringere Rolle spielen: das $X$ -Gate, das $Z$ -Gate und das SWAP-Gate.\n",
"\n",
"Dieses Modul kann mit sehr begrenzten Kenntnissen der linearen Algebra abgeschlossen werden, aber manchmal kann es hilfreich sein, quantenmechanische Gatter mit Hilfe von Matrizen und Vektoren zu visualisieren. Daher stellen wir hier auch die Matrix-/Vektorformen von Quantengattern/-zuständen vor.\n",
"\n",
"Die Zustände, die wir bereits vorgestellt haben, sind (teils aus Konvention, teils aus Zwängen) so gewählt, dass sie Vektorformen haben:\n",
"\n",
"$$\n",
"|0\\rangle = \\begin{pmatrix}1 \\\\ 0\\end{pmatrix}\n",
"$$\n",
"\n",
"$$\n",
"|1\\rangle = \\begin{pmatrix}0 \\\\ 1\\end{pmatrix}\n",
"$$\n",
"\n",
"Auf diese Weise kann ein beliebiger Zustand $|\\psi\\rangle = a|0\\rangle+b|1\\rangle$ geschrieben werden als\n",
"\n",
"$$\n",
"|\\psi\\rangle =\\begin{pmatrix}a \\\\ b\\end{pmatrix}\n",
"$$\n",
"\n",
"Es gibt einige Möglichkeiten, die Notation auf Mehr-Qubit-Zustände auszudehnen, aber die nachstehende Wahl ist ziemlich Standard:\n",
"\n",
"$$\n",
"|00\\rangle = \\begin{pmatrix}1 \\\\ 0 \\\\ 0 \\\\ 0\\end{pmatrix},|01\\rangle = \\begin{pmatrix}0 \\\\ 1 \\\\ 0 \\\\ 0\\end{pmatrix},\n",
"|10\\rangle = \\begin{pmatrix}0 \\\\ 0 \\\\ 1 \\\\0\\end{pmatrix},|11\\rangle = \\begin{pmatrix}0 \\\\ 0 \\\\ 0 \\\\ 1\\end{pmatrix}.\n",
"$$\n",
"\n",
"Mit dieser Wahl der Vektorschreibweise im Hinterkopf können wir unsere benötigten Quantengatter, ihre Auswirkungen auf Quantenzustände und ihre Matrixformen vorstellen.\n",
"\n",
"**H Hadamard-Tor:** Erzeugt einen Überlagerungszustand. Ein-Qubit-Tor.\n",
"\n",
"$$\n",
"H|0\\rangle = \\frac{1}{\\sqrt{2}}\\left(|0\\rangle+|1\\rangle\\right),\n",
"$$\n",
"\n",
"$$\n",
"H|1\\rangle = \\frac{1}{\\sqrt{2}}\\left(|0\\rangle-|1\\rangle\\right)\n",
"$$\n",
"\n",
"$$\n",
"H=\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix}\n",
"$$\n",
"\n",
"Eine Schaltung mit einem Hadamard-Gatter wird wie folgt aufgebaut:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "a66b8ef2-6660-45b8-97bd-dbc98db49857",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"qc = QuantumCircuit(1)\n",
"qc.h(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "19b06d0f-0811-48aa-bf5d-a575f7b63876",
"metadata": {},
"source": [
"**CNOT-Gatter (Controlled-NOT):** Dieses Gatter verwendet zwei Qubits: ein Steuer- und ein Ziel-Qubit. Überprüft den Zustand eines Kontroll-Qubits, der sich nicht verändert hat. Befindet sich das Steuer-Qubit jedoch im Zustand $|1\\rangle$, so verändert das Gatter den Zustand des Ziel-Qubits; befindet sich das Steuer-Qubit im Zustand $|0\\rangle$, so erfolgt keinerlei Veränderung. In der folgenden Darstellung wird davon ausgegangen, dass das Qubit $A$ (das Qubit ganz rechts) das Steuerqubit und das Qubit $B$ (das Qubit ganz links) das Zielqubit ist. Im Folgenden wird die Notation „ $CNOT(q_{control},q_{target})|BA\\rangle$ “ verwendet.\n",
"\n",
"$$\n",
"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\n",
"$$\n",
"\n",
"Manchmal wird CNOT so geschrieben, dass die Reihenfolge der Kontrolle und des Ziels einfach impliziert wird. Aber es gibt keine solche Zweideutigkeit im Code oder in Schaltplänen.\n",
"\n",
"$$\n",
"CNOT=\\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0\\end{pmatrix}\n",
"$$\n",
"\n",
"Ein CNOT-Gatter sieht in einer Schaltung etwas anders aus, da es zwei Qubits benötigt. So wird sie umgesetzt:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "df5acfc1-feb8-4008-8e51-d9709352edde",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(2)\n",
"qc.cx(0, 1)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "131d90c7-6ef3-4c32-a01b-52da9f8e0e83",
"metadata": {},
"source": [
"\n",
"\n",
"#### Überprüfen Sie Ihr Verständnis\n",
"\n",
"Die meisten Gatter haben in Qiskit dieselbe Matrixform wie überall sonst auch. Das CNOT-Gatter wirkt jedoch auf zwei Qubits, sodass plötzlich die Reihenfolge der Qubits zu einem Problem wird. Texte, in denen Qubits geordnet werden $|q_0,q_1,...\\rangle$, weisen für ihre CNOT-Gatter eine andere Matrixform auf. Überprüfen Sie durch explizite Matrixmultiplikation, ob die obige CNOT-Matrix die richtige Wirkung auf den Zustands $|01\\rangle$ hat.\n",
"\n",
"\n",
" \n",
" $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$\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "2c1a61f3-770a-443e-8e01-26fc1106f92b",
"metadata": {},
"source": [
"**$X$ Gate** : Äquivalent zu einer NOT-Operation. Ein-Qubit-Tor.\n",
"\n",
"$$\n",
"X|0\\rangle = |1\\rangle,\\\\X|1\\rangle=|0\\rangle\n",
"$$\n",
"\n",
"$$\n",
"X=\\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix}\n",
"$$\n",
"\n",
"In Qiskit sieht das Erstellen eines Schaltkreises mit einem $X$ Gate wie folgt aus:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "5a23a576-385b-4a7c-899d-67ef4bb0bfed",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(1)\n",
"qc.x(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "81eaa9dc-740a-4a99-8950-fc7724c6440b",
"metadata": {},
"source": [
"**$Z$ Tor** : Fügt einem Zustand eine \"Phase\" hinzu (einen Vorfaktor, der im Falle der Z-Eigenzustände $|0\\rangle$ und $|1\\rangle$ entweder eine 1 oder -1 ist). Ein-Qubit-Tor.\n",
"\n",
"$$\n",
"Z|0\\rangle = |0\\rangle,\\\\Z|1\\rangle=-|1\\rangle\n",
"$$\n",
"\n",
"$$\n",
"Z=\\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix}\n",
"$$\n",
"\n",
"In Qiskit sieht das Erstellen eines Schaltkreises mit einem $Z$ Gate wie folgt aus:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "653b2420-eaa8-41ef-8262-3a9efa638cd3",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(1)\n",
"qc.z(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "476c82d2-4c58-4c25-8f0d-646cd4afb757",
"metadata": {},
"source": [
"\n",
"\n",
"## Theorie\n",
"\n",
"Lassen Sie uns das Protokoll für die Quantenteleportation mit Hilfe der Mathematik aufstellen. Im nächsten Abschnitt werden wir diesen Aufbau dann mit einem Quantencomputer realisieren.\n",
"\n",
"**Alice und Bob verschränken ihre Qubits:** Zu Beginn befinden sich das Qubit von Alice und das Qubit von Bob jeweils getrennt im Zustand $|0\\rangle$ (eine gute Annahme und auch die richtige 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 passiert, wenn Alice und Bob mit dem Hadamard-Gatter auf Alices Qubit und dann mit einem CNOT-Gatter mit Alices Qubit als Kontrolle und Bobs Qubit als Ziel agieren:\n",
"\n",
"$$\n",
"\\begin{aligned}\n",
"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)\\\\\n",
"&=\\frac{1}{\\sqrt{2}}\\left(CNOT(A,B)|0\\rangle_B|0\\rangle_A+CNOT(A,B)|0\\rangle_B|1\\rangle_A\\right)\\\\\n",
"&=\\frac{1}{\\sqrt{2}}\\left(|0\\rangle_B|0\\rangle_A+|1\\rangle_B|1\\rangle_A\\right)\n",
"\\end{aligned}\n",
"$$\n",
"\n",
"Man beachte, dass nun die Qubits von Alice und Bob verschränkt sind. Obwohl es noch nicht von Natur aus feststeht, ob sich ihre beiden Qubits im Zustand $|0\\rangle$ oder im Zustand $|1\\rangle$ befinden, ist bekannt, dass sich ihre Qubits im gleichen Zustand befinden.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b51aed85-2976-4c46-a1d8-07dba8af78fe",
"metadata": {},
"source": [
"**Alice und Bob trennen sich:** Die beiden Freunde verschieben ihre Qubits an neue Orte, die möglicherweise sehr weit voneinander entfernt sind. Dies ist mit einer Reihe von Vorbehalten verbunden: Es ist nicht trivial, Quanteninformationen zu bewegen, ohne sie zu stören. Aber sie kann verschoben werden, und in der Tat werden Sie sie in diesem Modul verschieben. Aber bedenken Sie, dass wir mit einigen Fehlern rechnen müssen, wenn wir Quanteninformationen viel bewegen.\n",
"\n",
"**Q wird eingeführt:** Der geheime Zustand wird auf dem Q-Bit Q vorbereitet:\n",
"\n",
"$$\n",
"|\\psi\\rangle_Q = \\alpha_0 |0\\rangle_Q + \\alpha_1 |1\\rangle_Q\n",
"$$\n",
"\n",
"An diesem Punkt grenzt Q einfach an das Qubit von Alice (A). Es gab keine Verschränkung, so dass der Quantenzustand der drei Qubits zusammen wie folgt geschrieben werden kann:\n",
"\n",
"$$\n",
"|\\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).\n",
"$$\n",
"\n",
"Ziel ist es, die Informationen über Q vom Standort von Alice zum Standort von Bob zu bringen. An dieser Stelle erheben wir keine Ansprüche oder Anforderungen an die Geheimhaltung oder die Geschwindigkeit der Informationsübertragung. Wir untersuchen lediglich, wie Informationen von Alice zu Bob gelangen können.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "cd8f8dab-601f-42b6-8b1e-027568f8726c",
"metadata": {},
"source": [
"Da die Information mit Q beginnt, nehmen wir an, dass Q die niedrigste Nummer in der Qubit-Nummerierung zugewiesen ist, so dass Q in der folgenden Rechnung das letzte Qubit rechts ist (Little-Endian-Notation).\n",
"\n",
"**Alice verschränkt die Qubits A und Q:** Alice wendet nun ein CNOT-Gatter an, wobei Q als Steuerqubit und ihr eigenes Qubit als Zielqubit dienen, und wendet anschließend ein Hadamard-Gatter auf Q an. Berechnen wir den 3-Qubit-Zustand nach dieser Operation:\n",
"\n",
"$$\n",
"\\begin{aligned}\n",
"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)\\\\\n",
"&= 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)\\right. \\\\\n",
"&+\\left. \\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)\\\\\n",
"&= 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 \\right. \\\\\n",
"&+\\left. \\alpha_0 |1\\rangle_B|1\\rangle_A|0\\rangle_Q + \\alpha_1 |1\\rangle_B|0\\rangle_A|1\\rangle_Q\\right)\\\\\n",
"&= \\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 \\right. \\\\\n",
"&+ \\left. \\alpha_1 |0\\rangle_B|1\\rangle_A|0\\rangle_Q-\\alpha_1 |0\\rangle_B|1\\rangle_A|1\\rangle_Q\\right)\\\\\n",
"&+\\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 \\right. \\\\\n",
"&+ \\left. \\alpha_1 |1\\rangle_B|0\\rangle_A|0\\rangle_Q - \\alpha_1 |1\\rangle_B|0\\rangle_A|1\\rangle_Q\\right)\n",
"\\end{aligned}\n",
"$$\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "78aaf4c7-2775-483e-91cd-11d400793776",
"metadata": {},
"source": [
"Da sich A und Q am selben Ort befinden, gruppieren wir die obigen Begriffe nach den Ergebnissen der Messungen an den Q-Bits A und Q:\n",
"\n",
"$$\n",
"\\begin{aligned}\n",
"|\\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 \\right. \\\\\n",
"& + \\left. (\\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)\\\\\n",
"\\end{aligned}\n",
"$$\n",
"\n",
"\n",
"\n",
"#### Überprüfen Sie Ihr Verständnis\n",
"\n",
"Wie hoch ist angesichts des obigen Ausdrucks für die Zustände aller drei Qubits die Wahrscheinlichkeit, dass eine Messung an den Qubits A und Q das Ergebnis „ $|0\\rangle_A|0\\rangle_Q?$ “ liefert?\n",
"\n",
"\n",
" \n",
" 25%. Um dies zu erkennen, muss der Zustand von Bob normalisiert werden, d. h $ |_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}$\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "8df3034b-9807-487b-a046-e689061cb026",
"metadata": {},
"source": [
"Nun kann Alice die Qubits A und Q messen. Sie kann das Ergebnis dieser Messung nicht beeinflussen, da Quantenmessungen probabilistisch sind. Wenn sie also misst, gibt es vier 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$. Beachten Sie, dass jedes Ergebnis unterschiedliche Auswirkungen auf Bobs Qubit hat. Wenn Alice beispielsweise feststellt, dass sich ihre Qubits im Zustand $|0\\rangle_A|0\\rangle_Q$ befinden, hat dies dazu geführt, dass der gesamte 3-Qubit-Quantenzustand in den Zustand $(\\alpha_0|0\\rangle_B+\\alpha_1|1\\rangle_B)|0\\rangle_A|0\\rangle_Q$ kollabiert ist. Andere Messergebnisse für Alice führen zu unterschiedlichen Zuständen für Bob. Diese sind in der folgenden Tabelle zusammengefasst.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "99e01c8f-e6e1-4679-8e48-1e33a1b78e63",
"metadata": {},
"source": [
"| Alice Ergebnis | Bobs Zustand | Anweisung an Bob | Ergebnis |\n",
"| ------------------------------------ | ---------------------------------------------------- | ---------------- | --------------------------------------------------- |\n",
"| $ \\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$ |\n",
"| $ \\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$ |\n",
"| $ \\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$ |\n",
"| $ \\vert 1\\rangle_A \\vert 1\\rangle_Q$ | $-\\alpha_1\\vert 0\\rangle_B+\\alpha_0\\vert 1\\rangle_B$ | $X$ dann $Z$ | $\\alpha_0\\vert 0\\rangle_B+\\alpha_1\\vert 1\\rangle_B$ |\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ff32d084-31ea-4408-b3cb-b5bebb845a3b",
"metadata": {},
"source": [
"Bei allen möglichen Messergebnissen auf Alices Q-Bits bleibt Bobs Q-Bit in einem Zustand, der dem ursprünglichen geheimen Zustand von Q nur vage ähnelt. In dem Fall, in dem Alice $|0\\rangle_C|0\\rangle_A$ misst (die erste Zeile der Tabelle), bleibt Bobs Qubit in genau dem geheimen Zustand! In den anderen Fällen ist etwas mit dem Staat nicht in Ordnung. Die Koeffizienten ( $\\alpha$ 's) sind vertauscht, oder es gibt ein \"-\"-Zeichen, wo ein \"+\"-Zeichen sein sollte, oder beides. Um Bobs Qubit so zu verändern, dass es genau dem geheimen Zustand entspricht, muss Alice Bob anrufen (mit einem Mittel der klassischen Kommunikation) und ihm sagen, dass er zusätzliche Operationen an seinem Qubit durchführen soll, wie in der Tabelle beschrieben. In der dritten Zeile sind beispielsweise die Koeffizienten vertauscht. Wenn Alice Bob anruft und ihm sagt, er solle ein $X$ -Gatter auf sein Qubit anwenden, verwandelt sich ein $|0\\rangle$ in ein $|1\\rangle$ und umgekehrt, und der geheime Zustand wird sichtbar.\n",
"\n",
"Nun sollte klar sein, warum wir mit diesem Aufbau keine Informationen schneller als Licht übertragen können. Vielleicht haben wir Glück und messen „ $|0\\rangle_A|0\\rangle_Q$ “, was bedeutet, dass Bob genau diesen geheimen Zustand hat – und zwar sofort. 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.“\n",
"\n",
"In dem Gedankenexperiment werden die Qubits oft physisch getrennt und an einen neuen Ort gebracht. IBM® quantencomputer verwenden Festkörper-Qubits auf einem Chip, die nicht getrennt werden können. Anstatt also Alice und Bob an verschiedene Orte zu versetzen, werden wir die Informationen auf dem Chip selbst trennen, indem wir sogenannte \"Swap Gates\" verwenden, um die Informationen von einem Qubit zum anderen zu verschieben.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "efa0afed-97e7-42fd-a06d-7c095e703537",
"metadata": {},
"source": [
"\n",
"\n",
"## Experiment 1: Grundlegende Teleportation\n",
"\n",
"IBM Quantum empfiehlt, Probleme der Quanteninformatik mit Hilfe eines Rahmens zu lösen, den wir \"Qiskit-Muster\" nennen. Sie besteht aus den folgenden Schritten.\n",
"\n",
"* Schritt 1: Übertragen Sie Ihr Problem auf einen Quantenkreis\n",
"* Schritt 2: Optimieren Sie Ihre Schaltung für den Betrieb auf echter Quantenhardware\n",
"* Schritt 3: Führen Sie Ihren Job auf den Quantencomputern von IBM unter Verwendung der Primitive von IBM Quantum aus\n",
"* Schritt 4: Nachbearbeitung der Ergebnisse\n",
"\n",
"\n",
"\n",
"### Schritt 1: Ordnen Sie Ihr Problem einem Quantenschaltkreis zu\n",
"\n",
"Alle Berechnungen, die wir oben angestellt haben, dienten der Beschreibung von Schritt 1. Wir werden es jetzt umsetzen, indem wir unseren Quantenschaltkreis mit Qiskit bauen! Wir beginnen mit der Erstellung eines Quantenschaltkreises mit drei Qubits und der Verschränkung der beiden Qubits von Alice und Bob. Wir nehmen an, dass dies die Qubits 1 und 2 sind, und wir reservieren das Qubit 0 für den geheimen Zustand.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6e3e0d07-b52f-4e17-9233-0a00065f2d77",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Step 1: Map your problem to a quantum circuit\n",
"\n",
"# Import some general packages\n",
"from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n",
"import numpy as np\n",
"\n",
"# Define registers\n",
"secret = QuantumRegister(1, \"Q\")\n",
"Alice = QuantumRegister(1, \"A\")\n",
"Bob = QuantumRegister(1, \"B\")\n",
"\n",
"cr = ClassicalRegister(3, \"c\")\n",
"\n",
"qc = QuantumCircuit(secret, Alice, Bob, cr)\n",
"\n",
"# We entangle Alice's and Bob's qubits as in our work above.\n",
"# We apply a Hadamard gate and then a CNOT gate.\n",
"# Note that the second argument in the CNOT gate is the target.\n",
"qc.h(Alice)\n",
"qc.cx(Alice, Bob)\n",
"\n",
"# Inserting a barrier changes nothing about the logic. It just allows us to\n",
"# force gates to be positioned in \"layers\".\n",
"qc.barrier()\n",
"\n",
"# Now we will use random variables to create the secret state.\n",
"# Don't worry about the \"u\" gate and the details.\n",
"np.random.seed(42) # fixing seed for repeatability\n",
"theta = np.random.uniform(0.0, 1.0) * np.pi # from 0 to pi\n",
"varphi = np.random.uniform(0.0, 2.0) * np.pi # from 0 to 2*pi\n",
"\n",
"# Assign the secret state to the qubit on the other side of Alice's (qubit 0), labeled Q\n",
"qc.u(theta, varphi, 0.0, secret)\n",
"qc.barrier()\n",
"\n",
"# Now entangle Q and Alice's qubits as in the discussion above.\n",
"qc.cx(secret, Alice)\n",
"qc.h(secret)\n",
"qc.barrier()\n",
"\n",
"# Now Alice measures her qubits, and stores the outcomes in the \"classical registers\" cr[]\n",
"qc.measure(Alice, cr[1])\n",
"qc.measure(secret, cr[0])\n",
"\n",
"# Now we insert some conditional logic. If Alice measures Q in a \"1\" we need a Z gate, and if Alice\n",
"# measures A in a \"1\" we need an X gate (see the table).\n",
"with qc.if_test((cr[1], 1)):\n",
" qc.x(Bob)\n",
"with qc.if_test((cr[0], 1)):\n",
" qc.z(Bob)\n",
"\n",
"qc.draw(output=\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "2802dfbf-e3cb-4bd8-80cd-83ec972c7bd9",
"metadata": {},
"source": [
"Das ist alles, was wir tun müssen, damit Alices Zustand zu Bob teleportiert wird. Man sollte jedoch bedenken, dass wir bei der Messung eines Quantenzustands $\\alpha_0 |0\\rangle+\\alpha_1|1\\rangle$ entweder $|0\\rangle$ oder $|1\\rangle$ erhalten. Am Ende hat Bob also definitiv Alices geheimen Zustand, aber wir können dies nicht ohne Weiteres durch eine Messung überprüfen. Damit eine Messung uns zeigt, dass wir das richtig gemacht haben, müssen wir einen kleinen Trick anwenden. Wir hatten einen Operator mit der Bezeichnung „U“ für „unitar“, den wir zur Vorbereitung von Alices geheimem Zustand verwendet haben. Wir können die Inverse von U am Ende unserer Schaltung anwenden. Wenn man Alices Zustand $|0\\rangle$ auf $\\alpha_0 |0\\rangle+\\alpha_1|1\\rangle$ abbildet, dann bildet die Umkehrung von U Bobs Zustand $\\alpha_0 |0\\rangle+\\alpha_1|1\\rangle$ wieder auf $|0\\rangle$ ab. Dieser letzte Schritt wäre also nicht unbedingt erforderlich, wenn das Ziel lediglich darin bestünde, Quanteninformation zu übertragen. Das geschieht nur, damit wir uns selbst überprüfen können.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "dac9d281-6c57-4e70-9a61-74efa5d4bdc2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Add the inverse of U and measure Bob's qubit.\n",
"qc.barrier()\n",
"\n",
"qc.u(theta, varphi, 0.0, Bob).inverse() # inverse of u(theta,varphi,0.0)\n",
"qc.measure(Bob, cr[2]) # add measurement gate\n",
"\n",
"qc.draw(output=\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "bd6643de-e67f-44f6-b83d-d7ea9f314eb8",
"metadata": {},
"source": [
"Wenn wir also alles richtig gemacht haben, sollte unsere Messung an Bobs Qubit einen „ $|0\\rangle$ “-Zustand ergeben. Natürlich sind diese Messungen probabilistisch. Wenn also auch nur eine geringe Wahrscheinlichkeit besteht, dass sich Bobs Qubit im Zustand $|1\\rangle$ befindet, könnte eine einzige Messung zu $|1\\rangle$ führen. Wir würden also wirklich viele Messungen durchführen wollen, um sicherzugehen, dass die Wahrscheinlichkeit für $|0\\rangle$ recht hoch ist.\n",
"\n",
"\n",
"\n",
"### Schritt 2: Optimierung des Problems für die Quantenausführung\n",
"\n",
"In diesem Schritt werden die Operationen, die wir durchführen wollen, in Bezug auf die Funktionalität eines bestimmten Quantencomputers ausgedrückt. Außerdem wird unser Problem auf den Aufbau des Quantencomputers übertragen.\n",
"\n",
"Wir beginnen mit dem Laden mehrerer Pakete, die für die Kommunikation mit IBM Quantencomputern erforderlich sind. Wir müssen auch ein Backend auswählen, auf dem die Anwendung laufen soll. Wir können entweder das am wenigsten ausgelastete Backend wählen oder ein bestimmtes Backend auswählen, dessen Eigenschaften wir kennen.\n",
"\n",
"Unten finden Sie einen Code, mit dem Sie Ihre Anmeldedaten bei der ersten Verwendung speichern können. Achten Sie darauf, diese Informationen aus dem Notebook zu löschen, nachdem Sie es in Ihrer Umgebung gespeichert haben, damit Ihre Anmeldedaten nicht versehentlich weitergegeben werden, wenn Sie das Notebook freigeben. Weitere Anleitungen finden Sie unter [Einrichten Ihres IBM Cloud Kontos](/docs/guides/initialize-account) und [Initialisieren des Dienstes in einer nicht vertrauenswürdigen Umgebung](/docs/guides/cloud-setup-untrusted).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8f24b6b9-db1b-4077-8660-e355e377807e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ibm_sherbrooke\n"
]
}
],
"source": [
"# Load IBM Quantum Compute Service\n",
"from qiskit_ibm_runtime import QiskitRuntimeService\n",
"\n",
"# Load IBM Quantum Compute Service\n",
"\n",
"# Syntax for first saving your token. Delete these lines after saving your credentials.\n",
"# QiskitRuntimeService.save_account(channel='ibm_quantum_platform',\n",
"# instance = '', token='', overwrite=True, set_as_default=True)\n",
"# service = QiskitRuntimeService(channel='ibm_quantum_platform')\n",
"\n",
"# Load saved credentials\n",
"service = QiskitRuntimeService()\n",
"\n",
"# Use the least busy backend, or uncomment the loading of a specific backend like \"ibm_brisbane\".\n",
"backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)\n",
"# backend = service.backend(\"ibm_brisbane\")\n",
"print(backend.name)"
]
},
{
"cell_type": "markdown",
"id": "35bb9c51-a573-4363-89ed-2159aaa1976f",
"metadata": {},
"source": [
"Wir aktivieren ausdrücklich die Logik bei Messungen.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e238e397-33f2-4fa1-99b1-94c78dd966f1",
"metadata": {},
"outputs": [],
"source": [
"from qiskit.circuit import IfElseOp\n",
"\n",
"backend.target.add_instruction(IfElseOp, name=\"if_else\")"
]
},
{
"cell_type": "markdown",
"id": "6074a3b9-54c3-4c52-90ee-f308bd96de76",
"metadata": {},
"source": [
"Jetzt müssen wir den Quantenkreislauf \"transpilieren\". Dies umfasst viele Teilschritte und ist ein faszinierendes Thema. Nur um ein Beispiel für einen Teilschritt zu geben: Nicht alle Quantencomputer können alle logischen Gatter in Qiskit direkt implementieren. Wir müssen die Gatter unserer Schaltung in Form von Gattern schreiben, die der Quantencomputer implementieren kann. Diesen und andere Prozesse können wir mit einem voreingestellten Passmanager durchführen. Die Einstellung `optimization = 3` (die höchste Optimierungsstufe) stellt sicher, dass die Abbildung unseres abstrakten Quantenschaltkreises auf die an den Quantencomputer gegebenen Anweisungen so effizient ist, wie es unsere Vorverarbeitung zulässt.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "c533d4a7-c53c-4048-bf99-46e06ad9cb95",
"metadata": {},
"outputs": [],
"source": [
"# Step 2: Transpile\n",
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)"
]
},
{
"cell_type": "markdown",
"id": "85f3e53c-f910-4427-a977-f6e24798542c",
"metadata": {},
"source": [
"Ein „Sampler“ ist eine Primitive, die dazu dient, mögliche Zustände, die sich aus einem Quantenschaltkreis ergeben, zu untersuchen und statistische Daten darüber zu sammeln, welche Zustände mit welcher Wahrscheinlichkeit gemessen werden könnten. Hier importieren wir den „ IBM Quantum “-Sampler:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "d3292506-1486-48cd-bf1e-696135572eab",
"metadata": {},
"outputs": [],
"source": [
"# Load the Runtime primitive and session\n",
"from qiskit_ibm_runtime import SamplerV2 as Sampler\n",
"\n",
"sampler = Sampler(mode=backend)"
]
},
{
"cell_type": "markdown",
"id": "5ea27bf8-2dbf-4d68-8375-e40e89b71341",
"metadata": {},
"source": [
"Nicht alle Berechnungen auf einem Quantencomputer lassen sich auf klassischen Computern vernünftig simulieren. Diese einfache Teleportation kann durchaus sein, aber es ist überhaupt nicht überraschend, dass wir Informationen klassischerweise an dem einen oder anderen Ort speichern können. Wir empfehlen dringend, diese Berechnungen mit einem echten IBM Quantencomputer durchzuführen. Falls Sie jedoch Ihr monatliches Freikontingent ausgeschöpft haben oder wenn Sie etwas im Unterricht erledigen müssen und nicht in der Warteschlange warten können, können Sie dieses Modul mit einem Simulator absolvieren. Führen Sie dazu einfach die unten stehende Zelle aus und entfernen Sie die entsprechenden Zeilen in den \"Ausführen\"-Schritten.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2332b984-cff6-4022-b7fa-f100d35a2719",
"metadata": {},
"outputs": [],
"source": [
"# Load the backend sampler\n",
"from qiskit.primitives import BackendSamplerV2\n",
"\n",
"# Load the Aer simulator and generate a noise model based on the currently-selected backend.\n",
"from qiskit_aer import AerSimulator\n",
"from qiskit_aer.noise import NoiseModel\n",
"\n",
"\n",
"noise_model = NoiseModel.from_backend(backend)\n",
"\n",
"# Define a simulator using Aer, and use it in Sampler.\n",
"backend_sim = AerSimulator(noise_model=noise_model)\n",
"sampler_sim = BackendSamplerV2(backend=backend_sim)\n",
"\n",
"# Alternatively, load a fake backend with generic properties and define a simulator.\n",
"# backend_gen = GenericBackendV2(num_qubits=18)\n",
"# sampler_gen = BackendSamplerV2(backend=backend_gen)"
]
},
{
"cell_type": "markdown",
"id": "bff5bb04-fc2d-45f4-ab26-98fe9a5a0b5c",
"metadata": {},
"source": [
"\n",
"\n",
"### Schritt 3: Ausführen\n",
"\n",
"Verwenden Sie den Sampler, um Ihren Auftrag auszuführen, mit dem Stromkreis als Argument.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cbf63f9a-5b93-4bbd-b527-f3892e2188bd",
"metadata": {},
"outputs": [],
"source": [
"job = sampler.run([qc_isa])\n",
"# job = sampler_sim.run([qc_isa])\n",
"res = job.result()\n",
"counts = res[0].data.c.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "a6a68d85-486a-401a-8336-805713eafd57",
"metadata": {},
"source": [
"\n",
"\n",
"### Schritt 4: Nachbearbeitung und Analyse\n",
"\n",
"Stellen wir die Ergebnisse dar und interpretieren sie.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "47488ddf-9357-41e4-a0fb-45616bee307c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# This required 5 s to run on a Heron r2 processor on 10-28-24\n",
"from qiskit.visualization import plot_histogram\n",
"\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "12dcb4f6-d105-41f0-8800-87f291ce1aeb",
"metadata": {},
"source": [
"\n",
"\n",
"#### Überprüfen Sie Ihr Verständnis\n",
"\n",
"Welche der oben genannten Zustände weisen auf eine erfolgreiche Teleportation hin, und woran lässt sich das erkennen?\n",
"\n",
"\n",
" \n",
" Die Zustände $|000\\rangle$, $|001\\rangle$, $|010\\rangle$, $|011\\rangle$ stehen alle im Einklang mit einer erfolgreichen Teleportation. Das liegt daran, dass wir ein Gatter hinzugefügt haben, um die anfängliche Vorbereitung des geheimen Zustands rückgängig zu machen. Wenn der geheime Zustand erfolgreich auf Bobs Qubit teleportiert wurde, sollte dieses zusätzliche Gatter Bobs Qubit wieder in den Zustand „ $|0\\rangle$ “ versetzen. Jeder der oben genannten Zustände, bei dem sich Bobs Qubit (Qubit 0, das ebenfalls auf die 0. Komponente des klassischen Registers gemessen wird und somit die höchste bzw. ganz rechts liegende Komponente darstellt) im Zustand „ $|0\\rangle$ “ befindet, deutet auf einen Erfolg hin.\n",
" \n",
"\n",
"\n",
"Diese Grafik zeigt alle Messergebnisse für die drei Qubits über 5.000 Versuche oder \"Schüsse\". Wir haben bereits darauf hingewiesen, dass Alice alle möglichen Zustände der Qubits A und Q mit gleicher Wahrscheinlichkeit messen würde. Wir haben die Q-Bits 0-2 in der Schaltung in dieser Reihenfolge Q, A und B zugewiesen. In Little-Endian-Notation ist Bobs Qubit das am weitesten links stehende/unterste. Die vier Balken auf der linken Seite entsprechen also Bobs Qubit $|0\\rangle$ und den beiden anderen Qubits, die sich mit ungefähr gleicher Wahrscheinlichkeit in allen möglichen Kombinationen befinden. Man beachte, dass fast alle (normalerweise \\~95%) der Messungen Bobs Qubit im Zustand $|0\\rangle$ ergeben, was bedeutet, dass unser Aufbau erfolgreich war! Es gibt eine Handvoll Schüsse (\\~5%), die Bobs Qubit in den Zustand $|1\\rangle$ versetzt haben. Das sollte logischerweise nicht möglich sein. Alle modernen Quantencomputer leiden jedoch in viel stärkerem Maße unter Rauschen und Fehlern als klassische Computer. Und die Quantenfehlerkorrektur ist noch ein junges Gebiet.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "cd75b04b-2d2d-4d87-b6cc-b0fed440d912",
"metadata": {},
"source": [
"\n",
"\n",
"## Experiment 2: Teleportation über einen Prozessor hinweg\n",
"\n",
"Das Interessanteste an der Quantenteleportation ist wohl, dass ein Quantenzustand sofort über große Entfernungen teleportiert werden kann (obwohl die klassische Kommunikation von Extra-Gates nicht sofort erfolgt). Wie bereits erwähnt, können wir die Qubits nicht aus dem Prozessor herauslösen und sie verschieben. Aber wir können die Information von einem Qubit zum anderen verschieben, bis sich die an der Teleportation beteiligten Qubits auf gegenüberliegenden Seiten des Prozessors befinden. Wir wiederholen die oben beschriebenen Schritte, bauen aber eine größere Schaltung mit genügend Qubits, um den Prozessor zu überbrücken.\n",
"\n",
"\n",
"\n",
"### Schritt 1: Ordnen Sie Ihr Problem einem Quantenschaltkreis zu\n",
"\n",
"Dieses Mal ändern sich die Qubits, die Alice und Bob entsprechen. Wir werden also nicht ein einzelnes Qubit \"A\" und ein anderes \"B\" nennen. Vielmehr werden wir die Qubits nummerieren und Variablen verwenden, um die aktuelle Position der Informationen auf den Qubits von Alice und Bob darzustellen. Alle anderen Schritte mit Ausnahme der Swap-Gates sind wie zuvor beschrieben.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7d7742fa-e9a2-4ca0-9d9b-f29d73e07cd9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Step 1: Map\n",
"\n",
"# Define registers\n",
"qr = QuantumRegister(13, \"q\")\n",
"\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Define registers\n",
"secret = QuantumRegister(1, \"Q\")\n",
"ebitsa = QuantumRegister(6, \"A\")\n",
"ebitsb = QuantumRegister(6, \"B\")\n",
"# q = ClassicalRegister(1, \"q meas\")\n",
"# a = ClassicalRegister(1, \"a\")\n",
"# b = ClassicalRegister(1, \"b\")\n",
"cr = ClassicalRegister(3, \"c\")\n",
"qc = QuantumCircuit(secret, ebitsa, ebitsb, cr)\n",
"\n",
"# We'll start Alice in the middle of the circuit, then move information outward in both directions.\n",
"Alice = 5\n",
"Bob = 0\n",
"qc.h(ebitsa[Alice])\n",
"qc.cx(ebitsa[Alice], ebitsb[Bob])\n",
"\n",
"# Starting with Bob and Alice in the center, we swap their information onto adjacent qubits,\n",
"# until the information is on distant qubits.\n",
"\n",
"for n in range(Alice):\n",
" qc.swap(ebitsb[Bob], ebitsb[Bob + 1])\n",
" qc.swap(ebitsa[Alice], ebitsa[Alice - 1])\n",
" Alice = Alice - 1\n",
" Bob = Bob + 1\n",
"\n",
"qc.barrier()\n",
"\n",
"# Create a random state for Alice (qubit zero)\n",
"np.random.seed(42) # fixing seed for repeatability\n",
"# theta = np.random.uniform(0.0, 1.0) * np.pi #from 0 to pi\n",
"theta = 0.3\n",
"varphi = np.random.uniform(0.0, 2.0) * np.pi # from 0 to 2*pi\n",
"\n",
"\n",
"qc.u(theta, varphi, 0.0, secret)\n",
"\n",
"# Entangle Alice's two qubits\n",
"qc.cx(secret, ebitsa[Alice])\n",
"qc.h(secret)\n",
"\n",
"qc.barrier()\n",
"\n",
"# Make measurements of Alice's qubits and store the results in the classical register.\n",
"qc.measure(ebitsa[Alice], cr[1])\n",
"qc.measure(secret, cr[0])\n",
"\n",
"# Send instructions to Bob's qubits based on the outcome of Alice's measurements.\n",
"with qc.if_test((cr[1], 1)):\n",
" qc.x(ebitsb[Bob])\n",
"with qc.if_test((cr[0], 1)):\n",
" qc.z(ebitsb[Bob])\n",
"\n",
"qc.barrier()\n",
"\n",
"# Invert the preparation we did for Carl's qubit so we can check whether we did this correctly.\n",
"qc.u(theta, varphi, 0.0, ebitsb[Bob]).inverse() # inverse of u(theta,varphi,0.0)\n",
"qc.measure(ebitsb[Bob], cr[2]) # add measurement gate\n",
"\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "5174ffeb-28d4-49d4-9693-5271e026b026",
"metadata": {},
"source": [
"Im Schaltplan können Sie sehen, dass die logischen Schritte die gleichen sind. Der einzige Unterschied besteht darin, dass wir die Tauschgatter verwendet haben, um den Zustand von Alices Q-Bit von Q-Bit 6 ( $A_5$ ) auf Q-Bit 1 ( $A_0$ ) zu bringen, direkt neben Q. Und wir haben Swap-Gates verwendet, um Bobs Anfangszustand von Q-Bit 7 ( $B_0$ ) auf Q-Bit 12 ( $B_5$ ) zu bringen. Man beachte, dass der Zustand von Q-Bit 12 nicht einmal mit dem geheimen Zustand von Q in Verbindung steht, bis Messungen an den entfernten Q-Bits 0 und 1 durchgeführt werden, und der Zustand von Q-Bit 12 ist nicht gleich dem geheimen Zustand, bis die bedingten $X$ und $Z$ Gatter angewendet werden.\n",
"\n",
"\n",
"\n",
"### Schritt 2: Optimieren Sie Ihre Schaltung\n",
"\n",
"Wenn wir den Pass-Manager zum Umsetzen und Optimieren unserer Schaltungen verwenden, ist es in der Regel sinnvoll, `optimization_level = 3` einzustellen, denn wir wollen, dass unsere Schaltungen so effizient wie möglich sind. In diesem Fall gibt es für uns keinen rechnerischen Grund, Zustände von den Qubits 6 und 7 auf die Qubits 1 und 12 zu übertragen. Das haben wir nur gemacht, um die Teleportation über eine bestimmte Entfernung zu demonstrieren. Wenn wir den Pass-Manager bitten, unsere Schaltung zu optimieren, wird er erkennen, dass es keinen logischen Grund für diese Tauschgatter gibt, und er wird sie entfernen und die Gatteroperationen auf benachbarten Qubits durchführen. Für diesen speziellen Fall verwenden wir also `optimization_level = 0`.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "d7865560-a8a6-4abb-af8d-6a86ecc76bff",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"105\n"
]
}
],
"source": [
"# Step 2: Transpile\n",
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
"\n",
"target = backend.target\n",
"pmzero = generate_preset_pass_manager(target=target, optimization_level=0)\n",
"\n",
"qc_isa_zero = pmzero.run(qc)\n",
"\n",
"print(qc_isa_zero.depth())"
]
},
{
"cell_type": "markdown",
"id": "38c1dc99-e5e0-4969-b7a0-cdc1e4e6bedd",
"metadata": {},
"source": [
"Mit der Funktion `plot_circuit_layout` können wir visualisieren, wo sich diese Qubits auf dem Quantenprozessor befinden.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "6a74e5a5-d32f-41a5-adf8-29174a0d5e8a",
"metadata": {},
"source": [
"\n",
"\n",
"### Schritt 3: Ausführen\n",
"\n",
"Wie bisher empfehlen wir den Betrieb auf echten IBM Quantencomputern. Wenn Ihre monatliche freie Nutzung erreicht ist, können Sie die Simulatorzellen deaktivieren, um sie auf einem Simulator auszuführen.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "5536d98a-480b-4193-8c63-2ef77d1aeda0",
"metadata": {},
"outputs": [],
"source": [
"# This required 5 s to run on a Heron r2 processor on 10-28-24\n",
"job = sampler.run([qc_isa_zero])\n",
"# job = sampler_sim.run([qc_isa_zero])\n",
"counts = job.result()[0].data.c.get_counts()"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "13b6375b-73c7-436d-bf1c-98de45ef4056",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.visualization import plot_histogram\n",
"\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "49ed3ba0-3482-4ad5-84c3-f8fba80d8668",
"metadata": {},
"source": [
"\n",
"\n",
"### Schritt 4: Klassische Nachbearbeitung\n",
"\n",
"Auch hier sehen wir, dass die Wahrscheinlichkeiten für die möglichen Ergebnisse für Alices Qubits ziemlich einheitlich sind. Es besteht eine starke Präferenz dafür, Bobs Qubit in $|0\\rangle$ zu finden, nachdem der geheime Code invertiert wurde, d.h. es besteht eine hohe Wahrscheinlichkeit, dass wir den geheimen Zustand korrekt über den Prozessor von Q zu Bob teleportiert haben (Qubits 0 bis 12). Wir stellen jedoch fest, dass für Bob nun eine höhere Wahrscheinlichkeit besteht, dass er *nicht* gemessen wird: $|0\\rangle$. Dies ist eine wichtige Lektion in der Quanteninformatik: Je mehr Gatter man hat, insbesondere Multi-Qubit-Gatter wie Swap-Gatter, desto mehr Rauschen und Fehler werden auftreten.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ede2724d-536b-472a-b4bd-b1276b5b851d",
"metadata": {},
"source": [
"\n",
"\n",
"## Fragen\n",
"\n",
"Lehrkräfte können Versionen dieser Hefte mit Antwortschlüsseln und Hinweisen zur Einordnung in gängige Lehrpläne anfordern, indem sie diese [kurze Umfrage](https://ibm.biz/classrooms_instructor_key_request) zur Verwendung der Hefte ausfüllen.\n",
"\n",
"\n",
"\n",
"### Kritische Konzepte\n",
"\n",
"* Qubits können verschränkt sein, d. h. die Messung eines Qubits beeinflusst oder bestimmt sogar den Zustand eines anderen Qubits.\n",
"* Verschränkung unterscheidet sich von klassischen Korrelationen; so könnten sich beispielsweise die Qubits A und B in einer Überlagerung von Zuständen wie $\\alpha_0|00\\rangle+\\alpha_1|11\\rangle$ befinden. Der Zustand von A oder B könnte von Natur aus unbestimmt sein, und dennoch könnte garantiert werden, dass sich A und B im selben Zustand befinden.\n",
"* Durch eine Kombination von Verschränkungen und Messungen können wir einen Zustand (der Informationen speichern kann) von einem Qubit auf ein anderes übertragen. Diese Übertragung kann sogar über große Entfernungen erfolgen, was als Quantenteleportation bezeichnet wird.\n",
"* Die Quantenteleportation beruht auf Quantenmessungen, die probabilistisch sind. Daher kann eine klassische Kommunikation notwendig sein, um die teleportierten Zustände zu beeinflussen. Dadurch wird verhindert, dass bei der Quantenteleportation Informationen schneller als das Licht übertragen werden. Die Quantenteleportation verstößt nicht gegen die Relativitätstheorie oder die Kausalität.\n",
"* Moderne Quantencomputer sind anfälliger für Rauschen und Fehler als klassische Computer. Rechnen Sie mit einem Fehler von einigen Prozent.\n",
"* Je mehr Gatter man hintereinander schaltet (insbesondere 2-Qubit-Gatter), desto mehr Fehler und Rauschen sind zu erwarten.\n",
"\n",
"\n",
"\n",
"### Richtig/Falsch-Fragen\n",
"\n",
"1. T/F Die Quantenteleportation kann genutzt werden, um Informationen schneller als das Licht zu übertragen.\n",
"2. T/F Moderne Erkenntnisse deuten darauf hin, dass sich der Zusammenbruch eines Quantenzustands schneller als das Licht ausbreitet.\n",
"3. T/F In Qiskit sind die Qubits in Zuständen geordnet, wobei das Qubit mit der niedrigsten Nummer rechts steht, wie in $|q_3,q_2,q_1, q_0\\rangle$\n",
"\n",
"\n",
"\n",
"### MC-Fragen\n",
"\n",
"1. Die Qubits A und B sind verschränkt und dann durch eine große Entfernung $d$ getrennt. Qubit A wird gemessen. Welche Aussage über die Geschwindigkeit, mit der der Zustand von Qubit B beeinflusst wird, ist richtig?\n",
"\n",
"* a. Qubit B wird in den bisherigen Experimenten innerhalb der experimentellen Toleranz sofort beeinflusst.\n",
"* b. Qubit B ist nach einer Zeit $d/c$ betroffen, d. h. der Quantenzustand \"kollabiert\" ungefähr mit Lichtgeschwindigkeit, innerhalb der experimentellen Toleranz.\n",
"* c. Qubit B ist erst betroffen, nachdem die klassische Kommunikation stattgefunden hat, was bedeutet, dass sie in einer längeren Zeit als $d/c$ stattfindet.\n",
"* d. Keines der oben genannten.\n",
"\n",
"2. Man beachte, dass die Messwahrscheinlichkeit mit den Amplituden in Quantenzuständen zusammenhängt. Befindet sich ein Qubit beispielsweise anfänglich im Zustand $\\alpha_0|0\\rangle+\\alpha_1 |1\\rangle$, beträgt die Wahrscheinlichkeit, den Zustand $|0\\rangle$ zu messen, $|\\alpha_0|^2$. Aufgrund der endlichen Anzahl von Messungen werden nicht alle Messreihen genau diesen Wahrscheinlichkeiten entsprechen (genauso wie beim Werfen einer Münze zweimal hintereinander „Kopf“ fallen kann). Welchem der folgenden Quantenzustände könnte das untenstehende Messhistogramm entsprechen? Wählen Sie die beste Option aus.\n",
"\n",
"\n",
"\n",
"* a. $|0\\rangle$\n",
"* b. $\\frac{1}{\\sqrt{2}}\\left(|0\\rangle-|1\\rangle\\right)$\n",
"* c. $\\frac{1}{\\sqrt{2}}\\left(|0\\rangle+|1\\rangle\\right)$\n",
"* d. $\\frac{4}{5}|0\\rangle+\\frac{3}{5}|1\\rangle$\n",
"* e. $\\frac{3}{5}|0\\rangle+\\frac{4}{5}|1\\rangle$\n",
"\n",
"3. Welche(r) der folgenden Zustände zeigt/zeigen die Qubits A und B verschränkt? Wählen Sie alle Optionen aus, die zutreffen.\n",
"\n",
"* a. $\\frac{1}{\\sqrt{2}}\\left(|0\\rangle_B|0\\rangle_A+|1\\rangle_B|1\\rangle_A\\right)$\n",
"* b. $\\frac{4}{5}|0\\rangle_B|0\\rangle_A+\\frac{3}{5}|1\\rangle_B|1\\rangle_A$\n",
"* c. $\\frac{1}{\\sqrt{2}}\\left(|0\\rangle_B|1\\rangle_A-|1\\rangle_B|0\\rangle_A\\right)$\n",
"* d. $\\frac{1}{\\sqrt{2}}\\left(|0\\rangle_B|0\\rangle_A+|1\\rangle_B|0\\rangle_A\\right)$\n",
"* e. $|0\\rangle_B|0\\rangle_A$\n",
"\n",
"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 man für ein ähnliches Protokoll verwenden könnte. Welcher der folgenden Zustände könnte ein 2-Qubit-Messhistogramm wie das folgende ergeben? Wählen Sie die beste Antwort aus.\n",
"\n",
"\n",
"\n",
"* a. $\\frac{1}{\\sqrt{2}}\\left(|0\\rangle_B|0\\rangle_A+|1\\rangle_B|1\\rangle_A\\right)$\n",
"* b. $\\frac{4}{5}|0\\rangle_B|0\\rangle_A+\\frac{3}{5}|1\\rangle_B|1\\rangle_A$\n",
"* c. $\\frac{1}{\\sqrt{2}}\\left(|0\\rangle_B|1\\rangle_A-|1\\rangle_B|0\\rangle_A\\right)$\n",
"* d. $\\frac{4}{5}|0\\rangle_B|1\\rangle_A+\\frac{3}{5}|1\\rangle_B|0\\rangle_A$\n",
"* e. $|0\\rangle_B|0\\rangle_A$\n",
"\n",
"\n",
"\n",
"### DISKUSSIONSFRAGEN\n",
"\n",
"1. Beschreiben Sie Ihrem Partner/Ihrer Gruppe das Quanten-Teleportationsprotokoll, von Anfang bis Ende. Fragen Sie, ob sie etwas hinzufügen möchten oder Fragen haben.\n",
"\n",
"2. Gibt es irgendetwas Einzigartiges an dem verschränkten Ausgangszustand 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 das Besondere an ihm? Wenn nicht, welche anderen verschränkten Zustände hätten wir verwenden können?\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"in_page_toc_max_heading_level": 2,
"in_page_toc_min_heading_level": 2,
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 4
}