{
"cells": [
{
"cell_type": "markdown",
"id": "4046fd82",
"metadata": {},
"source": [
"---\n",
"title: \"Überlagerung mit Qiskit\"\n",
"description: \"Erfahren Sie mehr über Superposition und was sie für Messungen auf Quantencomputern bedeutet.\"\n",
"---\n",
"\n",
"{/* cspell:ignore nflips fliplist qcoin squareroot qnot qsqrtnot qphase qhadamard */}\n",
"\n",
"\n",
"\n",
"# Quantum Coins – ein Modul über Superposition und Interferenz\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "bc3346f6",
"metadata": {},
"source": [
"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 47 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": "3cf87503",
"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": "fba0059c-4008-4076-95f2-18dab949ca9e",
"metadata": {},
"source": [
"Schauen Sie sich den Modul-Walkthrough von Dr. Katie McCormick unten an, oder klicken Sie [hier](https://www.youtube.com/watch?v=TZ-sUHK8vVQ\\&list=PLOFEBzvs-Vvrs2fuvsuT039ariYPsua3d\\&index=6), um ihn auf YouTube zu sehen.\n",
"\n",
"***\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "8ef56d8f-1358-4c3e-b1be-f56597a5ee89",
"metadata": {
"jp-MarkdownHeadingCollapsed": true
},
"source": [
"\n",
"\n",
"## Einführung\n",
"\n",
"In diesem Modul erforschen wir eines der Kernprinzipien der Quantentheorie: die Superposition. In unserer Alltagserfahrung haben Objekte immer bestimmte Merkmale. Ihr Standort, ihre Größe, ihre Form, ihre Farbe - alles an ihnen - ist bestimmt und sicher, auch wenn wir als Beobachter sie noch nicht gemessen haben. In der Quantenwelt ist das nicht unbedingt der Fall. Ein Quantenobjekt kann sich in einer so genannten \"Superposition\" aus mehreren klassisch zulässigen Zuständen befinden. Wenn die Überlagerung gemessen wird, \"kollabiert\" sie zufällig in einen dieser Zustände.\n",
"\n",
"In gewisser Weise gleicht die Messung eines Überlagerungszustands dem Werfen einer Münze: Man kann im Voraus nicht wissen, auf welcher Seite sie landen wird. Dieser grundlegende Indeterminismus ist ein unbequemer Aspekt der Quantenmechanik, mit dem sogar Einstein seine Schwierigkeiten hatte. Zu dieser Zufälligkeit sagte er den berühmten Satz: „Gott würfelt nicht.“ Aber wie wir noch sehen werden, spielt Gott tatsächlich Würfel – und wirft Münzen.\n",
"\n",
"Wir werden uns einen klassischen Münzwurf als Analogie zur Messung eines Überlagerungszustands vorstellen. Und - indem wir mit einer \"Quantenmünze\" mit Qiskit und einem Qubit auf einem IBM® Quantenprozessor spielen - werden wir schnell die Grenzen dieser Analogie herausfinden.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "bcf4cb9b-7e3a-49f0-9d0d-756fb42eaae3",
"metadata": {},
"source": [
"\n",
"\n",
"### Klassische Münze\n",
"\n",
"Lassen Sie uns mit einer klassischen Münze beginnen. Werfen Sie eine Münze, und sie wird entweder Kopf oben oder Kopf unten landen, mit einer Wahrscheinlichkeit von 50 $~$ % für beide. Zwar könnte man im *Prinzip* berechnen, auf welcher Seite die Münze landen wird, wenn man die genauen Ausgangsbedingungen der Münze und die Kraft/das Drehmoment des Wurfs kennt, doch in der *Praxis* gibt es keine Möglichkeit, von vornherein zu wissen, auf welcher Seite die Münze landen wird. Aus diesem Grund verwenden wir den Münzwurf als kanonisches Beispiel für einen *klassischen probabilistischen Zustand*, bei dem das Ergebnis im Wesentlichen zufällig ist. Wir können den Zustand der Münze, bevor sie fällt, schreiben, um diese 50/50-Wahrscheinlichkeit widerzuspiegeln:\n",
"\n",
"$$\n",
"S(coin) = \\frac{1}{2}|up\\rangle + \\frac{1}{2}|down\\rangle\n",
"$$\n",
"\n",
"Hier stehen die beiden Terme für die beiden möglichen Ergebnisse der Umdrehung und ihre Koeffizienten für die Wahrscheinlichkeiten der einzelnen Ergebnisse. Beachten Sie, dass das \" $|\\rangle$ \" (bekannt als \"ket\") normalerweise verwendet wird, um einen Quantenzustand darzustellen, aber hier geht es um einen *klassischen* probabilistischen Zustand. In [Lektion 1: Einzelsysteme](/learning/courses/basics-of-quantum-information/single-systems/introduction) im Kurs Grundlagen der Quanteninformation erfahren Sie mehr darüber, wie wir klassische und Quanteninformationen darstellen.\n",
"\n",
"Wenn wir 1000 Mal eine Münze werfen und die Anzahl der Köpfe nach oben und unten aufzeichnen würden, ergäbe sich etwa folgendes Bild:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "f302ea9f-12af-4950-bce3-7416c163272b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# import necessary packages:\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import random\n",
"\n",
"\n",
"nflips = 1000\n",
"fliplist = [random.randint(0, 1) for f in range(nflips)]\n",
"\n",
"\n",
"# bar plots using get_gaussian_probs function\n",
"plt.hist(fliplist)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "6f2bc32b-cb77-40fc-849a-e1b9de46b813",
"metadata": {},
"source": [
"\n",
"\n",
"### Quantenmünze\n",
"\n",
"Mit einem Qubit auf unserem Quantencomputer können wir einen ähnlichen probabilistischen Zustand erzeugen. Wie der Münzwurf kann auch ein Qubit in zwei möglichen Zuständen gemessen werden: $|0\\rangle$ und $|1\\rangle$. Wir erzeugen den probabilistischen \"Superpositions\"-Zustand, indem wir mit dem Zustand $|0\\rangle$ beginnen und dann ein so genanntes Hadamard-Gatter auf das Qubit anwenden. Damit befindet sie sich in einer gleichwertigen Überlagerung von $|0\\rangle$ und $|1\\rangle$. Beachten Sie, dass dieser Überlagerungszustand zwar auf den ersten Blick wie eine Münze aussieht und sich auch so verhält, aber wir werden bald sehen, dass noch viel mehr dahintersteckt. Dieses Modul soll Ihnen zeigen, dass eine Überlagerung nicht dasselbe ist wie ein klassischer Münzwurf.\n",
"\n",
"Da sich das Qubit also in einer gleichwertigen Überlagerung von 0 und 1 befindet, besteht bei der Messung des Qubits eine 50%ige Chance, dass wir $|0\\rangle$ messen, und eine 50%ige Chance, dass wir $|1\\rangle$ messen. Wir schreiben diesen Zustand ein wenig anders als den klassischen probabilistischen Fall, aus Gründen, die später klar werden:\n",
"\n",
"$$\n",
"|\\psi\\rangle = \\frac{1}{\\sqrt{2}} |0\\rangle + \\frac{1}{\\sqrt{2}} |1\\rangle\n",
"$$\n",
"\n",
"In diesem Fall sind die Wahrscheinlichkeiten für die Messung jedes der beiden Zustände **nicht mehr** gleich den Koeffizienten, wie es im klassischen probabilistischen Zustand der Fall war. Stattdessen ist es das **Quadrat** der Koeffizienten, das uns die Wahrscheinlichkeiten liefert, und jeder dieser Koeffizienten kann nun komplex sein, das heißt, er kann sowohl reale als auch imaginäre Teile haben.\n",
"\n",
"Trotz dieser Unterschiede ist das Ergebnis der Messung dieses Zustands im Wesentlichen dasselbe wie das Werfen einer Münze.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "57f4c8c7-5524-4fcb-a37f-60a2c10bfa9b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"qcoin = QuantumCircuit(1)\n",
"qcoin.h(0)\n",
"qcoin.measure_all()\n",
"\n",
"qcoin.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "286f964c-08fb-4df7-be8c-b3c6eebdf8da",
"metadata": {},
"source": [
"Die Anwendung des Hadamard-Gatters entspricht also im Grunde genommen dem Werfen einer Münze. Und genau wie wir die Münze 1000 Mal geworfen haben, um die Statistiken darüber zu betrachten, ob die Münze auf Kopf oder Zahl gelandet ist, können wir mit unserer „Quantenmünze“ in Qiskit etwas Ähnliches machen Wir können eine Primitive namens verwenden `Sampler`, die einen Durchlauf mehrmals wiederholt, um die statistischen Eigenschaften des resultierenden Zustands zu erfassen.\n",
"\n",
"Zunächst laden wir den „ IBM Quantum “ Compute Service und die Primitive, anschließend wählen wir ein Backend aus, auf dem der Schaltkreis ausgeführt werden soll.\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": "3afaafe6",
"metadata": {},
"outputs": [],
"source": [
"# Load IBM Quantum Compute Service\n",
"from qiskit_ibm_runtime import QiskitRuntimeService\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()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "47c48517-5b27-47df-9ea8-18459d4bf720",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ibm_kingston\n"
]
}
],
"source": [
"# Load the Runtime primitive and session\n",
"from qiskit_ibm_runtime import (\n",
" SamplerV2 as Sampler,\n",
" EstimatorV2 as Estimator,\n",
")\n",
"\n",
"# Use the least busy backend\n",
"backend = service.least_busy()\n",
"print(backend.name)"
]
},
{
"cell_type": "markdown",
"id": "a2e39d00-db68-46cb-b4af-7b2559955313",
"metadata": {},
"source": [
"Wenn Sie nicht mehr Zeit auf Ihrem Konto zur Verfügung haben, können Sie stattdessen auch einen Simulator verwenden. Dekommentieren Sie einfach den Code und führen Sie die unten stehende Zelle aus, um dies zu tun:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "f85953c3-d67d-4c84-b078-80669e51f9ca",
"metadata": {},
"outputs": [],
"source": [
"## Use a local simulator\n",
"\n",
"# from qiskit_aer import AerSimulator\n",
"\n",
"## Generate a simulator that mimics the real quantum system\n",
"\n",
"# backend_sim = AerSimulator.from_backend(backend)\n",
"\n",
"## Import an estimator, this time from qiskit (we will import from Runtime for real hardware)\n",
"\n",
"# from qiskit.primitives import BackendSamplerV2\n",
"# sampler_sim = BackendSamplerV2(backend = backend_sim)\n",
"# from qiskit.primitives import BackendEstimatorV2\n",
"# estimator_sim = BackendEstimatorV2(backend = backend_sim)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "634fb53f-944c-4c2c-9e98-357acd0281aa",
"metadata": {},
"outputs": [],
"source": [
"## 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",
"\n",
"qc_isa = pm.run(qcoin)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "e7930b08-d235-4c16-8af4-1d258dd80300",
"metadata": {},
"outputs": [],
"source": [
"## Execute\n",
"\n",
"# On real hardware:\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs, shots=1000)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.meas.get_counts()\n",
"\n",
"# or with Aer simulator with noise model from real backend\n",
"# job = sampler_sim.run([qc_isa])\n",
"# counts=job.result()[0].data.meas.get_counts()"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "e3b16bd7-276f-4dca-b56e-3dd88bb17b68",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## Analysis\n",
"from qiskit.visualization import plot_histogram\n",
"\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "61743091-7f5b-4660-875c-6ddf7b61d0ab",
"metadata": {},
"source": [
"Mit 1000 Stichproben der obigen Schaltung haben wir etwas, das im Grunde genommen mit dem klassischen Münzhistogramm identisch ist, bis auf eine gewisse statistische Fluktuation.\n",
"\n",
"Neben der Erfassung der Statistiken der Quantenmünze können wir auch eine weitere Primitive namens verwenden, `Estimator` um den sogenannten *Erwartungswert* einer *Observable* des Zustands zu messen. Um zu veranschaulichen, was dieser Erwartungswert ist, nehmen wir die klassische Münze als Beispiel. Angenommen, du nutzt die Münze zum Zocken: Jedes Mal, wenn du die Münze wirfst und sie mit der „Kopfseite“ nach oben landet, gewinnst du einen Dollar. Aber jedes Mal, wenn sie mit der „Kopfseite nach unten“ landet, verlierst du einen Dollar. Wenn Sie wissen möchten, wie viel Geld Sie voraussichtlich bei jedem Münzwurf erhalten (den Erwartungswert der beobachtbaren Größe „Geld“), dann würden Sie Folgendes berechnen:\n",
"\n",
"$$\n",
"E(money) = \\frac{1}{2} (+ \\text{1 dollar}) + \\frac{1}{2} (- \\text{1 dollar}) = \\text{0 dollars}\n",
"$$\n",
"\n",
"Da die Wahrscheinlichkeit, einen Dollar zu gewinnen, gleich groß ist wie die, einen Dollar zu verlieren, beträgt der Erwartungswert 0.\n",
"\n",
"In ähnlicher Weise können wir mit einem Quantenzustand den Erwartungswert der Beobachtungsgröße \"Z\" berechnen, wobei Z die Pauli-Matrix mit den Werten +1 und -1 ist, die den Zuständen $|0\\rangle$ bzw. $|1\\rangle$ zugeordnet sind.\n",
"\n",
"$$\n",
"\\langle \\psi|Z|\\psi \\rangle = \\frac{1}{2} \\langle 0 | Z | 0 \\rangle + \\frac{1}{2} \\langle 1 | Z | 1 \\rangle = \\frac{1}{2} (+1) + \\frac{1}{2}(-1) = 0\n",
"$$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "775d62ec-3f26-4238-a1c5-292a6a606581",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.quantum_info import Pauli\n",
"\n",
"qcoin = QuantumCircuit(1)\n",
"qcoin.h(0)\n",
"\n",
"# for Estimator, we do not apply the measurement to the circuit"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "25350a19-390d-450c-89f3-2646d5b6b1a7",
"metadata": {},
"outputs": [],
"source": [
"## 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",
"\n",
"obs = Pauli(\"Z\")\n",
"\n",
"qc_isa = pm.run(qcoin)\n",
"obs_isa = obs.apply_layout(layout=qc_isa.layout)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "47ba8097-c109-4f9f-80a4-44e14ce044a2",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"-0.014799284701239441\n"
]
}
],
"source": [
"## Execute\n",
"\n",
"# On real hardware:\n",
"estimator = Estimator(mode=backend)\n",
"pubs = [(qc_isa, obs_isa)]\n",
"job = estimator.run([[qc_isa, obs_isa]])\n",
"res = job.result()\n",
"\n",
"# On a simulator:\n",
"# job = estimator_sim.run([[qc_isa, obs_isa]])\n",
"# res=job.result()\n",
"\n",
"print(res[0].data.evs)"
]
},
{
"cell_type": "markdown",
"id": "eed36776-de55-40a4-b63e-0aa17f144bff",
"metadata": {},
"source": [
"Wie erwartet erhalten wir einen Erwartungswert von 0 (hah). Dies ist ein weiterer Weg, um zu bestätigen, dass die Wahrscheinlichkeit, 0 oder 1 zu messen, tatsächlich gleich groß ist, und scheint sich wie ein Münzwurf zu verhalten.\n",
"\n",
"Zu diesem Zeitpunkt sieht die \"Quantenmünze\" genauso aus wie die klassische Münze. Aber im nächsten Abschnitt werden wir einige Experimente durchführen, die die grundlegenden Unterschiede zwischen den beiden aufzeigen werden.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "7d10d957-2e8d-4c63-b4a4-7744b9e1a0e9",
"metadata": {},
"source": [
"\n",
"\n",
"## Das Quantenphänomen enthüllt: ein Experiment in drei Dimensionen\n",
"\n",
"Lassen Sie uns ein Gedankenexperiment machen: Angenommen, Sie werfen eine Münze in die Luft und lassen sie nicht zu Boden fallen, sondern klatschen, während sie zwischen Ihren Händen hindurchgeht, und klemmen die Münze zwischen Ihre Handflächen. Jetzt ist die Münze nicht mehr Kopf oben oder unten, sondern Kopf links oder rechts.\n",
"\n",
"\n",
"\n",
"#### Überprüfen Sie Ihr Verständnis\n",
"\n",
"Wie hoch ist die Wahrscheinlichkeit für jedes dieser Ergebnisse, Kopf links oder Kopf rechts?\n",
"\n",
"\n",
" \n",
" Die Wahrscheinlichkeit ist immer noch 50:50. Es sollte keine Rolle spielen, an welcher Dimension wir das Ergebnis des Münzwurfs messen wollen.\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "907ac0e3-12cb-4444-ad2e-0b33189b43e6",
"metadata": {},
"source": [
"Sie haben hoffentlich geantwortet, dass die Wahrscheinlichkeit, links oder rechts Kopf zu finden, immer noch 50:50 ist. Die Dimension, entlang derer der Münzwurf gemessen wird, sollte keinen Einfluss auf die Wahrscheinlichkeit des Ergebnisses haben.\n",
"\n",
"Doch wie würde es bei unserer Quantenmünze anders aussehen? Schauen wir nach.\n",
"\n",
"Wir können unsere Quantenüberlagerung auf die gleiche Weise wie beim letzten Mal mit einem Hadamard-Tor herstellen. Um \"Kopf links oder rechts\" auf unserer Quantenmünze zu messen, können wir dasselbe tun wie bei der klassischen Münze: entlang einer anderen Achse messen. Unsere Standardmessungen auf dem Quantencomputer erfolgen entlang der vertikalen Achse, genau wie die übliche \"Kopf hoch oder runter\"-Messung der klassischen Münze. Wir können unsere Quantenmünze aber auch fragen, ob sie links oder rechts Kopf ist, oder ob sie sich in den Zuständen $|+\\rangle$ oder $|-\\rangle$ befindet, die entlang der $x$ -Achse zeigen. `Sampler` nur Stichproben in der Messbasis Z, aber wir können `Estimator` verwenden, um den Erwartungswert von X zu erhalten. Die Werte von X sind +1 und -1 für die Zustände $|+\\rangle$ bzw. $|-\\rangle$.\n",
"\n",
"\n",
"\n",
"#### Überprüfen Sie Ihr Verständnis\n",
"\n",
"Wenn sich die Quantenmünze in diesem Fall wie die klassische Münze verhalten würde, hätten wir eine 50:50-Wahrscheinlichkeit, den Zustand $|+\\rangle$ und $|-\\rangle$ zu messen. Welchen Erwartungswert von X würden wir von `Estimator` erwarten, wenn dies der Fall wäre?\n",
"\n",
"\n",
" \n",
" Wenn wir X auf den Zustand $|+\\rangle$ anwenden, erhalten wir den Wert und +1 und auf den Zustand $|-\\rangle$ erhalten wir -1, so dass wir bei einer 50-50-Verteilung einen Erwartungswert von 0 erhalten würden.\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "2cc7a79f-527c-4af1-a207-06cfa20ac92c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.9985207100591716\n"
]
}
],
"source": [
"# Step 1: map problem\n",
"\n",
"qcoin_lr = QuantumCircuit(1)\n",
"qcoin_lr.h(0)\n",
"\n",
"obs = Pauli(\"X\")\n",
"\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qcoin_lr)\n",
"obs_isa = obs.apply_layout(layout=qc_isa.layout)\n",
"\n",
"# Step 3: Run the circuit on a real quantum computer\n",
"\n",
"estimator = Estimator(mode=backend)\n",
"pubs = [(qc_isa, obs_isa)]\n",
"job = estimator.run([[qc_isa, obs_isa]])\n",
"res = job.result()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"# job = estimator_sim.run([[qc_isa,obs_isa]])\n",
"# res=job.result()\n",
"\n",
"# Step 4: Return the result in classical form, and analyze.\n",
"\n",
"print(res[0].data.evs)"
]
},
{
"cell_type": "markdown",
"id": "51f97d72-b152-4527-8e42-c066cec33524",
"metadata": {},
"source": [
"Der Erwartungswert von X für diesen Zustand ist 1. Es besteht also **keine** 50:50-Wahrscheinlichkeit für die Messung von $|+\\rangle$ und $|-\\rangle$.\n",
"\n",
"\n",
"\n",
"#### Überprüfen Sie Ihr Verständnis\n",
"\n",
"Was sagt uns dieser Erwartungswert über den Zustand $|\\psi\\rangle$? Wie groß ist die Wahrscheinlichkeit, $|+\\rangle$ und $|-\\rangle$ in dieser X-Basis zu messen?\n",
"\n",
"\n",
" \n",
" Da der Erwartungswert gleich dem Wert von X für den Zustand $|+\\rangle$ ist, bedeutet dies, dass wir mit 100%iger Wahrscheinlichkeit den Zustand $|+\\rangle$ messen, wenn wir entlang von X messen.\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "37b04a99-0256-41f4-8bf5-362b3508ca34",
"metadata": {},
"source": [
"Was ist hier eigentlich los? Es scheint, als ob unsere Quantenmünze in einer Dimension zufällige, wahrscheinliche Ergebnisse haben kann, in einer anderen aber vollkommen vorhersehbare Ergebnisse. Das wäre so, als würde man eine Münze werfen und garantieren, dass jedes Mal, wenn man sie auffängt, indem man sie zwischen zwei Hände klemmt, der Kopf nach rechts zeigt.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ace0c3e8-e9b7-4fc9-a312-78c0264a171a",
"metadata": {},
"source": [
"\n",
"\n",
"### Die Quantenphase\n",
"\n",
"Der entscheidende Unterschied der Quantenmünze besteht darin, dass sie eine andere Eigenschaft hat als die klassische Münze. Denken Sie daran, dass in einem klassischen probabilistischen Zustand,\n",
"\n",
"$$\n",
"S(coin) = c_1|up\\rangle + c_2|down\\rangle\n",
"$$\n",
"\n",
"jeder Koeffizient ist einfach eine reelle, positive Zahl, die die Wahrscheinlichkeit der Messung eines bestimmten Zustands darstellt. In einem Quantenzustand,\n",
"\n",
"$$\n",
"|\\psi\\rangle = c_1 |0\\rangle + c_2 |1\\rangle\n",
"$$\n",
"\n",
"die Koeffizienten sind komplex, sie enthalten also einen realen und einen imaginären Teil. Jeder Koeffizient $c_i$ kann als zweidimensionaler Vektor in der komplexen Ebene ausgedrückt werden, mit dem Betrag $|c_i|$ und dem Winkel $\\phi_i$, den er mit der reellen Achse bildet:\n",
"\n",
"$$\n",
"c_i = |c_i| e^{i \\phi_i}.\n",
"$$\n",
"\n",
"\n",
"\n",
"Wir nennen $\\phi_i$ die Phase. Die Phase gibt an, wie zwei Terme in einem Quantenzustand *interferieren* oder wie sie sich wie Wellen addieren oder aufheben. Wenn zwei Wellen in Phase zueinander sind, d. h. ihre Wellenberge und Wellentäler in einer Linie liegen, dann verbinden sie sich zu einer doppelt so hohen Welle. Wir nennen dies konstruktive Interferenz. Wenn sie phasenverschoben sind, d. h., wenn ein Hochpunkt des einen mit einem Tiefpunkt des anderen zusammentrifft und umgekehrt, überlagern sie sich in destruktiver Weise und heben sich gegenseitig vollständig auf.\n",
"\n",
"Wie Wellen können sich auch Quantenzustände konstruktiv oder destruktiv addieren. Es kann schwieriger sein, dies zu erkennen, da es sich oft nicht um eine tatsächliche Welle im physischen Raum handelt. Im Fall unserer Qubits findet die Interferenz im abstrakten Informationsraum der Qubits statt. Da nur die *relative* Phase zwischen den beiden Wellen für die Interferenz von Bedeutung ist - d. h. die Phasendifferenz $\\Delta \\phi = \\phi_2 - \\phi_1$ der beiden Koeffizienten - wenden wir normalerweise eine *globale Phase* von $-\\phi_1$ auf den gesamten Zustand an, so dass $c_1$ rein real ist und die *relative Phase* vollständig in $c_2$ erfasst wird.\n",
"\n",
"Um zu sehen, wie die Phase Interferenzen in unserer Quantenmünze verursachen kann, wollen wir versuchen, den Hadamard zweimal statt nur einmal anzuwenden. Klassischerweise würde dies keinen Sinn ergeben - wenn die Anwendung der Hadamard-Methode dem Werfen einer Münze entspricht, dann kann man keine Münze werfen, die bereits geworfen wurde. Aber schauen wir mal, was mit der Quantenmünze passiert:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "610af24c-d489-4239-b31f-cea67a563b69",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qcoin_0 = QuantumCircuit(1)\n",
"qcoin_0.h(0)\n",
"qcoin_0.h(0)\n",
"qcoin_0.measure_all()\n",
"\n",
"qcoin_0.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "6fd8711d-1bef-4706-a5a9-039531af658b",
"metadata": {},
"source": [
"Bevor wir nun `Sampler` verwenden, um den resultierenden Zustand zu messen, sollten wir darüber nachdenken, wie dieses Qubit durch jedes Gatter transformiert wird. Sie beginnt, wie üblich, in $|0\\rangle$. Dann transformiert die erste Hadamard-Transformation den Zustand in die Überlagerung, wie wir bereits gesehen haben:\n",
"\n",
"$$\n",
"H|0\\rangle = \\frac{1}{\\sqrt{2}} |0\\rangle + \\frac{1}{\\sqrt{2}} |1\\rangle.\n",
"$$\n",
"\n",
"In diesem Fall sind beide Koeffizienten vollständig reell und positiv, was bedeutet, dass die Phase $\\phi=0$ ist.\n",
"\n",
"Die zweite Hadamard-Methode wird dann auf jeden Teil des Überlagerungszustands separat angewendet. Wir wissen bereits, wie die Hadamard-Transformation den Zustand $|0\\rangle$ transformiert. Aber was ist mit $|1\\rangle$?\n",
"\n",
"$$\n",
"H|1\\rangle = \\frac{1}{\\sqrt{2}} |0\\rangle - \\frac{1}{\\sqrt{2}} |1\\rangle\n",
"$$\n",
"\n",
"Auch hier handelt es sich um eine gleichwertige Überlagerung von 0 und 1, ähnlich wie beim Werfen einer Münze, aber der Koeffizient dieses Zustands vor $|1\\rangle$ hat eine Phase von $\\phi = \\pi$, um ihm das negative Vorzeichen zu geben.\n",
"\n",
"\n",
"\n",
"#### Überprüfen Sie Ihr Verständnis\n",
"\n",
"Berechnen Sie den resultierenden Zustand nach Anwendung des zweiten Hadamard. Das heißt, berechnen Sie: $H(\\frac{1}{\\sqrt{2}} |0\\rangle + \\frac{1}{\\sqrt{2}} |1\\rangle)$. Beachten Sie, dass $H$ distributiv ist, so dass wir es auf jeden der Terme einzeln anwenden können.\n",
"\n",
"\n",
" \n",
" $$\n",
" H(\\frac{1}{\\sqrt{2}} |0\\rangle + \\frac{1}{\\sqrt{2}} |1\\rangle) = \\frac{1}{\\sqrt{2}} H|0\\rangle + \\frac{1}{\\sqrt{2}} H|1\\rangle = \\frac{1}{2} [(|0\\rangle + |1\\rangle) + (|0\\rangle - |1\\rangle)] = |0\\rangle\n",
" $$\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "e19dd16b-50b2-435e-b83e-b65af3f642be",
"metadata": {},
"source": [
"Nun wollen wir unsere Vorhersage mit `Sampler` überprüfen.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "6390f58c-057a-4ec2-a7ca-4a45410631c0",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## Transpile\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"\n",
"qc_isa = pm.run(qcoin_0)\n",
"\n",
"## Execute\n",
"\n",
"# On real hardware:\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs, shots=1000)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.meas.get_counts()\n",
"\n",
"\n",
"# or with Aer simulator with noise model from real backend\n",
"# job = sampler_sim.run([qc_isa])\n",
"# counts=job.result()[0].data.meas.get_counts()\n",
"\n",
"## Analyze\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "b5ff1950-9401-4461-bb07-0e8e5a44cb13",
"metadata": {},
"source": [
"Der zweite Hadamard-Wert hat den ersten aufgehoben, und wir sind zum Zustand 0 zurückgekehrt, in dem wir begonnen haben! Dies liegt daran, dass die Hadamard-Transformation sowohl den Zustand $|0\\rangle$ als auch den Zustand $|1\\rangle$ in ähnliche Zustände, jedoch mit entgegengesetzten Phasen, verwandelt. Nach dem zweiten Hadamard-Terminus sehen wir, dass die Terme von $|0\\rangle$ konstruktiv interferieren, aber die Terme von $|1\\rangle$ interferieren destruktiv und heben sich gegenseitig auf.\n",
"\n",
"Wir können die Phase mit Hilfe eines \"PHASE\"-Gatters ändern. Wenden wir nun einen Hadamard an, um die Überlagerung zu erzeugen, wenden wir eine Phasenverschiebung von $\\pi$ an und wenden wir dann den zweiten Hadamard an:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "ad819e8b-bc89-41d6-b375-428da51220be",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qcoin_pi = QuantumCircuit(1)\n",
"qcoin_pi.h(0)\n",
"qcoin_pi.p(np.pi, 0)\n",
"qcoin_pi.h(0)\n",
"qcoin_pi.measure_all()\n",
"\n",
"qcoin_pi.draw(\"mpl\")"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "06e21f78-e3e2-4fbf-b636-460f3ce5b3c7",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## Transpile\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"\n",
"qc_isa = pm.run(qcoin_pi)\n",
"\n",
"## Execute\n",
"\n",
"# On real hardware:\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs, shots=1000)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.meas.get_counts()\n",
"\n",
"\n",
"# or with Aer simulator with noise model from real backend\n",
"# job = sampler_sim.run([qc_isa])\n",
"# counts=job.result()[0].data.meas.get_counts()\n",
"\n",
"## Analyze\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "35078634-0d0a-43bc-a220-50c927d4c088",
"metadata": {},
"source": [
"Nun wird gemessen, dass sich das Qubit im Zustand 1 statt 0 befindet.\n",
"\n",
"Schon an diesen wenigen, einfachen Experimenten können Sie erkennen, welch drastischen Unterschied diese Phase in einem Quantenschaltkreis ausmachen kann. Sie kann subtil sein und ist anfangs schwer zu erkennen. In unserem ersten Experiment, bei dem wir einfach unsere Quantenmünze mit einem Hadamard-Gatter geworfen und das Ergebnis des Wurfs gemessen haben, war nichts von der Wirkung der Phase zu erkennen. Erst als wir tiefer gingen, entdeckten wir den Unterschied, den eine Phase ausmachen kann. Es kann dazu führen, dass dasselbe Quantengatter buchstäblich die entgegengesetzte Wirkung auf ein Qubit hat.\n",
"\n",
"\n",
"\n",
"#### Probieren Sie es selbst aus:\n",
"\n",
"Bearbeiten Sie die untenstehende Codezelle, um die Phase so zu ändern, dass der zweite Hadamard einen Überlagerungszustand mit einer Wahrscheinlichkeit von 25 % bzw. 75 % des Auffindens des Zustands in $|0\\rangle$ bzw. $|1\\rangle$ erzeugt. Überprüfen Sie Ihre Antwort mit Mathematik.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "fef281ef",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qcoin_phase = QuantumCircuit(1)\n",
"qcoin_phase.h(0)\n",
"# replace \"x\" below with a phase from 0 to 2*np.pi (this cell won't run if you leave x)\n",
"# qcoin_phase.rz(x, 0)\n",
"qcoin_phase.h(0)\n",
"qcoin_phase.measure_all()\n",
"\n",
"\n",
"## Transpile\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"\n",
"qc_isa = pm.run(qcoin_phase)\n",
"\n",
"## Execute\n",
"\n",
"# On real hardware:\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs, shots=1000)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.meas.get_counts()\n",
"\n",
"\n",
"# or with Aer simulator with noise model from real backend\n",
"# job = sampler_sim.run([qc_isa])\n",
"# counts=job.result()[0].data.meas.get_counts()\n",
"\n",
"## Analyze\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "3cd238cb-6346-40f4-af87-fdbd1b806106",
"metadata": {},
"source": [
"\n",
"\n",
"## Eine weitere (bessere) Münzanalogie unter Verwendung des „ $\\sqrt{\\text{NOT}}$ “-Tors\n",
"\n",
"Inzwischen haben wir gelernt, dass das Werfen einer Münze etwas ganz anderes ist als die Erzeugung eines Überlagerungszustands. Gibt es eine bessere Analogie zu einer Münze, die mehr von den überlagerungsähnlichen Phänomenen erfasst? Ja. Ja, die gibt es.\n",
"\n",
"Wir werden ein weiteres Gedankenexperiment mit einer Münze durchführen. Stellen Sie sich vor, die Münze liegt mit dem Kopf nach oben auf dem Tisch. Um ihn auf den Kopf zu stellen, können wir ihn einfach umdrehen. Dies ist das rechnerische Äquivalent eines \"NOT\"-Gatters.\n",
"\n",
"Nehmen wir an, wir wollen eine Operation konstruieren, die, wenn sie zweimal angewendet wird, dem NOT-Gatter entspricht. Das heißt, wir wollen eine \"Quadratwurzel von NOT\", oder $\\sqrt{\\text{NOT}}$. Wir können dies erreichen, indem wir uns überlegen, wie das NOT-Gatter physisch auf der Münze implementiert ist: Es ist einfach eine Drehung um 180 Grad, zum Beispiel um die x-Achse. Wenn wir also die Münze nur um 90 Grad um die x-Achse drehen würden, entspräche dies einem $\\sqrt{\\text{NOT}}$ gate.\n",
"\n",
"Stellen Sie sich vor, dass wir nach der Anwendung des $\\sqrt{\\text{NOT}}$ Gatters fragen wollen, ob die Münze Kopf oder Zahl ist. Weder das eine noch das andere - er steht auf seiner Kante relativ zur vertikalen Achse. Aber jetzt definieren wir unsere \"Messung\" der Münze so um, dass wir erstens die Münze entlang der Messachse zusammenklappen (indem wir sie mit der Hand zusammendrücken, so dass sie flach liegt) und zweitens überprüfen, ob sie Kopf oder Zahl ist.\n",
"\n",
"Wenn wir diese \"Messung\" an der Münze durchführen, die auf dem Rand steht, dann \"fällt\" die Münze mit gleicher Wahrscheinlichkeit auf Kopf oder Kopf unten. Ähnlich wie beim Münzwurf kann die Richtung, in die die Münze fällt, im Prinzip anhand der Ausgangsbedingungen der Münze und der Art und Weise, wie genau die Kraft unserer Hand auf die Münze einwirkt, um sie \"umfallen\" zu lassen, vorhergesagt werden. In der Praxis dürfte es jedoch schwierig sein vorherzusagen, auf welcher Seite man landet, so dass es im Wesentlichen zufällig ist.\n",
"\n",
"Wir können diese Münze auf drei verschiedenen Achsen messen: $x$, $y$, und $z$. Wir sehen, dass der Rand der Münze entlang der $x$ und $z$ zeigt, so dass die Messung in diese Richtungen ein \"Zusammenklappen\" der Münze erfordert - daher wird entlang dieser Achsen zufällig mit einer Wahrscheinlichkeit von 50:50 Kopf oben und unten gemessen. Entlang der $y$ -Achse ist er jedoch bereits flach und sein Kopf zeigt in Richtung -y. Wir können das \"Kopf nach vorne\" nennen\n",
"\n",
"Während also die x- und z-Messungen zufällige Ergebnisse lieferten, wird die y-Messung immer das gleiche Ergebnis liefern! Wenn Sie sich an das Experiment des \"Quanten-Münzwurfs\" aus dem vorigen Abschnitt erinnern, erinnert dies an das Verhalten der Quantenmünze. Es wurde gemessen, dass sie mit einer Wahrscheinlichkeit von 50/50 in z-Richtung 0 oder 1 ist, aber immer $|+\\rangle$ und nie $|-\\rangle$ entlang X. **Dies deutet darauf hin, dass sich der Überlagerungszustand eines Qubits vielleicht besser mit einer Münze veranschaulichen lässt, die still auf ihrem Rand liegt, als mit einer Münze, die wild durch die Luft fliegt.**\n",
"\n",
"Verwenden wir Qiskit, um zu sehen, ob sich unsere \"Quantenmünze\" genauso verhält wie unsere klassische Münze, wenn ein $\\sqrt{\\text{NOT}}$ Gate angewendet wird. Wir werden $\\sqrt{\\text{NOT}}$ auf ein Qubit anwenden, beginnend mit $|0\\rangle$, und dann `Estimator` verwenden, um den Erwartungswert der drei Observablen X, Y und Z zu überprüfen.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "ab97d4c5-285c-4efd-bc54-efda675e35fa",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qcoin_sx = QuantumCircuit(1)\n",
"qcoin_sx.sx(0)\n",
"\n",
"qcoin_sx.draw(\"mpl\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "28b2db66-c9d3-43a8-bfba-d90f6fd310e6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[-0.01234492]\n",
" [-1.00388865]\n",
" [ 0.00740695]]\n"
]
}
],
"source": [
"obs1 = Pauli(\"X\")\n",
"obs2 = Pauli(\"Y\")\n",
"obs3 = Pauli(\"Z\")\n",
"\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qcoin_sx)\n",
"obs1_isa = obs1.apply_layout(layout=qc_isa.layout)\n",
"obs2_isa = obs2.apply_layout(layout=qc_isa.layout)\n",
"obs3_isa = obs3.apply_layout(layout=qc_isa.layout)\n",
"\n",
"\n",
"# Step 3: Run the circuit on a real quantum computer\n",
"\n",
"estimator = Estimator(mode=backend)\n",
"pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]\n",
"job = estimator.run(pubs)\n",
"res = job.result()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"# pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]\n",
"# job = estimator_sim.run(pubs)\n",
"# res=job.result()\n",
"\n",
"# Step 4: Return the result in classical form, and analyze.\n",
"\n",
"print(res[0].data.evs)"
]
},
{
"cell_type": "markdown",
"id": "f14bd04e-255c-4bdd-a1fa-34c71273a369",
"metadata": {},
"source": [
"Die Erwartungswerte sind 0, -1 und 0 für X, Y bzw. Z.\n",
"\n",
"\n",
"\n",
"#### Überprüfen Sie Ihr Verständnis\n",
"\n",
"Wie groß ist angesichts der Erwartungswerte die Wahrscheinlichkeit, dass die Quantenmünze bei jeder der drei Messachsen Kopf oben/unten (oder links/rechts oder vorne/hinten) ist?\n",
"\n",
"\n",
" \n",
" Die Wahrscheinlichkeit, dass einer der beiden Zustände in X- und Z-Richtung gemessen wird, ist 50/50, und der Zustand wird immer in der Richtung -y in Y-Richtung gemessen.\n",
" \n",
"\n",
"\n",
"Dies ist das gleiche Ergebnis wie bei unserem Gedankenexperiment, bei dem wir die klassische Münze um 90 Grad gedreht haben ( $\\sqrt{\\text{NOT}}$ ). In der Tat gibt es jetzt eine genaue Analogie zwischen der Münze und dem Qubit-Zustand. Wir können uns den Qubit-Zustand als einen Vektor vorstellen, der in die Richtung von Köpfen auf einer Münze zeigt, normal zur Oberfläche der Münze. Kopf oben oder der Zustand $|0\\rangle$ auf einer Quantenmünze entspricht also einem Vektor, der gerade nach oben zeigt; Kopf unten oder $|1\\rangle$ ist gerade nach unten gerichtet. Eine beliebige gleichmäßige Überlagerung von $|0\\rangle$ und $|1\\rangle$ Punkten in horizontaler Richtung. Die Phase des Zustands bestimmt die genaue horizontale Richtung - die Richtung, in die er entlang des Äquators zeigt, ist gleich der Richtung, in die der Koeffizient $c_2$ in der komplexen Ebene zeigt.\n",
"\n",
"*Jedes* Tor, das wir in diesem Heft gesehen haben, kann als eine Drehung (oder eine Reihe von Drehungen) der Münze/des Vektors dargestellt werden.\n",
"\n",
"* NICHT: 180 Grad um die x-Achse\n",
"\n",
"* $\\sqrt{\\text{NOT}}$ : 90 Grad um die x-Achse\n",
"\n",
"* PHASE: Drehung von $\\phi$ um die z-Achse\n",
"\n",
"* Hadamard: Das ist ein bisschen schwieriger. Wir haben es zunächst mit dem Werfen einer Münze verglichen, die sich unkontrolliert in der Luft dreht. Aber das Hadamard-Tor ist eigentlich eine kontrollierte, deterministische Drehung der Münze, wie die anderen Tore. Das Hadamard-Verfahren wird durch eine Drehung um 90 Grad um die y-Achse und anschließend um 180 Grad um die x-Achse durchgeführt.\n",
"\n",
"Es gibt also nichts Zufälliges an einem Quantenüberlagerungszustand oder an einer der Standardoperationen, die wir mit dem Qubit durchführen. Jeder Vorgang ist deterministisch und reversibel. Der Zufall kommt nur dann ins Spiel, wenn wir uns entscheiden, den Quantenzustand *zu messen*.\n",
"\n",
"\n",
"\n",
"### Der Qubit-Zustand als Bloch-Vektor\n",
"\n",
"Dieser Vektor, der in Richtung des \"Kopfes\" der Münze zeigt, wird als \"Bloch-Vektor\" bezeichnet Formal kann ein beliebiger (isolierter) Qubit-Zustand durch einen Vektor dargestellt werden, der auf der Oberfläche einer Kugel mit dem Radius 1 und den Koordinaten $(r, \\theta, \\phi)$ liegt. In Form dieser Koordinaten ausgedrückt, ist der Qubit-Zustand:\n",
"\n",
"$|\\psi\\rangle = \\cos{\\frac{\\theta}{2}} |0\\rangle + e^{i \\phi} \\sin{\\frac{\\theta}{2}} |1\\rangle$\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a9e7efad-9561-4613-b2e2-d5201d3cef72",
"metadata": {},
"source": [
"Nun wollen wir mit Qiskit überprüfen, wie sich der Bloch-Vektor verändert, wenn wir verschiedene Gatter auf unser Qubit anwenden, ausgehend vom Zustand $|0\\rangle$.\n",
"\n",
"\n",
"\n",
"#### NICHT\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "d33d6191-c455-4cac-8947-0d68030278e9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.visualization import plot_bloch_multivector\n",
"\n",
"qnot = QuantumCircuit(1)\n",
"qnot.x(0)\n",
"\n",
"plot_bloch_multivector(qnot)"
]
},
{
"cell_type": "markdown",
"id": "69f06a6c-1a33-48a7-84de-30c49fc11f97",
"metadata": {},
"source": [
"\n",
"\n",
"#### $\\sqrt{\\text{NOT}}$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "8648c4b8-edd1-4e40-9c74-50219c84c928",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qsqrtnot = QuantumCircuit(1)\n",
"qsqrtnot.sx(0)\n",
"\n",
"plot_bloch_multivector(qsqrtnot)"
]
},
{
"cell_type": "markdown",
"id": "f0145781-8534-4f94-bea4-11111dfffdfb",
"metadata": {},
"source": [
"\n",
"\n",
"#### PHASE ( $\\phi = \\pi$ )\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "f2b33aa1-2460-4e66-aa48-cbceef02729e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qphase = QuantumCircuit(1)\n",
"qphase.p(np.pi, 0)\n",
"\n",
"plot_bloch_multivector(qphase)"
]
},
{
"cell_type": "markdown",
"id": "9ca1c439-055e-4c11-a730-2dfa1f6141e4",
"metadata": {},
"source": [
"\n",
"\n",
"#### Hadamard\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "1371f0a1-8279-4dff-987b-050511ba629b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qhadamard = QuantumCircuit(1)\n",
"qhadamard.h(0)\n",
"\n",
"plot_bloch_multivector(qhadamard)"
]
},
{
"cell_type": "markdown",
"id": "f66be32d-6452-4ba0-8dcf-5e248ce37605",
"metadata": {},
"source": [
"\n",
"\n",
"## Fazit – Was *ist* also ein Überlagerungszustand?\n",
"\n",
"Zu Beginn dieses Moduls haben wir die Zufälligkeit der Messung eines Quantenüberlagerungszustands mit einem Münzwurf verglichen. Wir haben das \"Hadamard-Tor\", das eine Quantensuperposition erzeugt, mit dem Werfen einer Münze verglichen. Aber durch eine Reihe von Experimenten haben wir gelernt, dass es grundlegende Unterschiede zwischen einem klassischen Münzwurf und einer Quantenüberlagerung gibt.\n",
"\n",
"Wir haben gelernt, dass ein Qubit in einem Überlagerungszustand nichts \"Zufälliges\" an sich hat. Sie ist wie eine Münze, die im dreidimensionalen Raum stillsteht. Tatsächlich ist eine Münze, die sich in drei Dimensionen frei drehen kann, eine sehr enge Analogie zu einer bestimmten Art der Visualisierung des Quantenzustands eines Qubits, dem so genannten Bloch-Vektor. Quantengatter drehen diesen Münz/Bloch-Vektor deterministisch und reversibel. Erst wenn wir das Qubit **messen**, kommt der Zufall ins Spiel. Wir verglichen diesen Messvorgang mit dem Zusammendrücken der Münze, damit sie flach in Richtung der Messachse liegt.\n",
"\n",
"Ob sich ein Quantenzustand überhaupt in einer Superposition befindet, liegt im Auge des Betrachters. Wie Sie wahrscheinlich schon erfahren haben, können wir unser Koordinatensystem frei wählen - $x$, $y$ und $z$ können in drei beliebige orthogonale Richtungen zeigen. Wenn wir also in einem Koordinatensystem eine Überlagerung von 0 und 1 haben, können wir ein neues Koordinatensystem - oder äquivalent dazu eine neue \"Messbasis\" - definieren, in dem der Zustand rein in die Richtung $+z$ zeigt und sich somit nicht in einem Überlagerungszustand befindet. Wenn wir also sagen, dass sich ein Qubit in einer Superposition befindet, müssen wir auch die Frage beantworten: \"Superposition von *was*?\"\n",
"\n",
"Sie werden dieses Modul vielleicht mit dem Eindruck verlassen, dass wir der Quantenmechanik gerade alle Geheimnisse entlockt haben. Schließlich ist einer der vermeintlich \"seltsamsten\" Aspekte, der Überlagerungszustand eines Qubits, in Wirklichkeit so einfach wie ein dreidimensionaler Vektor. Aber bedenken Sie, dass die Münze immer noch nur eine Analogie ist, und auch der Bloch-Vektor ist nur ein Visualisierungsinstrument zur Berechnung von Wahrscheinlichkeiten von Messergebnissen. Wir können nicht sagen, was ein Quantenzustand *wirklich* tut, bevor er gemessen wurde. Denn um das zu überprüfen, ist eine Messung erforderlich!\n",
"\n",
"Dieses Rätsel, was die \"wahre\" Natur eines Quantenzustands ist und wie das Quantenphänomen der Verschränkung uns helfen kann, dies zu ergründen, werden wir im Modul Bellsche Ungleichung diskutieren.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "3425eb14-a8fd-4894-83a8-268a93733795",
"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",
"### Wichtige Konzepte:\n",
"\n",
"* Während die Messung eines Qubits in einer Superposition probabilistisch ist, wie das Werfen einer Münze, verhält sich der Superpositionszustand selbst anders als eine geworfene Münze.\n",
"* Ein Hauptunterschied zwischen einer klassischen Wahrscheinlichkeitsverteilung und einer Überlagerung besteht darin, dass die Überlagerung *Phasenkohärenz* besitzt, wodurch sie konstruktiv oder destruktiv interferieren kann.\n",
"* Der Zustand eines einzelnen, isolierten Qubits kann als Punkt auf der so genannten \"Bloch-Kugel\" visualisiert werden, wobei die relativen Amplituden der Komponenten $|0\\rangle$ und $|1\\rangle$ den Polarwinkel $\\theta$ und die relativen Phasen zwischen den beiden Komponenten den Azimutalwinkel $\\phi$ bestimmen.\n",
"* Alle Ein-Qubit-Quantengatter können als Rotationen des Vektors auf dieser Kugel betrachtet werden.\n",
"\n",
"\n",
"\n",
"### Richtig/Falsch-Fragen:\n",
"\n",
"1. T/F Eine Quantenüberlagerung ist im Grunde dasselbe wie ein probabilistisches Ereignis in der klassischen Physik, wie das Werfen einer Münze.\n",
"\n",
"2. T/F Die Länge des Bloch-Vektors, der den Zustand eines einzelnen isolierten Qubits beschreibt, ist immer 1.\n",
"\n",
"3. T/F Ein-Qubit-Quantengatter ändern die Länge des Bloch-Vektors nicht.\n",
"\n",
"\n",
"\n",
"### MC-Fragen:\n",
"\n",
"1. Wählen Sie den richtigen Bloch-Vektor aus, der den Zustand $|\\Psi\\rangle = \\sqrt{\\frac{1}{3}}|0\\rangle + e^{i \\pi / 4} \\sqrt{\\frac{2}{3}}|1\\rangle$ repräsentiert:\n",
"\n",
"\n",
"\n",
"2. Die Bloch-Sphäre beschreibt die Eigenschaften eines Qubits: (bitte alles Zutreffende auswählen)\n",
"\n",
" a. Amplitude\n",
"\n",
" b. verschränkung mit anderen Qubits\n",
"\n",
" c. Phase\n",
"\n",
" d. Farbe\n",
"\n",
" e. wahrscheinlichkeit von Messergebnissen\n",
"\n",
"\n",
"\n",
"### Diskussionsfragen:\n",
"\n",
"1. Warum kann der Zustand eines Qubits auf der Blochkugel dargestellt werden, die Wahrscheinlichkeitsverteilung eines Münzwurfs aber nicht?\n",
"\n",
"2. Warum ist eine in die Luft geworfene Münze nicht die beste Analogie zu einem Quantenüberlagerungszustand? Welcher Aspekt von Überlagerungen wird in dieser Analogie nicht erfasst?\n",
"\n",
"\n",
"\n",
"### Herausfordernde Probleme:\n",
"\n",
"1. Verwenden Sie Qiskit, um eine Schaltung zu erstellen, die den Zustand $|0\\rangle$ in den Zustand $\\frac{\\sqrt{3}}{2}|0\\rangle + \\frac{1}{2}e^{i \\frac{5\\pi}{6}}|1\\rangle$\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": 5
}