Eksperimen kuantum pertamamu

Pendahuluan

Dalam video berikut, Olivia Lanes akan memandu kamu melalui materi di pelajaran ini. Atau, kamu bisa membuka video YouTube untuk pelajaran ini di jendela terpisah.

Sampai di sini, kamu sudah menjalankan Circuit kuantum pertamamu dan mempelajari dasar-dasar komputasi kuantum: bagaimana keadaan kuantum direpresentasikan, bagaimana Gate bekerja pada keadaan tersebut, dan bagaimana fitur kuantum seperti superposisi dan entanglement terlibat. Kini saatnya mempraktikkan semua ini dan menyelesaikan masalah pertamamu di komputer kuantum.

Kita akan menjelajahi lanskap masalah yang cocok untuk kuantum dalam pelajaran berikutnya. Untuk sekarang, kita akan fokus pada masalah dalam domain simulasi alam: menggunakan komputer kuantum sebagai pengganti yang lebih bersih dan lebih terkontrol untuk sistem kuantum alami. Faktanya, ini adalah aplikasi pertama yang dibayangkan Richard Feynman untuk komputer kuantum pada tahun 1980-an. Seperti yang terkenalnya: "Alam itu tidak klasik, sial, dan jika kamu mau membuat simulasi alam, kamu lebih baik membuatnya mekanika kuantum..."

Dalam pelajaran ini, kita akan mengikuti prinsip tersebut untuk menyimulasikan interaksi antara dua spin, yang bisa kamu bayangkan sebagai magnet kecil. Tergantung pada tanda interaksinya, mereka mungkin lebih suka sejajar dan menunjuk ke arah yang sama, atau anti-sejajar dan menunjuk ke arah yang berlawanan. Kita akan fokus pada kasus terakhir karena sering menimbulkan perilaku yang lebih menarik — dan lebih menantang. Setelah memahami sistem dua-qubit kecil ini, kita akan menunjukkan bagaimana ide yang sama bisa diskalakan, memungkinkan komputer kuantum memanfaatkan penskalaan eksponensialnya saat menyimulasikan sistem spin yang besar.

Dua magnet yang berinteraksi

Untuk masalah ini, kita akan menggunakan dua qubit, satu untuk setiap spin dalam model kita. Setiap spin bisa menunjuk ke atas (keadaan qubit $|0\rangle$), ke bawah (keadaan qubit $|1\rangle$), atau dalam superposisi dari dua keadaan.

Jika spin memiliki interaksi antiferromagnetik, artinya mereka ingin anti-sejajar, jadi ketika satu menunjuk ke atas, yang lain ingin menunjuk ke bawah, dan sebaliknya.

Sekarang misalkan ada juga medan magnet yang menunjuk dari kiri ke kanan dalam sistem kita. Karena medan ini menunjuk melintasi arah biasa atas-bawah dari spin, disebut medan transversal. Medan ini bisa membalik spin, yang menyebabkan konfigurasi energi terendah berupa superposisi tertentu dari susunan spin atas-bawah daripada pola spin tunggal yang pasti.

Kita dapat mendeskripsikan semua efek ini menggunakan objek matematis yang disebut Hamiltonian. Hamiltonian memberi tahu kita energi sistem untuk susunan spin tertentu:

$$H = J Z_1 Z_0 + h_x (X_1 + X_0)$$

di mana $J$ adalah koefisien yang mengontrol kekuatan interaksi antara spin dan $h_x$ adalah koefisien untuk kekuatan medan magnet eksternal. $Z_1 Z_0$ memberi reward atau penalti pada spin tergantung apakah mereka sejajar atau anti-sejajar, dan $X_0$ dan $X_1$ merepresentasikan efek pembalikan spin dari medan magnet.

Dalam fisika, sistem cenderung menetap ke keadaan dengan energi paling rendah yang mungkin, yang disebut keadaan dasar. Menemukan keadaan energi terendah ini adalah masalah yang umum, tetapi memerlukan teknik optimasi yang di luar cakupan pelajaran ini.

Sebagai gantinya, kita akan mengajukan pertanyaan yang lebih sederhana: Jika kita menyiapkan spin dalam keadaan tertentu, berapa energi dari keadaan tersebut?

Untuk menjawabnya, kita akan:

1. Menyiapkan spin dalam keadaan pilihan kita
2. Mengukur energi keadaan tersebut menggunakan Hamiltonian di atas

Ini adalah jenis perhitungan yang muncul dalam algoritma kuantum yang lebih besar, seperti algoritma variatif, yang bisa kamu jelajahi dalam kursus berikutnya.

Implementasi Qiskit

Sebelum langsung menulis kode, kita perlu sedikit konteks. Ketika kita menjalankan Circuit kuantum, kita selalu mengakhiri dengan mengukur qubit. Tapi ada dua jenis pertanyaan yang mungkin ingin kita tanyakan tentang hasil pengukuran itu: Kadang, kita hanya ingin tahu apa keadaan qubit. Lain waktu, kita ingin tahu, berdasarkan keadaan kuantum, apa nilai besaran fisik, seperti energi?

Di Qiskit, dua jenis pertanyaan ini ditangani oleh dua alat berbeda, yang disebut primitif.

Sampler menjawab jenis pertanyaan pertama. Ia menjalankan Circuit berkali-kali dan memberi tahu kita seberapa sering kita mengukur setiap kemungkinan hasil, seperti 00, 01, 10, atau 11. Hasilnya adalah histogram yang menunjukkan probabilitas setiap hasil pengukuran.

Estimator menjawab jenis pertanyaan kedua. Alih-alih memberi kita histogram, ia menggabungkan banyak pengukuran di balik layar untuk menghitung satu angka, seperti energi keadaan menurut Hamiltonian yang kita berikan.

Untuk membantu kamu memahami kapan dan mengapa kita menggunakan masing-masing alat ini, kita akan menelusuri dua alur kerja lengkap (yang disebut "pola Qiskit") yang diterapkan pada sistem dua-qubit yang sama.

Alur kerja pola Qiskit

Alur kerja pola Qiskit adalah kerangka umum yang kita gunakan untuk menyelesaikan masalah kuantum dengan Qiskit. Alur ini membagi tugas komputasi kuantum menjadi empat langkah:

1. Petakan masalah ke model yang bisa direpresentasikan oleh Circuit kuantum
2. Optimalkan Circuit untuk dijalankan di Backend tertentu
3. Jalankan Circuit yang sudah dioptimalkan di Backend yang dipilih
4. Proses pasca data pengukuran mentah

Eksperimen 1: Gunakan Sampler untuk mengukur keadaan

Petakan

Secara umum, langkah pemetaan adalah tempat kita mencari tahu cara merepresentasikan masalah dunia nyata dalam bentuk qubit, operator, dan pengukuran. Dalam banyak aplikasi, ini adalah bagian alur kerja yang paling rumit dan paling banyak terlibat — bahkan pertanyaan sederhana, seperti "apa yang direpresentasikan setiap qubit?" tidak selalu memiliki jawaban yang mudah.

Namun dalam eksperimen ini, pemetaannya sengaja dibuat sederhana. Setiap derajat kebebasan fisik dipetakan langsung ke satu qubit. Karena korespondensi satu-ke-satu ini, langkah pemetaan direduksi menjadi memilih keadaan kuantum yang ingin kita siapkan dan menulis Circuit yang menyiapkan serta mengukur keadaan tersebut.

Di sini, kita akan menyiapkan Bell state yang terjerat, mirip dengan yang kita buat di pelajaran pertama kursus ini:

$$\vert\Psi\rangle = \frac{1}{\sqrt{2}}(\vert 10\rangle - \vert 01\rangle)$$

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

# Import Qiskit primitives
from qiskit import QuantumCircuit

# Make state
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.x(1)
qc.z(0)

# Measure state
qc.measure_all()

# Draw circuit
qc.draw("mpl")

Optimalkan

Sebelum kita menjalankan Circuit di komputer kuantum (atau simulator jika kamu sudah menghabiskan waktu gratis di komputer kuantum sungguhan untuk bulan ini), kita perlu mempersiapkannya untuk eksekusi. Langkah ini disebut optimasi. (Catatan: penggunaan kata "optimasi" ini bisa membingungkan. Dalam komputasi kuantum, masalah optimasi merujuk pada kelas masalah tertentu. Di sini, kita menggunakan optimasi untuk mendeskripsikan langkah persiapan yang diperlukan yang dilalui setiap Circuit kuantum sebelum bisa dijalankan secara efisien di hardware.)

Selama optimasi:

1. Kita memilih Backend — komputer kuantum sungguhan atau simulator.
2. Kita menetapkan qubit Circuit kita ke qubit fisik pada perangkat.
3. Kita menulis ulang Circuit menggunakan hanya Gate yang benar-benar bisa dilakukan oleh komputer kuantum.
4. Secara opsional menerapkan teknik mitigasi dan supresi error untuk mengurangi efek noise.

Di Qiskit, ini ditangani secara otomatis oleh Transpiler. Setelah kamu memilih Backend, Transpiler melakukan semua pekerjaan untuk membuat Circuit siap dieksekusi, jadi kamu tidak perlu menyesuaikan Gate atau penugasan qubit secara manual. Transpiler juga menawarkan level optimasi yang berbeda, yang dapat membantu mengurangi error jika diperlukan. Optimasi dilakukan dalam tahapan yang disebut 'pass'. Jadi optimasi ini akan ditangani oleh pass_manager dalam kode di bawah ini. Untuk mempelajari lebih lanjut tentang error dan mitigasi error, lihat kursus Quantum Computing in Practice oleh Olivia Lanes.

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

## Load the Qiskit Runtime service
# QiskitRuntimeService.save_account(
#    channel="ibm_quantum_platform",
#    token="YOUR_TOKEN_HERE",
#    overwrite=True,
#    set_as_default=True,
# )
# service = QiskitRuntimeService(channel="ibm_quantum_platform")

# Or load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_brisbane".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_brisbane")
print(backend.name)

ibm_fez

# Transpile the circuit and optimize for running on the quantum computer selected
# 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)

qc_isa.draw("mpl")

Jalankan

Sekarang kita siap untuk menjalankan! Kita akan memuat Sampler, lalu mengirim pekerjaan ke Backend.

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

sampler = Sampler(mode=backend)

Atau, jika kamu menggunakan simulator, kamu bisa membuka komentar dan menjalankan sel ini sebagai gantinya:

## Load the backend sampler
# from qiskit.primitives import BackendSamplerV2

## Load the Aer simulator and generate a noise model based on the currently-selected backend.
# from qiskit_aer import AerSimulator
# from qiskit_aer.noise import NoiseModel

# noise_model = NoiseModel.from_backend(backend)

## Define a simulator using Aer, and use it in Sampler.
# backend_sim = AerSimulator(noise_model=noise_model)
# sampler_sim = BackendSamplerV2(backend=backend_sim)

## Alternatively, load a fake backend with generic properties and define a simulator.
## backend_gen = GenericBackendV2(num_qubits=18)
## sampler_gen = BackendSamplerV2(backend=backend_gen)

job = sampler.run([qc_isa], shots=100)
# job = sampler_sim.run([qc_isa]) # uncomment if you want to run on a simulator
res = job.result()
counts = res[0].data.meas.get_counts()

Proses pasca

from qiskit.visualization import plot_histogram

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

counts =  {'10': 49, '01': 50, '11': 1}

Kita melihat bahwa sebagian besar hitungan ada di 01 atau 10, artinya ketika satu qubit diukur menjadi 0, yang lainnya adalah 1, dan sebaliknya. Ini konsisten dengan Bell state $\vert \Psi^- \rangle$ yang kita siapkan.

Eksperimen 2: Gunakan Estimator untuk mengukur energi

Setelah melihat cara mengambil sampel keadaan kuantum, sekarang mari gunakan Estimator untuk menghitung energi dari Bell state $\vert \Psi^- \rangle = \frac{1}{\sqrt{2}}(\vert 01 \rangle - \vert 10 \rangle)$ kita.

Petakan

Sebagai pengingat, energi sistem ditentukan oleh interaksi antara spin ($J$) dan medan magnet eksternal ($h_x$) sebagaimana ditangkap oleh Hamiltonian:

$$H = J Z_1 Z_0 + h_x (X_1 + X_0)$$

Setiap suku dalam Hamiltonian memberi tahu kita bagaimana kombinasi spin tertentu berkontribusi pada energi. Di Qiskit, kita dapat merepresentasikan suku-suku ini sebagai operator Pauli, yang hanyalah label untuk tindakan sederhana pada qubit:

• $Z_1 Z_0$ bekerja dengan $Z$ pada kedua qubit.
• $X_0$ bekerja dengan $X$ pada qubit 0.
• $X_1$ bekerja dengan $X$ pada qubit 1.

SparsePauliOp di Qiskit adalah cara untuk menyimpan daftar operator Pauli ini beserta koefisien numeriknya. Operator Pauli ini adalah observabel yang ingin kita minta komputer kuantum untuk diukur — besaran yang memberi tahu kita tentang sistem. Menggunakan Estimator, kita dapat menghitung nilai rata-rata dari setiap observabel pada keadaan kita dan menggabungkannya sesuai koefisien dalam Hamiltonian untuk mendapatkan total energi.

# Import Qiskit primitives
from qiskit.quantum_info import SparsePauliOp

# Parameters
J = 1.0  # antiferromagnetic coupling (J<0)
hx = -0.5  # transverse field strength

# 1. Define the Hamiltonian H = J Z1 Z2 + hx (X1 + X2)
obs = SparsePauliOp.from_list([("ZZ", J), ("XI", hx), ("IX", hx)])

# Make state
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.x(1)
qc.z(0)

<qiskit.circuit.instructionset.InstructionSet at 0x1387ed630>

Perhatikan bahwa kita menghilangkan baris qc.measure_all() dalam kode kita. Ini karena dengan Estimator, kita tidak perlu menentukan di mana harus mengukur dalam Circuit. Kita hanya akan memberi tahu observabel mana yang ingin kita estimasi, dan Qiskit mengurus pengukuran di balik layar.

Optimalkan

Langkah optimasi berlanjut seperti sebelumnya, dengan tambahan memastikan observabel kita juga ditulis dengan cara yang bisa dipahami komputer kuantum.

# Transpile the circuit and optimize for running on the quantum computer selected
# 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)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

qc_isa.draw("mpl")

Jalankan

Dalam langkah Jalankan, kita akan memuat Estimator, lalu mengirim Circuit beserta daftar observabel yang ingin kita estimasi ke komputer kuantum.

# Load the Runtime primitive and session
from qiskit_ibm_runtime import EstimatorV2 as Estimator

estimator = Estimator(mode=backend)

# Load the backend sampler

# noise_model = NoiseModel.from_backend(backend)

# Use Aer simulator in Estimator
# estimator_sim = BackendEstimatorV2(backend=backend_sim)

# Alternatively, load a fake backend with generic properties and define a simulator.
# backend_gen = GenericBackendV2(num_qubits=18)
# estimator_gen = BackendEstimatorV2(backend=backend_gen)

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

# Uncomment lines below to run the job on the Aer simulator with noise model from real backend
# job = estimator_sim.run([[qc_isa,obs_isa]])
# res=job.result()

Proses pasca

Terakhir, dalam langkah pasca-pemrosesan, kita cukup mencetak energi yang dihitung di balik layar oleh Estimator.

print(res[0].data.evs)

-0.9934112021453058

Ini adalah energi dari keadaan kita!

Kesimpulan

Dalam pelajaran ini, kita belajar cara menyiapkan keadaan kuantum dua-qubit sederhana yang merepresentasikan dua spin yang berinteraksi. Kita melihat cara menggunakan Sampler untuk mengamati distribusi hasil pengukuran dan cara menggunakan Estimator untuk menghitung energi keadaan menurut Hamiltonian. Sepanjang jalan, kita melihat bagaimana Hamiltonian mengkodekan interaksi antara spin dan efek medan eksternal, serta bagaimana keadaan yang berbeda bisa memiliki energi yang berbeda.

Perluasan ke banyak spin

Sejauh ini, kita hanya melihat dua spin, yang cukup sederhana untuk dianalisis secara manual. Dalam sistem fisik nyata, seperti magnet atau material kompleks lainnya, sering ada banyak spin yang berinteraksi. Ketika jumlah spin meningkat, Hamiltonian menjadi lebih kompleks dan menemukan keadaan energi terendah menjadi jauh lebih sulit. Di sinilah komputer kuantum bisa membantu: dengan menyiapkan berbagai keadaan dan mengestimasi energinya, kita dapat menjelajahi konfigurasi energi rendah lebih efisien dibanding komputer klasik untuk sistem yang besar.

Perluasan alami dari eksperimen ini adalah meningkatkan jumlah qubit untuk merepresentasikan lebih banyak spin dan menyesuaikan cara spin disiapkan untuk mencoba menemukan keadaan energi terendah. Pendekatan ini adalah inti dari metode variatif, yang bisa kamu pelajari dalam kursus Variational Quantum Algorithms.

Ada juga pendekatan kuantum lain untuk mempelajari energi keadaan dasar yang melampaui teknik variatif. Metode-metode ini tidak dibahas di sini, tetapi diperkenalkan dalam kursus Quantum Diagonalization Algorithms jika kamu tertarik untuk mempelajarinya lebih lanjut.

Tujuan pembelajaran

Kembali ke awal Eksperimen 2 dan coba lagi dengan keadaan superposisi yang berbeda. Bisakah kamu menemukan keadaan dengan energi yang lebih rendah dari yang kita gunakan?