Buat dan jalankan program 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.

Selamat datang di Gunakan komputer kuantum hari ini! Tujuan kursus ini adalah agar kamu bisa menjalankan kode pada komputer kuantum sungguhan dalam waktu sesingkat mungkin, tanpa latar belakang khusus yang diperlukan. Ayo kita mulai.

Pelajaran pertama ini adalah pengenalan praktis yang lembut tentang komputasi kuantum, cocok untuk pemula yang penasaran maupun para pemimpin yang sibuk. Kamu akan belajar tentang Circuit kuantum dan menulis program kuantum kecil yang menciptakan entanglement, lalu menjalankannya di komputer kuantum IBM® yang sungguhan. Kamu juga punya opsi untuk menjalankan program yang sama di simulator, jika memilih untuk melewati eksekusi di komputer kuantum sungguhan.

Kamu bisa menjalankan notebook ini dari atas ke bawah di runtime Google Colab yang baru, atau secara lokal.

Persiapan

Untuk menjalankan notebook ini di Google Colab, kamu perlu akun Google agar bisa membuka notebook dan menjalankan sel di browser.

Untuk menjalankan di komputer kuantum IBM sungguhan, kamu juga perlu (gratis) akun IBM Quantum® Platform. Kamu bisa membuka instance menggunakan Open Plan untuk mendapatkan 10 menit waktu quantum processor unit (QPU) per jendela bergulir 28 hari, yang sebenarnya cukup banyak! Jika ada masalah dengan akunmu, lihat halaman Support.

Kamu juga bisa menjalankan notebook ini secara lokal setelah menginstal Qiskit dengan mengikuti petunjuk di IBM Quantum Platform.

Instalasi dan impor

Di Colab, kita menginstal dependensi di dalam notebook agar semua orang menggunakan alat yang sama. Sel berikutnya menginstal Qiskit dengan modul visualisasi ditambah dua add-on: Aer (simulator cepat) dan klien IBM Runtime (untuk menjalankan di komputer kuantum).

Selanjutnya, ada beberapa impor. Kelas QuantumCircuit adalah tempat kita mendefinisikan bit kuantum, atau qubit, dan mendefinisikan operasi pada qubit tersebut. Ini adalah istilah kuantum pertama kita: qubit adalah blok bangunan dasar komputasi kuantum, sama seperti bit adalah blok bangunan komputasi klasik. Kita akan mempelajari lebih lanjut tentang sifat-sifat khusus qubit saat kita membuat Circuit. Selanjutnya, plot_histogram akan digunakan untuk memvisualisasikan hasil Circuit kuantum kita. AerSimulator memungkinkan kita menyimulasikan Circuit kuantum di komputer klasik. Namun simulator tidak bisa menjalankan Circuit kuantum pada skala yang sama seperti komputer kuantum sungguhan; itulah mengapa kita membutuhkan komputer kuantum sungguhan. Ini bisa berguna untuk pengujian, debugging, atau tujuan pendidikan; atau jika kamu sudah menghabiskan 10 menit gratis waktu QPU. preset_passmanagers membantu mengoptimalkan Circuit agar berjalan efisien di hardware, yang menjadi sangat penting saat Circuit kita semakin kompleks. Sampler dan QiskitRuntimeService diperlukan untuk benar-benar menjalankan Circuit di komputer kuantum. Lebih lanjut tentang ini nanti.

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

!pip install 'qiskit[visualization]' qiskit-ibm-runtime qiskit-aer
# Core Qiskit imports
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit_aer import AerSimulator
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# IBM Runtime specific imports
from qiskit_ibm_runtime import SamplerV2 as Sampler, QiskitRuntimeService

Selanjutnya kita akan melakukan pemeriksaan lingkungan cepat. Kita mengonfirmasi versi dan mengonfirmasi impor.

Jika ada yang gagal di sini, biasanya masalah instalasi dependensi; memperbaikinya sekarang mencegah error yang membingungkan nanti.

import sys

import qiskit
import qiskit_aer
import qiskit_ibm_runtime

print("Python:", sys.version.split()[0])
print("qiskit:", qiskit.__version__)
print("qiskit-aer:", qiskit_aer.__version__)
print("qiskit-ibm-runtime:", qiskit_ibm_runtime.__version__)

Python: 3.12.2
qiskit: 2.2.3
qiskit-aer: 0.17.2
qiskit-ibm-runtime: 0.41.1

Sedikit mampir: gunakan Composer

Sebelum menulis kode, ada baiknya melihat Circuit secara visual. IBM Quantum Composer memungkinkan kamu membangun Circuit dengan cara menyeret Gate ke kabel. Ini adalah cara yang bagus untuk mempelajari apa yang dilakukan Circuit tanpa terganggu oleh sintaksis.

Buka Composer di sini.

Setelah dimuat, jalankan tutorial terpandu dari menu: Help | Build your first circuit. Kerjakan sesuai kecepatanmu. Saat melakukannya, perhatikan bagaimana setiap Gate mengubah apa yang kamu harapkan untuk diukur.

Tutorial ini memandu kamu membangun Circuit "Hello World". Circuit tersebut divisualisasikan dalam apa yang disebut diagram Circuit, di mana qubit direpresentasikan oleh garis horizontal dan Gate yang bekerja pada qubit tersebut direpresentasikan oleh kotak atau simbol lain pada garis. Circuit ini memperkenalkan kita pada beberapa fitur utama qubit dan komputer kuantum:

Pertama, kotak merah berlabel "H" adalah Hadamard Gate, yang menciptakan keadaan superposisi dari qubit 0. Tidak seperti bit yang hanya bisa berada dalam keadaan 1 atau 0, keadaan qubit bisa mencakup kedua kemungkinan sekaligus, dengan bobot tertentu (disebut amplitudo) yang melekat pada masing-masing. Superposisi tidak berarti kamu akan pernah melihat kedua hasil dalam satu pengukuran; ini berarti keadaan diatur sehingga salah satu hasil bisa terjadi saat kamu mengukur.

Kedua, lingkaran dan garis vertikal yang menghubungkan dua qubit adalah CNOT Gate, yang menghasilkan entanglement antara dua qubit. Entanglement adalah jenis ikatan khusus antara qubit. Saat qubit saling terikat (entangled), hasil pengukuran bisa berkorelasi kuat dengan cara yang tidak sesuai dengan apa yang kita harapkan dari lemparan koin independen biasa, atau dari korelasi klasik mana pun. Saat dua qubit saling terikat, mengukur satu akan langsung memberitahu kamu hasil pengukuran yang lain.

Ide kunci lain yang akan kamu lihat dalam tutorial adalah shots. Karena pengukuran adalah saat qubit berhenti berperilaku seperti keadaan kuantum dan memberikan pembacaan klasik, keadaan superposisi akan secara probabilistik runtuh ke 0 atau 1 saat diukur. Jadi, untuk mempelajari superposisi tersebut, kamu perlu mengukurnya berkali-kali dengan menjalankan Circuit yang sama untuk mengumpulkan statistik. Ini disebut shots.

Uji pemahamanmu

Pikirkan setiap pertanyaan di bawah ini, lalu klik untuk mengungkap jawabannya.

Bisakah kamu melihat superposisi langsung dari satu pengukuran?

Jawaban

Tidak. Satu pengukuran selalu mengembalikan nilai klasik: 0 atau 1. Gagasan "campuran" hanya muncul dalam statistik yang kamu lihat setelah banyak pengulangan, yang juga disebut shots.

Dengan bahasa sederhana, apa yang diberikan entanglement kepadamu?

Jawaban

Entanglement memberikan hasil yang terhubung. Mengukur satu qubit memberitahu kamu sesuatu tentang yang lain. Hubungan ini lebih kuat dari keacakan independen dan lebih kuat dari korelasi klasik atau keacakan bersama mana pun yang bisa menjelaskannya.

Jika sebuah qubit berada dalam superposisi, apa yang kamu lihat dalam satu pengukuran, dan mengapa kamu perlu banyak shots?

Jawaban

Dalam satu pengukuran kamu hanya melihat satu hasil klasik: 0 atau 1. Kamu membutuhkan banyak shots karena "superposisi" muncul sebagai distribusi probabilitas, yang hanya bisa kamu perkirakan dengan mengumpulkan statistik dari pengulangan yang berulang.

Lihat histogram pengukuran Circuit Hello World kamu di Composer. Apa yang kamu lihat? Mengapa ini adalah tanda dari entanglement?

Jawaban

Itu menunjukkan peluang 50% berada dalam keadaan $|00\rangle$ dan peluang 50% berada dalam keadaan $|11\rangle$. Ini berarti jika kamu mengukur satu bernilai 0, yang lain akan bernilai 0 juga, dan jika kamu mengukur satu bernilai 1, yang lain juga akan bernilai 1. Ini adalah korelasi antara dua qubit yang bisa dijelaskan oleh entanglement.

Buat dan jalankan program kuantum menggunakan Qiskit

Oke, kembali ke coding. Kita akan menghasilkan keadaan yang sama seperti yang kita lakukan di Composer (disebut $\Phi^+$ (phi-plus) Bell state) tapi kali ini, kita akan menulis kodenya sendiri. Kita perlu membangun keterampilan ini karena saat kita skala ke lebih banyak qubit dan Circuit yang lebih kompleks, Composer tidak akan bisa membantu kita.

Untuk membangun Bell state Circuit, kita menggunakan Gate $H$ (Hadamard) untuk menempatkan qubit pertama ke dalam superposisi yang sama. Kemudian kita menerapkan Gate $CX$ (controlled-NOT), yang mengikat kedua keadaan bersama. Kedua qubit sekarang berkorelasi dengan cara yang tidak memiliki padanan klasik.

# --- Build the Bell circuit (phi-plus) ---
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()  # creates a classical register named "meas"

bell.draw("mpl")

Fungsi pembantu untuk menjalankan Circuit

Sekarang mari kita definisikan fungsi pembantu yang menangani proses menjalankan Circuit kuantum dan mengambil hasil pengukuran. Fungsi ini mengurus transpilasi Circuit agar sesuai dengan instruction set Backend, menjalankannya melalui primitif Sampler, dan mengekstrak perhitungan dari hasilnya.

def run_circuit_and_get_counts(circuit, backend, shots=1000):
    """
    Runs a quantum circuit on a specified backend and returns the measurement counts.

    Args:
        circuit (QuantumCircuit): The quantum circuit to run.
        backend: The Qiskit backend (real device or simulator).
        shots (int): The number of shots to run the circuit.

    Returns:
        dict: A dictionary of measurement counts.
    """
    pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
    isa_circuit = pm.run(circuit)

    sampler = Sampler(mode=backend)

    job = sampler.run([isa_circuit], shots=shots)
    result = job.result()

    return result[0].data.meas.get_counts()

Jalankan di QPU dan visualisasikan hasilnya

Terakhir, kita menjalankan Circuit di unit pemrosesan kuantum (QPU) IBM di cloud untuk 1000 shots dan memplot hasilnya. QPU IBM adalah sistem fisik yang bisa menangkap noise, sehingga Gate sedikit tidak sempurna, pengukuran bisa salah kadang-kadang, dan kalibrasi perangkat berubah seiring waktu.

Menjalankan di komputer kuantum sungguhan juga menimbulkan pertimbangan praktis. Pekerjaan bisa menunggu dalam antrian, karena banyak orang mungkin menggunakan perangkat yang sama. Kamu juga harus memilih jumlah shot yang menyeimbangkan pertimbangan statistik (lebih banyak shots berarti rasio signal-to-noise yang lebih tinggi) dengan batasan waktu/biaya.

Ikuti petunjuk dalam komentar kode pada sel berikutnya. Setelah menjalankan sel, kamu seharusnya melihat histogram dengan jumlah yang kira-kira sama untuk bitstring $00$ dan $11$, dengan beberapa kemunculan $01$ atau $10$ karena noise. Sel berikutnya dalam notebook ini menjalankan Circuit yang sama pada simulator, jika kamu memilih untuk melewati eksekusi di QPU.

# Syntax for first saving your token.  Delete these lines after saving your credentials.
QiskitRuntimeService.save_account(
    channel="ibm_quantum_platform",
    token="YOUR_TOKEN_HERE",
    overwrite=True,
    set_as_default=True,
)
service = QiskitRuntimeService(channel="ibm_quantum_platform")

# Load saved credentials
service = QiskitRuntimeService()

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

ibm_pittsburgh

counts = run_circuit_and_get_counts(bell, backend, shots=1000)
plot_histogram(counts)

Jalankan di simulator dan visualisasikan hasilnya

Simulator adalah versi "dunia sempurna" dari komputasi kuantum. Di sini kita menjalankan Circuit di simulator untuk 1000 shots dan memplot hasilnya. Kamu seharusnya melihat jumlah yang kira-kira sama untuk keadaan $00$ dan $11$, tanpa kemunculan $01$ atau $10$, yang merupakan tanda korelasi sempurna Bell state.

backend = AerSimulator()
counts = run_circuit_and_get_counts(bell, backend, shots=1000)

plot_histogram(counts)

Uji pemahamanmu

Apa dua Gate yang menciptakan Bell state di sini?

Jawaban

Gate H pada qubit 0, diikuti oleh Gate CX dengan qubit 0 sebagai kontrol dan qubit 1 sebagai target.

Pada simulator ideal, dua bitstring mana yang seharusnya mendominasi histogram?

Jawaban

00 dan 11 seharusnya mendominasi.

Mengapa simulator yang sempurna tidak selalu memiliki jumlah 00 yang persis sama dengan jumlah 11?

Jawaban

Meskipun simulator "sempurna" dan menghasilkan Bell state yang sempurna, itu masih menyimulasikan proses yang secara inheren acak, sehingga fluktuasi statistik tetap akan terjadi. Ini seperti melempar koin 1000 kali: meskipun ada peluang tepat 50-50 koin mendarat di sisi kepala atau ekor, itu tidak berarti kamu selalu mendapatkan tepat 500 kepala dan 500 ekor.

Mengapa komputer kuantum sungguhan bisa menunjukkan beberapa hasil 01 atau 10 meskipun simulator tidak?

Jawaban

Karena perangkat sungguhan memiliki noise. Gate dan pengukuran tidak sempurna, dan itu bisa menimbulkan kesalahan sesekali.

Apa satu perbedaan praktis antara simulator dan komputer kuantum sungguhan selain noise?

Jawaban

Komputer kuantum bisa melibatkan waktu antrian, ketersediaan terbatas, dan batasan khusus perangkat yang memengaruhi cara Circuit dijalankan.

Kesimpulan

Kita mulai dengan menyiapkan Qiskit di lingkungan Colab yang baru, yang persis seperti cara banyak alur kerja notebook dunia nyata dimulai. Kita kemudian melakukan perjalanan ke komputasi kuantum menggunakan Composer. Kemudian kita membangun Circuit dua-qubit sederhana yang menghasilkan $\Phi^+$ Bell state dan menggunakan sampling berulang serta memvisualisasikan entanglement sebagai korelasi dalam histogram pengukuran qubit. Kita juga melihat bagaimana komputer kuantum sungguhan memperkenalkan noise dan kesalahan.

Tujuan pembelajaran

Sekarang setelah kita membahas cara membuat $\Phi^+$ Bell state, coba lihat apakah kamu bisa mengedit kode untuk membuat salah satu dari tiga Bell state lainnya. Khususnya, keadaan $\Psi^-$ akan digunakan dalam pelajaran mendatang, jadi jika kamu berhasil membuatnya, kamu akan selangkah lebih maju.