Eksperimen Stern-Gerlach menggunakan komputer kuantum

Untuk modul Qiskit in Classrooms ini, mahasiswa harus memiliki lingkungan Python yang berfungsi dengan paket-paket berikut yang sudah terpasang:

• 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 menyiapkan dan memasang paket-paket di atas, lihat panduan Install Qiskit. Untuk menjalankan job pada komputer kuantum sungguhan, mahasiswa perlu membuat akun IBM Quantum® dengan mengikuti langkah-langkah dalam panduan Siapkan akun IBM Cloud kamu.

Modul ini telah diuji dan menggunakan 2 detik waktu QPU. Ini hanyalah perkiraan. Penggunaan aktualmu bisa berbeda.

# Added by doQumentation — required packages for this notebook
!pip install -q 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.

---

Latar Belakang

Di awal tahun 1900-an, bukti perilaku terkuantisasi pada skala atom semakin banyak. Banyak interpretasi data yang berhasil, seperti penjelasan Max Planck tentang bencana ultraviolet, dan eksperimen seperti yang dilakukan oleh Otto Stern dan Walther Gerlach sangat penting dalam meyakinkan dunia bahwa sistem mekanika kuantum diperlukan, dan bahwa fenomena fisik tertentu adalah terkuantisasi. Dalam kasus eksperimen Stern-Gerlach (digagas oleh Stern pada tahun 1921 dan dilakukan oleh Stern dan Gerlach pada tahun 1922), tujuannya adalah untuk memeriksa kuantisasi momentum sudut dalam atom.

Sekitar waktu yang sama, model atom yang umum digunakan adalah model Bohr-Sommerfeld, yang merupakan perluasan dari model Bohr, dan seperti model Bohr, model ini memprediksi bahwa elektron berada dalam orbit terkuantisasi tertentu, mirip seperti planet yang mengorbit matahari.

Meskipun pada akhirnya perlakuan ini tidak cukup untuk menjelaskan perilaku mekanika kuantum atom, secara umum model ini memang memprediksi banyak fenomena yang diamati, seperti garis spektrum diskret dari atom. Orbit terkuantisasi elektron dengan energi spesifik sesuai dengan nilai-nilai terkuantisasi dari momentum sudut. Inilah momentum sudut orbital yang ingin diamati Stern dan Gerlach dalam eksperimen mereka, meskipun eksperimen ini berlaku untuk semua jenis momentum sudut terkuantisasi, termasuk spin. Kamu mungkin sering mendengar eksperimen Stern-Gerlach diterapkan pada spin. Fokus eksperimen aslinya adalah pada momentum sudut orbital karena George Uhlenbeck dan Samuel Goudsmit baru akan mengajukan teori keberadaan spin pada tahun 1925.

Terlepas dari jenis momentum sudutnya, muatan dengan momentum sudut memiliki momen magnetik. Dalam perlakuan klasik gerak orbital, seseorang akan mengharapkan partikel bermuatan $q$, massa $m$ dan momentum sudut $\vec{L}$ memiliki momen magnetik $\mu$ yang diberikan oleh

$$\vec{\mu} = \frac{q}{2m}\vec{L}$$

Ternyata hampir rumus yang sama berlaku untuk momentum sudut mekanika kuantum, dengan catatan penambahan rasio numerik yang berkaitan dengan jenis momentum sudut, yang disebut g-faktor $g$. Saat menggabungkan berbagai jenis momentum sudut, atau menggeneralisasi ke jenis sembarang, seseorang sering melihat $\vec{J}$ digunakan sebagai pengganti $\vec{L}$, sehingga kita menulis:

$$\vec{\mu} = \frac{gq}{2m}\vec{J}$$

Untuk objek klasik $g=1$. Untuk elektron, $g\approx 2$, dan ada banyak nilai untuk berbagai inti dan partikel subatomik. Poin utamanya di sini adalah bahwa momentum sudut terkuantisasi berarti momen magnetik yang terkuantisasi!

Momen magnetik ini akan mengalami torsi dalam medan magnet:

$$\vec{\tau}=\vec{\mu}\times \vec{B}$$

Dan akan mengalami gaya dalam medan magnet dengan gradien tak nol:

$$\vec{F} = \nabla(\vec{\mu}\cdot\vec{B})$$

Kita sering akan mempertimbangkan ekspresi di atas satu komponen sekaligus, sehingga mungkin lebih mudah untuk memikirkan komponen $z$-nya:

$$F_z = \mu_z \frac{dB_z}{dz}$$

Dengan menggabungkan ekspresi-ekspresi, kita bisa mendapatkan

$$F_z = \frac{gq}{2m} \frac{dB_z}{dz} J_z$$

Stern dan Gerlach tidak mengetahui tentang faktor $g$, tetapi bahkan dengan adanya faktor itu dalam ekspresi, kita memiliki gaya yang sama dengan beberapa konstanta yang diketahui atau terukur dikalikan momentum sudut. Jadi, menggunakan medan magnet dengan gradien yang diketahui, dan mengukur defleksi partikel saat melewati medan tersebut, kita seharusnya mendapatkan informasi tentang momentum sudut. Inilah inti dari eksperimen Stern-Gerlach.

Gbr. Eksperimen Stern–Gerlach[1]: Atom perak yang bergerak melalui medan magnet tak homogen, dan dibelokkan ke atas atau ke bawah tergantung pada spin mereka. Secara klasik, kita mengharapkan distribusi kontinu pada layar, tetapi dalam eksperimen kita melihat dua titik berbeda.

Atom perak netral dipanaskan dalam sebuah oven. Saat berkas atom perak mengalir dari oven, kolimator berkas digunakan untuk memilih hanya atom-atom yang bergerak mendekati pusat medan magnet tak homogen. Tentu saja, beberapa atom sedikit menyimpang ke kiri atau kanan, dan mengalami gradien medan yang lebih lemah, atau tidak ada gradien sama sekali. Jadi, kita tidak terlalu mempermasalahkan perilaku atom yang jauh ke kiri atau kanan. Kita tertarik pada apa yang terjadi pada atom-atom yang bergerak di sepanjang tengah saluran, di mana gradien medan magnet akan menghasilkan gaya yang membelokkan atom hanya dalam arah $z$.

Apa yang seharusnya kita harapkan secara klasik?

Bagaimana atom-atom ini akan berperilaku jika mereka persis seperti magnet klasik yang besar? Kamu bisa melakukan eksperimennya. Bayangkan menembakkan magnet neodimium kecil melewati magnet besar dan kuat. Orientasi magnet-magnet kecil itu acak. Namun saat melewati magnet besar, mereka cepat mengorientasikan diri untuk sejajar dengan medan, dan tertarik ke magnet besar. Sebagian besar magnet kecil dibelokkan ke arah magnet besar. Pengamat yang sangat jeli mungkin bertanya, "Bagaimana dengan konservasi energi?"

Memang, momen magnetik dalam medan magnet eksternal memiliki energi potensial yang terkait dengannya:

$$U = -\vec{\mu}\cdot \vec{B} = -\mu B \cos(\theta)$$

Jadi, jika momen magnetik berputar dalam medan magnet eksternal, akan ada perubahan energi yang diberikan oleh:

$$\Delta U = U_f - U_i = -\mu B (\cos(\theta_f) - \cos(\theta_i)).$$

Dalam kasus khusus magnet kecil yang anti-sejajar sempurna dengan medan eksternal membalik dan sejajar dengannya, ini akan sesuai dengan penurunan energi potensial:

$$\Delta U = U_f - U_i = -\mu B (\cos(0) - \cos(\pi)) = -2\mu B.$$

Jadi ke mana energi itu pergi? Magnet klasik seperti magnet kulkas neodimium kecil memiliki banyak partikel dan dapat membuang hampir semua jumlah energi sebagai panas. Sudut awal dan akhir antara momen magnetik dan medan magnet eksternal bisa berupa apa saja, dan setidaknya orientasi awal akan acak. Jadi jumlah energi yang berbeda akan dibuang sebagai panas untuk setiap magnet kecil. Namun secara klasik ini bukan masalah, karena kumpulan partikel klasik dapat membuang energi berapa pun sebagai panas.

Apa yang seharusnya kita harapkan dengan menerapkan pemikiran klasik ke skala atom?

Setidaknya ini tidak sama untuk magnet berskala atom, karena ada lebih sedikit partikel yang terlibat, lebih sedikit derajat kebebasan untuk membuang energi. Proposal mekanika kuantum awal lebih jauh menyarankan bahwa energi yang dapat diserap oleh partikel individual, seperti elektron, akan terkuantisasi, artinya elektron hanya dapat menyerap beberapa jumlah energi tertentu. Karena orientasi awal yang acak memerlukan pembuangan energi dalam jumlah acak, ini seharusnya tidak mungkin terjadi pada sistem dengan tingkat energi terkuantisasi. Energi berlebih tidak bisa dibuang sebagai panas. Jadi apa yang akan terjadi sebagai gantinya?

Cek pemahamanmu

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

Jelaskan apa yang menurutmu akan terjadi dalam situasi seperti yang dijelaskan di atas. Yaitu, kamu memiliki magnet berukuran atom yang tidak dapat membuang energi sebagai panas. Jadi, energi potensial magnetik awal apa pun harus tetap dalam sistem. Namun, torsi diterapkan oleh medan magnet eksternal, yang mencoba memutar magnet kecil agar sejajar dengan medan eksternal. Apa yang terjadi?

Jawaban:

Momen magnetik kecil akan berputar menuju kesejarajan dengan medan eksternal. Namun ketika sejenak sejajar, ia akan memiliki energi kinetik rotasional yang akan membuatnya terus berputar melampaui medan dan kembali keluar dari kesejarajan. Perilaku ini bahkan bisa dilihat pada magnet klasik besar. Namun dalam sistem klasik tersebut, osilasi momen magnetik kecil akhirnya berhenti karena energi dibuang menjadi panas. Namun dalam sistem tanpa mekanisme disipasi seperti itu, osilasi seharusnya berlanjut tanpa batas.

Dengan perilaku yang diharapkan dalam jawaban di atas, distribusi partikel magnetik seperti apa yang kamu harapkan terlihat di layar?

Jawaban:

Distribusi halus dari defleksi maksimum ke arah sisi medan magnet yang lebih kuat (partikel-partikel yang kebetulan mulai sejajar dengan medan eksternal) hingga defleksi maksimum ke arah sisi medan yang lebih lemah (partikel-partikel yang mulai anti-sejajar dengan medan eksternal), dan setiap defleksi di antaranya, sesuai dengan setiap orientasi awal di antara kedua ekstrem tersebut.

Apa yang akan diprediksi mekanika kuantum?

Mungkin yang paling aneh dari semua kemungkinan adalah sebagai berikut: Bagaimana jika momentum sudut elektron terkuantisasi, tetapi juga proyeksinya pada suatu sumbu juga terkuantisasi? Kuantisasi momentum sudut sebagai besaran menarik, tetapi seseorang mungkin mencoba berargumen melaluinya menggunakan intuisi klasik, seperti orbit planet yang menetap dalam jalur tetap yang tidak saling berpotongan, dengan hanya momentum sudut tertentu yang diizinkan. Tetapi bagaimana jika vektor momentum sudut itu hanya bisa menunjuk tepat sepanjang $z$ atau tepat berlawanan dengan $z$, tetapi tidak memiliki komponen lain sepanjang $z$? Bagaimana jika kemudian ketika diukur sepanjang arah yang berbeda, vektor tersebut hanya bisa menunjuk sepenuhnya sepanjang $x$ atau sepenuhnya berlawanan dengan $x$, dan tidak ada yang di antaranya? Itu akan menjadi sesuatu yang aneh dengan cara yang mengacaukan semua intuisi klasik.

Cek pemahamanmu

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

Distribusi partikel seperti apa di layar yang kamu harapkan akan ditemukan dalam kasus terakhir ini, di mana proyeksi momentum sudut sepanjang arah medan terkuantisasi? Kamu bebas mempertimbangkan hanya partikel yang melewati tepat di tengah perangkat, atau menyertakan juga yang sedikit melenceng ke samping di mana gradiennya lebih lemah. Cukup jelaskan secara eksplisit.

Jawaban:

Partikel-partikel di pusat perangkat akan mengalami satu medan tak homogen tunggal dan semuanya akan diukur memiliki salah satu dari dua orientasi momen magnetik mereka. Jadi, mereka akan dibelokkan secara maksimal mengikuti gradien atau secara maksimal berlawanan gradien, dan tidak ada yang di antaranya. Tentu saja, di kedua sisi, di mana gradiennya lebih lemah, defleksinya akan lebih kecil. Pada posisi lateral yang sangat besar, mereka mungkin berada sepenuhnya di luar gradien, dan bisa saja ada hanya satu wilayah partikel yang tidak terdefleksi.

Bagaimana qubit akan membantu kita menguji ini?

Sebagian besar komputer kuantum menggunakan "qubit" — analog kuantum dari bit klasik. Lebih tepatnya, mereka dirancang sebagai sistem dua tingkat, analog dengan keadaan "on"/"off" dari bit klasik. Paradigma komputasi kuantum memang ada yang menggunakan sistem tiga tingkat (yang disebut "qutrit") atau sistem banyak tingkat (yang disebut "qudit"). Namun sebagian besar pekerjaan terkonsentrasi pada qubit. Secara khusus, komputer kuantum IBM® menggunakan apa yang disebut qubit transmon frekuensi tetap. Ini cukup berbeda dari momentum sudut orbital atau spin atom. Namun seperti spin elektron, qubit IBM® adalah sistem mekanika kuantum yang dapat berinteraksi dengan cahaya dan di mana pengukuran dapat dilakukan. Faktanya, seseorang sering menemukan analogi yang dibuat antara keadaan spin mekanika kuantum dan keadaan komputasi Qubit. Misalnya, seseorang sering melihat keadaan "spin-up" dikaitkan dengan keadaan komputasi 0, dan "spin-down" dikaitkan dengan keadaan komputasi 1:

$$|\uparrow\rangle \sim |0\rangle$$ $$|\downarrow \rangle \sim |1\rangle$$

Kita bisa menggunakan kesamaan-kesamaan ini untuk mengamati perilaku mekanika kuantum dalam komputer kuantum IBM yang meniru perilaku mekanika kuantum dari momentum sudut orbital atau spin dalam atom. Kita akan membuat pengamatan serupa menggunakan kombinasi linear dari keadaan-keadaan ini yang memungkinkan kita memperluas diskusi ke momentum sudut dalam arah mana pun.

Eksperimen pertama: Satu pengukuran

Dalam eksperimen pertama ini dan sepanjang modul ini, kita akan menggunakan kerangka kerja komputasi kuantum yang dikenal sebagai "pola Qiskit", yang membagi 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: Pasca-pemrosesan dan analisis klasik

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

Langkah 1: Petakan input klasik ke masalah kuantum

Di sini, input klasik adalah orientasi spin sebelum pengukuran dalam perangkat Stern-Gerlach. Jangan terlalu khawatir tentang sifat pasti dari keadaan kuantum sebelum pengukuran. Itu adalah subjek dari modul Qiskit Classrooms yang berbeda, tentang teorema Bell.

Perhatikan bahwa komputer kuantum IBM mengukur keadaan sepanjang sumbu $z$. Jadi eksperimen pertama ini akan sangat mirip dengan eksperimen Stern-Gerlach dengan gradien medan magnet sepanjang $z$. Kita akan melihat cara mengubah sistem untuk mengukur sepanjang arah yang berbeda, nanti.

Mari kita mulai dengan membuat analog dari keadaan spin, yaitu beberapa campuran $|\uparrow\rangle$ dan $|\downarrow\rangle$ atau secara ekuivalen dari $|0\rangle$ dan $|1\rangle$. Kita telah mengusulkan beberapa nilai awal. Tapi kamu bebas bermain dengan nilai lain atau bahkan nilai acak.

import random
from numpy import pi
import numpy as np

# Use these lines to choose your own arbitrary state vector and normalize it.
# a = 2
# b = (1+1j)
# norm = np.sqrt(a*np.conjugate(a)+b*np.conjugate(b))
# a = a/norm
# b = b/norm
# print(a,b)

# Use these lines if you would rather look at at random spin orientations.
a = random.random()
b = random.random()
norm = np.sqrt(a * np.conjugate(a) + b * np.conjugate(b))
a = a / norm
b = b / norm
print(a, b)

0.7032089086145691 0.7109832845047109

Sekarang kita akan menggunakan sudut-sudut di atas sebagai parameter dalam Circuit kuantum. Kita hanya mempertimbangkan satu partikel sekaligus, jadi kita hanya akan menggunakan satu Qubit dalam Circuit kita, dan kita hanya memerlukan satu register klasik.

from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit, Parameter

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

# Initialize the quantum state
qc.initialize([a, b])
qc.measure(0, 0)
qc.draw("mpl")

Langkah 2: Optimalkan masalah untuk eksekusi kuantum

Untuk menjalankan eksperimen kita pada komputer kuantum sungguhan, kita perlu memuat Qiskit Runtime Service, dan memilih komputer kuantum (atau "Backend"). Di bawah ini, kita cukup memilih komputer kuantum yang paling tidak sibuk yang tersedia bagi kita.

Ada kode di bawah ini untuk menyimpan kredensialmu saat pertama kali digunakan. Pastikan untuk menghapus informasi ini dari notebook setelah menyimpannya ke lingkunganmu, agar kredensialmu tidak dibagikan secara tidak sengaja saat kamu berbagi notebook. Lihat Siapkan akun IBM Cloud kamu dan Inisialisasi layanan di lingkungan yang tidak terpercaya untuk panduan lebih lanjut.

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

# Syntax for specifying a channel and instance (if you need to change from the default set above)
# service = QiskitRuntimeService(channel='<channel name here>', instance="<your instance name here>")

# Load saved credentials
service = QiskitRuntimeService()

# Load the Runtime primitive and session
from qiskit_ibm_runtime import Session, SamplerV2 as Sampler

# Use the least busy backend, specify options as needed
# backend = service.least_busy(operational=True, simulator=False, min_num_qubits = 127)
backend = service.least_busy()
print(backend.name)

ibm_sherbrooke

Kita sekarang harus men-transpile Circuit, artinya kita harus memetakan Circuit kita ke gate dasar yang tersedia pada komputer kuantum yang dipilih, dan kita ingin mengoptimalkan Circuit kita untuk dijalankan pada komputer kuantum tersebut.

# Transpile the circuit and optimize for running on the quantum computer selected
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
qc_ibm = pm.run(qc)

Langkah 3: Jalankan menggunakan Qiskit Runtime Primitives

Sekarang kita ingin menjalankan ini pada komputer kuantum sungguhan. Semua sintaks yang diperlukan untuk itu ada dalam blok kode di bawah ini. Jika kamu telah menghabiskan waktu yang dialokasikan pada komputer kuantum sungguhan, atau jika kamu tidak memiliki koneksi internet, kamu dapat menghapus komentar dari blok kode berikutnya, yang akan menjalankan kode pada simulator lokal.

# Specify that we want to use only a single shot, to represent a single measurement of a spin in a SG device.
num_shots = 1

# Evaluate the problem using a QPU via Qiskit IBM Runtime
# The best practice is to use a session as shown below. This is available to Premium Plan, Flex Plan, and On-Prem (IBM Quantum Platform API) Plan users.
with Session(backend=backend) as session:
    sampler = Sampler(mode=session)
    dist = sampler.run([qc_ibm], shots=num_shots).result()
session.close()
counts = dist[0].data.c.get_counts()

# Open users can still carry out this experiment, but without making use of a session, meaning repeated queuing is possible.
# from qiskit_ibm_runtime import Batch,
# batch = Batch(backend=backend)
# sampler = Sampler(mode=batch)
# dist = sampler.run([qc_ibm], shots=num_shots).result()
# Close the batch because no context manager was used.
# batch.close()
# counts = dist[0].data.c.get_counts()

Gunakan kode di bawah ini jika kamu tidak dapat menjalankan eksperimen pada komputer kuantum sungguhan.

# This uses a local simulator
# from qiskit_aer import AerSimulator

# This generates a simulator that mimics the real quantum system
# backend_sim = AerSimulator.from_backend(backend)

# Import an estimator, this time from qiskit (we import from Runtime for real hardware)
# from qiskit.primitives import BackendSamplerV2
# sampler = BackendSamplerV2(backend = backend_sim)

# num_shots = 1

# This runs the job
# dist = sampler.run([qc_ibm], shots = num_shots).result()

# This selects measurement counts for the 0th circuit, which in this case is the only circuit
# counts=dist[0].data.c.get_counts()

Langkah 4: Pasca-pemrosesan dan analisis klasik

Untuk eksperimen yang sangat sederhana ini, analisis klasik hanya terdiri dari visualisasi hasil eksperimen.

from qiskit.visualization import plot_histogram

print("counts = ", counts)
plot_histogram(counts)

counts =  {'0': 1}

Kita membuat satu pengukuran dan mendapatkan "0". Ini tidak mengejutkan bagi kita. Kita tahu kita menggunakan komputer kuantum yang terdiri dari qubit dan kita sangat terbiasa dengan bit klasik yang mengembalikan 0 atau 1. Namun ingat: ini adalah analog komputasi kuantum dari eksperimen yang dilakukan dengan partikel-partikel yang memiliki momen magnetik. Jika kita mengharapkan sebaran merata antara 0 dan +1, mungkin memang mengejutkan kita bahwa kita mendapatkan salah satu ekstrem pada pengukuran pertama kita. Inilah kuantisasi hasil yang mengejutkan dalam eksperimen Stern-Gerlach yang membawa kita pada pemahaman alam yang lebih baik, dan yang pada gilirannya membantu kita akhirnya membangun komputer kuantum.

Mari kita lihat apa yang terjadi ketika kita membuat sekumpulan pengukuran.

Eksperimen kedua: Mengukur banyak partikel

Untuk mengumpulkan statistik dari banyak pengukuran seperti itu, kita tidak perlu mengulangi langkah 1 & 2. Kita cukup meningkatkan jumlah shot dalam eksperimen kita. Kamu bebas bermain dengan jumlah shot dalam contoh langkah 3 di bawah ini.

from qiskit_ibm_runtime import Session, SamplerV2 as Sampler

num_shots = 100

# Evaluate the problem using a QPU via Qiskit IBM Runtime
# The best practice is to use a session as shown below. This is available to Premium Plan, Flex Plan, and On-Prem (IBM Quantum Platform API) Plan users.
with Session(backend=backend) as session:
    sampler = Sampler(mode=session)
    dist = sampler.run([qc_ibm], shots=num_shots).result()
session.close()
counts = dist[0].data.c.get_counts()

# Open users can still carry out this experiment, but without making use of a session, meaning repeated queuing is possible.
# batch = Batch(backend=backend)
# sampler = Sampler(mode=batch)
# dist = sampler.run([qc_ibm], shots=num_shots).result()
# Close the batch because no context manager was used.
# batch.close()
# counts = dist[0].data.c.get_counts()

Seperti sebelumnya, jika kamu tidak dapat menjalankan pada komputer kuantum sungguhan, hapus komentar dari blok di atas dari eksperimen pertama, dan cukup ubah num_shots = 1 menjadi num_shots = 100 atau lebih.

plot_histogram(counts)

Kita melihat bahwa kita terkadang mengukur 0 dan terkadang mengukur 1. Perhatikan bahwa kita tidak pernah mengukur hal lain! Kamu bisa mengubah jumlah shot, dan memperhatikan bahwa probabilitas pengukuran 0 atau 1 tampaknya cukup konsisten antara berbagai run dengan jumlah shot yang berbeda. Jadi, sesuatu tentang persiapan keadaan tampaknya menentukan probabilitas hasil pengukuran, meskipun setiap satu pengukuran dapat menghasilkan 0 atau 1.

Eksperimen ketiga: Spin acak dalam oven

Dalam eksperimen Stern-Gerlach, para peneliti tidak dapat menentukan sudut di mana vektor momentum sudut akan keluar dari oven. Orientasinya acak (atau sesuatu yang bahkan lebih misterius! Lihat modul Qiskit Classroom tentang teorema Bell). Analog yang masuk akal dari eksperimen itu adalah kita secara acak menginisialisasi keadaan Qubit kita dan melakukan banyak pengukuran.

Langkah 1: Petakan input klasik ke masalah kuantum

Circuit yang ingin kita buat adalah sama seperti sebelumnya. Satu-satunya perbedaan adalah bahwa kali ini, kita akan membangun Circuit menggunakan gate dengan parameter bebas $\theta$ dan $\phi$. Nilai numerik untuk parameter-parameter tersebut kemudian akan ditetapkan untuk setiap run baru.

# from qiskit.circuit import QuantumCircuit, Parameter

theta = Parameter("θ")
phi = Parameter("$\phi$")

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

# Add rotation gates for rotating the state of qubit 0 to random orientations
qc.rx(theta, 0)
qc.rz(phi, 0)
qc.measure(0, 0)

qc.draw("mpl")

Menjalankan Circuit kuantum hanya untuk satu shot dan melakukannya untuk banyak konfigurasi acak adalah alur kerja yang tidak biasa untuk komputer kuantum. Ini tentu bisa dilakukan, tetapi demi kesederhanaan, kita akan menggunakan simulator lokal di sini.

# This uses a local simulator
from qiskit_aer import AerSimulator

# Import an estimator, this time from qiskit (we import from Runtime for real hardware)
from qiskit.primitives import BackendSamplerV2

# This generates a simulator that mimics the real quantum system
backend_sim = AerSimulator.from_backend(backend)
sampler_sim = BackendSamplerV2(backend=backend_sim)

# from qiskit.primitives import BackendSamplerV2
# sampler = BackendSamplerV2(backend=backend)

# A list to store the accumulated probabilities of the two possible measurement outcomes.
probslist = {"0": 0.0, "1": 0.0}

# Choose how many "particles"/measurements
measurements = 100
num_shots = 1

for i in range(measurements):
    # Assign a random orientation for each measurement
    phi = random.random() * 2 * pi
    theta = random.random() * 2 * pi

    angles = [phi, theta]
    circuit = qc.assign_parameters(angles)
    qc_ibm = pm.run(circuit)

    # Run the circuit
    # job = sampler.run([circuit],num_shots = 1)
    dist = sampler_sim.run([qc_ibm], shots=num_shots).result()

    # Update the list of probabilities
    zeroterm = dist[0].data.c.get_counts().get("0") or 0
    oneterm = dist[0].data.c.get_counts().get("1") or 0
    probslist.update({"0": probslist.get("0") + zeroterm})
    probslist.update({"1": probslist.get("1") + oneterm})

probslist.update({"0": probslist.get("0") / measurements})
probslist.update({"1": probslist.get("1") / measurements})
# print(probslist)

plot_histogram(probslist)

Jadi kita melihat bahwa keadaan awal acak dari qubit (yang sesuai dengan orientasi acak momentum sudut dalam eksperimen Stern-Gerlach) menghasilkan jumlah keadaan 0 dan 1 yang serupa (seperti jumlah keadaan spin atas dan spin bawah yang serupa). Inilah tepatnya yang ditunjukkan oleh eksperimen Stern-Gerlach asli.

Eksperimen keempat: Pengukuran berulang

Ketika sebuah qubit dimulai dalam keadaan acak, kita melihat ada peluang sekitar 50-50 untuk mengukur satu nilai ekstrem dibanding yang lain. Tapi apa yang terjadi pada keadaan qubit (atau momentum sudut partikel) setelah pengukuran? Untuk menjawabnya, kita perlu mendefinisikan sebuah Circuit yang memungkinkan kita melakukan beberapa pengukuran pada qubit yang sama. Mari kita definisikan sebuah Circuit yang bisa kita gunakan untuk menyelidiki ini. Kita ingin memungkinkan kemungkinan mengukur kedua keadaan $|0\rangle$ dan $|1\rangle$, jadi kita butuh sesuatu untuk memutar keadaan awal qubit dari keadaan default $|0\rangle$. Dalam hal ini, kita akan menggunakan hadamard Gate $H$, karena $H|0\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. Perhatikan bahwa, secara default, kedua pengukuran ini akan dilakukan sepanjang $z$.

from qiskit import QuantumCircuit

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

# Initialize the qubit to be a mixture of 0 and 1 states.
qc.h(0)

# Add a first measurement
qc.measure(0, 0)
qc.barrier()

# Add a second measurement
qc.measure(0, 1)

qc.draw("mpl")

qc_ibm = pm.run(qc)

# Step 3: Run the job

num_shots = 1000
dist = sampler.run([qc_ibm], shots=num_shots).result()
# To run on a simulator, uncomment the line below and comment out the line above.
# dist = sampler_sim.run([qc_ibm], shots=num_shots).result()
counts = dist[0].data.c.get_counts()
print(counts)

{'00': 497, '11': 498, '01': 3, '10': 2}

# Step 4: Post-process
plot_histogram(counts)

Pada gambar di atas, bin-bin diberi label "00", "01" dan seterusnya. Di sini, angka-angka ini mengacu pada "hasil ke-2, hasil ke-1". Jadi "00" berarti kedua pengukuran menghasilkan keadaan $|0\rangle$, dan "01" berarti pengukuran pertama menghasilkan $|1\rangle$, dan pengukuran kedua menghasilkan $|0\rangle$. Sebagian besar qubit diukur dalam keadaan $|0\rangle$ dua kali, atau diukur dalam keadaan $|1\rangle$ dua kali. Sangat jarang qubit diukur dalam satu keadaan lalu diukur dalam keadaan lain, dan beberapa kasus di mana itu terjadi (~1%) disebabkan oleh noise. Dalam hal ini, noise tersebut telah disimulasikan sesuai perilaku sistem kuantum nyata. Korelasi yang diamati antara pengukuran-pengukuran berturutan ini juga diamati dalam pengukuran tipe Stern-Gerlach pada partikel dengan momentum sudut spin. Jika sebuah partikel diukur sebagai "spin-up", pengukuran berikutnya segera setelah itu akan sekali lagi menghasilkan "spin-up" (dengan sedikit variasi akibat noise).

Ini mungkin terlihat sepele. Bagaimanapun, jika sebuah qubit diukur dalam satu keadaan, dan kemudian saya mengukurnya lagi, dengan cepat, mengapa tidak akan tetap dalam keadaan itu? Tapi jika kita benar-benar memperhatikan kehalusan ini, itu mungkin membantu kita memilih alat matematika untuk mendeskripsikan fenomena ini.

Analisis eksperimen sejauh ini

Mari kita kumpulkan beberapa pengamatan dari eksperimen kita sejauh ini:

• Pengukuran sistem mekanika kuantum hanya akan menghasilkan salah satu dari sekumpulan "nilai yang diizinkan". Untuk sistem dua-tingkat seperti qubit atau partikel spin-1/2, sebuah pengukuran hanya akan menghasilkan salah satu dari dua hasil biner.
• Ketika kita menginisialisasi keadaan sistem biner kita secara acak (seperti partikel spin-1/2 yang keluar dari tungku), salah satu dari dua hasil pengukuran biner mungkin terjadi.
• Setelah sebuah pengukuran dibuat dan keadaan sistem diketahui, mengulangi pengukuran observabel fisik yang sama tidak mengubah keadaan! Artinya, jika kita mendapatkan keadaan 0 sekali, saat kita mengukur lagi masih dalam keadaan 0 (dengan sedikit noise dalam sistem ~0,1% hingga 1%).

Perhatikan secara eksplisit bahwa kita belum membahas sifat probabilistik mekanika kuantum, juga belum mengatakan apa pun tentang "runtuhnya" keadaan menjadi eigenstate. Hanya menggunakan pengamatan di atas, mungkin ada godaan untuk mencari operasi matematika $O$ yang membiarkan beberapa keadaan mekanika kuantum khusus $|\psi\rangle$ tidak berubah hingga mungkin sebuah konstanta: $O|\psi\rangle = c|\psi \rangle$, karena mengukur sepanjang $z$ dua kali menghasilkan hasil yang sama. Pada akhirnya, pencarian itu akan gagal mendeskripsikan semua perilaku yang akan kita lihat. Tapi itu bisa mendeskripsikan beberapa hal, jadi kita akan mengejarnya sedikit lebih lama.

Memang ada operasi seperti itu. Operasi matriks pada beberapa vektor mengubah vektor-vektor tersebut, dan operasi matriks pada vektor-vektor lain (eigenvector) membiarkan vektor tidak berubah hingga sebuah konstanta. Ambil contoh matriks $M$ dan vektor $|v\rangle$ di mana

$$M= \begin{pmatrix} 1 & 2 \\ 2 & 1\end{pmatrix}$$

dan

$$|v\rangle = \begin{pmatrix} 1\\1 \end{pmatrix}$$

Perhatikan bahwa

$$M|v\rangle= \begin{pmatrix} 1 & 2 \\ 2 & 1\end{pmatrix}\begin{pmatrix} 1\\1 \end{pmatrix} = \begin{pmatrix} 1*1+2*1\\2*1+1*1 \end{pmatrix} = \begin{pmatrix} 3\\3 \end{pmatrix} = 3|v\rangle.$$

Tapi untuk vektor lain, katakanlah $|v'\rangle = \begin{pmatrix} 1\\2\end{pmatrix}$, kita punya

$$M|v'\rangle= \begin{pmatrix} 1 & 2 \\ 2 & 1\end{pmatrix}\begin{pmatrix} 1\\2 \end{pmatrix} = \begin{pmatrix} 1*1+2*2\\2*1+1*2 \end{pmatrix} = \begin{pmatrix} 5\\4 \end{pmatrix} \neq c|v'\rangle.$$

Kita mungkin mencoba mendeskripsikan spin partikel menggunakan sebuah matriks, dan kita mungkin mencoba mendeskripsikan keadaan partikel setelah pengukuran menggunakan sebuah vektor, yang disebut "vektor keadaan". Sama sekali tidak jelas nilai-nilai apa yang harus masuk ke dalam matriks atau vektor keadaan seperti itu, tapi satu-satunya properti yang kita miliki dari pengukuran sejauh ini yang bisa kita gunakan untuk melabeli keadaan adalah probabilitas mengukur 0 atau 1 ("spin-up" atau "spin-down" dalam konteks partikel spin-1/2). Kita harus mempertimbangkan bahwa entri dalam vektor keadaan harus berkaitan dengan probabilitas ini (tepatnya probabilitas, "amplitudo probabilitas" - artinya kita mengkuadratkan entri untuk mendapatkan probabilitas, dan seterusnya). Tapi pada titik ini, kita tidak yakin apakah entri dalam matriks-matriks ini harus benar-benar real, kompleks, atau apa. Untuk amannya, mari kita coba mengembangkan kerangka di mana vektor-vektor dan matriks-matriks memenuhi hal berikut:

• Operator matriks terhubung ke eksperimen sebanyak mungkin. Misalnya, kita bisa mengasosiasikan eigenvalue dari matriks spin dengan proyeksi spin yang diamati secara eksperimental.
• Vektor keadaan harus dihubungkan ke probabilitas dengan cara berikut: Jika sebuah partikel dalam vektor keadaan $|A\rangle$, probabilitas bahwa pengukuran berikutnya akan menemukan partikel dalam keadaan $|B\rangle$ adalah $P_{AB}\equiv |\langle A| B \rangle|^2$.

Ini memberi kita banyak kebebasan dalam mengembangkan matriks-matriks pertama kita. Misalnya, kita bisa secara naif mencoba

$$|0\rangle \sim |\uparrow\rangle \sim \begin{pmatrix} 1 \\0 \end{pmatrix}.$$

Di sini $|0\rangle \sim |\uparrow\rangle$ berarti ada keadaan dalam komputer kuantum dan dalam sistem spin-1/2 yang sangat mirip dan sering dipetakan satu sama lain. Mereka jelas tidak persis sama, karena mereka mengacu pada sistem yang berbeda. Tapi aljabar yang mendeskripsikan sistem dua-keadaan ini bisa sesuai dengan aturan yang sama (spoiler: mereka memang sesuai!). Perhatikan bahwa pilihan acak ini sudah memiliki satu atribut yang bagus. Perhatikan bahwa

$$P_{00} = |\langle 0| 0 \rangle|^2 = \vert \begin{pmatrix} 1 & 0\end{pmatrix} \begin{pmatrix} 1 \\ 0\end{pmatrix}\vert ^2 = |1|^2 = 1.$$

Artinya, jika sebuah partikel sudah dalam keadaan $|0\rangle$, probabilitas bahwa pengukuran berikutnya juga akan menghasilkan $|0\rangle$ adalah 1 (kecuali efek dari noise). Ini sangat bagus, karena kita sudah melihat bahwa sekali keadaan dalam keadaan 0 atau "spin-up", keadaan itu tetap di sana saat pengukuran berikutnya. Probabilitas di atas memang harus 100%.

Uji pemahamanmu

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

Mengapa

$$|0\rangle = \begin{pmatrix} 1 \\0 \end{pmatrix}$$

adalah pilihan yang lebih baik daripada, katakanlah,

$$|0\rangle = \begin{pmatrix} 2 \\0 \end{pmatrix}?$$

Jawaban:

Upaya kita untuk mengasosiasikan probabilitas pengukuran dengan kuadrat perkalian dalam berarti kita perlu besaran setiap vektor menjadi 1. Artinya, $|\langle v|v\rangle|^2 = 1$ untuk semua $|v\rangle$, karena probabilitas suatu benda dalam keadaan $|v\rangle$ berada dalam keadaan $|v\rangle$ adalah 100%. Ini dikenal sebagai "kondisi normalisasi".

Mengapa

$$|0\rangle = \begin{pmatrix} 1 \\0 \end{pmatrix}$$

adalah pilihan yang lebih baik daripada, katakanlah,

$$|0\rangle = \begin{pmatrix} 0 \\1 \end{pmatrix}?$$

Jawaban:

Tidak ada alasannya. Tidak ada alasan mengapa kita perlu awalnya memilih $|0\rangle = \begin{pmatrix} 1 \\0 \end{pmatrix}$. Sebaliknya, ini adalah sebuah konvensi. Namun, setelah kita membuat pilihan itu, pilihan tersebut memang memberikan kendala tertentu pada pilihan-pilihan berikutnya. Lihat di bawah.

Ingat bahwa dalam eksperimen di atas, kita menemukan bahwa qubit yang awalnya dalam keadaan $|0\rangle$ tetap dalam keadaan itu saat pengukuran berikutnya. Hal yang sama berlaku untuk $|1\rangle$. Ini berarti qubit yang ada dalam $|0\rangle$ memiliki probabilitas nol untuk diukur dalam keadaan $|1\rangle$ (kecuali efek noise). Koneksi yang kita butuhkan antara perkalian dalam dan probabilitas pengukuran kemudian memberi tahu kita bahwa

$$P_{01} = P_{10}=0.$$

Tanpa mengurangi keumuman, kita bisa menulis vektor keadaan $|1\rangle = \begin{pmatrix} a \\ b \end{pmatrix}$. Kemudian kita bisa menulis

$$P_{01} = |\langle 0| 1 \rangle|^2 = \vert \begin{pmatrix} 1 & 0\end{pmatrix} \begin{pmatrix} a \\ b\end{pmatrix}\vert ^2 = |a|^2 = 0.$$

Persyaratan bahwa $P_{11} = 1$, yang disebut "kondisi normalisasi" memberi tahu kita bahwa $|b|^2=1$. Ini sendiri sebenarnya hanya membatasi kita pada $b=e^{i\phi}$ untuk $\phi \in \mathbb{R}$. Ternyata ada alasan lain untuk memilih $b=1$ yang berada di luar pengantar topik ini. Untuk sekarang, cukuplah bahwa $b=1$ adalah satu solusi yang dapat diterima.

Kita sudah cukup jauh dalam analisis kita. Memilih bentuk untuk vektor keadaan kita memungkinkan kita membangun sebuah matriks yang mendeskripsikan sesuatu tentang fenomena fisika yang terjadi di sini. Secara khusus, karena eksperimen Stern-Gerlach asli mengukur pemisahan lintasan berdasarkan komponen momentum sudut spin sepanjang sumbu $z$, kita ingin sebuah operator yang mendeskripsikan tepatnya itu: $S_z$. Koneksi penting lainnya ke eksperimen adalah bahwa dari jumlah defleksi, waktu perjalanan, dan kekuatan medan magnet yang diketahui, kita dapat menentukan besaran komponen $z$ dari spin. Meskipun ini membutuhkan banyak asumsi tentang presisi pengaturan eksperimen, di sini kita hanya akan menegaskan kembali bahwa komponen $z$ dari momentum sudut spin yang diukur adalah $\pm \hbar/2$.

Kemudian kita mencari matriks dengan eigenvalue real (dipenuhi oleh matriks Hermitian) dengan eigenvalue yang sesuai dengan komponen spin yang diamati secara eksperimental ini. Tanpa mengurangi keumuman, kita bisa menulis $S_z = \begin{pmatrix} s_{11} & s_{12} \\ s_{21} & s_{22}\end{pmatrix}$, dan kita bisa meminta:

$$S_z |\uparrow\rangle = \begin{pmatrix} s_{11} & s_{12} \\ s_{21} & s_{22}\end{pmatrix}\begin{pmatrix}1 \\0\end{pmatrix} = \begin{pmatrix} s_{11} \\ s_{21} \end{pmatrix} \overset{!}{=} \frac{\hbar}{2} \begin{pmatrix}1 \\0\end{pmatrix} \rightarrow s_{11} = \hbar/2,s_{21}=0$$ $$S_z |\downarrow\rangle = \begin{pmatrix} s_{11} & s_{12} \\ s_{21} & s_{22}\end{pmatrix}\begin{pmatrix}0 \\1\end{pmatrix} = \begin{pmatrix} s_{12} \\ s_{22} \end{pmatrix} \overset{!}{=} -\frac{\hbar}{2} \begin{pmatrix}0 \\1\end{pmatrix} \rightarrow s_{12} = 0, s_{22}=-\hbar/2$$

Menggabungkan, dan menarik faktor keseluruhan $\hbar/2$, kita mendapatkan

$$S_z = \frac{\hbar}{2} \begin{pmatrix} 1 & 0 \\ 0 & -1\end{pmatrix}.$$

Ini adalah operator spin-z yang terkenal yang ditemukan di semua buku teks mekanika kuantum. Sering kali kita melihat ini tanpa $\hbar/2$, dalam hal ini disebut operator "Pauli-z", biasanya dilambangkan $\sigma_z$:

$$\sigma_z = \begin{pmatrix} 1 & 0 \\ 0 & -1\end{pmatrix}.$$

Ini berguna, karena operator Pauli ini (dan matriks terkait) dapat mendeskripsikan banyak sistem fisik yang melibatkan dua tingkat atau dua hasil pengukuran yang mungkin, termasuk keadaan qubit transmon dalam komputer kuantum.

Sebelum kita beralih ke operator dan keadaan lain yang terkait dengan ini, kita harus membahas satu fakta yang banyak orang salah mengerti. Aksi operator tidak sama dengan pengukuran. Dalam satu arti, kamu mungkin berkata, "Tentu saja tidak! Satu terjadi di atas kertas sebagai bagian dari perhitungan matematika, dan yang lain terjadi di laboratorium pada sistem fisik." Ya, itu benar, tapi ada lebih dari itu. Melakukan pengukuran komponen $z$ dari spin akan selalu menghasilkan keadaan "spin-up" atau "spin-down", terlepas dari keadaan awal sistem. Kita melihat ini dengan analog komputasi kuantum $|0\rangle$ dan $|1\rangle$. Kita menginisialisasi keadaan dalam ratusan orientasi acak, dan pengukuran selalu menghasilkan $|0\rangle$ atau $|1\rangle$. Ini dikenal sebagai pengukuran yang "meruntuhkan keadaan" menjadi eigenstate. Ini tidak terjadi ketika kamu menerapkan sebuah matriks ke sebuah keadaan. Coba pertanyaan-pertanyaan di bawah untuk mengeksplorasi ini.

Uji pemahamanmu

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

Misalkan kamu memulai dengan sebuah partikel dalam keadaan spin

$$|\psi\rangle = \begin{pmatrix}\sqrt{3/5} \\ \sqrt{2/5}\end{pmatrix}.$$

(a) Apa yang kamu dapatkan jika kamu menerapkan operator $S_z$ pada vektor keadaan ini? (b) Apa yang kamu peroleh jika kamu melakukan satu pengukuran komponen $z$ dari spin partikel ini? (c) Apa yang kamu dapatkan jika kamu menyiapkan banyak partikel identik dengan keadaan ini dan melakukan ribuan pengukuran komponen $z$ dari spin?

Jawaban:

(a) Kamu mendapatkan

$$S_z |\psi\rangle = \frac{\hbar}{2} \begin{pmatrix} 1 & 0 \\ 0 & -1\end{pmatrix} \begin{pmatrix}\sqrt{3/5} \\ \sqrt{2/5}\end{pmatrix}$$$$= \frac{\hbar}{2} \begin{pmatrix}\sqrt{3/5} \\ -\sqrt{2/5}\end{pmatrix}.$$

Hanya itu. Tidak ada hasil eksperimental. Kamu hanya menerapkan matriks ke vektor dan kamu mendapatkan vektor yang sedikit berbeda yang sekarang memiliki tanda "-" baru, dan tidak lagi memiliki besaran 1, karena memiliki prefaktor $\hbar/2$.

(b) Kamu akan mendapatkan $|\uparrow\rangle$ atau $|\downarrow\rangle$. Ini sesuai dengan mengamati proyeksi spin pada sumbu $z$ sebesar $\hbar/2$ atau $-\hbar/2$, masing-masing. Kita juga dapat menentukan probabilitas setiap hasil, karena

$$P_{\uparrow\psi}=|\langle \uparrow|\psi\rangle|^2 = \vert \begin{pmatrix}1 & 0\end{pmatrix} \begin{pmatrix}\sqrt{3/5} \\ \sqrt{2/5}\end{pmatrix}\vert^2 = |\sqrt{3/5}|^2 = \frac{3}{5}$$$$P_{\downarrow\psi}=|\langle \downarrow|\psi\rangle|^2 = \vert \begin{pmatrix}0 & 1\end{pmatrix} \begin{pmatrix}\sqrt{3/5} \\ \sqrt{2/5}\end{pmatrix}\vert^2 = |\sqrt{2/5}|^2 = \frac{2}{5}$$

Jadi meskipun keadaan spin-up 20% lebih mungkin, salah satu hasil dimungkinkan, dan kita hanya akan mendapatkan salah satu dari dua keadaan ini.

(c) Sekitar 60% dari pengukuran akan menghasilkan partikel spin-up, dan sekitar 40% dari pengukuran akan menghasilkan partikel spin-down, sesuai dengan probabilitas pengukuran yang dihitung pada bagian (b).

Verifikasi jawaban untuk bagian (b) dan (c) dari pertanyaan sebelumnya dengan menggunakan analogi antara keadaan spin-up atom dan keadaan qubit:

$$|\uparrow\rangle\sim|0\rangle.$$

Buat kode Circuit kuantum untuk membuat keadaan awal yang diinginkan, lalu gunakan hardware nyata atau simulator untuk memeriksa hasil dari satu pengukuran, dan dari ensemble ratusan atau bahkan ribuan pengukuran.

Jawaban:

#Use the backend sampler for part (b) because it allows us to use a single shot.
from qiskit_aer import AerSimulator
backend_sim = AerSimulator.from_backend(backend)
from qiskit.primitives import BackendSampler
sampler = BackendSampler(backend = backend_sim)

#Create a quantum circuit to initialize the state.
import math
psi = [math.sqrt(3/5),math.sqrt(2/5)]
qc = QuantumCircuit(1,1)
qc.initialize(psi, [0])

#Add measurement to the circuit
qc.measure(0,0)
qc.draw('mpl')

#Set num_shots =1 for part (b) and num_shots = 1000 or more for part (c).
num_shots = 1000

#Run the job and print the result. You should obtain only 0 or 1 in part (b) for a single shot.
#You should obtain a probability distribution with approximately 60% 0 and 40% 1 in part (c)

dist = sampler.run([qc_ibm], shots = num_shots).result()
counts=dist[0].data.c.get_counts()
print(counts)

#You should obtain {0: 599, 1: 401} or something equivalently close to the 60%-40% distribution predicted.

Eksperimen kelima: Mengukur observabel berbeda

Sejauh ini kita hanya melakukan pengukuran sepanjang sumbu z. Dalam eksperimen Stern-Gerlach, jika kita ingin mengukur sepanjang, katakanlah, sumbu x, kita cukup mengarahkan medan magnet tidak homogen untuk menunjuk sepanjang sumbu $x$, dan mencari defleksi sepanjang $x$ di layar. Komputer kuantum IBM, bagaimanapun, dirancang untuk melakukan pengukuran hanya sepanjang satu sumbu ($z$). Untuk mengukur keadaan sepanjang $x$ kita harus melakukan "perubahan basis". Ini berarti kita harus melakukan operasi yang membawa keadaan sepanjang $x$ di bola Bloch ke $z$, dan sebaliknya. Ada beberapa cara mengimplementasikan ini, tapi cara yang lebih disukai adalah Hadamard Gate:

$$H=\frac{1}{\sqrt{2}}\begin{pmatrix}1 & 1 \\ 1 & -1\end{pmatrix}$$

Uji pemahamanmu

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

Tunjukkan bahwa $H|0\rangle = |+\rangle_x$ dan bahwa $H|+\rangle_x = |0\rangle$

Jawaban:

$$H|0\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix}1 & 1 \\ 1 & -1\end{pmatrix}\begin{pmatrix}1 \\ 0\end{pmatrix} = \frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ 1\end{pmatrix} = |+\rangle_x$$$$H|+\rangle_x = \frac{1}{\sqrt(2)}\begin{pmatrix}1 & 1 \\ 1 & -1\end{pmatrix}\frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ 1\end{pmatrix} = \frac{1}{2}\begin{pmatrix}2 \\ 0\end{pmatrix} = \begin{pmatrix}1 \\ 0\end{pmatrix} = |0\rangle$$

Tunjukkan bahwa $H|1\rangle = |-\rangle_x$ dan bahwa $H|-\rangle_x = |1\rangle$

Jawaban:

$$H|1\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix}1 & 1 \\ 1 & -1\end{pmatrix}\begin{pmatrix}0 \\ 1\end{pmatrix} = \frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ -1\end{pmatrix} = |-\rangle_x$$$$H|-\rangle_x = \frac{1}{\sqrt(2)}\begin{pmatrix}1 & 1 \\ 1 & -1\end{pmatrix}\frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ -1\end{pmatrix} = \frac{1}{2}\begin{pmatrix}0 \\ 2\end{pmatrix} = \begin{pmatrix}0 \\ 1\end{pmatrix} = |1\rangle$$

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

# Add a hadamard gate to rotate into the x-basis
qc.h(0)
qc.measure(0, 0)

qc.draw("mpl")

Circuit ini memutar sistem kita sehingga pengukuran (sepanjang $z$) memberi tahu kita tentang karakteristik $x$ sebelum rotasi. Kita sudah tahu bahwa komputer kuantum menginisialisasi keadaan ke $|0\rangle$ yang sesuai dengan $|\uparrow\rangle$. Mari kita lihat apa yang terjadi ketika kita mengukur proyeksi spin sepanjang $x$ untuk keadaan yang awalnya dalam $|\uparrow\rangle$. Kita menunjukkan langkah ini pada simulator untuk mendorongmu mengeksplorasi statistik Circuit lain dengan inisialisasi berbeda.

from qiskit.primitives import StatevectorSampler as Sampler

sampler_sv = Sampler()

job = sampler_sv.run([qc], shots=10000)
print(job.result()[0].data.c.get_counts())

{'1': 4977, '0': 5023}

Ini menunjukkan kepada kita bahwa untuk qubit yang awalnya dalam $|0\rangle$ (atau setara, spin dalam $|\uparrow\rangle$) probabilitas mengukur proyeksi sepanjang $+x$ atau $-x$ adalah sekitar 50-50. Dalam beberapa hal, ini masuk akal. Bagaimanapun, jika sesuatu menunjuk sepanjang arah z, tidak akan ada preferensi khusus untuk $\pm x$. Kita mungkin berharap hal yang sama berlaku, jika kita memulai dengan keadaan $|1\rangle$ (atau $|\downarrow\rangle$). Mari kita periksa:

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

# Add a NOT gate and hadamard gate. Measure.
qc.x(0)
qc.h(0)
qc.measure(0, 0)

qc.draw("mpl")

job = sampler_sv.run([qc], shots=10000)
print(job.result()[0].data.c.get_counts())

{'0': 4935, '1': 5065}

Ya! Sekali lagi, kita menemukan probabilitas 50-50 untuk mengukur proyeksi sepanjang $\pm x$. Dengan analogi pengukuran sepanjang $z$, kita mungkin lebih jauh menduga bahwa partikel yang runtuh ke keadaan pasti sepanjang $+x$ mungkin memiliki probabilitas nol untuk kemudian diukur sepanjang $-x$. Mari kita periksa:

from qiskit import QuantumCircuit

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

# Rotate into x-basis using a Hadamard gate, then make two measurements in succession
qc.h(0)
qc.measure(0, 0)
qc.barrier()
qc.measure(0, 1)

qc.draw("mpl")

job = sampler_sv.run([qc])
print(job.result()[0].data.c.get_counts())
plot_histogram(job.result()[0].data.c.get_counts())

{'00': 504, '11': 520}

Seperti yang diharapkan, kita mendapatkan hasil di mana proyeksi sepanjang $+x$, dan kemudian sekali lagi sepanjang $+x$, dan kita mendapatkan hasil di mana proyeksi awalnya sepanjang $-x$ dan kemudian sekali lagi sepanjang $-x$. Kita tidak melihat kasus di mana proyeksi beralih dari $+x$ ke $-x$ atau sebaliknya. Kita bisa mengumpulkan pengamatan kita dan menggunakannya untuk mengembangkan operator lebih lanjut dalam bentuk matriks, dan vektor keadaan lebih lanjut.

Kita tahu:

• Keadaan dengan proyeksi pasti sepanjang $+z$ atau $-z$ memiliki peluang 50% untuk ditemukan memiliki proyeksi sepanjang $+x$ dan 50% kemungkinan memiliki proyeksi sepanjang $-x$.
• Keadaan dengan proyeksi pasti sepanjang $+x$ memiliki kemungkinan nol untuk kemudian ditemukan memiliki proyeksi sepanjang $-x$, dan sebaliknya.

Kita bisa menggunakan hasil ini untuk membangun keadaan dengan proyeksi pasti dan positif sepanjang $x$ (yang kita sebut $|+x\rangle$), dan yang memiliki proyeksi pasti dan negatif sepanjang $x$ (yang kita sebut $|-x\rangle$). Dari keadaan-keadaan tersebut, kita dapat membangun matriks yang sesuai dengan $S_x$, persis seperti yang kita lakukan untuk $S_z$. Kita tinggalkan ini sebagai latihan untuk pelajar. Demikian pula, orang bisa membangun eksperimen yang melakukan pengukuran sepanjang sumbu $y$, menentukan vektor untuk $|+y\rangle$ dan $|-y\rangle$, dan akhirnya mendapatkan ekspresi untuk $S_y$.

Mengumpulkan semua vektor dan matriks ini bersama-sama, kita mendapatkan

$$\begin{aligned} |+x\rangle &= \frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ 1\end{pmatrix} & \: & |-x\rangle &=& \frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ -1\end{pmatrix} & \: &S_x &=& \frac{\hbar}{2} \begin{pmatrix} 0 & 1 \\ 1 & 0\end{pmatrix}\\ |+y\rangle &= \frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ i\end{pmatrix} & \: & |-y\rangle &=& \frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ -i\end{pmatrix} & \: &S_y &=& \frac{\hbar}{2} \begin{pmatrix} 0 & -i \\ i & 0\end{pmatrix}\\ |+z\rangle &= \begin{pmatrix}1 \\ 0\end{pmatrix} & \: &|-z\rangle &=& \begin{pmatrix}0 \\ 1\end{pmatrix} & \: &S_z &=& \frac{\hbar}{2} \begin{pmatrix} 1 & 0 \\ 0 & 1\end{pmatrix}\\ \end{aligned}$$

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 penting:

• Untuk partikel spin-1/2, pengukuran proyeksi spin pada suatu sumbu hanya dapat menghasilkan salah satu dari dua hasil, sering disebut "up" dan "down".
• Qubit hanya bisa diukur dalam salah satu dari dua keadaan, sering disebut sebagai $|0\rangle$ dan $|1\rangle$.
• Kita bisa memodelkan eksperimen Stern-Gerlach pada partikel spin-1/2 menggunakan qubit dalam komputer kuantum.
• Pengukuran berulang dari observabel fisik yang sama pada partikel/qubit yang sama akan menghasilkan hasil yang sama (kecuali sistem terganggu oleh noise).
• Kita bisa menggunakan hasil dari eksperimen Stern-Gerlach atau dari eksperimen analog dengan komputer kuantum untuk menurunkan sistem vektor keadaan dan operator matriks yang mendeskripsikan spin mekanika kuantum.

Pertanyaan B/S:

1. B/S Dimulai dari pengamatan eksperimental, satu-satunya pilihan valid untuk vektor yang mewakili $|\uparrow\rangle$ adalah $\begin{pmatrix}1 \\ 0\end{pmatrix}$
2. B/S Jika $|\uparrow\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix}$, satu-satunya pilihan untuk $|\downarrow\rangle$ adalah $\begin{pmatrix}0 \\ 1\end{pmatrix}$ (hingga fase global).
3. B/S Partikel yang diukur berada dalam keadaan $|0\rangle$ akan terus ditemukan dalam keadaan $|0\rangle$ pada pengukuran berikutnya sepanjang $z$.
4. B/S Partikel yang diukur berada dalam keadaan $|0\rangle$ akan terus ditemukan dalam keadaan $|0\rangle$ pada pengukuran berikutnya sepanjang $x$.
5. B/S Partikel yang diukur berada dalam keadaan $|0\rangle$ akan selalu ditemukan dalam keadaan $|+\rangle_x$ pada pengukuran berikutnya sepanjang $x$.

Pertanyaan pilihan ganda:

1. Partikel yang awalnya dalam $|\uparrow\rangle$ memiliki probabilitas berapa untuk diukur dalam keadaan $|+x\rangle$?

   • a. 0%
   • b. 25%
   • c. 50%
   • d. 71%
   • e. 100%

2. Partikel yang awalnya dalam $|\uparrow\rangle$ memiliki probabilitas berapa untuk diukur dalam keadaan $|\downarrow\rangle$?

   • a. 0%
   • b. 25%
   • c. 50%
   • d. 71%
   • e. 100%

3. Keadaan $|\uparrow\rangle$ dari partikel spin-1/2 paling umum dikaitkan dengan keadaan komputasi kuantum apa?

   • a. $|+\rangle$
   • b. $|-\rangle$
   • c. $|0\rangle$
   • d. $|1\rangle$
   • e. Tidak ada di atas

Pertanyaan diskusi:

1. Tiga teman sedang mendiskusikan pengukuran kuantum dan operator. Teman A berkata, "Melakukan pengukuran sepanjang $z$ dan menerapkan operator $\sigma_z$ adalah hal yang sama." Teman B berkata, "Nah, keduanya adalah prosedur yang berbeda, tapi memiliki hasil yang sama." Teman C berkata, "Keduanya benar-benar berbeda; bahkan memiliki efek yang berbeda pada sebagian besar keadaan." Dengan siapakah kamu setuju dan mengapa?

Masalah respons bebas:

1. Diberikan pengamatan eksperimental dan sintaks yang diusulkan:

$P_{\uparrow+x}=\vert \begin{pmatrix}1 & 0\end{pmatrix}\begin{pmatrix}a \\ b\end{pmatrix}\vert^2 = |a|^2 =\frac{1}{2}$ $P_{\downarrow+x}=\vert \begin{pmatrix}0 & 1\end{pmatrix}\begin{pmatrix}a \\ b\end{pmatrix}\vert^2 = |b|^2 =\frac{1}{2}$

tunjukkan bahwa hingga fase global

$|+\rangle_x = \frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ e^{i\alpha}\end{pmatrix}$

Pilih $\alpha = 0$ untuk mendapatkan hasil standar.

2. Diberikan pengamatan eksperimental dan sintaks yang diusulkan:

$P_{\uparrow-x}=\vert \begin{pmatrix}1 & 0\end{pmatrix}\begin{pmatrix}a \\ b\end{pmatrix}\vert^2 = |a|^2 =\frac{1}{2}$ $P_{\downarrow-x}=\vert \begin{pmatrix}0 & 1\end{pmatrix}\begin{pmatrix}a \\ b\end{pmatrix}\vert^2 = |b|^2 =\frac{1}{2}$

Dan menggunakan hasil dari soal tantangan 3:

$P_{+x-x}=\vert \frac{1}{\sqrt{2}}\begin{pmatrix}1 & 1\end{pmatrix}\begin{pmatrix}c \\ d\end{pmatrix}\vert^2 = \frac{1}{2}|c+d|^2 =0$

tunjukkan bahwa hingga fase global

$|+\rangle_x = \frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ -1\end{pmatrix}$

Ucapan terima kasih

[1] By Tatoute - Own work, CC BY-SA 4.0, https://commons.wikimedia.org/w/index.php?curid=34095239