Koin Kuantum — modul tentang superposisi dan interferensi

Untuk modul Qiskit in Classrooms ini, siswa harus memiliki lingkungan Python yang berfungsi dengan paket-paket berikut 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 mengatur dan menginstal paket-paket di atas, lihat panduan Install Qiskit. Untuk menjalankan job pada komputer kuantum nyata, siswa perlu membuat akun di IBM Quantum® dengan mengikuti langkah-langkah dalam panduan Set up your IBM Cloud account.

Modul ini sudah diuji dan menggunakan 47 detik waktu QPU. Ini hanya perkiraan. Penggunaan aktual kamu bisa berbeda.

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy qiskit 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 walkthrough modul oleh Dr. Katie McCormick di bawah ini, atau klik di sini untuk menontonnya di YouTube.

---

Pendahuluan

Dalam modul ini, kita akan mengeksplorasi salah satu prinsip inti di jantung teori kuantum: superposisi. Dalam pengalaman sehari-hari, objek selalu memiliki ciri-ciri yang pasti. Lokasi, ukuran, bentuk, warna — semuanya — sudah ditentukan dan pasti, meskipun kita sebagai pengamat belum mengukurnya. Di dunia kuantum, ini belum tentu demikian. Objek kuantum bisa berada dalam sesuatu yang disebut "superposisi" dari beberapa keadaan yang secara klasik diperbolehkan. Ketika superposisi diukur, ia akan secara acak "kolaps" ke salah satu keadaan tersebut.

Dalam beberapa hal, mengukur keadaan superposisi itu seperti melempar koin: tidak ada cara untuk mengetahui sebelumnya ke sisi mana ia akan jatuh. Indeterminisme fundamental ini merupakan aspek mekanika kuantum yang tidak nyaman bahkan bagi Einstein. Ia terkenal berkata, "Tuhan tidak bermain dadu" tentang keacakan ini. Tapi, seperti yang akan kita lihat, Tuhan memang bermain dadu — dan melempar koin.

Kita akan memikirkan lemparan koin klasik sebagai analogi untuk pengukuran keadaan superposisi. Dan — dengan bermain dengan "koin kuantum" menggunakan Qiskit dan sebuah qubit pada prosesor kuantum IBM® — kita akan segera menemukan batas-batas analogi tersebut.

Koin klasik

Mari mulai dengan koin klasik. Lempar koin, dan ia akan jatuh dengan sisi kepala menghadap ke atas atau ke bawah, masing-masing dengan peluang 50$~$%. Walaupun secara prinsip, seseorang bisa menghitung sisi mana yang akan mendarat jika mereka mengetahui kondisi awal koin secara tepat beserta gaya/torsi lemparannya, secara praktik, tidak ada cara untuk mengetahui sebelumnya sisi mana yang akan mendarat. Itulah mengapa kita menggunakan lemparan koin sebagai contoh kanonik dari keadaan probabilistik klasik, di mana hasilnya pada dasarnya acak. Kita bisa menuliskan keadaan koin sebelum mendarat untuk mencerminkan probabilitas 50/50 ini:

$$S(coin) = \frac{1}{2}|up\rangle + \frac{1}{2}|down\rangle$$

Di sini, dua suku tersebut mewakili dua kemungkinan hasil lemparan, dan koefisiennya mewakili probabilitas masing-masing hasil. Perhatikan bahwa biasanya, "$|\rangle$" (dikenal sebagai "ket") digunakan untuk merepresentasikan keadaan kuantum, tapi di sini, kita berbicara tentang keadaan probabilistik klasik. Lihat Pelajaran 1: Sistem Tunggal dalam kursus Basics of Quantum Information untuk mempelajari lebih lanjut tentang cara kita merepresentasikan informasi klasik dan kuantum.

Jika kita melempar koin 1000 kali dan mencatat jumlah kepala yang menghadap ke atas dan ke bawah, kita akan mendapatkan sesuatu seperti ini:

# import necessary packages:
import numpy as np
import matplotlib.pyplot as plt
import random

nflips = 1000
fliplist = [random.randint(0, 1) for f in range(nflips)]

# bar plots using get_gaussian_probs function
plt.hist(fliplist)
plt.show()

Koin kuantum

Kita bisa membuat keadaan probabilistik serupa menggunakan qubit pada komputer kuantum kita. Seperti lemparan koin, qubit juga bisa diukur dalam dua keadaan yang mungkin: $|0\rangle$ dan $|1\rangle$. Kita membuat keadaan probabilistik "superposisi" dengan mulai dari keadaan $|0\rangle$, kemudian menerapkan sesuatu yang disebut Hadamard Gate pada qubit. Ini menempatkannya dalam superposisi yang sama antara $|0\rangle$ dan $|1\rangle$. Perhatikan bahwa meskipun keadaan superposisi ini mungkin terlihat dan berperilaku seperti koin pada pandangan pertama, kita akan segera melihat bahwa ada lebih banyak hal di dalamnya. Tujuan modul ini adalah untuk menunjukkan bahwa superposisi tidak sama dengan lemparan koin klasik.

Jadi, karena qubit berada dalam superposisi yang sama antara 0 dan 1, ketika kita mengukur qubit tersebut, akan ada peluang 50% kita mengukur $|0\rangle$, 50% peluang kita mengukur $|1\rangle$. Kita menuliskan keadaan ini sedikit berbeda dari kasus probabilistik klasik, karena alasan yang akan menjadi jelas nanti:

$$|\psi\rangle = \frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle$$

Di sini, probabilitas pengukuran masing-masing dari dua keadaan tidak lagi sama dengan koefisiennya, seperti yang terjadi dalam keadaan probabilistik klasik di atas. Sebagai gantinya, kuadrat dari koefisien itulah yang memberikan probabilitasnya, dan masing-masing koefisien ini sekarang bisa bersifat kompleks, artinya bisa memiliki bagian real dan imajiner.

Meskipun ada perbedaan-perbedaan ini, hasil pengukuran keadaan ini pada dasarnya sama seperti melempar koin.

from qiskit import QuantumCircuit

qcoin = QuantumCircuit(1)
qcoin.h(0)
qcoin.measure_all()

qcoin.draw("mpl")

Jadi, pada dasarnya, menerapkan Hadamard Gate adalah analogi dari melempar koin. Dan sama seperti kita melempar koin 1000 kali untuk melihat statistik koin mendarat kepala ke atas atau ke bawah, kita bisa melakukan hal serupa di Qiskit dengan "koin kuantum" kita. Kita bisa menggunakan primitive Qiskit yang disebut Sampler, yang akan mengulangi Circuit beberapa kali untuk mengambil sampel statistik dari keadaan yang dihasilkan.

Pertama, kita memuat layanan Qiskit Runtime dan primitive, kemudian kita memilih Backend untuk menjalankan Circuit.

Ada kode di bawah untuk menyimpan kredensial kamu 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 Set up your IBM Cloud account dan Initialize the service in an untrusted environment 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')

# Load saved credentials
service = QiskitRuntimeService()

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

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

ibm_kingston

Jika kamu tidak memiliki waktu yang tersedia lagi di akunmu, kamu juga bisa memilih untuk menjalankan ini pada simulator. Cukup batalkan komentar pada kode dan jalankan sel di bawah untuk melakukannya:

## Use a local simulator

# from qiskit_aer import AerSimulator

## Generate a simulator that mimics the real quantum system

# backend_sim = AerSimulator.from_backend(backend)

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

# from qiskit.primitives import BackendSamplerV2
# sampler_sim = BackendSamplerV2(backend = backend_sim)
# from qiskit.primitives import BackendEstimatorV2
# estimator_sim = BackendEstimatorV2(backend = backend_sim)

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

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

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

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analysis
from qiskit.visualization import plot_histogram

plot_histogram(counts)

Dengan 1000 sampel dari Circuit di atas, kita mendapatkan sesuatu yang terlihat pada dasarnya identik dengan histogram koin klasik, dengan sedikit fluktuasi statistik.

Selain mengambil sampel statistik dari koin kuantum, kita juga bisa menggunakan primitive Qiskit lain yang disebut Estimator untuk mengukur apa yang disebut nilai ekspektasi dari sebuah observable pada keadaan tersebut. Untuk menggambarkan apa nilai ekspektasi ini, mari gunakan koin klasik sebagai contoh. Katakanlah kamu menggunakan koin untuk berjudi: setiap kali kamu melempar koin dan mendarat "kepala ke atas," kamu menang satu dolar. Tapi setiap kali mendarat "kepala ke bawah," kamu kehilangan satu dolar. Jika kamu ingin tahu berapa banyak uang yang diharapkan kamu dapatkan per lemparan (nilai ekspektasi dari observable "uang"), maka kamu akan menghitung:

$$E(money) = \frac{1}{2} (+ \text{1 dollar}) + \frac{1}{2} (- \text{1 dollar}) = \text{0 dollars}$$

Karena kamu sama-sama mungkin menang satu dolar maupun kehilangan satu dolar, nilai ekspektasinya adalah $0.

Demikian pula, dengan keadaan kuantum, kita bisa menghitung nilai ekspektasi dari observable "Z", di mana Z adalah matriks Pauli dengan nilai +1 dan -1 yang terkait dengan keadaan $|0\rangle$ dan $|1\rangle$, masing-masing.

$$\langle \psi|Z|\psi \rangle = \frac{1}{2} \langle 0 | Z | 0 \rangle + \frac{1}{2} \langle 1 | Z | 1 \rangle = \frac{1}{2} (+1) + \frac{1}{2}(-1) = 0$$

from qiskit.quantum_info import Pauli

qcoin = QuantumCircuit(1)
qcoin.h(0)

# for Estimator, we do not apply the measurement to the circuit

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

## Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

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

obs = Pauli("Z")

qc_isa = pm.run(qcoin)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

## Execute

# On real hardware:
estimator = Estimator(mode=backend)
pubs = [(qc_isa, obs_isa)]
job = estimator.run([[qc_isa, obs_isa]])
res = job.result()

# On a simulator:
# job = estimator_sim.run([[qc_isa, obs_isa]])
# res=job.result()

print(res[0].data.evs)

-0.014799284701239441

Kita mendapatkan nilai ekspektasi 0, seperti yang diharapkan (ha). Ini adalah cara lain untuk mengkonfirmasi bahwa memang ada probabilitas yang sama untuk mengukur 0 dan 1, dan tampaknya berperilaku seperti lemparan koin.

Pada titik ini, "koin kuantum" terlihat persis seperti koin klasik. Tapi di bagian berikutnya, kita akan melakukan beberapa eksperimen yang akan mengungkap perbedaan mendasar antara keduanya.

Kuantum yang terungkap: eksperimen dalam tiga dimensi

Mari lakukan eksperimen pikiran: Katakanlah kamu melempar koin ke udara, dan alih-alih membiarkannya jatuh ke tanah, kamu memiliki koordinasi untuk bertepuk tangan saat koin melewati antara tanganmu dan menjepit koin di antara telapak tanganmu. Sekarang, alih-alih koin berada kepala ke atas atau ke bawah, ia berada kepala ke kiri atau ke kanan.

Cek pemahamanmu

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

Berapa probabilitas masing-masing hasil ini, kepala ke kiri atau kepala ke kanan?

Jawaban:

Probabilitasnya tetap akan 50-50. Seharusnya tidak masalah dimensi mana yang kita pilih untuk mengukur hasil lemparan koin.

Semoga kamu menjawab bahwa probabilitas mendapatkan kepala ke kiri atau ke kanan tetap 50-50. Dimensi di mana lemparan koin diukur seharusnya tidak mempengaruhi probabilitas hasil.

Tapi bagaimana tampilannya berbeda untuk koin kuantum kita? Mari kita cek.

Kita bisa membuat superposisi kuantum dengan cara yang sama seperti sebelumnya, dengan Hadamard Gate. Untuk mengukur "kepala ke kiri atau kanan" pada koin kuantum kita, kita bisa melakukan apa yang kita lakukan dengan koin klasik: mengukur sepanjang sumbu yang berbeda. Pengukuran standar kita pada komputer kuantum adalah sepanjang sumbu vertikal, seperti pengukuran "kepala ke atas atau ke bawah" biasa dari koin klasik. Tapi kita juga bisa menanyakan koin kuantum apakah ia berada kepala ke kiri atau ke kanan, atau secara setara, apakah ia berada dalam keadaan $|+\rangle$ atau $|-\rangle$, yang menunjuk sepanjang sumbu $x$. Sampler hanya mengambil sampel dalam basis pengukuran Z, tapi kita bisa menggunakan Estimator untuk memberikan nilai ekspektasi X. Nilai X adalah +1 dan -1 untuk keadaan $|+\rangle$ atau $|-\rangle$, masing-masing.

Cek pemahamanmu

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

Jika koin kuantum berperilaku seperti koin klasik dalam kasus ini, kita akan memiliki probabilitas 50-50 untuk mengukur keadaan berada di $|+\rangle$ dan $|-\rangle$. Nilai ekspektasi X apa yang kita harapkan dikembalikan oleh Estimator, jika itu masalahnya?

Jawaban:

Ketika kita menerapkan X pada keadaan $|+\rangle$, kita mendapatkan nilai +1 dan pada keadaan $|-\rangle$ kita mendapatkan -1, jadi jika kita memiliki distribusi 50-50, kita akan mendapatkan nilai ekspektasi 0.

# Step 1: map problem

qcoin_lr = QuantumCircuit(1)
qcoin_lr.h(0)

obs = Pauli("X")

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qcoin_lr)
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 = estimator_sim.run([[qc_isa,obs_isa]])
# res=job.result()

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

print(res[0].data.evs)

0.9985207100591716

Nilai ekspektasi X untuk keadaan ini adalah 1. Jadi, tidak ada probabilitas 50-50 untuk mengukur $|+\rangle$ dan $|-\rangle$.

Cek pemahamanmu

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

Apa yang nilai ekspektasi ini katakan kepada kita tentang keadaan $|\psi\rangle$? Berapa probabilitas pengukuran $|+\rangle$ dan $|-\rangle$ dalam basis X ini?

Jawaban:

Karena nilai ekspektasinya sama dengan nilai X untuk keadaan $|+\rangle$, itu berarti kita memiliki probabilitas 100% untuk mengukur keadaan $|+\rangle$ ketika kita mengukur sepanjang X.

Ada apa di sini? Tampaknya koin kuantum kita bisa memiliki hasil acak dan probabilistik sepanjang satu dimensi, tapi hasil yang bisa diprediksi dengan sempurna sepanjang dimensi lainnya. Itu akan seperti melempar koin dan menjamin bahwa setiap kali ia ditangkap dengan menjepit di antara dua tangan, kepala akan selalu menghadap ke kanan.

Fase kuantum

Perbedaan utama koin kuantum adalah ia memiliki sifat lain yang tidak dimiliki koin klasik. Ingat bahwa dalam keadaan probabilistik klasik,

$$S(coin) = c_1|up\rangle + c_2|down\rangle$$

setiap koefisien hanyalah bilangan real positif yang merepresentasikan probabilitas mengukur keadaan tertentu. Dalam keadaan kuantum,

$$|\psi\rangle = c_1 |0\rangle + c_2 |1\rangle$$

koefisiennya bersifat kompleks, sehingga mengandung bagian real dan bagian imajiner. Setiap koefisien $c_i$ bisa dinyatakan sebagai vektor dua dimensi pada bidang kompleks, dengan magnitudo $|c_i|$ dan sudut $\phi_i$ yang dibentuknya terhadap sumbu real:

$$c_i = |c_i| e^{i \phi_i}.$$

Kita menyebut $\phi_i$ sebagai fase. Fase memberitahu kita bagaimana dua suku dalam keadaan kuantum akan berinterferensi, atau bagaimana keduanya akan saling menjumlahkan atau saling membatalkan seperti gelombang. Jika dua gelombang sefase satu sama lain, sehingga puncak dan lembahnya berimpit, maka keduanya akan bergabung membentuk gelombang yang dua kali lebih tinggi. Ini disebut interferensi konstruktif. Jika keduanya berbeda fase, artinya puncak satu berimpit dengan lembah yang lain, dan sebaliknya, maka keduanya berinterferensi secara destruktif dan saling menghilangkan sepenuhnya.

Seperti gelombang, keadaan kuantum juga bisa berjumlah secara konstruktif maupun destruktif. Ini kadang lebih sulit dilihat karena seringkali kita tidak berbicara tentang gelombang nyata di ruang fisik. Dalam kasus qubit kita, interferensi terjadi di ruang informasi abstrak qubit. Perlu juga dicatat bahwa karena hanya fase relatif antara dua gelombang yang menentukan cara interferensinya — yaitu, selisih fase $\Delta \phi = \phi_2 - \phi_1$ dari dua koefisien — kita biasanya menerapkan fase global $-\phi_1$ ke seluruh keadaan sehingga $c_1$ menjadi murni real dan fase relatif sepenuhnya tercermin dalam $c_2$.

Untuk melihat bagaimana fase dapat menyebabkan interferensi pada koin kuantum kita, mari coba terapkan Hadamard dua kali berturut-turut alih-alih hanya sekali. Secara klasik, ini tidak masuk akal — jika menerapkan Hadamard setara dengan melempar koin, maka kamu tidak bisa melempar koin yang sudah berputar. Tapi mari lihat apa yang terjadi pada koin kuantum:

qcoin_0 = QuantumCircuit(1)
qcoin_0.h(0)
qcoin_0.h(0)
qcoin_0.measure_all()

qcoin_0.draw("mpl")

Sekarang, sebelum menggunakan Sampler untuk mengukur keadaan yang dihasilkan, mari pikirkan bagaimana qubit ini akan diubah oleh setiap Gate. Seperti biasa, qubit dimulai dari $|0\rangle$. Lalu, Hadamard pertama mengubah keadaan menjadi superposisi, seperti yang sudah kita lihat:

$$H|0\rangle = \frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle.$$

Dalam kasus ini, kedua koefisien sepenuhnya real dan positif, artinya fasenya adalah $\phi=0$.

Hadamard kedua kemudian diterapkan ke setiap bagian dari keadaan superposisi secara terpisah. Kita sudah tahu bagaimana Hadamard mengubah keadaan $|0\rangle$. Tapi bagaimana dengan $|1\rangle$?

$$H|1\rangle = \frac{1}{\sqrt{2}} |0\rangle - \frac{1}{\sqrt{2}} |1\rangle$$

Ini juga merupakan superposisi setara antara 0 dan 1, mirip dengan melempar koin, tetapi koefisien keadaan ini di depan $|1\rangle$ memiliki fase $\phi = \pi$ yang memberikan tanda negatif.

Cek pemahamanmu

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

Hitung keadaan yang dihasilkan setelah menerapkan Hadamard kedua. Yaitu, hitung: $H(\frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle)$. Perhatikan bahwa $H$ bersifat distributif, sehingga kita bisa menerapkannya ke setiap suku secara terpisah.

Jawaban:

$$H(\frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle) = \frac{1}{\sqrt{2}} H|0\rangle + \frac{1}{\sqrt{2}} H|1\rangle = \frac{1}{2} [(|0\rangle + |1\rangle) + (|0\rangle - |1\rangle)] = |0\rangle$$

Sekarang mari verifikasi prediksi kita dengan Sampler.

## Transpile

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

qc_isa = pm.run(qcoin_0)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

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

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

Hadamard kedua telah membatalkan yang pertama, dan kita kembali ke keadaan 0 seperti semula! Ini karena Hadamard mengubah keadaan $|0\rangle$ dan $|1\rangle$ ke keadaan yang serupa, tetapi dengan fase yang berlawanan. Setelah Hadamard kedua, kita melihat bahwa suku $|0\rangle$ berinterferensi secara konstruktif, tetapi suku $|1\rangle$ berinterferensi secara destruktif dan saling menghilangkan.

Mari kita jelajahi lebih lanjut: kita bisa mengubah fase menggunakan Gate "PHASE". Sekarang mari terapkan Hadamard untuk membuat superposisi, terapkan pergeseran fase sebesar $\pi$ radian, lalu terapkan Hadamard kedua:

qcoin_pi = QuantumCircuit(1)
qcoin_pi.h(0)
qcoin_pi.p(np.pi, 0)
qcoin_pi.h(0)
qcoin_pi.measure_all()

qcoin_pi.draw("mpl")

## Transpile

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

qc_isa = pm.run(qcoin_pi)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

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

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

Dan sekarang qubit diukur berada di keadaan 1, bukan 0.

Jadi, bahkan dari beberapa eksperimen sederhana ini, kamu sudah bisa melihat perbedaan drastis yang bisa ditimbulkan fase ini pada Circuit kuantum. Efeknya bisa halus dan sulit dilihat pada awalnya. Dalam eksperimen pertama kita, di mana kita sekadar melempar koin kuantum dengan Gate Hadamard dan mengukur hasil lemparan, tidak ada efek fase yang terlihat. Baru ketika kita menggali lebih dalam kita menemukan perbedaan yang bisa ditimbulkan fase. Fase bisa menyebabkan Gate kuantum yang sama memiliki efek yang secara harfiah berlawanan pada sebuah qubit.

Coba sendiri:

Edit sel kode di bawah untuk mengubah fase sehingga Hadamard kedua menciptakan keadaan superposisi dengan probabilitas 25% dan 75% untuk menemukan keadaan di $|0\rangle$ dan $|1\rangle$ secara berturut-turut. Verifikasi jawabanmu dengan matematika.

qcoin_phase = QuantumCircuit(1)
qcoin_phase.h(0)
# replace "x" below with a phase from 0 to 2*np.pi (this cell won't run if you leave x)
# qcoin_phase.rz(x, 0)
qcoin_phase.h(0)
qcoin_phase.measure_all()

## Transpile

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

qc_isa = pm.run(qcoin_phase)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

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

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

Analogi koin lain (yang lebih baik) menggunakan Gate $\sqrt{\text{NOT}}$

Sampai sini kita sudah tahu bahwa tindakan melempar koin cukup berbeda dari menciptakan keadaan superposisi. Apakah ada analogi koin yang lebih baik yang menangkap lebih banyak fenomena mirip superposisi? Ya. Memang ada.

Kita akan melakukan eksperimen pikiran lain dengan koin. Bayangkan koin tergeletak di atas meja, sisi kepala menghadap atas. Untuk membuatnya menghadap bawah, kita cukup membaliknya. Ini setara secara komputasi dengan Gate "NOT".

Katakanlah kita ingin membuat operasi yang, jika diterapkan dua kali, setara dengan Gate NOT. Artinya, kita ingin "akar kuadrat dari NOT," atau $\sqrt{\text{NOT}}$. Kita bisa melakukan ini dengan mempertimbangkan bagaimana Gate NOT diimplementasikan secara fisik pada koin: itu hanyalah rotasi 180 derajat mengelilingi, misalnya, sumbu x. Jadi, jika kita memutar koin hanya 90 derajat mengelilingi sumbu x, itu setara dengan Gate $\sqrt{\text{NOT}}$.

Bayangkan bahwa setelah menerapkan Gate $\sqrt{\text{NOT}}$, kita ingin bertanya apakah koin menghadap atas atau bawah. Jawabannya bukan keduanya — koin berdiri di tepinya relatif terhadap sumbu vertikal. Tapi sekarang, mari definisikan ulang "pengukuran" koin kita sebagai: pertama, runtuhkan koin sepanjang sumbu pengukuran (dengan menepuk koin dengan tanganmu sehingga tergeletak datar), dan kedua, periksa apakah sisi kepala menghadap atas atau bawah.

Jika kita melakukan "pengukuran" ini pada koin yang berdiri di tepinya, koin akan "runtuh" ke kepala atas dan kepala bawah dengan probabilitas yang sama. Mirip dengan lemparan koin, pada prinsipnya, arah jatuhnya koin bisa diprediksi berdasarkan kondisi awal koin dan bagaimana tepatnya gaya tangan kita diterapkan untuk "meruntuhkannya." Namun dalam praktiknya, sulit diprediksi sisi mana yang akan mendarat ke atas, sehingga pada dasarnya bersifat acak.

Kita sebenarnya bisa mengukur koin ini sepanjang tiga sumbu berbeda: $x$, $y$, dan $z$. Kita melihat bahwa tepi koin mengarah sepanjang $x$ dan $z$, sehingga pengukuran di arah tersebut memerlukan "keruntuhan" koin — karenanya, di sepanjang sumbu tersebut, hasilnya acak dengan probabilitas 50:50 antara kepala atas dan kepala bawah. Namun sepanjang sumbu $y$, koin sudah datar, dengan sisi kepalanya menghadap arah -y. Kita bisa menyebutnya "kepala ke depan."

Jadi, sementara pengukuran x dan z menghasilkan hasil acak, pengukuran y akan selalu menghasilkan hasil yang sama! Jika kamu mengingat eksperimen "lemparan koin kuantum" dari bagian sebelumnya, ini mengingatkan pada bagaimana koin kuantum berperilaku. Koin diukur sebagai 0 atau 1 dengan probabilitas 50/50 dalam arah z, tetapi selalu $|+\rangle$ dan tidak pernah $|-\rangle$ sepanjang X. Ini menunjukkan bahwa mungkin koin yang diam berdiri di tepinya adalah cara yang lebih baik untuk memvisualisasikan keadaan superposisi qubit daripada koin yang berputar liar di udara.

Mari gunakan Qiskit untuk melihat apakah "koin kuantum" kita berperilaku sama seperti koin klasik ketika Gate $\sqrt{\text{NOT}}$ diterapkan. Kita akan menerapkan $\sqrt{\text{NOT}}$ pada qubit yang dimulai dari $|0\rangle$, lalu menggunakan Estimator untuk memeriksa nilai ekspektasi dari tiga observabel: X, Y, dan Z.

qcoin_sx = QuantumCircuit(1)
qcoin_sx.sx(0)

qcoin_sx.draw("mpl")

obs1 = Pauli("X")
obs2 = Pauli("Y")
obs3 = Pauli("Z")

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qcoin_sx)
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

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

# Run the job on the Aer simulator with noise model from real backend
# pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]
# job = estimator_sim.run(pubs)
# res=job.result()

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

print(res[0].data.evs)

[[-0.01234492]
 [-1.00388865]
 [ 0.00740695]]

Nilai ekspektasinya adalah 0, -1, dan 0 untuk X, Y, dan Z secara berturut-turut.

Cek pemahamanmu

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

Berdasarkan nilai ekspektasi tersebut, berapa probabilitas mengukur koin kuantum sebagai kepala atas/bawah (atau kiri/kanan atau maju/mundur) untuk masing-masing dari 3 sumbu pengukuran?

Jawaban:

Ada probabilitas 50/50 untuk mengukur salah satu keadaan sepanjang X dan Z, dan keadaan selalu diukur dalam arah -y sepanjang Y.

Ini adalah hasil yang sama yang kita dapatkan dari eksperimen pikiran kita menerapkan rotasi 90 derajat "$\sqrt{\text{NOT}}$" pada koin klasik. Faktanya, sekarang ada analogi yang tepat antara koin dan keadaan qubit. Kita bisa memvisualisasikan keadaan qubit sebagai vektor yang mengarah ke arah sisi kepala pada koin, tegak lurus terhadap permukaan koin. Jadi, kepala atas, atau keadaan $|0\rangle$ pada koin kuantum, setara dengan vektor yang mengarah lurus ke atas; kepala bawah, atau $|1\rangle$, mengarah lurus ke bawah. Setiap superposisi setara antara $|0\rangle$ dan $|1\rangle$ mengarah secara horizontal. Fase keadaan menentukan arah horizontal yang tepat — arah yang ditunjuknya sepanjang ekuator sama dengan arah yang ditunjuk koefisien $c_2$ di bidang kompleks.

Sekarang, setiap Gate yang telah kita lihat di notebook ini bisa divisualisasikan sebagai rotasi (atau serangkaian rotasi) dari koin/vektor tersebut.

• NOT: 180 derajat mengelilingi sumbu x

• $\sqrt{\text{NOT}}$: 90 derajat mengelilingi sumbu x

• PHASE: rotasi sebesar $\phi$ mengelilingi sumbu z

• Hadamard: Yang satu ini sedikit lebih rumit. Awalnya kita menyamakannya dengan melempar koin, membuat koin berputar tak terkendali di udara. Tapi Hadamard sebenarnya adalah rotasi koin yang terkontrol dan deterministik, seperti Gate-Gate lainnya. Hadamard dilakukan dengan memutar 90 derajat mengelilingi sumbu y, lalu 180 derajat mengelilingi sumbu x.

Jadi, tidak ada yang acak dari keadaan superposisi kuantum atau operasi standar yang kita lakukan pada qubit. Setiap operasi bersifat deterministik dan reversibel. Satu-satunya saat keacakan muncul adalah ketika kita memutuskan untuk mengukur keadaan kuantum.

Keadaan qubit sebagai vektor Bloch

Vektor yang mengarah ke arah "kepala" koin ini dikenal sebagai "vektor Bloch." Secara formal, keadaan qubit terisolasi yang sembarang bisa direpresentasikan oleh vektor yang terletak di permukaan bola berjari-jari 1 dengan koordinat $(r, \theta, \phi)$. Ditulis dalam koordinat tersebut, keadaan qubit adalah:

$|\psi\rangle = \cos{\frac{\theta}{2}} |0\rangle + e^{i \phi} \sin{\frac{\theta}{2}} |1\rangle$

Sekarang mari periksa dengan Qiskit bagaimana vektor Bloch berubah ketika kita menerapkan berbagai Gate pada qubit yang dimulai dari keadaan $|0\rangle$.

NOT

from qiskit.visualization import plot_bloch_multivector

qnot = QuantumCircuit(1)
qnot.x(0)

plot_bloch_multivector(qnot)

$\sqrt{\text{NOT}}$

qsqrtnot = QuantumCircuit(1)
qsqrtnot.sx(0)

plot_bloch_multivector(qsqrtnot)

PHASE ($\phi = \pi$)

qphase = QuantumCircuit(1)
qphase.p(np.pi, 0)

plot_bloch_multivector(qphase)

Hadamard

qhadamard = QuantumCircuit(1)
qhadamard.h(0)

plot_bloch_multivector(qhadamard)

Kesimpulan — jadi apa sebenarnya keadaan superposisi itu?

Kita memulai modul ini dengan membandingkan keacakan pengukuran keadaan superposisi kuantum dengan lemparan koin. Kita menyamakan "Gate Hadamard" yang menghasilkan superposisi kuantum dengan tindakan melempar koin. Tapi, melalui serangkaian eksperimen, kita menemukan bahwa ada perbedaan mendasar antara lemparan koin klasik dan superposisi kuantum.

Kita belajar bahwa sebenarnya tidak ada yang "acak" dari qubit dalam keadaan superposisi. Ini seperti koin yang diam dalam ruang tiga dimensi. Bahkan, koin yang bebas berotasi dalam 3 dimensi adalah analogi yang sangat mirip dengan cara tertentu untuk memvisualisasikan keadaan kuantum sebuah qubit, yang disebut vektor Bloch. Gate-Gate kuantum memutar koin/vektor Bloch ini secara deterministik dan reversibel. Keacakan hanya muncul ketika kita mengukur qubit. Kita membandingkan proses pengukuran ini dengan menepuk koin sehingga tergeletak datar dalam arah sumbu pengukuran.

Apakah suatu keadaan kuantum berada dalam superposisi sebenarnya hanya bergantung pada sudut pandang pengamat. Seperti yang mungkin pernah kamu temui sebelumnya, kita bebas memilih sistem koordinat kita — $x$, $y$, dan $z$ bisa mengarah ke tiga arah tegak lurus mana saja. Jadi, jika kita memiliki superposisi antara 0 dan 1 dalam satu sistem koordinat, kita bisa mendefinisikan sistem koordinat baru — atau secara setara, "basis pengukuran" baru — di mana keadaan mengarah murni ke arah $+z$, dan karenanya tidak berada dalam keadaan superposisi. Jadi, ketika kita mengatakan sebuah qubit berada dalam superposisi, kita juga harus menjawab pertanyaan, "superposisi dari apa?"

Kamu mungkin meninggalkan modul ini dengan kesan bahwa kita baru saja menghilangkan semua misteri dari mekanika kuantum. Bagaimanapun, salah satu aspek yang konon "paling aneh", yaitu keadaan superposisi qubit, sebenarnya sesederhana vektor tiga dimensi. Tapi ingatlah bahwa koin hanyalah sebuah analogi, dan bahkan vektor Bloch pun hanya alat visualisasi untuk menghitung probabilitas hasil pengukuran. Kita tidak bisa mengatakan apa yang "sebenarnya" dilakukan keadaan kuantum sebelum diukur. Karena untuk memeriksanya, diperlukan pengukuran!

Kita akan membahas dilema tentang apa "sifat sejati" dari keadaan kuantum, bagaimana fenomena kuantum berupa keterikatan (entanglement) dapat membantu kita menjelaskan hal ini, di modul Ketidaksetaraan Bell.

Pertanyaan

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

Konsep kritis:

• Meskipun pengukuran qubit dalam superposisi bersifat probabilistik, seperti melempar koin, keadaan superposisi itu sendiri berperilaku berbeda dari koin yang melayang.
• Perbedaan utama antara distribusi probabilitas klasik dan superposisi adalah bahwa superposisi memiliki koherensi fase, yang memungkinkannya berinterferensi secara konstruktif atau destruktif.
• Keadaan satu qubit terisolasi bisa divisualisasikan sebagai sebuah titik di atas yang disebut "bola Bloch," di mana amplitudo relatif komponen $|0\rangle$ dan $|1\rangle$ menentukan sudut polar $\theta$ dan fase relatif antara kedua komponen menentukan sudut azimut $\phi$.
• Semua Gate kuantum satu qubit bisa dipandang sebagai rotasi vektor pada bola ini.

Pertanyaan B/S:

1. B/S Superposisi kuantum pada dasarnya sama dengan kejadian probabilistik dalam fisika klasik, seperti melempar koin.

2. B/S Panjang vektor Bloch yang menggambarkan keadaan satu qubit terisolasi selalu 1.

3. B/S Gate kuantum satu qubit tidak mengubah panjang vektor Bloch.

Pertanyaan pilihan ganda:

1. Pilih vektor Bloch yang tepat yang merepresentasikan keadaan $|\Psi\rangle = \sqrt{\frac{1}{3}}|0\rangle + e^{i \pi / 4} \sqrt{\frac{2}{3}}|1\rangle$:

2. Bola Bloch menggambarkan: (pilih semua yang berlaku)

   a. amplitudo

   b. keterikatan (entanglement) dengan qubit lain

   c. fase

   d. warna

   e. probabilitas hasil pengukuran

Pertanyaan diskusi:

1. Mengapa keadaan qubit bisa divisualisasikan di bola Bloch, sedangkan distribusi probabilitas lemparan koin tidak bisa?

2. Mengapa koin yang melayang di udara bukan analogi terbaik untuk keadaan superposisi kuantum? Aspek superposisi apa yang tidak tertangkap dalam analogi ini?

Soal tantangan:

1. Gunakan Qiskit untuk membuat Circuit yang mengubah keadaan $|0\rangle$ ke keadaan $\frac{\sqrt{3}}{2}|0\rangle + \frac{1}{2}e^{i \frac{5\pi}{6}}|1\rangle$