Menjelajahi ketidakpastian

Untuk modul Qiskit in Classrooms ini, siswa harus memiliki lingkungan Python yang berfungsi dengan paket-paket berikut terinstal:

• qiskit v2.1.0 atau lebih baru
• qiskit-ibm-runtime v0.40.1 atau lebih baru
• qiskit-aer v0.17.0 atau lebih baru
• qiskit.visualization
• numpy
• pylatexenc

Untuk mengatur dan menginstal paket-paket di atas, lihat panduan Install Qiskit. Untuk menjalankan job di komputer kuantum nyata, siswa perlu membuat akun di IBM Quantum® dengan mengikuti langkah-langkah di panduan Set up your IBM Cloud account.

Modul ini telah diuji dan menggunakan 8 menit waktu QPU. Ini hanya perkiraan. Penggunaan aktual kamu mungkin berbeda. Dua perhitungan yang memakan waktu ditandai demikian dalam komentar header dan bisa dijalankan di simulator jika siswa kekurangan waktu QPU. Dengan penghilangan keduanya, modul hanya memerlukan sekitar ~30 detik waktu QPU.

# 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'

Tonton panduan modul oleh Dr. Katie McCormick di bawah ini, atau klik di sini untuk menontonnya di YouTube.

---

Pendahuluan

Kamu mungkin pernah mendengar tentang prinsip ketidakpastian, bahkan di luar pelajaran fisika. Pernyataan sehari-hari yang umum dari ketidakpastian adalah "Dengan melihat sesuatu, kamu mempengaruhinya." Itu memang benar. Tapi cara yang lebih fisikal untuk menggambarkan ketidakpastian adalah bahwa ada besaran fisik tertentu yang memiliki ketidaksesuaian yang mencegah keduanya diketahui secara bersamaan dengan akurasi sembarang. Banyak siswa pertama kali menemui pasangan variabel yang tidak kompatibel $x$ dan $p_x$, yang berarti posisi sepanjang satu sumbu yang disebut sumbu-$x$, dan momentum linier sepanjang arah tersebut, masing-masing. Untuk variabel-variabel tersebut, batasan ketidakpastian ditulis $\Delta x \Delta p_x \geq \frac{\hbar}{2}.$ Di sini, $\Delta x$ disebut "ketidakpastian dalam $x$", yang memiliki definisi yang sama dengan deviasi standar dalam statistik, dan dapat didefinisikan sebagai $\Delta x = \sqrt{\langle x^2 \rangle - \langle x \rangle^2}.$ $\Delta p_x$ didefinisikan dengan cara yang sama. Di sini, kita tidak akan menurunkan hubungan ketidakpastian ini; kita akan menunjukkan bahwa hal ini konsisten dengan pemahaman kita tentang gelombang klasik. Artinya, gelombang dengan benar-benar satu frekuensi sempurna $f$ dan panjang gelombang $\lambda$ akan terus berlanjut selamanya sebagai sinusoid sempurna. Secara mekanika kuantum, ini akan berhubungan dengan mengetahui momentum secara sempurna sesuai hipotesis de Broglie: $\lambda = h/p$. Tapi untuk mengetahui $di\ mana$ partikel seperti gelombang itu berada, gelombang yang menggambarkannya harus menjadi lebih tajam dalam ruang, seperti Gaussian yang sangat sempit, misalnya. Kita tahu bahwa kita bisa mengungkapkan fungsi kontinu apa pun, termasuk fungsi gelombang yang berpuncak tajam seperti itu, sebagai deret Fourier dari fungsi sinusoidal dengan panjang gelombang yang berbeda. Namun saat fungsi gelombang menjadi lebih berpuncak tajam (dan posisi lebih diketahui), kita akan membutuhkan lebih banyak suku dalam deret Fourier, yang berarti campuran lebih banyak panjang gelombang (dan dengan demikian, secara mekanika kuantum, lebih banyak nilai momentum).

Lebih sederhana: sebuah keadaan dengan momentum yang terdefinisi dengan baik (sinusoid sempurna dalam ruang) memiliki posisi yang sangat tidak pasti. Sebuah keadaan dengan posisi yang terdefinisi dengan baik (seperti distribusi delta Dirac) memiliki momentum yang sangat tidak pasti.

Ada variabel lain yang menunjukkan ketidaksesuaian seperti itu. Misalnya, spin partikel mungkin memiliki proyeksi yang terdefinisi dengan baik sepanjang satu sumbu, tetapi kemudian kita tidak tahu apa-apa tentang proyeksi pada sumbu yang tegak lurus. Misalnya keadaan $|0\rangle \sim |\uparrow\rangle$ (untuk Qubit atau partikel spin-1/2) memiliki proyeksi pasti sepanjang sumbu $z$ (bernilai 1 dalam konteks Qubit, dan $\hbar/2$ dalam konteks partikel spin-1/2). Tetapi keadaan ini dapat ditulis sebagai superposisi dari dua keadaan yang masing-masing memiliki proyeksi terdefinisi dengan baik pada sumbu $x$: $|0\rangle = \frac{1}{\sqrt{2}}(|+\rangle_x+|-\rangle_x)$ atau ekuivalennya $\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$ memiliki proyeksi terdefinisi dengan baik pada $x$, begitu pula $|-\rangle_x$. Jadi jika kita menentukan proyeksi sebuah keadaan sepanjang sumbu $x$, kita tidak tahu proyeksi sepanjang sumbu $z$. Dan jika kita menentukan proyeksi pada sumbu $z$, kita tidak tahu proyeksi sepanjang $x$. Ada perbedaan kecil saat membahas ini dalam konteks spin dan dalam Qubit. Tapi secara umum, eigenstate dari matriks Pauli memiliki hubungan yang menarik yang dapat kita jelajahi. Sepanjang pelajaran ini, kita akan memeriksa secara eksperimental intuisi kita tentang ketidakpastian dalam variabel-variabel yang tidak kompatibel ini, dan memverifikasi bahwa hubungan ketidakpastian berlaku pada komputer kuantum IBM®.

Pemeriksaan sederhana intuisi

Dalam eksperimen pertama ini dan sepanjang modul, kita akan menggunakan kerangka kerja untuk komputasi kuantum yang dikenal sebagai "Qiskit patterns", yang memecah alur kerja menjadi langkah-langkah berikut:

• Langkah 1: Petakan input klasik ke masalah kuantum
• Langkah 2: Optimalkan masalah untuk eksekusi kuantum
• Langkah 3: Jalankan menggunakan Qiskit Runtime Primitives
• Langkah 4: Post-processing dan analisis klasik

Kita umumnya akan mengikuti langkah-langkah ini, meski kita mungkin tidak selalu secara eksplisit memberi labelnya.

Mari mulai dengan memuat beberapa paket yang diperlukan termasuk Runtime primitives. Kita juga akan memilih komputer kuantum yang paling tidak sibuk yang tersedia untuk kita.

Ada kode di bawah ini untuk menyimpan kredensial kamu pada penggunaan pertama. Pastikan untuk menghapus informasi ini dari notebook setelah menyimpannya ke lingkunganmu, agar kredensialmu tidak dibagikan secara tidak sengaja saat kamu berbagi notebook. Lihat Set up your IBM Cloud account dan Initialize the service in an untrusted environment untuk panduan lebih lanjut.

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

Jika seorang siswa menghabiskan waktu komputasi kuantum yang tersedia selama pelajaran, baris-baris di bawah ini bisa di-uncomment dan digunakan untuk menyiapkan simulator yang sebagian meniru perilaku noise dari komputer kuantum yang dipilih di atas.

# 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}})

Kamu mungkin ingat bahwa eigenstate dari satu operator, Z, bukan eigenstate dari operator lain X. Kita akan mengamati hal itu sekarang, secara eksperimental dengan melakukan pengukuran sepanjang sumbu $x$ dan $z$. Untuk pengukuran sepanjang $z$, kita cukup menggunakan qc.measure(), karena komputer kuantum IBM dirancang untuk mengukur sepanjang $z$. Tapi untuk mengukur sepanjang $x$, kita harus merotasi sistem untuk secara efektif memindahkan sumbu $x$ ke orientasi yang kita ukur. Ini dilakukan dengan Hadamard Gate. Ada langkah serupa yang diperlukan untuk pengukuran sepanjang $y$. Langkah-langkah yang diperlukan dikumpulkan di sini untuk kemudahan:

• Untuk mengukur sepanjang $z$: qc.measure()
• Untuk mengukur sepanjang $x$: qc.h() lalu qc.measure()
• Untuk mengukur sepanjang $y$: qc.sdg(), qc.h(), qc.s lalu qc.measure()

Langkah 1: Petakan input klasik ke masalah kuantum

Dalam hal ini, langkah pemetaan hanyalah mengungkapkan pengukuran dan rotasi yang dijelaskan di atas dalam Circuit kuantum:

# 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")

Langkah 2: Optimalkan masalah untuk eksekusi kuantum

Langkah ini mengambil operasi yang ingin kita lakukan dan mengungkapkannya dalam hal fungsionalitas komputer kuantum tertentu. Ini juga memetakan masalah kita ke tata letak komputer kuantum.

# 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)

Langkah 3: Jalankan menggunakan Qiskit Runtime primitives

Kita bisa menggunakan Sampler untuk mengumpulkan statistik pengukuran. Kita akan membuat primitif Sampler untuk dijalankan di komputer kuantum nyata menggunakan mode = backend. Ada mode lain untuk alur kerja lain, dan kita akan menggunakan salah satunya di bawah ini. Sampler akan digunakan dengan memanggil metode run() dengan daftar "PUB" (Primitive Unified Blocs). Setiap PUB berisi hingga tiga nilai yang, bersama-sama, mendefinisikan unit komputasi pekerjaan bagi Estimator untuk diselesaikan: Circuit, observables, parameter. Kamu juga bisa memberikan daftar Circuit, daftar observables, dan daftar parameter. Untuk informasi lebih lanjut, baca Overview of PUBs.

Kita ingin menjalankan di komputer kuantum nyata, agar kita menjalankan eksperimen fisika kuantum yang sesungguhnya. Jika kamu menghabiskan waktu yang dijatahkan di komputer kuantum nyata, kamu bisa mengomentari kode di bawah ini untuk komputer kuantum, dan uncomment kode untuk menjalankan di simulator.

# 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()

Langkah 4: Post-processing

Ini adalah kasus post-processing yang sangat sederhana, di mana kita hanya memvisualisasikan counts.

Perlu dicatat bahwa Qiskit mengurutkan Qubit, pengukuran, dan hal-hal lain dengan mencantumkan item bernomor terendah terakhir / di sebelah kanan, sebuah konvensi yang disebut sebagai "little-endian". Ini berarti kolom di bawah yang berlabel "10" mengacu pada counts di mana pengukuran pertama menghasilkan "0", dan pengukuran kedua menghasilkan "1".

# Step 4: Post-process

from qiskit.visualization import plot_histogram

plot_histogram(counts)

Jika konvensi ini tidak cocok untukmu, kamu bisa menggunakan marginal_counts untuk memvisualisasikan hasil setiap pengukuran secara terpisah:

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"
)

Secara default, keadaan dalam Qiskit diinisialisasi ke keadaan $|0\rangle$. Jadi tidak mengejutkan bahwa hampir semua pengukuran pertama menghasilkan $|0\rangle$. Namun perhatikan bahwa ada hampir pembagian yang merata pada pengukuran kedua (yang memberi informasi tentang proyeksi keadaan pada $x$). Sepertinya keadaan yang memberi kita hasil pengukuran yang sangat dapat diprediksi sepanjang $z$ memberi kita hasil yang sangat tidak dapat diprediksi untuk pengukuran sepanjang $x$. Mari kita jelajahi ini.

Apa yang terjadi jika kita melakukan pengukuran dalam urutan yang berlawanan? Kita bisa mulai dengan menggunakan Hadamard Gate untuk mendapatkan statistik tentang probabilitas $|0\rangle$ diukur dalam $|\pm\rangle_x$. Kemudian untuk pengukuran kedua, kita akan kembali ke basis $z$ menggunakan Hadamard Gate kedua.

# 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)

Di sini, sepertinya kita memiliki ketidakprediktabilan yang lebih rendah! Sebelumnya, kita setidaknya tahu hasil apa yang akan terjadi dari pengukuran pertama, sekarang kita memiliki distribusi yang cukup merata di semua kemungkinan keadaan. Tidak terlalu sulit untuk melihat mengapa ini terjadi. Kita mulai dari $|0\rangle$, yang merupakan campuran 50-50 dari $|+\rangle_x$ dan $|-\rangle_x$, sesuai dengan $|0\rangle=\frac{1}{\sqrt{2}}(|+\rangle_x+|-\rangle_x)$ Jadi jelas harus ada probabilitas yang sama untuk mendapatkan keadaan + atau - (dipetakan ke 0 dan 1 dalam grafik) untuk pengukuran pertama. Pengukuran sepanjang $x$ meruntuhkan keadaan menjadi baik eigenstate $|+\rangle_x$ atau eigenstate $|-\rangle_x$. Setiap keadaan itu adalah campuran 50-50 dari $|0\rangle$ dan $|1\rangle$, sesuai dengan $|+\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ $|-\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle-|1\rangle)$ Jadi begitu sistem berada dalam eigenstate $x$, jelas pengukuran sepanjang $z$ akan menghasilkan $|0\rangle$ dan $|1\rangle$, dan melakukannya dengan probabilitas yang kurang lebih sama. Jadi contoh pertama kita menunjukkan bahwa beberapa keadaan akan memiliki hasil yang sangat dapat diprediksi untuk beberapa pengukuran, tetapi hasil yang tidak dapat diprediksi untuk pengukuran lain. Contoh saat ini menunjukkan bahwa kita bisa lebih buruk dari itu. Ada keadaan yang dapat memberi kita hasil yang tidak dapat diprediksi untuk kedua pengukuran, bahkan jika yang kita lakukan hanyalah menukar urutan pengukuran. Mari kita selidiki seberapa pasti atau tidak pasti suatu besaran untuk keadaan tertentu.

Menghitung ketidakpastian

Kita bisa mengkuantifikasi ini menggunakan ketidakpastian, atau varians. "Ketidakpastian" sering didefinisikan sebagai akar kuadrat dari "varians" suatu distribusi. Artinya, ketidakpastian untuk beberapa observabel $S$ dilambangkan $\Delta S$ dan diberikan oleh

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

Untuk kasus matriks Pauli, di mana $S^2 = I$, ini menjadi

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

Mari kita terapkan ini ke contoh konkret. Mari mulai dengan keadaan $|\psi\rangle = |+\rangle_y = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ i \end{pmatrix},$ dan kita tentukan ketidakpastian dari observabel $X$ dalam keadaan tersebut.

Periksa pemahamanmu

Baca pertanyaan di bawah, pikirkan jawabanmu, lalu klik segitiga untuk mengungkap solusinya.

Hitung ketidakpastian $X$ dalam keadaan $|+\rangle_y = |+i\rangle$, secara manual.

Jawaban:

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

Dalam keadaan yang diberikan, ini menghasilkan:

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

Kita bisa membuat keadaan awal sembarang menggunakan qc.initialize(). Perlu dicatat bahwa sintaks untuk unit imajiner di sini adalah $1j$.

# 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

Sesuai persamaan kita di atas, $(\Delta X)^2 = 1 - \langle X \rangle^2 = 1-(0.0015...)^2 \rightarrow \Delta X = 0.999...$ Mari tetap dengan keadaan yang sama, tapi sekarang cari nilai ekspektasi $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

Kita bisa melakukan matematika yang sama seperti sebelumnya, tapi kita akan melihat bahwa variansnya lagi-lagi sangat mendekati 1.0. Kita bisa menyimpulkan bahwa $\Delta X \Delta Z \approx 1.0$. Memang ini kira-kira benar untuk keadaan yang kita pilih. Tapi bisakah kita melakukan lebih baik? Atau lebih buruk?

Ingat bahwa ada hubungan ketidakpastian antara posisi sepanjang satu arah, $x,$ dan momentum sepanjang arah yang sama, $p_x.$ Untuk variabel-variabel tersebut, tapi bentuk yang paling familiar mungkin adalah $\Delta x \Delta p_x \geq \hbar/2$ Jika ini semua yang kita ingat, kita mungkin tergoda untuk berpikir bahwa $\Delta X$ dan $\Delta Z$ juga bisa memiliki batas fundamental pada ketidakpastian. Mungkin tidak mungkin bagi produk $\Delta X \Delta Z$ untuk mencapai nol? Mari coba keadaan lain dan lihat apakah ini berlaku. Kali ini, kita akan menggunakan $|\psi\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix}.$ Mari lihat apa yang terjadi. Perhatikan bahwa dalam kode di bawah ini, Estimator dapat menerima dua set Circuit dan observables dalam pengiriman job yang sama.

# 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

Nilai ekspektasi $X$ seharusnya mendekati 1.0, tapi tidak boleh melebihi 1.0. Jangan khawatir jika melebihi 1.0 dengan jumlah yang sangat kecil. Ini bisa dikaitkan dengan faktor seperti noise dan/atau kesalahan readout. Meskipun ini adalah topik yang sangat penting, kita bisa mengabaikannya untuk saat ini.

Kita mendapatkan nilai ekspektasi $X$ yang sangat mendekati 1.0 (sesuai dengan varians yang sangat rendah untuk $X$). Ini membuat produk dari dua varians cukup rendah:

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

Meskipun ini tidak persis nol, nilai ini semakin kecil dibandingkan dengan eigenvalue operator Pauli ($\pm 1$). Nah, kamu mungkin ingat bahwa hubungan ketidakpastian antara posisi linier dan momentum bisa ditulis secara berbeda, secara eksplisit menggunakan hubungan komutasi antara operator $x$ dan $p_x$:

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

di mana

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

adalah komutator dari $x$ dan $p_x$.

Ini adalah bentuk yang paling mudah diperluas ke operator Pauli. Secara umum, untuk dua operator $A$ dan $B$,

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

Dan dalam kasus matriks Pauli $X$ dan $Z$, kita memerlukan $[X,Z]$ untuk menghitung

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

Kita tunjukkan ini di sini, dan sisakan perhitungan serupa kepada pembaca sebagai latihan:

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

Ini adalah jawaban yang sangat bisa diterima, tapi dengan satu langkah lagi, kita lihat

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

Hubungan ketidakpastian kita dengan demikian menjadi

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

Periksa pemahamanmu

Baca pertanyaan di bawah, pikirkan jawabanmu, lalu klik segitiga untuk mengungkap solusinya.

Tentukan $[X,Y]$ dan $[Y,Z]$. Gunakan ini untuk menuliskan hubungan ketidakpastian antara $X$ & $Y$, dan $Y$ & $Z$.

Jawaban:

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

Dikombinasikan dengan hubungan ketidakpastian umum, kita punya

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

Verifikasi konsistensi

Sebelum melanjutkan, mari kita periksa bahwa ini konsisten dengan temuan sebelumnya. Kita menggunakan keadaan $|\psi\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix}.$ Dan kita menemukan bahwa $\Delta X \Delta Z = 0.171.$ Sekarang kita tahu produk ini harus lebih besar dari atau sama dengan

$$|\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.$$

Jadi memang, $\Delta X \Delta Z = 0.171 \geq |\langle Y \rangle|=0$ Gunakan pertanyaan di bawah ini untuk membangun intuisi tentang temuan-temuan ini:

Periksa pemahamanmu

Baca pertanyaan di bawah, pikirkan jawabanmu, lalu klik segitiga untuk mengungkap solusinya.

Jawab item-item berikut bersama sebagai satu set:

(a) Keadaan apa yang kamu harapkan memiliki ketidakpastian nol dalam $X$?

(b) Keadaan apa yang kamu harapkan memiliki ketidakpastian nol dalam $Z$?

(c) Dalam keadaan apa kamu akan mendapatkan nilai ekspektasi nol $\langle Y \rangle$?

(d) Apakah jawaban atas pertanyaan-pertanyaan di atas konsisten dengan kasus $\Delta X \Delta Z \geq |\langle Y \rangle|$?

(e) Tulis kode untuk secara eksplisit memverifikasi ini menggunakan Estimator.

Jawaban:

(a) Kita mungkin mengharapkan eigenstate dari operator $X$ menghasilkan ketidakpastian nol dalam $X$. Memang, menggunakan $|\psi\rangle = |+\rangle_x,$ kita punya $\Delta X = \sqrt{1-\langle X \rangle^2} = \sqrt{1-1^2} = 0.$

(b) Kita mungkin mengharapkan eigenstate dari operator $Z$ menghasilkan ketidakpastian nol dalam $Z$. Memang, menggunakan $|\psi\rangle = |1\rangle,$ kita punya $\Delta Z = \sqrt{1-\langle Z \rangle^2} = \sqrt{1-(-1)^2} = 0.$

(c) Kita mengharapkan $\langle Y \rangle=0$ untuk keadaan apa pun yang, saat diukur, menghasilkan proyeksi positif pada sumbu $y$ sesering proyeksi negatif. Ini termasuk eigenstate dari $X$ dan $Z$.

(d) Ya. Seseorang akan mengharapkan nilai yang sangat kecil untuk produk ketidakpastian $\Delta X \Delta Z$ untuk eigenstate dari $X$ atau $Z$: $\Delta X \Delta Z \approx 0.$ Ini bisa berlaku karena kita juga akan mengharapkan $\langle Y \rangle=0$ untuk keadaan yang sama. Jadi hubungan ketidakpastian bisa terpenuhi.

(e) Kode seperti berikut akan memverifikasi ini:

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()

Di mana hasilnya mengembalikan semua nilai ekspektasi. Untuk mengambil semua nilai ekspektasi dan menghitung ketidakpastian, kita bisa menggunakan:

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

Jawab item-item berikut bersama sebagai satu set:

(a) Bisakah kamu memikirkan keadaan di mana kamu akan memiliki nilai ekspektasi yang besar $\langle Y \rangle$?

(b) Apakah kamu mengharapkan keadaan yang sama memiliki ketidakpastian besar atau kecil dalam $X$?

(c) Apakah kamu mengharapkan keadaan yang sama memiliki ketidakpastian besar atau kecil dalam $Z$?

(d) Apakah jawaban atas pertanyaan-pertanyaan di atas konsisten dengan kasus $\Delta X \Delta Z \geq |\langle Y \rangle|$?

(e) Tulis kode untuk secara eksplisit memverifikasi ini menggunakan Estimator.

Jawaban:

(a) Kita mengharapkan $\langle Y \rangle\approx 1$ untuk eigenstate dari $Y$: $|+\rangle_y$.

(b) Kita mungkin mengharapkan $X$ memiliki ketidakpastian besar dalam keadaan $|+\rangle_y,$ karena mengukur $X$ dalam keadaan itu akan menghasilkan hasil positif dan negatif dengan frekuensi/probabilitas yang sama.

(c) Kita mungkin mengharapkan $Z$ memiliki ketidakpastian besar dalam keadaan $|+\rangle_y,$ karena mengukur $Z$ dalam keadaan itu akan menghasilkan hasil positif dan negatif dengan frekuensi/probabilitas yang sama.

(d) Ya. Seseorang akan mengharapkan nilai yang besar untuk produk ketidakpastian $\Delta X \Delta Z$ untuk eigenstate dari $Y,$ dan untuk $|+\rangle_y,$ khususnya. Kita juga akan mengharapkan $\langle Y \rangle\approx 1$ untuk keadaan yang sama. Jadi baik $\langle Y \rangle$ maupun $\Delta X \Delta Z$ keduanya cukup besar dalam keadaan ini, dan masuk akal bahwa hubungan ketidakpastian bisa lagi terpenuhi.

(e) Kode seperti berikut akan memverifikasi ini:

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()

Di mana hasilnya mengembalikan semua nilai ekspektasi. Untuk mengambil semua nilai ekspektasi dan menghitung ketidakpastian, kita bisa menggunakan:

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

Menguji relasi ketidakpastian

Pengujian di atas hanya menunjukkan validitas relasi ketidakpastian untuk satu pilihan vektor keadaan $|\psi\rangle = |+\rangle_x$. Agar kita lebih yakin bahwa ini secara umum konsisten dengan eksperimen, kita perlu melakukan perhitungan serupa menggunakan estimator untuk banyak pilihan vektor keadaan. Mari mulai dengan memutar vektor keadaan kita menjauhi sumbu $z$, menggunakan Gate RY untuk menghasilkan berbagai keadaan awal menggunakan parameter $\theta$.

# 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()

Perhatikan bahwa kurva merah $(\Delta X \Delta Z)$ selalu lebih besar dari kurva oranye $\langle Y \rangle.$ Kadang-kadang hasil kali ketidakpastian turun dan cukup dekat dengan batas, dan kadang-kadang naik dan lebih jauh dari batas, tapi selalu mematuhi relasi ketidakpastian.

Tentu saja, ini mungkin bukan pengujian terbaik untuk relasi ketidakpastian, karena batas kita $\langle Y \rangle$ selalu sangat dekat dengan nol. Mari gunakan keadaan kuantum yang memiliki proyeksi lebih besar pada eigenstate dari $Y$. Secara khusus, kita masih akan memutar $|0\rangle$ menjauhi sumbu $z$ dengan berbagai sudut, tapi sekarang kita juga akan memutar keadaan yang dihasilkan itu mengelilingi sumbu $z$ dengan sudut tertentu, misalnya $\pi/4$, dan lihat apa yang terjadi.

# 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()

Sekarang kita lihat bahwa batas ketidakpastian $(\Delta X \Delta Z)$ benar-benar diuji! Kurva merah jauh lebih dekat ke kurva oranye dibanding sebelumnya. Sebenarnya, tanpa adanya noise, relasi ketidakpastian akan tepat terpenuhi ($(\Delta X \Delta Z) = \langle Y \rangle$) di satu titik. Dengan adanya noise dan kesalahan readout, tidak mengejutkan jika suatu percobaan sesekali menghasilkan $(\Delta X \Delta Z)$ yang sedikit lebih besar dari $\langle Y \rangle.$ Ini bukan pelanggaran ketidakpastian yang sesungguhnya; ini hanya artefak dari error yang tidak nol.

Cek pemahamanmu

Baca pertanyaan di bawah ini, pikirkan jawabannya, lalu klik segitiga untuk mengungkap solusinya.

Jelaskan bagaimana kamu akan mendorong ini ke batas mutlak, membuat $\langle Y \rangle$ sebesar mungkin?

Jawaban:

Kode saat ini memiliki baris yang memutar keadaan awal default $|0\rangle$, menjauhi sumbu $z$ dengan sudut terparameter $\theta$ dan kemudian juga mengelilingi sumbu $z$ dengan sudut $\pi/4,$ yang memutar vektor keadaan sebagian menuju sumbu $y$.

qc.ry(theta,0)

qc.rz(pi/4,0)

Kita bisa mengubah rotasi terhadap $z$ dari $\pi/4$ menjadi $\pi/2$, memutar sepenuhnya ke eigenstate dari $Y$:

qc.ry(theta,0)

qc.rz(pi/2,0)

Tidak ada perubahan lain yang diperlukan.

Ubah kode atau salin dan implementasikan pengecekan relasi ketidakpastian tersebut dengan nilai ekspektasi Y yang dimaksimalkan. Apakah relasi ketidakpastian tetap berlaku?

Jawaban:

Kita akan menggunakan persis kode dari contoh di atas, dengan

qc.rz(pi/2,0)

ditukar untuk menggantikan

qc.rz(pi/4,0).

Gambar yang dihasilkan seharusnya terlihat seperti di bawah ini, dan ya, prinsip ketidakpastian seharusnya masih berlaku.

Modifikasi kode di atas untuk membuat gambar serupa, yang menunjukkan bahwa dari pengukuran di komputer kuantum hasil kali $\Delta X \Delta Y$ berperilaku sebagaimana mestinya. Pilih sekumpulan keadaan yang kamu suka.

Jawaban:

Kita akan menggunakan persis kode dari contoh di atas, dan bahkan kita bisa menggunakan hasil yang sama dari atas, hanya menggunakan nilai ekspektasi untuk menghitung ketidakpastian yang berbeda. Misalnya, kita bisa menggunakan

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)

dan kita bisa memplot

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()

Tantangan: Tulis kode untuk memindai banyak nilai $\phi$, seperti halnya kita memindai banyak nilai $\theta$, dan buat plot 3-D yang menunjukkan bahwa relasi ketidakpastian tidak pernah dilanggar. Pilih observable apa saja yang kamu suka.

Pertanyaan

Instruktur dapat meminta versi notebook ini dengan kunci jawaban dan panduan penempatan dalam kurikulum umum dengan mengisi survei singkat ini tentang bagaimana notebook digunakan.

Konsep-konsep kritis:

• Ada relasi ketidakpastian antara banyak pasang observabel fisik, termasuk posisi & momentum linear, dan komponen spin.
• Matriks Pauli tidak komutatif. Ini adalah cerminan matematis dari fakta bahwa tidak semua komponen spin dapat diketahui/ditentukan secara bersamaan.
• Komputasi kuantum banyak menggunakan operator/matriks Pauli, sehingga berguna untuk mengetahui relasi ketidakpastian untuk operator Pauli, serta operator spin yang berkaitan erat.
• Rumus umum untuk ketidakpastian dua operator $A$ dan $B$ adalah $\Delta A \Delta B \geq \frac{1}{2}|\langle [A,B] \rangle|.$
• Eigenstate $|a\rangle$ dari suatu operator $A$ menghasilkan ketidakpastian nol pada observabel fisik yang terkait dengan operator tersebut. Bahkan secara eksperimental, $\langle a|A|a\rangle \approx 0.$
• Eigenstate $|a\rangle$ dari suatu operator $A$ akan menghasilkan ketidakpastian yang lebih besar untuk operator $B$ yang tidak komutatif dengan $A$.
• Hasil eksperimen menggunakan komputer kuantum nyata mengkonfirmasi intuisi yang kita peroleh dari representasi matriks operator fisik.

Pertanyaan B/S:

1. B/S Seseorang bisa mengukur $X$ dan $Y$ secara bersamaan, tapi tidak $Z$.
2. B/S Seseorang bisa mengukur $X$ dan $Z$ secara bersamaan, tapi tidak $Y$.
3. B/S Operator posisi linear dan momentum linear tidak komutatif.
4. B/S Komputer kuantum IBM mengukur sepanjang $Z$ secara default, sehingga rotasi harus dilakukan untuk mengukur sepanjang arah lain.
5. B/S Circuit di bawah ini secara efektif mengukur $Z$ lalu $X$.

Pertanyaan Pilihan Ganda:

1. Diagram di bawah ini menunjukkan relasi ketidakpastian yang mana dari berikut ini?

   • 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. Tidak ada di atas

2. Mana urutan standar untuk melakukan pengukuran sepanjang $x$?

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

3. Keadaan mana dari berikut ini yang menghasilkan nilai ekspektasi terbesar $\langle X \rangle$?

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

4. Keadaan mana dari berikut ini yang menghasilkan ketidakpastian terbesar $\Delta X$?

   • a. $|+\rangle_x$
   • b. $|+\rangle_y$ disebut juga $|+i\rangle$
   • c. $|0\rangle$ disebut juga $|\uparrow\rangle$
   • d. a dan b seri
   • e. b dan c seri
   • f. a, b, dan c seri

Pertanyaan Diskusi:

1. Apakah konsep ketidakpastian ini bertentangan dengan gagasan spin sebagai panah vektor dalam ruang Cartesian? Bagaimana dengan di bola Bloch?

2. Misalkan kamu mengarahkan perangkat pengukuran sepanjang arah setengah jalan antara sumbu $x$ dan $y$. Apa yang terjadi? Bisakah kamu melakukan pengukuran sepanjang arah ini? Bagaimana ini berkaitan dengan ketidakpastian dalam $X$ dan $Y$?

3. Eksperimen tambahan apa yang ingin kamu lakukan untuk meyakinkan dirimu sendiri tentang hasil yang diperoleh di sini?