Eksperimen kuantum pertama anda

Pengenalan

Dalam video berikut, Olivia Lanes membimbing kamu melalui kandungan dalam pelajaran ini. Sebagai alternatif, kamu boleh buka video YouTube untuk pelajaran ini dalam tetingkap berasingan.

Sekarang, kamu dah jalankan Circuit kuantum pertama dan belajar asas pengkomputeran kuantum: cara keadaan kuantum diwakili, cara Gate bertindak ke atas keadaan tersebut, dan cara ciri kuantum seperti superposisi dan entanglement terlibat. Kini tiba masanya untuk praktikkan semua ini dan selesaikan masalah pertama kamu pada komputer kuantum.

Kita akan terokai landskap masalah yang sesuai untuk kuantum yang lebih luas dalam pelajaran kemudian. Buat masa ini, kita akan fokus pada masalah dalam domain simulasi alam: menggunakan komputer kuantum sebagai pengganti yang lebih bersih dan lebih terkawal untuk sistem kuantum semula jadi. Sebenarnya, ini adalah aplikasi pertama yang dibayangkan oleh Richard Feynman untuk komputer kuantum pada tahun 1980-an. Seperti katanya yang terkenal: "Alam semesta bukan klasik, celaka, dan kalau kamu nak buat simulasi alam, lebih baik buat secara mekanik kuantum..."

Dalam pelajaran ini, kita akan ikuti prinsip itu untuk mensimulasikan interaksi antara dua spin, yang boleh kamu bayangkan sebagai magnet kecil. Bergantung pada tanda interaksi mereka, mereka mungkin lebih suka sejajar dan menunjuk ke arah yang sama, atau anti-sejajar dan menunjuk ke arah yang bertentangan. Kita akan fokus pada kes kedua kerana ia sering membawa kepada tingkah laku yang lebih menarik — dan lebih mencabar. Setelah kita faham sistem dua qubit yang kecil ini, kita akan tunjukkan cara idea yang sama boleh diskala, membolehkan komputer kuantum memanfaatkan penskalaan eksponen mereka apabila mensimulasikan sistem spin yang besar.

Dua magnet yang berinteraksi

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

Jika spin mempunyai interaksi antiferomagnet, ia bermakna mereka mahu anti-sejajar, jadi apabila satu ke atas, yang satu lagi mahu ke bawah, dan sebaliknya.

Sekarang andaikan ada juga medan magnet yang menunjuk dari kiri ke kanan dalam sistem kita. Kerana medan ini menunjuk melintasi arah biasa atas-bawah spin, ia dipanggil medan melintang. Medan ini boleh membalikkan spin, yang menyebabkan konfigurasi tenaga terendah menjadi superposisi tertentu susunan spin atas-bawah dan bukannya sebarang corak spin tunggal yang pasti.

Kita boleh terangkan semua kesan ini menggunakan objek matematik yang dipanggil Hamiltonian. Hamiltonian memberitahu kita tenaga sistem untuk susunan spin tertentu:

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

di mana $J$ adalah pekali yang mengawal kekuatan interaksi antara spin dan $h_x$ adalah pekali untuk kekuatan medan magnet luaran. $Z_1 Z_0$ memberi ganjaran atau penalti kepada spin bergantung pada sama ada mereka sejajar atau anti-sejajar, dan $X_0$ serta $X_1$ mewakili kesan pembalikan spin medan magnet.

Dalam fizik, sistem cenderung menetap dalam keadaan dengan tenaga serendah mungkin, dipanggil keadaan dasar. Mencari keadaan tenaga terendah ini adalah masalah yang biasa, tetapi ia memerlukan teknik pengoptimuman yang di luar skop pelajaran ini.

Sebaliknya, kita akan tanya soalan yang lebih mudah: Jika kita sediakan spin dalam keadaan tertentu, apakah tenaga keadaan itu?

Untuk menjawab ini, kita akan:

1. Sediakan spin dalam keadaan pilihan kita
2. Ukur tenaga keadaan itu menggunakan Hamiltonian di atas

Ini adalah persis jenis pengiraan yang muncul dalam algoritma kuantum yang lebih besar, seperti algoritma variatif, yang boleh kamu terokai dalam kursus kemudian.

Pelaksanaan Qiskit

Sebelum mula menulis kod, kita perlu sedikit konteks. Apabila kita jalankan Circuit kuantum, kita sentiasa berakhir dengan mengukur qubit. Tetapi terdapat dua jenis soalan berbeza yang mungkin kita ingin tanya tentang hasil ukuran tersebut: Kadangkala, kita hanya ingin tahu apakah keadaan qubit. Kali lain, kita ingin tahu, berdasarkan keadaan kuantum, apakah nilai kuantiti fizikal, seperti tenaga?

Dalam Qiskit, dua jenis soalan ini dikendalikan oleh dua alat berbeza, dipanggil primitif.

Sampler menjawab jenis soalan pertama. Ia jalankan Circuit berkali-kali dan memberitahu kita berapa kerap kita mengukur setiap kemungkinan hasil, seperti 00, 01, 10, atau 11. Hasilnya adalah histogram yang menunjukkan kebarangkalian setiap hasil ukuran.

Estimator menjawab jenis soalan kedua. Berbanding memberikan kita histogram, ia menggabungkan banyak ukuran di sebalik tabir untuk mengira satu nombor tunggal, seperti tenaga keadaan mengikut Hamiltonian yang kita berikan.

Untuk membantu kamu memahami bila dan mengapa kita menggunakan setiap alat ini, kita akan lalui dua aliran kerja lengkap (dipanggil "corak Qiskit") yang digunakan pada sistem dua qubit yang sama.

Aliran kerja corak Qiskit

Aliran kerja corak Qiskit adalah rangka kerja am yang kita gunakan untuk menyelesaikan masalah kuantum dengan Qiskit. Ia memecahkan tugas pengkomputeran kuantum kepada empat langkah:

1. Petakan masalah kepada model yang boleh diwakili oleh Circuit kuantum
2. Optimumkan Circuit untuk dijalankan pada Backend tertentu
3. Laksanakan Circuit yang dioptimumkan pada Backend yang dipilih
4. Proses lepas data ukuran mentah

Eksperimen 1: Guna Sampler untuk mengukur keadaan

Petakan

Secara umum, langkah pemetaan adalah tempat kita fikirkan cara mewakili masalah dunia sebenar dalam bentuk qubit, operator, dan ukuran. Dalam banyak aplikasi, ini adalah bahagian aliran kerja yang paling rumit dan paling melibatkan — malah soalan mudah, seperti "apakah yang diwakili oleh setiap qubit?" tidak selalu mempunyai jawapan yang mudah.

Namun dalam eksperimen ini, pemetaan sengaja dibuat mudah. Setiap darjah kebebasan fizikal dipetakan terus ke satu qubit. Kerana perkadaran satu-ke-satu ini, langkah pemetaan menjadi memilih keadaan kuantum yang ingin kita sediakan dan menulis Circuit yang menyediakan dan mengukur keadaan tersebut.

Di sini, kita akan sediakan Bell state yang terbelit, serupa dengan yang kita buat dalam 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")

Optimumkan

Sebelum kita jalankan Circuit pada komputer kuantum (atau simulator jika kamu dah habiskan masa percuma pada komputer kuantum sebenar untuk bulan ini), kita perlu sediakan ia untuk pelaksanaan. Langkah ini dipanggil pengoptimuman. (Nota: penggunaan perkataan "pengoptimuman" ini boleh mengelirukan. Dalam pengkomputeran kuantum, masalah pengoptimuman merujuk kepada kelas masalah tertentu. Di sini, kita menggunakan pengoptimuman untuk menggambarkan langkah persediaan yang diperlukan yang dilalui setiap Circuit kuantum sebelum ia boleh dijalankan dengan cekap pada perkakasan.)

Semasa pengoptimuman:

1. Kita pilih Backend — sama ada komputer kuantum sebenar atau simulator.
2. Kita tugaskan qubit Circuit kita kepada qubit fizikal pada peranti.
3. Kita tulis semula Circuit menggunakan hanya Gate yang sebenarnya boleh dilaksanakan oleh komputer kuantum.
4. Secara pilihan laksanakan teknik pengurangan dan penindasan ralat untuk mengurangkan kesan bunyi.

Dalam Qiskit, ini dikendalikan secara automatik oleh Transpiler. Setelah kamu pilih Backend, Transpiler melakukan semua kerja untuk menjadikan Circuit kamu bersedia untuk pelaksanaan, jadi kamu tidak perlu laraskan Gate atau tugasan qubit secara manual. Transpiler juga menawarkan tahap pengoptimuman yang berbeza, yang boleh membantu mengurangkan ralat jika diperlukan. Pengoptimuman dilakukan dalam peringkat yang dipanggil 'laluan'. Jadi pengoptimuman ini akan dikendalikan oleh pass_manager dalam kod di bawah. Untuk mengetahui lebih lanjut tentang ralat dan pengurangan ralat, 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")

Laksanakan

Kini kita bersedia untuk laksanakan! Kita akan muatkan Sampler, kemudian hantar kerja 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 boleh uncomment dan jalankan sel ini sebaliknya:

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

from qiskit.visualization import plot_histogram

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

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

Kita lihat bahawa majoriti kiraan ada dalam 01 atau 10, bermakna apabila satu qubit diukur sebagai 0, yang satu lagi adalah 1, dan sebaliknya. Ini konsisten dengan Bell state $\vert \Psi^- \rangle$ yang kita sediakan.

Eksperimen 2: Guna Estimator untuk mengukur tenaga

Sekarang setelah kita tahu cara sampler keadaan kuantum, jom gunakan Estimator untuk mengira tenaga Bell state $\vert \Psi^- \rangle = \frac{1}{\sqrt{2}}(\vert 01 \rangle - \vert 10 \rangle)$ kita.

Petakan

Sebagai peringatan, tenaga sistem ditentukan oleh interaksi antara spin ($J$) dan medan magnet luaran ($h_x$) seperti yang ditangkap oleh Hamiltonian:

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

Setiap sebutan dalam Hamiltonian memberitahu kita bagaimana gabungan spin tertentu menyumbang kepada tenaga. Dalam Qiskit, kita boleh wakili sebutan-sebutan ini sebagai operator Pauli, yang hanyalah label untuk tindakan mudah ke atas qubit:

• $Z_1 Z_0$ bertindak dengan $Z$ pada kedua-dua qubit.
• $X_0$ bertindak dengan $X$ pada qubit 0.
• $X_1$ bertindak dengan $X$ pada qubit 1.

SparsePauliOp dalam Qiskit adalah cara untuk menyimpan senarai operator Pauli ini bersama pekali berangka mereka. Operator Pauli ini adalah boleh ukur yang kita mahu komputer kuantum ukur — kuantiti yang memberitahu kita tentang sistem. Menggunakan Estimator, kita boleh mengira nilai purata setiap boleh ukur pada keadaan kita dan menggabungkannya mengikut pekali dalam Hamiltonian untuk mendapatkan tenaga jumlah.

# 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 bahawa kita abaikan baris qc.measure_all() dalam kod kita. Ini kerana dengan Estimator, kita tidak perlu nyatakan di mana untuk mengukur dalam Circuit. Kita hanya perlu beritahu ia boleh ukur mana yang kita mahu dianggarkan, dan Qiskit menguruskan ukuran di sebalik tabir.

Optimumkan

Langkah pengoptimuman diteruskan seperti sebelumnya, dengan tambahan memastikan boleh ukur kita juga ditulis dengan cara yang boleh difahami oleh 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")

Laksanakan

Dalam langkah Laksana, kita akan muatkan Estimator, kemudian hantar Circuit bersama senarai boleh ukur yang kita mahu dianggarkan 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 lepas

Akhirnya, dalam langkah proses lepas, kita hanya cetak tenaga yang dikira di sebalik tabir oleh Estimator.

print(res[0].data.evs)

-0.9934112021453058

Inilah tenaga keadaan kita!

Kesimpulan

Dalam pelajaran ini, kita belajar cara menyediakan keadaan kuantum dua qubit yang mudah mewakili dua spin yang berinteraksi. Kita lihat cara menggunakan Sampler untuk memerhatikan taburan hasil ukuran dan cara menggunakan Estimator untuk mengira tenaga keadaan mengikut Hamiltonian. Dalam perjalanan ini, kita lihat bagaimana Hamiltonian mengekodkan interaksi antara spin dan kesan medan luaran, dan bagaimana keadaan yang berbeza boleh mempunyai tenaga yang berbeza.

Pelanjutan kepada banyak spin

Setakat ini, kita hanya lihat dua spin, yang cukup mudah untuk dianalisis dengan tangan. Dalam sistem fizikal sebenar, seperti dalam magnet atau bahan kompleks lain, selalunya ada banyak spin yang berinteraksi. Apabila bilangan spin meningkat, Hamiltonian menjadi lebih kompleks dan mencari keadaan tenaga terendah menjadi jauh lebih sukar. Di sinilah komputer kuantum boleh membantu: dengan menyediakan keadaan yang berbeza dan menganggarkan tenaga mereka, kita boleh meneroka konfigurasi tenaga rendah dengan lebih cekap berbanding komputer klasik untuk sistem yang besar.

Pelanjutan semula jadi eksperimen ini adalah meningkatkan bilangan qubit untuk mewakili lebih banyak spin dan melaraskan cara spin disediakan untuk cuba mencari keadaan tenaga terendah. Pendekatan ini adalah intipati kaedah variatif, yang boleh kamu pelajari dalam kursus Variational Quantum Algorithms.

Terdapat juga pendekatan kuantum lain untuk mengkaji tenaga keadaan dasar yang melampaui teknik variatif. Kaedah-kaedah ini tidak diliputi di sini, tetapi diperkenalkan dalam kursus Quantum Diagonalization Algorithms jika kamu berminat untuk mengetahui lebih lanjut.

Objektif pembelajaran

Kembali ke permulaan Eksperimen 2 dan cuba semula dengan keadaan superposisi yang berbeza. Bolehkah kamu cari keadaan dengan tenaga yang lebih rendah daripada yang kita gunakan?