Unbestimmtheit erkunden

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

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

Zur Einrichtung und Installation der oben genannten Pakete siehe die Anleitung Qiskit installieren. Um Jobs auf echten Quantencomputern auszuführen, müssen Studierende ein Konto bei IBM Quantum® einrichten, indem sie den Schritten in der Anleitung IBM Cloud-Konto einrichten folgen.

Dieses Modul wurde getestet und verbrauchte 8 Minuten QPU-Zeit. Dies ist nur eine Schätzung. Dein tatsächlicher Verbrauch kann abweichen. Zwei zeitaufwendige Berechnungen sind als solche in den Header-Kommentaren gekennzeichnet und können auf Simulatoren ausgeführt werden, wenn den Studierenden die QPU-Zeit knapp wird. Ohne diese benötigt das Modul nur ~30 Sekunden QPU-Zeit.

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

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

Sieh dir unten die Modulvorstellung von Dr. Katie McCormick an, oder klicke hier, um sie auf YouTube anzusehen.

---

Einführung

Du hast wahrscheinlich schon von der Unbestimmtheitsrelation gehört, auch außerhalb deiner Physikkurse. Eine gängige umgangssprachliche Umschreibung der Unbestimmtheit lautet: „Indem man etwas betrachtet, beeinflusst man es." Das ist sicherlich wahr. Aber eine physikalisch treffendere Beschreibung der Unbestimmtheit besagt, dass es bestimmte physikalische Observable gibt, die eine Inkompatibilität aufweisen, die verhindert, dass beide gleichzeitig mit beliebiger Genauigkeit bekannt sind. Viele Studierende begegnen erstmals dem Paar inkompatibler Variablen $x$ und $p_x$, also der Position entlang einer Achse, die als $x$-Achse bezeichnet wird, und dem linearen Impuls in diese Richtung. Für diese Variablen wird die Unbestimmtheitsrelation geschrieben als $\Delta x \Delta p_x \geq \frac{\hbar}{2}.$ Hier wird $\Delta x$ als „Unbestimmtheit in $x$" bezeichnet, was dieselbe Definition wie die Standardabweichung in der Statistik hat und definiert werden kann als $\Delta x = \sqrt{\langle x^2 \rangle - \langle x \rangle^2}.$ $\Delta p_x$ ist auf die gleiche Weise definiert. Hier werden wir diese Unbestimmtheitsrelation nicht herleiten; wir werden darauf hinweisen, dass sie mit unserem Verständnis klassischer Wellen konsistent ist. Das heißt, eine Welle mit wirklich einer perfekten Frequenz $f$ und Wellenlänge $\lambda$ würde ewig als perfekte Sinuswelle weiterlaufen. Quantenmechanisch würde dies einem perfekt bekannten Impuls nach der de-Broglie-Hypothese entsprechen: $\lambda = h/p$. Aber um zu wissen, $wo$ sich ein wellenartiges Teilchen befindet, muss die Welle, die es beschreibt, im Raum schärfer lokalisiert werden, wie zum Beispiel eine sehr schmale Gauß-Funktion. Wir wissen, dass wir jede stetige Funktion, einschließlich solcher scharf lokalisierter Wellenfunktionen, als Fourier-Reihe von Sinusfunktionen mit verschiedenen Wellenlängen ausdrücken können. Aber je schärfer die Wellenfunktion lokalisiert wird (und die Position besser bekannt ist), desto mehr Terme benötigen wir in der Fourier-Reihe, was eine Mischung aus mehr Wellenlängen (und damit quantenmechanisch mehr Impulswerten) bedeutet.

Einfacher ausgedrückt: Ein Zustand mit einem wohldefinierten Impuls (eine perfekte Sinuswelle im Raum) hat eine sehr unbestimmte Position. Ein Zustand mit einer wohldefinierten Position (wie eine Dirac-Delta-Distribution) hat einen sehr unbestimmten Impuls.

Es gibt weitere Variablen, die eine solche Inkompatibilität aufweisen. Zum Beispiel kann der Spin eines Teilchens eine wohldefinierte Projektion entlang einer Achse haben, aber dann wissen wir nichts über die Projektion auf eine orthogonale Achse. Beispielsweise hat der Zustand $|0\rangle \sim |\uparrow\rangle$ (für ein Qubit oder Spin-1/2-Teilchen) eine bestimmte Projektion entlang der $z$-Achse (von 1 im Kontext eines Qubits und von $\hbar/2$ im Kontext eines Spin-1/2-Teilchens). Aber dieser Zustand kann als Überlagerung zweier Zustände geschrieben werden, die jeweils eine wohldefinierte Projektion auf die $x$-Achse haben: $|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 $|-\rangle_x$. Wenn wir also die Projektion eines Zustands entlang der $x$-Achse festlegen, kennen wir die Projektion entlang der $z$-Achse nicht. Und wenn wir die Projektion auf die $z$-Achse festlegen, kennen wir die Projektion entlang $x$ nicht. Es gibt geringfügige Unterschiede, wenn man dies im Kontext von Spin und Qubits diskutiert. Aber allgemein gesprochen haben Eigenzustände der Pauli-Matrizen eine interessante Beziehung, die wir erkunden können. In dieser Lektion werden wir experimentell unsere Intuition für die Unbestimmtheit dieser inkompatiblen Variablen überprüfen und verifizieren, dass Unbestimmtheitsrelationen auf IBM®-Quantencomputern gelten.

Einfache Intuitionsüberprüfung

In diesem ersten Experiment und im gesamten Modul werden wir ein Framework für Quantencomputing namens „Qiskit Patterns" verwenden, das Arbeitsabläufe in die folgenden Schritte unterteilt:

• Schritt 1: Klassische Eingaben auf ein Quantenproblem abbilden
• Schritt 2: Problem für die Quantenausführung optimieren
• Schritt 3: Mit Qiskit Runtime Primitives ausführen
• Schritt 4: Nachbearbeitung und klassische Analyse

Wir werden diesen Schritten im Allgemeinen folgen, sie aber nicht immer explizit kennzeichnen.

Beginnen wir mit dem Laden einiger notwendiger Pakete, einschließlich der Runtime-Primitives. Wir werden auch den am wenigsten ausgelasteten verfügbaren Quantencomputer auswählen.

Unten findest du Code zum Speichern deiner Zugangsdaten bei der ersten Verwendung. Achte darauf, diese Informationen nach dem Speichern in deiner Umgebung aus dem Notebook zu löschen, damit deine Zugangsdaten nicht versehentlich weitergegeben werden, wenn du das Notebook teilst. Weitere Hinweise findest du unter IBM Cloud-Konto einrichten und Service in einer nicht vertrauenswürdigen Umgebung initialisieren.

from numpy import pi

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

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

# Load saved credentials
service = QiskitRuntimeService()

# Load the Runtime primitive and session
from qiskit_ibm_runtime import (
    Batch,
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
)

# Use the least busy backend
backend = service.least_busy(min_num_qubits=127)
print(backend.name)

ibm_sherbrooke

Falls ein Studierender die verfügbare Quantencomputing-Zeit während der Lektion aufbraucht, können die folgenden Zeilen auskommentiert und verwendet werden, um einen Simulator einzurichten, der das Rauschverhalten des oben ausgewählten Quantencomputers teilweise nachahmt.

# Import an estimator, this time from qiskit (we will import from Runtime for real hardware)
from qiskit_aer.primitives import SamplerV2, EstimatorV2
from qiskit_aer.noise import NoiseModel

# Generate the noise model from the backend properties
noise_model = NoiseModel.from_backend(backend)

noisy_sampler = SamplerV2(options={"backend_options": {"noise_model": noise_model}})
noisy_estimator = EstimatorV2(options={"backend_options": {"noise_model": noise_model}})

Du erinnerst dich vielleicht, dass ein Eigenzustand eines Operators Z kein Eigenzustand eines anderen Operators X ist. Wir werden das jetzt experimentell beobachten, indem wir Messungen entlang der $x$- und $z$-Achsen durchführen. Für die Messung entlang $z$ verwenden wir einfach qc.measure(), da IBM-Quantencomputer so konstruiert sind, dass sie entlang $z$ messen. Aber um entlang $x$ zu messen, müssen wir das System rotieren, um die $x$-Achse effektiv in die Orientierung zu bringen, entlang der wir messen. Dies wird mit einem Hadamard-Gate erreicht. Es gibt einen ähnlichen Schritt für Messungen entlang $y$. Die notwendigen Schritte sind hier zur Übersicht zusammengefasst:

• Um entlang $z$ zu messen: qc.measure()
• Um entlang $x$ zu messen: qc.h() dann qc.measure()
• Um entlang $y$ zu messen: qc.sdg(), qc.h(), qc.s dann qc.measure()

Schritt 1: Klassische Eingaben auf ein Quantenproblem abbilden

In diesem Fall besteht der Abbildungsschritt einfach darin, die oben beschriebenen Messungen und Rotationen in einem Quanten-Circuit auszudrücken:

# Step 1: Map

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

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)

# Add a first measurement
qc.measure(qr, cr[0])
qc.barrier()

# Change basis so that measurements made on quantum computer which normally tell us about z,
# now tell us about x.
qc.h(qr)

# Add a second measurement
qc.measure(qr, cr[1])

qc.draw("mpl")

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

Dieser Schritt nimmt die Operationen, die wir ausführen möchten, und drückt sie in der Funktionalität eines bestimmten Quantencomputers aus. Er bildet unser Problem auch auf das Layout des Quantencomputers ab.

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

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qc)

Schritt 3: Mit Qiskit Runtime Primitives ausführen

Wir können den Sampler verwenden, um Statistiken über die Messungen zu sammeln. Wir werden das Sampler-Primitive so konstruieren, dass es auf einem echten Quantencomputer läuft, indem wir mode = backend verwenden. Es gibt andere Modi für andere Arbeitsabläufe, und wir werden unten einen verwenden. Der Sampler wird durch Aufruf seiner run()-Methode mit einer Liste von „PUBs" (Primitive Unified Blocs) verwendet. Jedes PUB enthält bis zu drei Werte, die zusammen eine Berechnungseinheit für den Estimator definieren: Circuits, Observablen, Parameter. Du kannst auch eine Liste von Circuits, eine Liste von Observablen und eine Liste von Parametern angeben. Weitere Informationen findest du in der Übersicht der PUBs.

Wir möchten auf einem echten Quantencomputer rechnen, damit wir ein echtes quantenphysikalisches Experiment durchführen. Wenn du dein Zeitkontingent auf echten Quantencomputern aufbrauchst, kannst du den Code unten für den Quantencomputer auskommentieren und den Code für die Ausführung auf einem Simulator einkommentieren.

# Step 3: Run the job on a real quantum computer

sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs)
res = job.result()

counts = res[0].data.c.get_counts()

# Run the job on the Aer simulator with noise model from real backend

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

Schritt 4: Nachbearbeitung

Dies ist ein besonders einfacher Fall der Nachbearbeitung, bei dem wir die Zählungen einfach visualisieren.

Beachte, dass Qiskit Qubits, Messungen und andere Dinge ordnet, indem das niedrigst-nummerierte Element zuletzt/rechts aufgelistet wird, eine Konvention, die als „Little-Endian" bezeichnet wird. Das bedeutet, dass die Spalte unten mit der Bezeichnung „10" sich auf Zählungen bezieht, bei denen die erste Messung eine „0" ergab und die zweite Messung eine „1".

# Step 4: Post-process

from qiskit.visualization import plot_histogram

plot_histogram(counts)

Wenn dir diese Konvention nicht zusagt, kannst du marginal_counts verwenden, um die Ergebnisse jeder Messung separat zu visualisieren:

from qiskit.result import marginal_counts

plot_histogram(
    marginal_counts(counts, indices=[0]), title="Counts after first measurement"
)

plot_histogram(
    marginal_counts(counts, indices=[1]), title="Counts after second measurement"
)

Standardmäßig werden Zustände in Qiskit im $|0\rangle$-Zustand initialisiert. Es ist daher keine Überraschung, dass fast alle ersten Messungen $|0\rangle$ ergaben. Beachte jedoch, dass es bei der zweiten Messung (die Informationen über Projektionen des Zustands auf $x$ liefert) eine fast gleichmäßige Aufteilung gab. Es scheint, als würde dieser Zustand, der uns ein sehr vorhersagbares Ergebnis bei Messungen entlang $z$ liefert, eine sehr unvorhersagbare Menge an Ergebnissen für Messungen entlang $x$ ergeben. Untersuchen wir das genauer.

Was passiert, wenn wir die Messungen in umgekehrter Reihenfolge durchführen? Wir könnten damit beginnen, das Hadamard-Gate zu verwenden, um Statistiken über die Wahrscheinlichkeit zu erhalten, dass $|0\rangle$ in $|\pm\rangle_x$ gemessen wird. Dann werden wir für die zweite Messung mit einem zweiten Hadamard-Gate zur $z$-Basis zurückkehren.

# Step 1:

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)

# Change basis to measure along x.
qc.h(qr)
qc.measure(qr, cr[0])
qc.barrier()

# Change our basis back to z and make a second measurement
qc.h(qr)
qc.measure(qr, cr[1])

qc.draw("mpl")

# Step 2: Transpile the circuit for running on a quantum computer

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

# Step 3: Run the job on a real quantum computer

sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs)
res = job.result()
counts = res[0].data.c.get_counts()

# Run the job on the Aer simulator with noise model from real backend
# job = noisy_sampler.run([qc_isa])
# res=job.result()
# counts=res[0].data.c.get_counts()

# Step 4: Post-process
from qiskit.visualization import plot_histogram

plot_histogram(counts)

Hier scheinen wir noch weniger Vorhersagbarkeit zu haben! Zuvor wussten wir zumindest, was das Ergebnis der ersten Messung sein würde, jetzt haben wir eine ziemlich gleichmäßige Verteilung über alle möglichen Zustände. Es ist nicht schwer zu sehen, warum das passiert ist. Wir begannen in $|0\rangle$, was eine 50-50-Mischung aus $|+\rangle_x$ und $|-\rangle_x$ ist, gemäß $|0\rangle=\frac{1}{\sqrt{2}}(|+\rangle_x+|-\rangle_x)$ Es sollte also klar sein, dass es eine gleiche Wahrscheinlichkeit gibt, den + oder - Zustand (auf 0 und 1 im Diagramm abgebildet) bei der ersten Messung zu erhalten. Die Messung entlang $x$ kollabiert den Zustand in entweder den Eigenzustand $|+\rangle_x$ oder den Eigenzustand $|-\rangle_x$. 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, werden Messungen entlang $z$ eindeutig sowohl $|0\rangle$ als auch $|1\rangle$ ergeben, und zwar mit ungefähr gleicher Wahrscheinlichkeit. Unser erstes Beispiel zeigte uns also, dass einige Zustände sehr vorhersagbare Ergebnisse für einige Messungen haben, aber unvorhersagbare Ergebnisse für andere Messungen. Das aktuelle Beispiel zeigt uns, dass es noch schlechter geht. Es gibt Zustände, die uns unvorhersagbare Ergebnisse für beide Messungen liefern können, selbst wenn wir nur die Reihenfolge der Messungen vertauschen. Untersuchen wir, wie bestimmt oder unbestimmt eine Größe für einen gegebenen Zustand ist.

Berechnung der Unbestimmtheit

Wir können dies mit der Unbestimmtheit oder Varianz quantifizieren. Die „Unbestimmtheit" wird oft als Quadratwurzel der „Varianz" einer Verteilung definiert. Das heißt, die Unbestimmtheit für eine Observable $S$ wird mit $\Delta S$ bezeichnet und ist gegeben durch

$$\begin{aligned} (\Delta S)^2 & \equiv \langle (S - \langle S \rangle)^2 \rangle\\ (\Delta S)^2 & = \langle S^2 - 2 S \langle S \rangle +\langle S \rangle^2 \rangle\\ (\Delta S)^2 & = \langle S^2 \rangle - \langle S \rangle^2 \end{aligned}$$

Für den Fall der Pauli-Matrizen, bei denen $S^2 = I$ gilt, wird dies zu

$$(\Delta S)^2 = 1 - \langle S \rangle^2$$

Wenden wir dies auf ein konkretes Beispiel an. Beginnen wir mit dem Zustand $|\psi\rangle = |+\rangle_y = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ i \end{pmatrix},$ und bestimmen wir die Unbestimmtheit der Observablen $X$ in diesem Zustand.

Überprüfe dein Verständnis

Berechne die Unbestimmtheit von $X$ im Zustand $|+\rangle_y = |+i\rangle$ von Hand.

Answer

$$\Delta X =\sqrt{\langle+i| X^2 |+i\rangle - \langle+i| X |+i\rangle^2}$$

Im gegebenen Zustand ergibt dies:

$$\begin{aligned} \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}\\ \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}\\ \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}\\ \Delta X & =\sqrt{\frac{1}{2}(2)} = 1 \end{aligned}$$

Wir können einen beliebigen Anfangszustand mit qc.initialize() erstellen. Beachte, dass die Syntax für die imaginäre Einheit hier $1j$ ist.

# Step 1: Map the problem into a quantum circuit

from qiskit.quantum_info import SparsePauliOp
import numpy as np

obs = SparsePauliOp("X")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Initialize the state
qc.initialize([1, 1j] / np.sqrt(2))

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

estimator = Estimator(mode=backend)
pubs = [(qc_isa, obs_isa)]
job = estimator.run([[qc_isa, obs_isa]])
res = job.result()

# Run the job on the Aer simulator with noise model from real backend
# job = noisy_estimator.run([[qc_isa,obs_isa]])
# res=job.result()

# Step 4: Return the result in classical form, and analyze.

print(res[0].data.evs)

-0.02408454165642664

Gemäß unserer obigen Gleichung gilt: $(\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$:

# Step 1: Map the problem into a quantum circuit

obs = SparsePauliOp("Z")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Initialize the state to |+>_y
qc.initialize([1, 1j] / np.sqrt(2))

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

estimator = Estimator(mode=backend)
pubs = [(qc_isa, obs_isa)]
job = estimator.run(pubs)
res = job.result()

# Run the job on the Aer simulator with noise model from real backend
# job = noisy_estimator.run([[qc_isa,obs_isa]])
# res=job.result()

# Step 4: Return the result in classical form, and analyze.

print(res[0].data.evs)

0.04958271968581247

Wir könnten die gleiche Rechnung wie zuvor durchführen, würden aber sehen, dass die Varianz wieder sehr nahe bei 1,0 liegt. Wir könnten schlussfolgern, dass $\Delta X \Delta Z \approx 1{,}0$. Das ist in der Tat für den gewählten Zustand ungefähr korrekt. Aber können wir es besser machen? Oder schlechter?

Erinnere dich, dass es eine Unbestimmtheitsrelation zwischen der Position in einer Richtung, $x,$ und dem Impuls in derselben Richtung, $p_x,$ gibt. Für diese Variablen ist die bekannteste Form wahrscheinlich $\Delta x \Delta p_x \geq \hbar/2$ Wenn wir uns nur daran erinnern, könnten wir versucht sein zu denken, dass $\Delta X$ und $\Delta Z$ ebenfalls eine solche fundamentale Untergrenze der Unbestimmtheit haben könnten. Vielleicht ist es unmöglich, dass das Produkt $\Delta X \Delta Z$ null erreicht? Probieren wir einen anderen Zustand und sehen, ob das gilt. Diesmal verwenden wir $|\psi\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix}.$ Schauen wir, was passiert. Beachte, dass der Estimator im folgenden Code zwei Sätze von Circuits und Observablen in derselben Job-Einreichung akzeptieren kann.

# Step 1: Map the problem into a quantum circuit

obs1 = SparsePauliOp("X")
obs2 = SparsePauliOp("Z")

# Define registers

qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Initialize the state
qc.initialize([1, 1] / np.sqrt(2))

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
obs1_isa = obs1.apply_layout(layout=qc_isa.layout)
obs2_isa = obs2.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

with Batch(backend=backend) as batch:
    estimator = Estimator(mode=batch)
    pubs = [(qc_isa, obs1_isa), (qc_isa, obs2_isa)]
    job = estimator.run(pubs)
    res = job.result()
batch.close()

# Run the job on the Aer simulator with noise model from real backend

# job = noisy_estimator.run([[qc,obs1],[qc,obs2]])
# res=job.result()

# Step 4: Return the result in classical form, and analyze.

print("The expectation value of the first observable is: ", res[0].data.evs)
print("The expectation value of the second observable is: ", res[1].data.evs)

The expectation value of the first observable is:  1.0011036174126302
The expectation value of the second observable is:  0.0029429797670141016

Der Erwartungswert von $X$ sollte nahe bei 1,0 liegen, aber 1,0 nicht überschreiten. Mache dir keine Sorgen, wenn er 1,0 um einen sehr kleinen Betrag überschreitet. Dies kann auf Faktoren wie Rauschen und/oder Auslesefehler zurückgeführt werden. Obwohl dies ein sehr wichtiges Thema ist, können wir es vorerst ignorieren.

Wir erhielten einen Erwartungswert von $X$, der sehr nahe bei 1,0 liegt (was einer sehr niedrigen Varianz für $X$ entspricht). Dies macht das Produkt der beiden Varianzen recht klein:

$$\Delta X \Delta Z = \sqrt{1-(0.9853)^2} \times \sqrt{1-(-0.00195)^2} = 0.171.$$

Obwohl dies nicht genau null ist, wird dieser Wert im Vergleich zu den Eigenwerten der Pauli-Operatoren ($\pm 1$) klein. Nun, du erinnerst dich vielleicht, dass die Unbestimmtheitsrelation zwischen linearer Position und Impuls anders geschrieben werden konnte, nämlich explizit unter Verwendung der Kommutatorrelation zwischen den Operatoren $x$ und $p_x$:

$$\Delta x \Delta p_x \geq \frac{1}{2}|\langle [x,p_x] \rangle|$$

wobei

$$[x,p_x] = xp_x-p_xx$$

der Kommutator von $x$ und $p_x$ ist.

Dies ist die Form, die am einfachsten auf die Pauli-Operatoren erweitert werden kann. Allgemein gilt für zwei Operatoren $A$ und $B$:

$$\Delta A \Delta B \geq \frac{1}{2}|\langle [A,B] \rangle|.$$

Und im Fall der Pauli-Matrizen $X$ und $Z$ benötigen wir $[X,Z]$, um Folgendes zu berechnen:

$$\Delta X \Delta Z \geq \frac{1}{2}|\langle [X,Z] \rangle|.$$

Wir zeigen dies hier und überlassen ähnliche Berechnungen als Übung:

$$[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}$$ $$[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}$$

Das ist eine vollkommen akzeptable Antwort, aber mit einem weiteren Schritt sehen wir

$$[X,Z] = -2i\begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}=-2iY$$

Unsere Unbestimmtheitsrelation wird somit zu

$$\Delta X \Delta Z \geq |\langle Y \rangle|.$$

Überprüfe dein Verständnis

Bestimme $[X,Y]$ und $[Y,Z]$. Verwende dies, um die Unbestimmtheitsrelationen zwischen $X$ & $Y$ sowie $Y$ & $Z$ aufzuschreiben.

Answer

$$[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$$$$[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$$

In Kombination mit der allgemeinen Unbestimmtheitsrelation erhalten wir

$$\Delta X \Delta Y \geq |\langle Z \rangle|,$$$$\Delta Y \Delta Z \geq |\langle X \rangle|.$$

Konsistenz überprüfen

Bevor wir fortfahren, prüfen wir, ob dies mit unserem vorherigen Ergebnis konsistent war. Wir verwendeten den Zustand $|\psi\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix}.$ Und wir fanden, dass $\Delta X \Delta Z = 0{,}171.$ Jetzt wissen wir, dass dieses Produkt größer oder gleich sein sollte als

$$|\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}$$ $$|\langle Y \rangle| = \frac{1}{2}\begin{pmatrix} 1 & 1 \end{pmatrix}\begin{pmatrix} -i \\ i \end{pmatrix} = \frac{1}{2}(-i+i) = 0.$$

Also gilt in der Tat: $\Delta X \Delta Z = 0{,}171 \geq |\langle Y \rangle|=0$ Verwende die folgenden Fragen, um etwas Intuition für diese Ergebnisse aufzubauen:

Überprüfe dein Verständnis

Beantworte die folgenden Punkte zusammen als Gruppe:

(a) Welche Zustände würdest du erwarten, die eine Unbestimmtheit von null in $X$ haben?

(b) Welche Zustände würdest du erwarten, die eine Unbestimmtheit von null in $Z$ haben?

(c) In welchen Zuständen würdest du einen Erwartungswert $\langle Y \rangle$ von null erhalten?

(d) Sind die Antworten auf die obigen Fragen konsistent mit dem Fall $\Delta X \Delta Z \geq |\langle Y \rangle|$?

(e) Schreibe Code, um dies explizit mit dem Estimator zu überprüfen.

Answer

(a) Wir würden erwarten, dass Eigenzustände des $X$-Operators null Unbestimmtheit in $X$ ergeben. Tatsächlich ergibt sich mit $|\psi\rangle = |+\rangle_x$: $\Delta X = \sqrt{1-\langle X \rangle^2} = \sqrt{1-1^2} = 0.$

(b) Wir würden erwarten, dass Eigenzustände des $Z$-Operators null Unbestimmtheit in $Z$ ergeben. Tatsächlich ergibt sich mit $|\psi\rangle = |1\rangle$: $\Delta Z = \sqrt{1-\langle Z \rangle^2} = \sqrt{1-(-1)^2} = 0.$

(c) Wir erwarten $\langle Y \rangle=0$ für alle Zustände, die bei der Messung genauso oft eine positive wie eine negative Projektion auf die $y$-Achse ergeben. Dazu gehören die Eigenzustände von $X$ und $Z$.

(d) Ja. Man würde einen sehr kleinen Wert für das Produkt der Unbestimmtheiten $\Delta X \Delta Z$ für Eigenzustände von $X$ oder $Z$ erwarten: $\Delta X \Delta Z \approx 0.$ Dies kann gelten, weil wir für dieselben Zustände auch $\langle Y \rangle=0$ erwarten. Die Unbestimmtheitsrelation könnte also erfüllt sein.

(e) Code wie der folgende würde dies verifizieren:

obs1 = SparsePauliOp.from_list(
    [("X", 1.000)]
)
obs2 = SparsePauliOp.from_list(
    [("Y", 1.000)]
)
obs3 = SparsePauliOp.from_list(
    [("Z", 1.000)]
)
qc = QuantumCircuit(1,1)
qc.ry(pi/2,0)

job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)
res=job.result()

Dabei gibt das Ergebnis alle Erwartungswerte zurück. Um alle Erwartungswerte abzurufen und Unbestimmtheiten zu berechnen, könnten wir verwenden:

xs=res[0].data.evs[0]
ys=abs(res[0].data.evs[1])
zs=res[0].data.evs[2]

import math
prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5

Beantworte die folgenden Punkte zusammen als Gruppe:

(a) Kannst du dir einen Zustand vorstellen, in dem du einen großen Erwartungswert $\langle Y \rangle$ hättest?

(b) Würdest du erwarten, dass derselbe Zustand eine große oder kleine Unbestimmtheit in $X$ hat?

(c) Würdest du erwarten, dass derselbe Zustand eine große oder kleine Unbestimmtheit in $Z$ hat?

(d) Sind die Antworten auf die obigen Fragen konsistent mit dem Fall $\Delta X \Delta Z \geq |\langle Y \rangle|$?

(e) Schreibe Code, um dies explizit mit dem Estimator zu überprüfen.

Answer

(a) Wir erwarten $\langle Y \rangle\approx 1$ für den Eigenzustand von $Y$: $|+\rangle_y$.

(b) Wir könnten erwarten, dass $X$ eine große Unbestimmtheit im Zustand $|+\rangle_y$ hat, da die Messung von $X$ in diesem Zustand ein positives und negatives Ergebnis mit gleicher Häufigkeit/Wahrscheinlichkeit ergeben würde.

(c) Wir könnten erwarten, dass $Z$ eine große Unbestimmtheit im Zustand $|+\rangle_y$ hat, da die Messung von $Z$ in diesem Zustand ein positives und negatives Ergebnis mit gleicher Häufigkeit/Wahrscheinlichkeit ergeben würde.

(d) Ja. Man würde einen großen Wert für das Produkt der Unbestimmtheiten $\Delta X \Delta Z$ für Eigenzustände von $Y$ erwarten, und für $|+\rangle_y$ im Besonderen. Wir würden für denselben Zustand auch $\langle Y \rangle\approx 1$ erwarten. Sowohl $\langle Y \rangle$ als auch $\Delta X \Delta Z$ sind in diesem Zustand recht groß, und es ist plausibel, dass die Unbestimmtheitsrelation erneut erfüllt sein könnte.

(e) Code wie der folgende würde dies verifizieren:

obs1 = SparsePauliOp.from_list(
    [("X", 1.000)]
)
obs2 = SparsePauliOp.from_list(
    [("Y", 1.000)]
)
obs3 = SparsePauliOp.from_list(
    [("Z", 1.000)]
)
qc = QuantumCircuit(1,1)
qc.rx(-pi/2,0)

job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)
res=job.result()

Dabei gibt das Ergebnis alle Erwartungswerte zurück. Um alle Erwartungswerte abzurufen und Unbestimmtheiten zu berechnen, könnten wir verwenden:

xs=res[0].data.evs[0]
ys=abs(res[0].data.evs[1])
zs=res[0].data.evs[2]

import math
prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5

Testen von Unbestimmtheitsrelationen

Der obige Test hat die Gültigkeit der Unbestimmtheitsrelation nur für eine einzige Wahl des Zustandsvektors $|\psi\rangle = |+\rangle_x$ demonstriert. Um uns davon zu überzeugen, dass dies generell mit dem Experiment übereinstimmt, sollten wir ähnliche Berechnungen mit dem Estimator für viele verschiedene Zustandsvektoren durchführen. Beginnen wir damit, unseren Zustandsvektor von der $z$-Achse weg zu rotieren, indem wir ein RY-Gate verwenden, um verschiedene Anfangszustände mit einem Parameter $\theta$ zu erzeugen.

# The calculation below uses approximately 3-4 minutes of QPU time.
# Step 1: Map the problem into a quantum circuit

from qiskit.circuit import Parameter
import numpy as np

# Specify observables
obs1 = SparsePauliOp("X")
obs2 = SparsePauliOp("Y")
obs3 = SparsePauliOp("Z")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Rotate away from |0>
theta = Parameter("θ")
qc.ry(theta, 0)

params = np.linspace(0, 2, num=21)

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
obs1_isa = obs1.apply_layout(layout=qc_isa.layout)
obs2_isa = obs2.apply_layout(layout=qc_isa.layout)
obs3_isa = obs3.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

with Batch(backend=backend) as batch:
    estimator = Estimator(mode=batch)
    pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]
    job = estimator.run(pubs, precision=0.01)
    res = job.result()

batch.close()

# Run the job on the Aer simulator with noise model from real backend

# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])
# res=job.result()

# Step 4: Post-processing and classical analysis.
xs = res[0].data.evs[0]
ys = abs(res[0].data.evs[1])
zs = res[0].data.evs[2]

# Calculate uncertainties

delx = []
delz = []
prodxz = []
for i in range(len(xs)):
    delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)
    delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)
    prodxz.append(delx[i] * delz[i])

# Here we can plot the results from this simulation.
import matplotlib.pyplot as plt

plt.plot(params, delx, label=r"$\Delta$ X")
plt.plot(params, ys, label=r"$\langle$ Y $\rangle$")
plt.plot(params, delz, label=r"$\Delta$ Z")
plt.plot(params, prodxz, label=r"$\Delta$X $\Delta$Z")
plt.xlabel(r"$\theta$")
plt.ylabel("Expectation/Uncertainty Values")
plt.legend()
plt.show()

Beachte, dass die rote Kurve $(\Delta X \Delta Z)$ immer größer ist als die orange Kurve $\langle Y \rangle.$ Manchmal sinkt das Unbestimmtheitsprodukt und kommt der Grenze relativ nahe, und andere Male steigt es und ist weiter von der Grenze entfernt, aber es gehorcht immer der Unbestimmtheitsrelation.

Natürlich ist dies möglicherweise nicht der beste Test der Unbestimmtheitsrelation, da unsere Grenze $\langle Y \rangle$ immer sehr nahe bei null liegt. Verwenden wir einen Quantenzustand, der eine größere Projektion auf Eigenzustände von $Y$ hat. Konkret werden wir weiterhin $|0\rangle$ von der $z$-Achse herunter um verschiedene Winkel rotieren, aber jetzt werden wir den resultierenden Zustand auch um die $z$-Achse um einen Winkel drehen, vielleicht $\pi/4$, und sehen, was passiert.

# The calculation below uses approximately 3-4 minutes of QPU time.
from qiskit.circuit import Parameter
import numpy as np

# Step 1: Map the problem to a quantum circuit

# Specify observables
obs1 = SparsePauliOp("X")
obs2 = SparsePauliOp("Y")
obs3 = SparsePauliOp("Z")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Rotate away from |0> along one plane, and then along a transverse direction.
theta = Parameter("θ")
qc.ry(theta, 0)
qc.rz(pi / 4, 0)

params = np.linspace(0, 2, num=21)

# Step 2: Transpile the circuit

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

obs1_isa = obs1.apply_layout(layout=qc_isa.layout)
obs2_isa = obs2.apply_layout(layout=qc_isa.layout)
obs3_isa = obs3.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

with Batch(backend=backend) as batch:
    estimator = Estimator(mode=batch)
    pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]
    job = estimator.run(pubs, precision=0.01)
    res = job.result()

batch.close()

# Run the job on the Aer simulator with noise model from real backend

# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])
# res=job.result()

# Step 4: Post-processing and classical analysis.
xs = res[0].data.evs[0]
ys = abs(res[0].data.evs[1])
zs = res[0].data.evs[2]

# Calculate uncertainties

delx = []
delz = []
prodxz = []
for i in range(len(xs)):
    delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)
    delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)
    prodxz.append(delx[i] * delz[i])

# Here we can plot the results from this simulation.
import matplotlib.pyplot as plt

plt.plot(params, delx, label=r"$\Delta$ X")
plt.plot(params, ys, label=r"$\langle$ Y $\rangle$")
plt.plot(params, delz, label=r"$\Delta$ Z")
plt.plot(params, prodxz, label=r"$\Delta$X $\Delta$Z")
plt.xlabel(r"$\theta$")
plt.ylabel("Expectation/Uncertainty Values")
plt.legend()
plt.show()

Jetzt sehen wir, dass die Grenze der Unbestimmtheit $(\Delta X \Delta Z)$ auf die Probe gestellt wird! Die rote Kurve kommt der orangen Kurve viel näher als zuvor. Tatsächlich würde die Unbestimmtheitsrelation ohne Rauschen an einem Punkt exakt gesättigt sein ($(\Delta X \Delta Z) = \langle Y \rangle$). In Gegenwart von Rauschen und Auslesefehlern sollte es nicht überraschen, wenn ein Durchlauf gelegentlich $(\Delta X \Delta Z)$ sehr geringfügig größer als $\langle Y \rangle$ ergibt. Dies ist keine echte Verletzung der Unbestimmtheit; es ist lediglich ein Artefakt des Fehlers ungleich null.

Überprüfe dein Verständnis

Erkläre, wie du dies an die absolute Grenze treiben würdest, sodass $\langle Y \rangle$ so groß wie möglich wird.

Answer

Der Code enthält derzeit Zeilen, die den Standard-Anfangszustand $|0\rangle$ von der $z$-Achse herunter um einen parametrisierten Winkel $\theta$ rotieren und dann auch um die $z$-Achse um einen Winkel $\pi/4$, was den Zustandsvektor teilweise in Richtung der $y$-Achse dreht.

qc.ry(theta,0)

qc.rz(pi/4,0)

Wir könnten die Rotation um $z$ von $\pi/4$ auf $\pi/2$ ändern und damit ganz in einen Eigenzustand von $Y$ rotieren:

qc.ry(theta,0)

qc.rz(pi/2,0)

Keine weiteren Änderungen wären erforderlich.

Ändere den Code oder kopiere ihn und implementiere diese Überprüfung der Unbestimmtheitsrelation mit dem maximierten Erwartungswert von Y. Gilt die Unbestimmtheitsrelation?

Answer

Wir würden genau den Code aus dem obigen Beispiel verwenden, mit

qc.rz(pi/2,0)

anstelle von

qc.rz(pi/4,0).

Die resultierende Abbildung sollte wie die unten stehende aussehen, und ja, die Unbestimmtheitsrelation sollte weiterhin gelten.

Passe den obigen Code an, um ein ähnliches Bild zu erstellen, das zeigt, dass das Produkt $\Delta X \Delta Y$ aus Messungen auf dem Quantencomputer sich wie erwartet verhält. Wähle beliebige Zustände.

Answer

Wir würden genau den Code aus dem obigen Beispiel verwenden und könnten tatsächlich dieselben Ergebnisse wie oben nutzen, nur mit den Erwartungswerten zur Berechnung anderer Unbestimmtheiten. Zum Beispiel könnten wir verwenden:

xs=res[0].data.evs[0]
ys=res[0].data.evs[1]
zs=abs(res[0].data.evs[2])
import math
delx = []
dely = []
prodxy=[]
for i in range(len(xs)):
    delx.append((1-xs[i]*xs[i])**0.5)
    dely.append((1-ys[i]*ys[i])**0.5)
    prodxy.append(((1-xs[i]*xs[i])**0.5)*(1-ys[i]*ys[i])**0.5)

und plotten:

import matplotlib.pyplot as plt
plt.plot(params, delx, label=r'$\Delta$ X')
plt.plot(params, dely, label=r'$\langle$ Y $\rangle$')
plt.plot(params, zs, label=r'$\Delta$ Z')
plt.plot(params, prodxy, label=r'$\Delta$X $\Delta$Z')
plt.xlabel(r'$\theta$')
plt.ylabel('Expectation/Uncertainty Values')
plt.legend()
plt.show()

Herausforderung: Schreibe Code, der viele Werte von $\phi$ durchläuft, so wie wir viele Werte von $\theta$ durchlaufen haben, und erstelle einen 3-D-Plot, der zeigt, dass die Unbestimmtheitsrelation niemals verletzt wird. Wähle beliebige Observable.

Fragen

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

Zentrale Konzepte:

• Es gibt Unbestimmtheitsrelationen zwischen vielen Paaren physikalischer Observabler, einschließlich Position & linearem Impuls und Spinkomponenten.
• Die Pauli-Matrizen kommutieren nicht. Dies ist eine mathematische Widerspiegelung der Tatsache, dass nicht alle Spinkomponenten gleichzeitig bekannt/bestimmt sein können.
• Quantencomputing nutzt die Pauli-Operatoren/Matrizen intensiv, daher ist es nützlich, die Unbestimmtheitsrelation für Pauli-Operatoren sowie die eng verwandten Spin-Operatoren zu kennen.
• Eine allgemeine Formel für die Unbestimmtheit zweier Operatoren $A$ und $B$ lautet $\Delta A \Delta B \geq \frac{1}{2}|\langle [A,B] \rangle|.$
• Ein Eigenzustand $|a\rangle$ eines Operators $A$ ergibt null Unbestimmtheit in der physikalischen Observablen, die mit diesem Operator verbunden ist. Auch experimentell gilt $\Delta A \approx 0.$
• Ein Eigenzustand $|a\rangle$ eines Operators $A$ ergibt eine größere Unbestimmtheit für einen Operator $B$, der nicht mit $A$ kommutiert.
• Experimentelle Ergebnisse mit einem echten Quantencomputer bestätigen die Intuition, die wir aus Matrixdarstellungen physikalischer Operatoren gewinnen.

Wahr/Falsch-Fragen:

1. W/F Man kann $X$ und $Y$ gleichzeitig messen, aber nicht $Z$.
2. W/F Man kann $X$ und $Z$ gleichzeitig messen, aber nicht $Y$.
3. W/F Lineare Position und linearer Impuls-Operator kommutieren nicht.
4. W/F IBM-Quantencomputer messen standardmäßig entlang $Z$, daher muss eine Rotation durchgeführt werden, um entlang einer anderen Richtung zu messen.
5. W/F Der Circuit unten misst effektiv $Z$ und dann $X$.

Multiple-Choice-Fragen:

1. Das folgende Diagramm demonstriert welche der folgenden Unbestimmtheitsrelationen?

   • a. $\Delta X \Delta Y \geq |\langle Z \rangle|$
   • b. $\Delta Y \Delta Z \geq |\langle X \rangle|$
   • c. $\Delta Z \Delta X \geq |\langle Y \rangle|$
   • d. Keine der oben genannten

2. Welche der folgenden Sequenzen ist die Standardabfolge, um eine Messung entlang $x$ durchzuführen?

   • a. Nur qc.measure()
   • b. qc.h() dann qc.measure()
   • c. qc.h(), qc.h() dann qc.measure()
   • d. qc.h(), qc.s, qc.h() dann qc.measure()
   • e. qc.sdg(), qc.h(), qc.s dann qc.measure()
   • f. qc.sdg(), qc.h(), qc.s, qc.h() dann qc.measure()

3. Welcher der folgenden Zustände ergibt den größten Erwartungswert $\langle X \rangle$?

   • a. $|+\rangle_x$
   • b. $|-\rangle_x$
   • c. $|+\rangle_y$ auch $|+i\rangle$ genannt
   • d. $|-\rangle_y$ auch $|-i\rangle$ genannt
   • e. $|0\rangle$ auch $|\uparrow\rangle$ genannt
   • f. $|1\rangle$ auch $|\downarrow\rangle$ genannt

4. Welcher der folgenden Zustände ergibt die größte Unbestimmtheit $\Delta X$?

   • a. $|+\rangle_x$
   • b. $|+\rangle_y$ auch $|+i\rangle$ genannt
   • c. $|0\rangle$ auch $|\uparrow\rangle$ genannt
   • d. a und b sind gleichauf
   • e. b und c sind gleichauf
   • f. a, b und c sind gleichauf

Diskussionsfragen:

1. Steht dieses Konzept der Unbestimmtheit in irgendeiner Weise im Widerspruch zur Vorstellung von Spin als Vektorpfeil im kartesischen Raum? Wie sieht es auf der Bloch-Kugel aus?

2. Angenommen, du richtest ein Messgerät in einer Richtung aus, die genau zwischen der $x$- und der $y$-Achse liegt. Was passiert? Kannst du eine Messung in dieser Richtung durchführen? Wie hängt das mit der Unbestimmtheit in $X$ und $Y$ zusammen?

3. Welche zusätzlichen Experimente würdest du gerne durchführen, um dich von den hier gewonnenen Ergebnissen zu überzeugen?