{
"cells": [
{
"cell_type": "markdown",
"id": "f767af9e-cdd6-41f4-9279-9e92fa2dde06",
"metadata": {},
"source": [
"---\n",
"title: \"Erforschung von Unsicherheiten mit Qiskit\"\n",
"description: \"Erfahren Sie, welche physikalischen Messungen sich gegenseitig beeinflussen, und untersuchen Sie die fundamentale Unsicherheit in der Quantenmechanik mithilfe eines echten Quantencomputers\"\n",
"---\n",
"\n",
"{/* cspell:ignore prodxz delx delz dely prodxy uparrow downarrow */}\n",
"\n",
"\n",
"\n",
"# Unsicherheit erforschen\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "132cdf03-164e-4334-aab6-206aacacc25b",
"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 8 Minuten QPU-Zeit. Dies ist nur eine Schätzung. Ihre tatsächliche Nutzung kann davon abweichen. Zwei zeitaufwändige Berechnungen sind in den Kopfzeilen als solche gekennzeichnet und können an Simulatoren durchgeführt werden, wenn die Schüler nur wenig Zeit für QPU haben. Wenn diese entfernt werden, benötigt das Modul nur etwa 30 Sekunden QPU-Zeit.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dbda80f2-62c5-4f25-95cf-c5495bc171b1",
"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": "4283087e-cc02-467d-b02c-c1c131ad15f3",
"metadata": {},
"source": [
"Schauen Sie sich den Modul-Walkthrough von Dr. Katie McCormick unten an, oder klicken Sie [hier](https://www.youtube.com/watch?v=3h3pwrECbb8\\&list=PLOFEBzvs-Vvrs2fuvsuT039ariYPsua3d\\&index=5), um ihn auf YouTube zu sehen.\n",
"\n",
"***\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "be385aa2-9080-4c39-aba0-bc35087ced78",
"metadata": {},
"source": [
"\n",
"\n",
"## Einführung\n",
"\n",
"Wahrscheinlich haben Sie schon einmal von der Unschärferelation gehört, auch außerhalb Ihres Physikunterrichts. Eine gängige umgangssprachliche Umschreibung für Unsicherheit lautet: \"Indem man etwas betrachtet, beeinflusst man es\" Das ist sicherlich richtig. Eine physikalischere Art, die Unsicherheit zu beschreiben, besteht darin, dass es bestimmte physikalische Beobachtungsgrößen gibt, die eine Inkompatibilität aufweisen, die verhindert, dass sie beide gleichzeitig mit beliebiger Genauigkeit bekannt sind. Viele Schüler stoßen zunächst auf die beiden unvereinbaren Variablen $x$ und $p_x$, d. h. die Position entlang einer Achse, der $x$ -Achse, bzw. den linearen Impuls entlang dieser Richtung. Für diese Variablen wird die Unsicherheitsbeschränkung wie folgt geschrieben $\\Delta x \\Delta p_x \\geq \\frac{\\hbar}{2}.$ Hier wird $\\Delta x$ als die \"Unsicherheit in $x$ \" bezeichnet, die dieselbe Definition wie die Standardabweichung in der Statistik hat und wie folgt definiert werden kann $\\Delta x = \\sqrt{\\langle x^2 \\rangle - \\langle x \\rangle^2}.$ $\\Delta p_x$ ist auf die gleiche Weise definiert.\n",
"Wir werden diese Unschärferelation hier nicht herleiten, sondern nur darauf hinweisen, dass sie mit unserem Verständnis der klassischen Wellen übereinstimmt. Das heißt, eine Welle mit einer wirklich perfekten Frequenz $f$ und Wellenlänge $\\lambda$ würde als perfekte Sinuskurve ewig weiterlaufen. Quantenmechanisch würde dies einer perfekten Kenntnis des Impulses gemäß der de Broglie-Hypothese entsprechen: $\\lambda = h/p$. Um jedoch zu wissen, wo sich ein wellenförmiges Teilchen befindet ( $where$ ), muss die Welle, die es beschreibt, eine schärfere Spitze im Raum bilden, z. B. eine sehr schmale Gaußsche Kurve. Wir wissen, dass wir jede kontinuierliche Funktion, einschließlich solcher spitzen Wellenfunktionen, als eine Fourier-Reihe von Sinusfunktionen mit unterschiedlichen Wellenlängen ausdrücken können. Da die Wellenfunktion aber immer stärker spitz zuläuft (und die Position besser bekannt ist), benötigen wir mehr Terme in der Fourier-Reihe, was eine Mischung aus mehr Wellenlängen (und damit quantenmechanisch gesehen mehr Impulswerten) bedeutet.\n",
"\n",
"Einfacher ausgedrückt: Ein Zustand mit einem wohldefinierten Impuls (eine perfekte Sinuskurve im Raum) hat eine sehr unsichere Position. Ein Zustand mit einer genau definierten Position (wie eine Dirac-Delta-Verteilung) hat einen sehr unsicheren Impuls.\n",
"\n",
"Es gibt andere Variablen, die eine solche Unvereinbarkeit aufweisen. Der Spin eines Teilchens kann zum Beispiel eine wohldefinierte Projektion entlang einer Achse haben, aber wir wissen nichts über die Projektion auf eine orthogonale Achse. Zum Beispiel hat der Zustand $|0\\rangle \\sim |\\uparrow\\rangle$ (für ein Qubit oder spin-1/2 Teilchen) eine eindeutige Projektion entlang der Achse $z$ (von 1 im Zusammenhang mit einem Qubit und von $\\hbar/2$ im Zusammenhang mit einem spin-1/2 Teilchen). Dieser Zustand kann jedoch als Überlagerung von zwei Zuständen beschrieben werden, von denen jeder eine wohldefinierte Projektion auf die Achse $x$ hat: $|0\\rangle = \\frac{1}{\\sqrt{2}}(|+\\rangle_x+|-\\rangle_x)$ oder äquivalent $\\begin{pmatrix} 1 \\\\ 0\\end{pmatrix} = \\frac{1}{\\sqrt{2}}\\left[\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1\\end{pmatrix}+\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ -1\\end{pmatrix}\\right].$ $|+\\rangle_x$ hat eine wohldefinierte Projektion auf $x$, ebenso wie $|-\\rangle_x$. Wenn wir also die Projektion eines Zustands entlang der Achse $x$ angeben, kennen wir die Projektion entlang der Achse $z$ nicht. Und wenn wir die Projektion auf die Achse $z$ angeben, kennen wir die Projektion entlang $x$ nicht. Es gibt geringfügige Unterschiede, wenn man dies im Zusammenhang mit dem Spin und den Qubits diskutiert. Aber im Allgemeinen haben die Eigenzustände der Pauli-Matrizen eine interessante Beziehung, die wir untersuchen können.\n",
"In dieser Lektion werden wir unsere Intuition für die Unschärfe in diesen inkompatiblen Variablen experimentell überprüfen und nachweisen, dass die Unschärferelationen auf IBM® Quantencomputern gelten.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "eb8c7a0c-c962-4efd-ab82-905ba7415284",
"metadata": {},
"source": [
"\n",
"\n",
"## Einfache Überprüfung der Intuition\n",
"\n",
"In diesem ersten Experiment und während des gesamten Moduls werden wir einen Rahmen für Quantencomputer verwenden, der als \"Qiskit-Muster\" bekannt ist und Arbeitsabläufe in die folgenden Schritte unterteilt:\n",
"\n",
"* Schritt 1: Abbildung klassischer Eingaben auf ein Quantenproblem\n",
"* Schritt 2: Optimieren des Problems für die Quantenausführung\n",
"* Schritt 3: Ausführung mithilfe von „ IBM Quantum “-Primitiven\n",
"* Schritt 4: Nachbearbeitung und klassische Analyse\n",
"\n",
"Im Allgemeinen werden wir diese Schritte befolgen, auch wenn wir sie nicht immer explizit kennzeichnen.\n",
"\n",
"Beginnen wir mit dem Laden einiger notwendiger Pakete, einschließlich der Laufzeitprimitive. Wir werden auch den am wenigsten ausgelasteten Quantencomputer auswählen, der uns zur Verfügung steht.\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": "c26c8f6f-1ed7-4079-ba21-4747d318996f",
"metadata": {},
"outputs": [],
"source": [
"from numpy import pi\n",
"\n",
"# 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": 2,
"id": "7d34071a-6fb1-4a0a-9e66-c9ee40c3767b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ibm_sherbrooke\n"
]
}
],
"source": [
"# Load the Runtime primitive and session\n",
"from qiskit_ibm_runtime import (\n",
" Batch,\n",
" SamplerV2 as Sampler,\n",
" EstimatorV2 as Estimator,\n",
")\n",
"\n",
"# Use the least busy backend\n",
"backend = service.least_busy(min_num_qubits=127)\n",
"print(backend.name)"
]
},
{
"cell_type": "markdown",
"id": "fcbf932e-45b7-4a50-90e1-59dcb7577dfc",
"metadata": {},
"source": [
"Wenn ein Schüler seine verfügbare Zeit für Quantencomputer während des Unterrichts ausschöpft, können die folgenden Zeilen unkommentiert bleiben und dazu verwendet werden, einen Simulator einzurichten, der das Rauschverhalten des oben ausgewählten Quantencomputers teilweise nachahmt.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7265c432-19eb-41ba-940d-a80541fe0218",
"metadata": {},
"outputs": [],
"source": [
"# Import an estimator, this time from qiskit (we will import from Runtime for real hardware)\n",
"from qiskit_aer.primitives import SamplerV2, EstimatorV2\n",
"from qiskit_aer.noise import NoiseModel\n",
"\n",
"# Generate the noise model from the backend properties\n",
"noise_model = NoiseModel.from_backend(backend)\n",
"\n",
"noisy_sampler = SamplerV2(options={\"backend_options\": {\"noise_model\": noise_model}})\n",
"noisy_estimator = EstimatorV2(options={\"backend_options\": {\"noise_model\": noise_model}})"
]
},
{
"cell_type": "markdown",
"id": "5f072c75-efb7-4596-8bc6-ccae553684df",
"metadata": {},
"source": [
"Sie erinnern sich vielleicht, dass ein Eigenzustand eines Operators Z kein Eigenzustand eines anderen Operators X ist. Wir werden dies nun experimentell beobachten, indem wir Messungen entlang der Achsen $x$ und $z$ durchführen. Für die Messung entlang $z$ verwenden wir einfach ` qc.measure ()`, denn IBM Quantencomputer sind so aufgebaut, dass sie entlang $z$ messen. Aber um entlang $x$ zu messen, müssen wir das System drehen, um die $x$ Achse effektiv in die Richtung zu bewegen, entlang der wir messen. Dies wird mit einem Hadamard-Tor erreicht. Ein ähnlicher Schritt ist für Messungen entlang $y$ erforderlich. Der Einfachheit halber werden die erforderlichen Schritte hier zusammengefasst:\n",
"\n",
"* Zum Messen entlang $z$ : `qc.measure()`\n",
"* Zum Messen entlang $x$ : `qc.h()` dann `qc.measure()`\n",
"* Messung entlang $y$ : `qc.sdg()`, `qc.h()`, `qc.s`dann `qc.measure()`\n",
"\n",
"\n",
"\n",
"### Schritt 1: Klassische Eingaben einem Quantenproblem zuordnen\n",
"\n",
"In diesem Fall besteht der Abbildungsschritt einfach darin, die oben beschriebenen Messungen und Drehungen in einer Quantenschaltung auszudrücken:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8baef7f9-78bf-48c8-8359-efd65f943d96",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Step 1: Map\n",
"\n",
"# Import some general packages\n",
"from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n",
"\n",
"# Define registers\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(2, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Add a first measurement\n",
"qc.measure(qr, cr[0])\n",
"qc.barrier()\n",
"\n",
"# Change basis so that measurements made on quantum computer which normally tell us about z,\n",
"# now tell us about x.\n",
"qc.h(qr)\n",
"\n",
"# Add a second measurement\n",
"qc.measure(qr, cr[1])\n",
"\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "4d931ec8-6f8f-405f-a9ce-41724435f3a1",
"metadata": {},
"source": [
"\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"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "d613ac18-61ff-4e91-9f7d-73887bd2306a",
"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",
"\n",
"qc_isa = pm.run(qc)"
]
},
{
"cell_type": "markdown",
"id": "2f31c2b1-08be-43c7-8af3-5d9ee8a4dab0",
"metadata": {},
"source": [
"\n",
"\n",
"### Schritt 3: Ausführung mithilfe von „ IBM Quantum “-Primitiven\n",
"\n",
"Wir können den Sampler nutzen, um statistische Daten zu den Messungen zu erfassen. Wir werden die Sampler-Primitive so erstellen, dass sie auf einem echten Quantencomputer läuft, und zwar mithilfe von `mode = backend`. Es gibt weitere Modi für andere Arbeitsabläufe, und wir werden im Folgenden einen davon verwenden. Der Sampler wird verwendet, indem seine Methode `run()` mit einer Liste von „pubs“ (Primitive Unified Blocs) aufgerufen wird. Jede Zeile enthält bis zu drei Werte, die zusammen eine Berechnungseinheit bilden, die der Schätzer ausführen muss: Schaltkreise, Observablen und Parameter. Sie können außerdem eine Liste der Schaltungen, eine Liste der Messgrößen und eine Liste der Parameter angeben. Weitere Informationen finden Sie in der [Übersicht über PUBs](/docs/guides/primitive-input-output#pubs).\n",
"\n",
"Wir wollen auf einem echten Quantencomputer laufen, so dass wir ein echtes quantenphysikalisches Experiment durchführen. Wenn Sie die Ihnen zugewiesene Zeit auf echten Quantencomputern ausschöpfen, können Sie den nachstehenden Code für den Quantencomputer auskommentieren und den Code für die Ausführung auf einem Simulator auskommentieren.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8996bcf0-1848-4eda-b5a1-47190fede630",
"metadata": {},
"outputs": [],
"source": [
"# Step 3: Run the job on a real quantum computer\n",
"\n",
"\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.c.get_counts()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"\n",
"# job = noisy_sampler.run([qc_isa])\n",
"# res=job.result()\n",
"# counts=res[0].data.c.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "01dedf77-2ea7-45f4-9a84-8cd1caa26c14",
"metadata": {},
"source": [
"\n",
"\n",
"### Schritt 4: Nachbearbeitung\n",
"\n",
"Dies ist ein besonders einfacher Fall von Post-Processing, bei dem wir einfach die Zählungen visualisieren.\n",
"\n",
"Beachten Sie, dass Qiskit Qubits, Messungen und andere Dinge so anordnet, dass das Element mit der niedrigsten Nummer zuletzt / rechts steht, eine Konvention, die als \"Little-Endian\" bezeichnet wird. Das bedeutet, dass sich die Spalte mit der Bezeichnung \"10\" auf Zählungen bezieht, bei denen die erste Messung eine \"0\" und die zweite Messung eine \"1\" ergab.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "7cfeafbf-6a40-4829-9e1d-6c8dbdab9f23",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Step 4: Post-process\n",
"\n",
"from qiskit.visualization import plot_histogram\n",
"\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "2d21379b-b27f-4448-adb5-91f55e79b0e2",
"metadata": {},
"source": [
"Wenn Ihnen diese Konvention nicht zusagt, können Sie `marginal_counts` verwenden, um die Ergebnisse der einzelnen Messungen getrennt darzustellen:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "8c94042b-0e52-41f3-8231-ede9fab3ee51",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.result import marginal_counts\n",
"\n",
"plot_histogram(\n",
" marginal_counts(counts, indices=[0]), title=\"Counts after first measurement\"\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "d0ad384b-c2f1-4bc6-8730-ec8a4b593a50",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"plot_histogram(\n",
" marginal_counts(counts, indices=[1]), title=\"Counts after second measurement\"\n",
")"
]
},
{
"cell_type": "markdown",
"id": "258d66a0-ddfc-4c69-8943-37efb7c09b40",
"metadata": {},
"source": [
"Standardmäßig werden die Zustände in Qiskit mit dem Zustand $|0\\rangle$ initialisiert. Es ist daher nicht überraschend, dass fast alle der ersten Messungen $|0\\rangle$ ergaben. Es ist jedoch zu beachten, dass die zweite Messung (diejenige, die Informationen über die Projektion des Zustands auf $x$ liefert) eine fast gleichmäßige Verteilung ergab. Es scheint, als ob dieser Zustand, der uns ein sehr vorhersehbares Ergebnis für Messungen entlang von $z$ liefert, uns eine sehr unvorhersehbare Reihe von Ergebnissen für Messungen entlang von $x$ liefert. Lassen Sie uns dies untersuchen.\n",
"\n",
"Was passiert, wenn die Messungen in umgekehrter Reihenfolge durchgeführt werden? Wir könnten damit beginnen, das Hadamard-Gatter zu verwenden, um Statistiken über die Wahrscheinlichkeit zu erhalten, dass $|0\\rangle$ in $|\\pm\\rangle_x$ gemessen wird. Für die zweite Messung wechseln wir dann wieder zur Basis $z$ und verwenden ein zweites Hadamard-Gatter.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "4029873f-1260-4fc3-bfd2-e5a3f579a09c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Step 1:\n",
"\n",
"# Define registers\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(2, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Change basis to measure along x.\n",
"qc.h(qr)\n",
"qc.measure(qr, cr[0])\n",
"qc.barrier()\n",
"\n",
"# Change our basis back to z and make a second measurement\n",
"qc.h(qr)\n",
"qc.measure(qr, cr[1])\n",
"\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "c56d1649-de18-4417-8033-2be2a04a2582",
"metadata": {},
"outputs": [],
"source": [
"# Step 2: Transpile the circuit for running on a quantum computer\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "782f01c9-f9c2-4e5e-8638-7c9ba3347bfb",
"metadata": {},
"outputs": [],
"source": [
"# Step 3: Run the job on a real quantum computer\n",
"\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs)\n",
"res = job.result()\n",
"counts = res[0].data.c.get_counts()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"# job = noisy_sampler.run([qc_isa])\n",
"# res=job.result()\n",
"# counts=res[0].data.c.get_counts()"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "ce3fb0fd-a859-4c91-b2e5-c09343a397c2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Step 4: Post-process\n",
"from qiskit.visualization import plot_histogram\n",
"\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "d7862ea1-a9fd-4b23-9198-cfbfb05cf3dc",
"metadata": {},
"source": [
"Hier scheint es noch weniger Vorhersehbarkeit zu geben! Zuvor wussten wir zumindest, wie das Ergebnis der ersten Messung aussehen würde, jetzt haben wir eine ziemlich gleichmäßige Verteilung über alle möglichen Zustände. Es ist nicht allzu schwer zu verstehen, warum dies geschah. Wir haben mit $|0\\rangle$ begonnen, das eine 50-50-Mischung aus $|+\\rangle_x$ und $|-\\rangle_x$ ist $|0\\rangle=\\frac{1}{\\sqrt{2}}(|+\\rangle_x+|-\\rangle_x)$ Die Wahrscheinlichkeit, bei der ersten Messung den Zustand \"+\" oder \"-\" (im Diagramm auf 0 und 1 abgebildet) zu erhalten, sollte also gleich groß sein. Die Messung entlang $x$ lässt den Zustand entweder in einen Eigenzustand $|+\\rangle_x$ oder den Eigenzustand $|-\\rangle_x$ kollabieren. Jeder dieser Zustände ist eine 50-50-Mischung aus $|0\\rangle$ und $|1\\rangle$, gemäß $|+\\rangle_x = \\frac{1}{\\sqrt{2}}(|0\\rangle+|1\\rangle)$ $|-\\rangle_x = \\frac{1}{\\sqrt{2}}(|0\\rangle-|1\\rangle)$ Sobald sich das System also in einem Eigenzustand von $x$ befindet, führen Messungen entlang von $z$ sowohl zu $|0\\rangle$ als auch zu $|1\\rangle$, und zwar mit ungefähr gleicher Wahrscheinlichkeit.\n",
"Unser erstes Beispiel hat uns also gezeigt, dass einige Staaten sehr vorhersehbare Ergebnisse bei einigen Messungen, aber unvorhersehbare Ergebnisse bei anderen Messungen haben werden. Das aktuelle Beispiel zeigt uns, dass es noch schlimmer kommen kann. Es gibt Zustände, die bei beiden Messungen zu unvorhersehbaren Ergebnissen führen können, selbst wenn wir nur die Reihenfolge der Messungen vertauschen. Untersuchen wir, wie sicher oder unsicher eine Größe für einen bestimmten Zustand ist.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "292b878f-1792-4f55-8991-49e37c7db58b",
"metadata": {},
"source": [
"\n",
"\n",
"## Berechnung der Unsicherheit\n",
"\n",
"Wir können dies mit Hilfe der Unsicherheit bzw. Varianz quantifizieren. Die \"Unsicherheit\" wird oft als die Quadratwurzel der \"Varianz\" einer Verteilung definiert. Das heißt, die Unsicherheit für eine beobachtbare Größe $S$ wird mit $\\Delta S$ bezeichnet und ist gegeben durch\n",
"\n",
"$$\n",
"\\begin{aligned}\n",
"(\\Delta S)^2 & \\equiv \\langle (S - \\langle S \\rangle)^2 \\rangle\\\\\n",
"\n",
"(\\Delta S)^2 & = \\langle S^2 - 2 S \\langle S \\rangle +\\langle S \\rangle^2 \\rangle\\\\\n",
"\n",
"(\\Delta S)^2 & = \\langle S^2 \\rangle - \\langle S \\rangle^2\n",
"\\end{aligned}\n",
"$$\n",
"\n",
"Für den Fall der Pauli-Matrizen, für die $S^2 = I$ gilt, wird daraus\n",
"\n",
"$$\n",
"(\\Delta S)^2 = 1 - \\langle S \\rangle^2\n",
"$$\n",
"\n",
"Wenden wir dies einmal auf ein konkretes Beispiel an. Beginnen wir mit dem Zustands $|\\psi\\rangle = |+\\rangle_y = \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ i \\end{pmatrix}$ und bestimmen wir die Unsicherheit der Observable $X$ in diesem Zustand.\n",
"\n",
"\n",
"\n",
"#### Überprüfen Sie Ihr Verständnis\n",
"\n",
"Berechnen Sie die Unsicherheit von $X$ im Zustand $|+\\rangle_y = |+i\\rangle$ von Hand.\n",
"\n",
"\n",
" \n",
" $$\n",
" \\Delta X =\\sqrt{\\langle+i| X^2 |+i\\rangle - \\langle+i| X |+i\\rangle^2}\n",
" $$\n",
"\n",
" In dem gegebenen Zustand ergibt sich dies:\n",
"\n",
" $$\n",
" \\begin{aligned}\n",
" \\Delta X & =\\sqrt{\\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix} \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix} \\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 \\\\ i\\end{pmatrix} - \\left(\\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix} \\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 \\\\ i\\end{pmatrix}\\right)^2}\\\\\n",
"\n",
" \\Delta X & =\\sqrt{\\frac{1}{2}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}1 & 0 \\\\ 0 & 1\\end{pmatrix} \\begin{pmatrix}1 \\\\ i\\end{pmatrix} - \\left(\\frac{1}{2}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}i \\\\ 1\\end{pmatrix}\\right)^2}\\\\\n",
"\n",
" \\Delta X & =\\sqrt{\\frac{1}{2}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}1 \\\\ i\\end{pmatrix} - \\left(\\frac{1}{2}(0))\\right)^2}\\\\\n",
"\n",
" \\Delta X & =\\sqrt{\\frac{1}{2}(2)} = 1\n",
" \\end{aligned}\n",
" $$\n",
" \n",
"\n",
"\n",
"Mit `qc.initialize()` können wir einen beliebigen Ausgangszustand erzeugen. Beachten Sie, dass die Syntax für die imaginäre Einheit hier $1j$ lautet.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bf16b90b-d77a-477b-b432-963f8b81feed",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"-0.02408454165642664\n"
]
}
],
"source": [
"# Step 1: Map the problem into a quantum circuit\n",
"\n",
"from qiskit.quantum_info import SparsePauliOp\n",
"import numpy as np\n",
"\n",
"obs = SparsePauliOp(\"X\")\n",
"\n",
"# Define registers\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(1, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Initialize the state\n",
"qc.initialize([1, 1j] / np.sqrt(2))\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)\n",
"obs_isa = obs.apply_layout(layout=qc_isa.layout)\n",
"\n",
"# Step 3: Run the circuit on a real quantum computer\n",
"\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 = noisy_estimator.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": "e162abde-f346-4f2c-8358-d95c818a1021",
"metadata": {},
"source": [
"Nach unserer obigen Gleichung, $(\\Delta X)^2 = 1 - \\langle X \\rangle^2 = 1-(0.0015...)^2 \\rightarrow \\Delta X = 0.999...$ Bleiben wir bei demselben Zustand, finden aber jetzt den Erwartungswert von $Z$ :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c1918196-a26e-4419-8a25-488a3d1d4cc1",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.04958271968581247\n"
]
}
],
"source": [
"# Step 1: Map the problem into a quantum circuit\n",
"\n",
"obs = SparsePauliOp(\"Z\")\n",
"\n",
"# Define registers\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(1, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Initialize the state to |+>_y\n",
"qc.initialize([1, 1j] / np.sqrt(2))\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(qc)\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(pubs)\n",
"res = job.result()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"# job = noisy_estimator.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": "8ba18eed-5982-45ca-b0ed-5708b7d4aa17",
"metadata": {},
"source": [
"Wir könnten die gleichen Berechnungen anstellen wie zuvor, würden aber sehen, dass die Varianz wieder sehr nahe bei 1.0 liegt. Wir könnten daraus schließen, dass $\\Delta X \\Delta Z \\approx 1.0$. Tatsächlich ist dies für den von uns gewählten Zustand ungefähr richtig. Aber können wir es besser machen? Oder schlimmer?\n",
"\n",
"Erinnern wir uns daran, dass zwischen der Position in einer Richtung, $x$, und dem Impuls in derselben Richtung, $p_x$, ein Unschärferelation besteht. Für diese Größen ist die wohl bekannteste Form wahrscheinlich\n",
"$\\Delta x \\Delta p_x \\geq \\hbar/2$\n",
"Wenn wir uns nur daran erinnern, könnten wir versucht sein zu glauben, dass auch $\\Delta X$ und $\\Delta Z$ eine solche grundlegende Unschärfegrenze aufweisen könnten. Vielleicht ist es unmöglich, dass das Produkt $\\Delta X \\Delta Z$ den Wert Null erreicht? Probieren wir es mal mit einem anderen Bundesland aus und schauen wir, ob das auch dort zutrifft. Dieses Mal verwenden wir „ $|\\psi\\rangle = \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}$ “. Mal sehen, was passiert. Beachten Sie, dass der Schätzer im folgenden Code zwei Sätze von Schaltkreisen und Beobachtungsgrößen in derselben Job-Einreichung akzeptieren kann.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ef107fd6-03c2-42f2-a51d-e52957cfb82e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The expectation value of the first observable is: 1.0011036174126302\n",
"The expectation value of the second observable is: 0.0029429797670141016\n"
]
}
],
"source": [
"# Step 1: Map the problem into a quantum circuit\n",
"\n",
"obs1 = SparsePauliOp(\"X\")\n",
"obs2 = SparsePauliOp(\"Z\")\n",
"\n",
"# Define registers\n",
"\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(1, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Initialize the state\n",
"qc.initialize([1, 1] / np.sqrt(2))\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)\n",
"obs1_isa = obs1.apply_layout(layout=qc_isa.layout)\n",
"obs2_isa = obs2.apply_layout(layout=qc_isa.layout)\n",
"\n",
"# Step 3: Run the circuit on a real quantum computer\n",
"\n",
"with Batch(backend=backend) as batch:\n",
" estimator = Estimator(mode=batch)\n",
" pubs = [(qc_isa, obs1_isa), (qc_isa, obs2_isa)]\n",
" job = estimator.run(pubs)\n",
" res = job.result()\n",
"batch.close()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"\n",
"# job = noisy_estimator.run([[qc,obs1],[qc,obs2]])\n",
"# res=job.result()\n",
"\n",
"# Step 4: Return the result in classical form, and analyze.\n",
"\n",
"print(\"The expectation value of the first observable is: \", res[0].data.evs)\n",
"print(\"The expectation value of the second observable is: \", res[1].data.evs)"
]
},
{
"cell_type": "markdown",
"id": "489472e8-eefc-4740-aa7e-eba8e71d0d72",
"metadata": {},
"source": [
"Der Erwartungswert von $X$ sollte in der Nähe von 1.0 liegen, aber 1.0 nicht überschreiten. Machen Sie sich keine Sorgen, wenn die Zahl 1.0 nur geringfügig überschritten wird. Dies lässt sich auf Faktoren wie Rauschen und/oder Auslesefehler zurückführen. Obwohl dies ein sehr wichtiges Thema ist, können wir es vorerst ignorieren.\n",
"\n",
"Wir haben einen Erwartungswert für $X$ erhalten, der sehr nahe an 1.0 liegt (was einer sehr geringen Varianz für $X$ entspricht). Dies macht das Produkt der beiden Varianzen recht niedrig:\n",
"\n",
"$$\n",
"\\Delta X \\Delta Z = \\sqrt{1-(0.9853)^2} \\times \\sqrt{1-(-0.00195)^2} = 0.171.\n",
"$$\n",
"\n",
"Dies ist zwar nicht genau Null, aber dieser Wert wird im Vergleich zu den Eigenwerten der Pauli-Operatoren ( $\\pm 1$ ) klein. Sie erinnern sich vielleicht daran, dass die Unschärferelation zwischen linearer Position und Impuls auch anders geschrieben werden könnte, nämlich explizit unter Verwendung der Kommutationsbeziehung zwischen den Operatoren $x$ und $p_x$ :\n",
"\n",
"$$\n",
"\\Delta x \\Delta p_x \\geq \\frac{1}{2}|\\langle [x,p_x] \\rangle|\n",
"$$\n",
"\n",
"wo\n",
"\n",
"$$\n",
"[x,p_x] = xp_x-p_xx\n",
"$$\n",
"\n",
"ist der Kommutator von $x$ und $p_x$.\n",
"\n",
"Dies ist die Form, die sich am einfachsten auf die Pauli-Operatoren übertragen lässt. Im Allgemeinen gilt für zwei Betreiber $A$ und $B$,\n",
"\n",
"$$\n",
"\\Delta A \\Delta B \\geq \\frac{1}{2}|\\langle [A,B] \\rangle|.\n",
"$$\n",
"\n",
"Und im Fall der Pauli-Matrizen $X$ und $Z$ benötigen wir $[X,Z]$, um zu berechnen\n",
"\n",
"$$\n",
"\\Delta X \\Delta Z \\geq \\frac{1}{2}|\\langle [X,Z] \\rangle|.\n",
"$$\n",
"\n",
"Wir zeigen dies hier und überlassen ähnliche Berechnungen dem Leser als Übung:\n",
"\n",
"$$\n",
"[X,Z] = XZ-ZX = \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix}\\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}-\\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}\\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix}\n",
"$$\n",
"\n",
"$$\n",
"[X,Z] = \\begin{pmatrix}0 & -1 \\\\ 1 & 0\\end{pmatrix}-\\begin{pmatrix}0 & 1 \\\\ -1 & 0\\end{pmatrix} = 2\\begin{pmatrix}0 & -1 \\\\ 1 & 0\\end{pmatrix}\n",
"$$\n",
"\n",
"Dies ist eine durchaus akzeptable Antwort, aber mit einem weiteren Schritt sehen wir\n",
"\n",
"$$\n",
"[X,Z] = -2i\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}=-2iY\n",
"$$\n",
"\n",
"Unsere Unschärferelation lautet also\n",
"\n",
"$$\n",
"\\Delta X \\Delta Z \\geq |\\langle Y \\rangle|.\n",
"$$\n",
"\n",
"\n",
"\n",
"#### Überprüfen Sie Ihr Verständnis\n",
"\n",
"Bestimmen Sie $[X,Y]$ und $[Y,Z]$. Benutzen Sie dies, um die Unsicherheitsbeziehungen zwischen $X$ & $Y$ und $Y$ & $Z$ aufzuschreiben.\n",
"\n",
"\n",
" \n",
" $$\n",
" [X,Y] = XY-YX = \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix}\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}-\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}\\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix} = 2 \\begin{pmatrix}i & 0 \\\\ 0 & -i\\end{pmatrix}=2iZ\n",
" $$\n",
"\n",
" $$\n",
" [Y,Z] = YZ-ZY = \\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}\\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}-\\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix} = 2 \\begin{pmatrix}0 & i \\\\ i & 0\\end{pmatrix}=2iX\n",
" $$\n",
"\n",
" In Verbindung mit der allgemeinen Unschärferelation ergibt sich\n",
"\n",
" $$\n",
" \\Delta X \\Delta Y \\geq |\\langle Z \\rangle|,\n",
" $$\n",
"\n",
" $$\n",
" \\Delta Y \\Delta Z \\geq |\\langle X \\rangle|.\n",
" $$\n",
" \n",
"\n",
"\n",
"\n",
"\n",
"### Konsistenz überprüfen\n",
"\n",
"Bevor wir fortfahren, wollen wir überprüfen, ob dies mit unserer vorherigen Erkenntnis übereinstimmt. Wir haben die Zustands $|\\psi\\rangle = \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}$ angewendet. Dabei haben wir festgestellt, dass $\\Delta X \\Delta Z = 0.171$ gilt. Nun wissen wir, dass dieses Produkt größer oder gleich\n",
"\n",
"$$\n",
"|\\langle Y \\rangle|=\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 & 1 \\end{pmatrix}\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}\n",
"$$\n",
"\n",
"$$\n",
"|\\langle Y \\rangle| = \\frac{1}{2}\\begin{pmatrix} 1 & 1 \\end{pmatrix}\\begin{pmatrix} -i \\\\ i \\end{pmatrix} = \\frac{1}{2}(-i+i) = 0.\n",
"$$\n",
"\n",
"Das stimmt, $\\Delta X \\Delta Z = 0.171 \\geq |\\langle Y \\rangle|=0$\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "0ea50490-36e9-4ab6-b9e1-6840f6dedfec",
"metadata": {},
"source": [
"Nutzen Sie die folgenden Fragen, um ein Gefühl für diese Erkenntnisse zu bekommen:\n",
"\n",
"\n",
"\n",
"#### Überprüfen Sie Ihr Verständnis\n",
"\n",
"Beantworten Sie die folgenden Fragen gemeinsam als Satz:\n",
"\n",
"(a) Bei welchen Zuständen würden Sie erwarten, dass die Unsicherheit in $X$ gleich Null ist?\n",
"\n",
"(b) Bei welchen Zuständen würden Sie erwarten, dass die Unsicherheit in $Z$ gleich Null ist?\n",
"\n",
"(c) In welchen Zuständen würden Sie einen Null-Erwartungswert erhalten $\\langle Y \\rangle$?\n",
"\n",
"(d) Stimmen die Antworten auf die obigen Fragen mit dem Fall $\\Delta X \\Delta Z \\geq |\\langle Y \\rangle|$ überein?\n",
"\n",
"(e) Schreiben Sie einen Code, um dies mit Hilfe eines Schätzers explizit zu überprüfen.\n",
"\n",
"\n",
" \n",
" (a) Man könnte erwarten, dass Eigenzustände des Operators „ $X$ “ in „ $X$ “ eine Unsicherheit von Null ergeben. Tatsächlich gilt unter Verwendung von „ $|\\psi\\rangle = |+\\rangle_x$ “\n",
" $\\Delta X = \\sqrt{1-\\langle X \\rangle^2} = \\sqrt{1-1^2} = 0.$\n",
"\n",
" (b) Man könnte erwarten, dass Eigenzustände des Operators „ $Z$ “ zu einer Unsicherheit von Null in „ $Z$ “ führen. Tatsächlich ergibt sich unter Verwendung von „ $|\\psi\\rangle = |1\\rangle$ “ Folgendes: „\n",
" $\\Delta Z = \\sqrt{1-\\langle Z \\rangle^2} = \\sqrt{1-(-1)^2} = 0.$ “\n",
"\n",
" (c) Wir erwarten, $\\langle Y \\rangle=0$ für alle Zustände zu finden, die, wenn sie gemessen werden, genauso oft eine positive Projektion auf die Achse $y$ ergeben wie eine negative Projektion. Dazu gehören die Eigenzustände von $X$ und $Z$.\n",
"\n",
" (d) Ja. Man würde für Eigenzustände von $X$ oder $Z$ einen sehr kleinen Wert für das Produkt der Unsicherheiten $\\Delta X \\Delta Z $ erwarten: $\\Delta X \\Delta Z \\approx 0$. Dies kann zutreffen, da wir für dieselben Zustände auch $\\langle Y \\rangle=0$ erwarten würden. Somit könnte der Unschärferelation erfüllt sein.\n",
"\n",
" (e) Ein Code wie der folgende würde dies bestätigen:\n",
"\n",
" ```python\n",
" obs1 = SparsePauliOp.from_list(\n",
" [(\"X\", 1.000)]\n",
" )\n",
" obs2 = SparsePauliOp.from_list(\n",
" [(\"Y\", 1.000)]\n",
" )\n",
" obs3 = SparsePauliOp.from_list(\n",
" [(\"Z\", 1.000)]\n",
" )\n",
" qc = QuantumCircuit(1,1)\n",
" qc.ry(pi/2,0)\n",
"\n",
" job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)\n",
" res=job.result()\n",
" ```\n",
"\n",
" Wobei die Ergebnisse alle Erwartungswerte zurückgeben. Um alle Erwartungswerte abzurufen und die Unsicherheiten zu berechnen, können wir Folgendes verwenden:\n",
"\n",
" ```python\n",
" xs=res[0].data.evs[0]\n",
" ys=abs(res[0].data.evs[1])\n",
" zs=res[0].data.evs[2]\n",
"\n",
" import math\n",
" prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5\n",
"\n",
" ```\n",
" \n",
"\n",
"\n",
"Beantworten Sie die folgenden Fragen gemeinsam als Satz:\n",
"\n",
"(a) Können Sie sich einen Zustand vorstellen, in dem Sie einen großen Erwartungswert haben $\\langle Y \\rangle$?\n",
"\n",
"(b) Würden Sie erwarten, dass derselbe Zustand eine große oder kleine Unsicherheit in $X$ hat?\n",
"\n",
"(c) Würden Sie erwarten, dass derselbe Zustand eine große oder kleine Unsicherheit in $Z$ hat?\n",
"\n",
"(d) Stimmen die Antworten auf die obigen Fragen mit dem Fall $\\Delta X \\Delta Z \\geq |\\langle Y \\rangle|$ überein?\n",
"\n",
"(e) Schreiben Sie einen Code, um dies mit Hilfe eines Schätzers explizit zu überprüfen.\n",
"\n",
"\n",
" \n",
" (a) Wir erwarten, dass wir $\\langle Y \\rangle\\approx 1$ für den Eigenzustand von $Y$ : $|+\\rangle_y$ finden.\n",
"\n",
" (b) Es ist zu erwarten, dass „ $X$ “ in dem Zustand „ $|+\\rangle_y$ “ eine große Unsicherheit aufweist, da die Messung von „ $X$ “ in diesem Zustand mit gleicher Häufigkeit bzw. Wahrscheinlichkeit sowohl ein positives als auch ein negatives Ergebnis liefern würde.\n",
"\n",
" (c) Es ist zu erwarten, dass „ $Z$ “ eine große Unsicherheit im Zustand „ $|+\\rangle_y$ “ aufweist, da die Messung von „ $Z$ “ in diesem Zustand mit gleicher Häufigkeit bzw. Wahrscheinlichkeit sowohl ein positives als auch ein negatives Ergebnis liefern würde.\n",
"\n",
" (d) Ja. Man würde einen großen Wert für das Produkt der Unsicherheiten $\\Delta X \\Delta Z $ für Eigenzustände von $Y$ und insbesondere für $|+\\rangle_y$ erwarten. Für denselben Zustand würden wir außerdem $\\langle Y \\rangle\\approx 1$ erwarten. Sowohl $\\langle Y \\rangle$ als auch $\\Delta X \\Delta Z $ sind in diesem Zustand also beide recht groß, und es ist plausibel, dass die Unschärferelation erneut erfüllt sein könnte.\n",
"\n",
" (e) Ein Code wie der folgende würde dies bestätigen:\n",
"\n",
" ```python\n",
" obs1 = SparsePauliOp.from_list(\n",
" [(\"X\", 1.000)]\n",
" )\n",
" obs2 = SparsePauliOp.from_list(\n",
" [(\"Y\", 1.000)]\n",
" )\n",
" obs3 = SparsePauliOp.from_list(\n",
" [(\"Z\", 1.000)]\n",
" )\n",
" qc = QuantumCircuit(1,1)\n",
" qc.rx(-pi/2,0)\n",
"\n",
" job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)\n",
" res=job.result()\n",
" ```\n",
"\n",
" Wobei die Ergebnisse alle Erwartungswerte zurückgeben. Um alle Erwartungswerte abzurufen und die Unsicherheiten zu berechnen, können wir Folgendes verwenden:\n",
"\n",
" ```python\n",
" xs=res[0].data.evs[0]\n",
" ys=abs(res[0].data.evs[1])\n",
" zs=res[0].data.evs[2]\n",
"\n",
" import math\n",
" prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5\n",
"\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "26f11700-d6be-4ce1-9f97-b2d47ea933ec",
"metadata": {},
"source": [
"\n",
"\n",
"## Prüfung von Unsicherheitsbeziehungen\n",
"\n",
"Der obige Test hat nur die Gültigkeit der Unschärferelation für eine einzige Wahl des Zustandsvektors $|\\psi\\rangle = |+\\rangle_x$ gezeigt. Um uns davon zu überzeugen, dass dies im Allgemeinen mit dem Experiment übereinstimmt, sollten wir ähnliche Berechnungen mit dem Schätzer für viele verschiedene Zustandsvektoren durchführen. Beginnen wir damit, unseren Zustandsvektor von der Achse $z$ wegzudrehen, indem wir ein \\`RY'-Gatter verwenden, um verschiedene Anfangszustände mit einem Parameter $\\theta$ zu erzeugen.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c434a14d-c0ce-40bd-8f5e-7d35722e97bb",
"metadata": {},
"outputs": [],
"source": [
"# The calculation below uses approximately 3-4 minutes of QPU time.\n",
"# Step 1: Map the problem into a quantum circuit\n",
"\n",
"from qiskit.circuit import Parameter\n",
"import numpy as np\n",
"\n",
"# Specify observables\n",
"obs1 = SparsePauliOp(\"X\")\n",
"obs2 = SparsePauliOp(\"Y\")\n",
"obs3 = SparsePauliOp(\"Z\")\n",
"\n",
"# Define registers\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(1, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Rotate away from |0>\n",
"theta = Parameter(\"θ\")\n",
"qc.ry(theta, 0)\n",
"\n",
"params = np.linspace(0, 2, num=21)\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)\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",
"# Step 3: Run the circuit on a real quantum computer\n",
"\n",
"with Batch(backend=backend) as batch:\n",
" estimator = Estimator(mode=batch)\n",
" pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]\n",
" job = estimator.run(pubs, precision=0.01)\n",
" res = job.result()\n",
"\n",
"batch.close()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"\n",
"# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])\n",
"# res=job.result()"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "41d974bb-da9e-459e-8145-294f71cab4c7",
"metadata": {},
"outputs": [],
"source": [
"# Step 4: Post-processing and classical analysis.\n",
"xs = res[0].data.evs[0]\n",
"ys = abs(res[0].data.evs[1])\n",
"zs = res[0].data.evs[2]\n",
"\n",
"# Calculate uncertainties\n",
"\n",
"delx = []\n",
"delz = []\n",
"prodxz = []\n",
"for i in range(len(xs)):\n",
" delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)\n",
" delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)\n",
" prodxz.append(delx[i] * delz[i])"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "1599d4df-38f8-4171-95ae-6c3c61409201",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Here we can plot the results from this simulation.\n",
"import matplotlib.pyplot as plt\n",
"\n",
"plt.plot(params, delx, label=r\"$\\Delta$ X\")\n",
"plt.plot(params, ys, label=r\"$\\langle$ Y $\\rangle$\")\n",
"plt.plot(params, delz, label=r\"$\\Delta$ Z\")\n",
"plt.plot(params, prodxz, label=r\"$\\Delta$X $\\Delta$Z\")\n",
"plt.xlabel(r\"$\\theta$\")\n",
"plt.ylabel(\"Expectation/Uncertainty Values\")\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "1694ab4f-b5e2-46be-b453-2599f73c582d",
"metadata": {},
"source": [
"Beachten Sie, dass die rote Kurve $(\\Delta X \\Delta Z)$ stets größer ist als die orangefarbene Kurve $\\langle Y \\rangle$. Manchmal fällt das Unsicherheitsprodukt ab und liegt relativ nahe am Grenzwert, manchmal steigt es an und ist weiter vom Grenzwert entfernt, aber es hält sich stets an die Unschärferelation.\n",
"\n",
"Natürlich ist dies vielleicht nicht der beste Test für die Unschärferelation, da unser Grenzwert $\\langle Y \\rangle$ immer sehr nahe bei Null liegt. Nehmen wir einen Quantenzustand, der eine größere Projektion auf die Eigenzustände von $Y$ hat. Konkret werden wir $|0\\rangle$ immer noch um verschiedene Winkel von der Achse $z$ nach unten drehen, aber jetzt werden wir den resultierenden Zustand auch um einen bestimmten Winkel um $z$ drehen, vielleicht $\\pi/4$, und sehen, was passiert.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c9700dd1-d116-4f94-8c81-70383ce38671",
"metadata": {},
"outputs": [],
"source": [
"# The calculation below uses approximately 3-4 minutes of QPU time.\n",
"from qiskit.circuit import Parameter\n",
"import numpy as np\n",
"\n",
"# Step 1: Map the problem to a quantum circuit\n",
"\n",
"# Specify observables\n",
"obs1 = SparsePauliOp(\"X\")\n",
"obs2 = SparsePauliOp(\"Y\")\n",
"obs3 = SparsePauliOp(\"Z\")\n",
"\n",
"# Define registers\n",
"qr = QuantumRegister(1, \"q\")\n",
"cr = ClassicalRegister(1, \"c\")\n",
"qc = QuantumCircuit(qr, cr)\n",
"\n",
"# Rotate away from |0> along one plane, and then along a transverse direction.\n",
"theta = Parameter(\"θ\")\n",
"qc.ry(theta, 0)\n",
"qc.rz(pi / 4, 0)\n",
"\n",
"params = np.linspace(0, 2, num=21)\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)\n",
"\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",
"# Step 3: Run the circuit on a real quantum computer\n",
"\n",
"with Batch(backend=backend) as batch:\n",
" estimator = Estimator(mode=batch)\n",
" pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]\n",
" job = estimator.run(pubs, precision=0.01)\n",
" res = job.result()\n",
"\n",
"batch.close()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"\n",
"# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])\n",
"# res=job.result()"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "7e85e759-33a7-4539-80f7-05c769c46144",
"metadata": {},
"outputs": [],
"source": [
"# Step 4: Post-processing and classical analysis.\n",
"xs = res[0].data.evs[0]\n",
"ys = abs(res[0].data.evs[1])\n",
"zs = res[0].data.evs[2]\n",
"\n",
"# Calculate uncertainties\n",
"\n",
"delx = []\n",
"delz = []\n",
"prodxz = []\n",
"for i in range(len(xs)):\n",
" delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)\n",
" delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)\n",
" prodxz.append(delx[i] * delz[i])"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "6f129a2d-e029-45b7-bb77-bfa83babd8c9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Here we can plot the results from this simulation.\n",
"import matplotlib.pyplot as plt\n",
"\n",
"plt.plot(params, delx, label=r\"$\\Delta$ X\")\n",
"plt.plot(params, ys, label=r\"$\\langle$ Y $\\rangle$\")\n",
"plt.plot(params, delz, label=r\"$\\Delta$ Z\")\n",
"plt.plot(params, prodxz, label=r\"$\\Delta$X $\\Delta$Z\")\n",
"plt.xlabel(r\"$\\theta$\")\n",
"plt.ylabel(\"Expectation/Uncertainty Values\")\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "7b90bcd5-f561-4f7f-a5a3-7882b3ddb464",
"metadata": {},
"source": [
"Nun sehen wir, dass die Grenze der Unsicherheit $(\\Delta X \\Delta Z)$ auf die Probe gestellt wird! Die rote Kurve liegt nun viel näher an der orangefarbenen Kurve als zuvor. Tatsächlich wäre der Unschärferelation ohne Rauschen an einem Punkt genau gesättigt ( $(\\Delta X \\Delta Z) = \\langle Y \\rangle$ ). Angesichts von Rauschen und Auslesefehlern sollte es nicht überraschen, wenn bei einem Durchlauf gelegentlich ein Wert von $(\\Delta X \\Delta Z)$ ermittelt wird, der geringfügig größer ist als $\\langle Y \\rangle$. Dies stellt keine tatsächliche Verletzung der Unsicherheit dar, sondern ist lediglich ein Artefakt eines Fehlers ungleich Null.\n",
"\n",
"\n",
"\n",
"#### Überprüfen Sie Ihr Verständnis\n",
"\n",
"Erläutern Sie, wie Sie dies bis an die absoluten Grenzen ausreizen und „ $\\langle Y \\rangle$ “ so groß wie möglich gestalten würden.\n",
"\n",
"\n",
" \n",
" Der Code enthält derzeit Zeilen, die den Standard-Ausgangszustand $|0\\rangle$ um einen parametrisierten Winkel $\\theta$ von der Achse $z$ nach unten und anschließend um einen Winkel $\\pi/4$ um die Achse $z$ drehen, wodurch der Zustandsvektor teilweise in Richtung der Achse $y$ gedreht wird.\n",
"\n",
" `qc.ry(theta,0)`\n",
"\n",
" `qc.rz(pi/4,0)`\n",
"\n",
" Wir könnten die Rotation um $z$ von $\\pi/4$ auf $\\pi/2$ ändern und so bis zu einem Eigenzustand von $Y$ rotieren:\n",
"\n",
" `qc.ry(theta,0)`\n",
"\n",
" `qc.rz(pi/2,0)`\n",
"\n",
" Weitere Änderungen wären nicht erforderlich.\n",
" \n",
"\n",
"\n",
"Ändern Sie den Code oder kopieren Sie ihn und implementieren Sie diese Überprüfung der Unschärferelation mit maximiertem Erwartungswert von Y. Gilt die Unschärferelation?\n",
"\n",
"\n",
" \n",
" Wir würden genau den Code aus dem obigen Beispiel verwenden, mit\n",
"\n",
" `qc.rz(pi/2,0)`\n",
"\n",
" eingebaut als Ersatz für\n",
"\n",
" `qc.rz(pi/4,0).`\n",
"\n",
" Das Ergebnis sollte wie unten dargestellt aussehen, und ja, die Unschärferelation sollte immer noch gültig sein.\n",
"\n",
" \n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "6dd8c749-00d6-4a08-8d3c-2f5b5f3a0902",
"metadata": {},
"source": [
"Ändern Sie den obigen Code, um ein ähnliches Bild zu erstellen und zu zeigen, dass sich das Produkt $\\Delta X \\Delta Y$ nach den Messungen auf dem Quantencomputer so verhält, wie es sollte. Wählen Sie eine beliebige Anzahl von Staaten aus, die Sie mögen.\n",
"\n",
"\n",
" \n",
" Wir würden genau den Code aus dem obigen Beispiel verwenden, und im Gesicht könnten wir die gleichen Ergebnisse wie oben verwenden, nur unter Verwendung der Erwartungswerte, um verschiedene Unsicherheiten zu berechnen. Wir könnten zum Beispiel Folgendes verwenden\n",
"\n",
" ```python\n",
" xs=res[0].data.evs[0]\n",
" ys=res[0].data.evs[1]\n",
" zs=abs(res[0].data.evs[2])\n",
" import math\n",
" delx = []\n",
" dely = []\n",
" prodxy=[]\n",
" for i in range(len(xs)):\n",
" delx.append((1-xs[i]*xs[i])**0.5)\n",
" dely.append((1-ys[i]*ys[i])**0.5)\n",
" prodxy.append(((1-xs[i]*xs[i])**0.5)*(1-ys[i]*ys[i])**0.5)\n",
" ```\n",
"\n",
" und wir könnten die\n",
"\n",
" ```python\n",
" import matplotlib.pyplot as plt\n",
" plt.plot(params, delx, label=r'$\\Delta$ X')\n",
" plt.plot(params, dely, label=r'$\\langle$ Y $\\rangle$')\n",
" plt.plot(params, zs, label=r'$\\Delta$ Z')\n",
" plt.plot(params, prodxy, label=r'$\\Delta$X $\\Delta$Z')\n",
" plt.xlabel(r'$\\theta$')\n",
" plt.ylabel('Expectation/Uncertainty Values')\n",
" plt.legend()\n",
" plt.show()\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "571a0120-a9d3-44c5-9dce-1b021090f9d1",
"metadata": {},
"source": [
"Aufgabe: Schreiben Sie einen Code, um viele Werte von $\\phi$ abzufragen, genauso wie wir viele Werte von $\\theta$ abgefragt haben, und erstellen Sie eine 3-D-Darstellung, die zeigt, dass die Unschärferelation nie verletzt wird. Wählen Sie beliebige Observablen aus, die Ihnen gefallen.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b89eaae3-6ea9-486c-b93c-55431839d5f1",
"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",
"* Es gibt Unschärferelationen zwischen vielen physikalischen Messgrößen, darunter Position und linearer Impuls sowie Komponenten des Spins.\n",
"* Die Pauli-Matrizen sind nicht kommutabel. Dies ist ein mathematischer Ausdruck der Tatsache, dass nicht alle Komponenten des Spins gleichzeitig bekannt/bestimmt werden können.\n",
"* In der Quanteninformatik werden die Pauli-Operatoren/-Matrizen intensiv genutzt, so dass es nützlich ist, die Unschärferelation für die Pauli-Operatoren sowie die eng verwandten Spin-Operatoren zu kennen.\n",
"* Eine allgemeine Formel für die Unschärfe von zwei Operatoren $A$ und $B$ lautet $\\Delta A \\Delta B \\geq \\frac{1}{2}|\\langle [A,B] \\rangle|.$\n",
"* Ein Eigenzustand $|a\\rangle$ eines Operators $A$ führt zu einer Unsicherheit von Null bei der mit diesem Operator verbundenen physikalischen Observable. Selbst experimentell gilt: „ $\\Delta A \\approx 0$ “.\n",
"* Ein Eigenzustand $|a\\rangle$ eines Operators $A$ führt zu einer größeren Unsicherheit für einen Operator $B$, der nicht mit $A$ kommutiert.\n",
"* Experimentelle Ergebnisse mit einem echten Quantencomputer bestätigen die Intuition, die wir aus der Matrixdarstellung physikalischer Operatoren gewinnen.\n",
"\n",
"\n",
"\n",
"### Wahr/Falsch-Fragen:\n",
"\n",
"1. T/F Man kann gleichzeitig $X$ und $Y$ messen, aber nicht $Z$.\n",
"2. T/F Man kann gleichzeitig $X$ und $Z$ messen, aber nicht $Y$.\n",
"3. T/F Lineare Positions- und lineare Impulsoperatoren sind nicht kommutabel.\n",
"4. T/F IBM Quantencomputer messen standardmäßig entlang $Z$, so dass eine Drehung durchgeführt werden muss, um entlang einer anderen Richtung zu messen.\n",
"5. T/F Die folgende Schaltung misst tatsächlich $Z$ und dann $X$.\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"### MC-Fragen:\n",
"\n",
"1. Welche der folgenden Unschärferelationen wird in der folgenden Abbildung dargestellt?\n",
"\n",
" * a. $\\Delta X \\Delta Y \\geq |\\langle Z \\rangle|$\n",
" * b. $\\Delta Y \\Delta Z \\geq |\\langle X \\rangle|$\n",
" * c. $\\Delta Z \\Delta X \\geq |\\langle Y \\rangle|$\n",
" * d. Keines der oben genannten.\n",
"\n",
"\n",
"\n",
"2. Welches ist die Standardreihenfolge für die Durchführung einer Messung auf $x$?\n",
" * a. Nur `qc.measure()`\n",
" * b. `qc.h()` dann `qc.measure()`\n",
" * c. `qc.h()`, `qc.h()` dann `qc.measure()`\n",
" * d. `qc.h()`, `qc.s`, `qc.h()`dann `qc.measure()`\n",
" * e. `qc.sdg()`, `qc.h()`, `qc.s` dann `qc.measure()`\n",
" * f. `qc.sdg()`, `qc.h()`, `qc.s`, `qc.h()` dann `qc.measure()`\n",
"\n",
"3. Welcher der folgenden Zustände ergibt den größten Erwartungswert $\\langle X \\rangle$?\n",
" * a. $|+\\rangle_x$\n",
" * b. $|-\\rangle_x$\n",
" * c. $|+\\rangle_y$ auch genannt $|+i\\rangle$\n",
" * d. $|-\\rangle_y$ auch genannt $|-i\\rangle$\n",
" * e. $|0\\rangle$ auch genannt $|\\uparrow\\rangle$\n",
" * f. $|1\\rangle$ auch genannt $|\\downarrow\\rangle$\n",
"\n",
"4. Welcher der folgenden Zustände ergibt die größte Unsicherheit $\\Delta X$?\n",
" * a. $|+\\rangle_x$\n",
" * b. $|+\\rangle_y$ auch genannt $|+i\\rangle$\n",
" * c. $|0\\rangle$ auch genannt $|\\uparrow\\rangle$\n",
" * d. a und b sind unentschieden\n",
" * e. b und c sind unentschieden\n",
" * F. a, b und c sind unentschieden\n",
"\n",
"\n",
"\n",
"### Diskussionsfragen:\n",
"\n",
"1. Steht dieses Konzept der Ungewissheit in irgendeiner Weise im Widerspruch zu der Vorstellung vom Spin als Vektorpfeil im kartesischen Raum? Wie sieht es mit der Bloch-Kugel aus?\n",
"\n",
"2. Angenommen, Sie richten ein Messgerät in einer Richtung aus, die auf halbem Weg zwischen den Achsen $x$ und $y$ liegt. Was geschieht? Können Sie eine Messung in diese Richtung vornehmen? Wie verhält sich dies zur Unsicherheit auf $X$ und $Y$?\n",
"\n",
"3. Welche zusätzlichen Experimente würden Sie gerne durchführen, um sich von den hier erzielten Ergebnissen zu überzeugen?\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
}