Pengantar Praktis Kriteria DiVincenzo dengan Qiskit 2

Pendahuluan

Fisikawan David DiVincenzo memaparkan lima persyaratan utama untuk setiap implementasi fisik komputer kuantum, ditambah dua kriteria tambahan untuk komunikasi kuantum. Di notebook ini, kita akan merasakan langsung setiap kriteria DiVincenzo melalui demonstrasi Qiskit yang praktis. Daripada mendalami teori, setiap bagian menjelaskan secara singkat satu kriteria lalu menyediakan latihan kode menggunakan Qiskit 2. Kamu akan menjalankan Circuit pada simulator dan perangkat IBM Quantum nyata untuk menjelajahi setiap prinsip secara langsung.

Lima Kriteria DiVincenzo untuk Komputasi Kuantum:

1. Sistem fisik yang dapat diskalakan dengan Qubit yang terkarakterisasi dengan baik.
2. Kemampuan menginisialisasi Qubit ke keadaan fiducial sederhana (misalnya |00…0〉).
3. Waktu dekoherensi yang panjang (koherensi Qubit jauh lebih lama dari waktu operasi Gate).
4. Sekumpulan Gate kuantum universal (mampu melakukan operasi uniter sembarang).
5. Kemampuan pengukuran spesifik per Qubit (membaca keadaan setiap Qubit).

(DiVincenzo juga mendeskripsikan dua kriteria untuk komunikasi kuantum: kemampuan untuk saling mengubah Qubit stasioner dan "terbang", serta mengirimkan Qubit terbang secara setia antar lokasi. Kami menyertakan ini dalam aktivitas rekomendasi di akhir notebook ini.)

Setiap bagian berikut berkaitan dengan satu kriteria. Kita akan menggunakan Qiskit untuk mengilustrasikan konsep dengan kode dan eksperimen interaktif yang bisa kamu coba. Misalnya, kita akan melihat bagaimana penambahan jumlah Qubit dan kedalaman Circuit memengaruhi hasil (Kriteria 1), cara mereset dan menyiapkan keadaan Qubit (Kriteria 2), cara mengukur Qubit di simulator vs perangkat nyata (Kriteria 4), cara Qiskit menyusun Gate universal (Kriteria 3), dan bagaimana koherensi terbatas (T₁, T₂) memengaruhi komputasi (Kriteria 5). Di akhir, kamu akan memiliki intuisi yang lebih dalam tentang apa arti setiap kriteria DiVincenzo dalam praktik dan bagaimana Qiskit memungkinkan eksperimen dengannya.

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

# Install necessary packages
!pip install qiskit[visualization] qiskit-ibm-runtime qiskit-aer qiskit_ibm_runtime

1. Kriteria 1 – Qubit yang Dapat Diskalakan dan Terkarakterisasi dengan Baik

Kriteria 1: "Sistem fisik yang dapat diskalakan dengan Qubit yang terkarakterisasi dengan baik." Ini berarti kita membutuhkan platform perangkat keras kuantum di mana kita bisa meningkatkan jumlah Qubit dan tetap mengendalikannya dengan andal. Setiap properti Qubit (tingkat energi, tingkat kesalahan, konektivitas, dll.) harus dipahami dengan baik. Pada dasarnya, kita ingin membangun Circuit yang lebih besar tanpa sistem menjadi rusak. Dalam praktiknya, saat kita menambah jumlah Qubit atau kedalaman Circuit, kesalahan dan dekoherensi terakumulasi, sehingga menunjukkan skalabilitas juga berarti memahami bagaimana peningkatan ukuran memengaruhi performa.

Tujuan Demo: Gunakan Qiskit untuk menunjukkan efek penskalaan Circuit (dalam jumlah Qubit atau kedalaman Gate) terhadap fidelitas output. Kita akan mensimulasikan skenario ideal vs berderau untuk melihat bagaimana sistem yang lebih besar atau Circuit yang lebih dalam rentan terhadap dekoherensi dan kesalahan.

Pertama, mari buat keadaan terjalin kecil (keadaan GHZ) pada 3 Qubit, lalu yang lebih besar pada 5 Qubit, sebagai tes penskalaan sederhana. Keadaan GHZ dengan n Qubit adalah $\frac{1}{\sqrt{2}}(|0...0\rangle + |1...1\rangle)$. Dalam simulasi ideal, mengukur GHZ n-Qubit hanya menghasilkan dua kemungkinan (semua 0 atau semua 1) dengan probabilitas sama. Kita akan membandingkan output ideal dengan output berderau saat kita menambah n atau kedalaman Circuit.

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import SamplerV2 as Sampler

# 3-qubit GHZ circuit
qc3 = QuantumCircuit(3, 3)
qc3.h(0)
qc3.cx(0, 1)
qc3.cx(1, 2)
qc3.measure([0, 1, 2], [0, 1, 2])

# 5-qubit GHZ circuit (scaling up the number of qubits)
qc5 = QuantumCircuit(5, 5)
qc5.h(0)
qc5.cx(0, range(1, 5))    # entangle qubit 0 with all others
qc5.measure(range(5), range(5))

# Transpile for a simulator backend
sim_backend = AerSimulator()
pm = generate_preset_pass_manager(backend=sim_backend, optimization_level=1)
isa_qc3 = pm.run(qc3)
isa_qc5 = pm.run(qc5)

# Run ideal simulations (no noise)
sampler = Sampler(mode=sim_backend)

job3 = sampler.run([isa_qc3], shots=1024)
result3 = job3.result()
counts3 = result3[0].data.c.get_counts()

job5 = sampler.run([isa_qc5], shots=1024)
result5 = job5.result()
counts5 = result5[0].data.c.get_counts()

print("3-qubit GHZ counts (ideal):", counts3)
plot_histogram(counts3, legend=['3-qubit ideal'], figsize=(6,4))

3-qubit GHZ counts (ideal): {'000': 531, '111': 493}

print("5-qubit GHZ counts (ideal):", counts5)
plot_histogram(counts5, legend=['5-qubit ideal'], figsize=(6,4))

5-qubit GHZ counts (ideal): {'11111': 535, '00000': 489}

Hasil yang diharapkan (kasus ideal): GHZ 3-Qubit secara ideal menghasilkan sekitar 50% 000 dan 50% 111 dalam hitungan. GHZ 5-Qubit menghasilkan ~50% 00000 dan 50% 11111. Tidak ada bitstring lain yang muncul karena keadaannya secara ideal sepenuhnya koheren dan terjalin. Kamu akan melihat dua batang tinggi pada histogram untuk setiap Circuit yang berkorespondensi dengan hasil semua-nol dan semua-satu.

Berikutnya, mari lihat apa yang terjadi di lingkungan berderau. Kita akan menggunakan kemampuan model derau Qiskit Aer untuk meniru kesalahan perangkat nyata. Misalnya, kita bisa mengambil properti Backend IBM untuk membuat model derau yang mencakup kesalahan Gate, waktu Gate terbatas, relaksasi Qubit (T₁), dephasing (T₂), dan kesalahan pembacaan. Di sini, kita akan menggunakan fake backend yang merepresentasikan perangkat IBM Quantum Brisbane untuk membuat model derau, lalu menjalankan ulang Circuit GHZ melaluinya.

Latihan 1a: Simulasi dengan Derau

Lengkapi kode di bawah ini untuk mensimulasikan Circuit GHZ pada simulator berderau berbasis Backend FakeBrisbane. Ini akan menunjukkan bagaimana performa menurun saat sistem diskalakan dalam lingkungan derau yang realistis.

from qiskit_ibm_runtime.fake_provider import FakeBrisbane

# We will reuse the ideal circuits qc3 and qc5 and their results from the previous cell.

# --- YOUR CODE HERE ---

# 1. Create a fake backend for IBM Quantum Brisbane
###brisbane_backend = ...

# 2. Create a noisy AerSimulator from the fake backend's properties
###noisy_sim = ...

# 3. Transpile the circuits for the noisy simulator (this adapts them to the device's specific gates and connectivity)
###pm = ...

###isa_qc3_noisy = ...

###isa_qc5_noisy = ...

# 4. Run the noisy simulations using the Sampler and get the counts
###sampler = ...

###job3 = ...

###result3_noisy = ...

###counts3_noisy = ...

###job5 = ...

###result5_noisy = ...

###counts5_noisy = ...

# --- END YOUR CODE ---

# This part is done for you to print and plot the results:
print("3-qubit GHZ counts (noisy):", counts3_noisy)
plot_histogram(counts3_noisy, legend=['3-qubit noisy'], figsize=(6,4))

print("5-qubit GHZ counts (noisy):", counts5_noisy)
plot_histogram(counts5_noisy, legend=['5-qubit noisy'], figsize=(6,4))

Latihan 1b: Jalankan di Komputer IBM Quantum Nyata

Kode di bawah ini menjalankan Circuit GHZ pada komputer IBM Quantum nyata. Ini akan menunjukkan bagaimana performa menurun pada perangkat nyata.

# your_api_key = "deleteThisAndPasteYourAPIKeyHere"
# your_crn = "deleteThisAndPasteYourCRNHere"

# QiskitRuntimeService.save_account(
#     channel="ibm_quantum_platform",
#     token=your_api_key,
#     instance=your_crn,
#     name="fallfest-2025",
# )

# Check that the account has been saved properly
# service = QiskitRuntimeService(name="fallfest-2025")
# print(service.saved_accounts())

# We will reuse the ideal circuits qc3 and qc5 and their results from the previous cell.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService(name="fallfest-2025")
real_backend = service.least_busy(operational=True, simulator=False)
print("Running on " + real_backend.name)

pm = generate_preset_pass_manager(backend=real_backend, optimization_level=1)
isa_qc3r = pm.run(qc3)
isa_qc5r = pm.run(qc5)

sampler = Sampler(mode=real_backend)

job3r = sampler.run([isa_qc3r], shots=1024)
result3r = job3r.result()
counts3r = result3r[0].data.c.get_counts()

job5r = sampler.run([isa_qc5r], shots=1024)
result5r = job5r.result()
counts5r = result5r[0].data.c.get_counts()

print("3-qubit GHZ counts (real):", counts3r)
plot_histogram(counts3r, legend=['3-qubit real'], figsize=(6,4))

print("5-qubit GHZ counts (real):", counts5r)
plot_histogram(counts5r, legend=['5-qubit real'], figsize=(6,4))

Hasil yang diharapkan (berderau vs ideal): Dengan derau, baik yang disimulasikan maupun di perangkat nyata, keadaan GHZ menjadi kurang sempurna. Kamu akan melihat kemungkinan tambahan di luar semua-0 dan semua-1. Untuk 3 Qubit, alih-alih 100% di 000/111, sebagian probabilitas bocor ke bitstring lain (misalnya 001, 010, dll.) akibat kesalahan Gate atau dekoherensi yang membalik beberapa Qubit. Untuk 5 Qubit, efeknya bahkan lebih terasa; Circuit yang lebih besar (lebih banyak Qubit dan Gate CNOT) mengakumulasi lebih banyak kesalahan, sehingga puncak semua-0 dan semua-1 lebih rendah, dan banyak kemungkinan lain muncul. Tren ini menggambarkan tantangan skalabilitas: saat kita menskalakan, mempertahankan fidelitas tinggi semakin sulit tanpa koreksi kesalahan.

Wawasan: Komputer kuantum yang dapat diskalakan perlu mempertahankan korelasi kuantum seiring sistem bertumbuh. Contoh kita menunjukkan bagaimana peningkatan jumlah Qubit/kedalaman Gate menyebabkan fidelitas output menurun saat ada derau. Kriteria-kriteria berikutnya akan membahas cara menjaga Qubit berperilaku baik (kesalahan rendah, dapat diinisialisasi, dll.) saat kita menskalakan.

2. Kriteria 2 – Inisialisasi Qubit

Kriteria 2: "Kemampuan menginisialisasi keadaan Qubit ke keadaan fiducial sederhana, seperti |000…〉." Semua Qubit harus secara andal dimulai dalam keadaan referensi yang diketahui (biasanya keadaan dasar |0〉 untuk setiap Qubit). Inisialisasi sangat penting agar algoritma dimulai dengan slate bersih. Dalam praktiknya, pada perangkat IBM Quantum setiap Qubit secara otomatis direset ke |0〉 di awal setiap eksekusi Circuit. Qiskit juga menyediakan instruksi untuk mereset Qubit atau menyiapkan keadaan kustom selama komputasi berlangsung.

Tujuan Demo: Menunjukkan cara menginisialisasi Qubit di Qiskit, baik di awal maupun di tengah Circuit. Kita akan mendemonstrasikan penggunaan instruksi reset dan metode persiapan keadaan.

Latihan 2: Siapkan Keadaan Tertentu

Dalam blok kode di bawah ini, lengkapi QuantumCircuit untuk menyiapkan keadaan $|10\rangle$. Ini berarti Qubit 0 harus berada dalam keadaan $|0\rangle$ dan Qubit 1 dalam keadaan $|1\rangle$. Gunakan Gate dan instruksi yang tepat untuk mencapai ini.

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

# Create a circuit to initialize qubits to |10> and verify by measurement
qc_init = QuantumCircuit(2, 2)

# --- YOUR CODE HERE ---

# 1. Set qubit 1 to the |1> state

# 2. Explicitly reset qubit 0 to the |0> state

# --- END YOUR CODE ---

qc_init.measure([0, 1], [0, 1])
qc_init.draw('mpl')

# Run the circuit and check the outcome
sim_backend = AerSimulator()
pm = generate_preset_pass_manager(backend=sim_backend, optimization_level=1)
isa_qc_init = pm.run(qc_init)

sampler = Sampler(mode=sim_backend)

job = sampler.run([isa_qc_init], shots=1024)
result = job.result()
counts = result[0].data.c.get_counts()

print("Outcome of |10> state measured in Z-basis:", counts)
plot_histogram(counts)

Kamu seharusnya melihat 10 (biner untuk qubit1=1, qubit0=0) dengan probabilitas 100% dari simulasi, yang berarti Qubit 1 berhasil disiapkan dalam |1〉 dan Qubit 0 dalam |0〉.

Sekarang, untuk persiapan keadaan yang lebih umum, Qiskit memungkinkan inisialisasi ke keadaan sembarang menggunakan metode initialize. Misalnya, mari siapkan Qubit dalam keadaan $|+\rangle = (|0\rangle+|1\rangle)/\sqrt{2}$, yang merupakan keadaan superposisi, dan pasangan Qubit dalam keadaan Bell $(|00\rangle+|11\rangle)/\sqrt{2}$:

import numpy as np

# Initialize a single qubit in |+> state and measure in Z-basis
qc_plus = QuantumCircuit(1, 1)
state_plus = [1/np.sqrt(2), 1/np.sqrt(2)]   # amplitude for |0> and |1>
qc_plus.initialize(state_plus, 0)
qc_plus.measure(0, 0)

# Initialize two qubits in a Bell state manually
qc_bell = QuantumCircuit(2, 2)
bell_state = [1/np.sqrt(2), 0, 0, 1/np.sqrt(2)]  # amplitudes for |00>,|01>,|10>,|11>
qc_bell.initialize(bell_state, [0, 1])
qc_bell.measure([0, 1], [0, 1])

# Transpile and run the initialization circuits
isa_qc_plus = pm.run(qc_plus)
job_plus = sampler.run([isa_qc_plus], shots=1024)
result_plus = job_plus.result()
counts_plus = result_plus[0].data.c.get_counts()

print("Outcome of |+> state measured in Z-basis:", counts_plus)

isa_qc_bell = pm.run(qc_bell)
job_bell = sampler.run([isa_qc_bell], shots=1024)
result_bell = job_bell.result()
counts_bell = result_bell[0].data.c.get_counts()

print("Outcome of Bell state measured in Z-basis:", counts_bell)

Outcome of |+> state measured in Z-basis: {'1': 499, '0': 525}
Outcome of Bell state measured in Z-basis: {'00': 508, '11': 516}

Hasil yang diharapkan: Keadaan |+〉 Qubit tunggal, saat diukur, akan menghasilkan 0 dan 1 dengan probabilitas masing-masing sekitar 50%. Pengukuran keadaan Bell seharusnya memberikan sekitar 50% 00 dan 50% 11. Jika kamu melihat ini, artinya inisialisasi ke keadaan-keadaan tersebut berhasil.

Inisialisasi di tengah Circuit: reset Qiskit dapat digunakan di tengah Circuit untuk menginisialisasi ulang Qubit ke |0〉 secara langsung. Misalnya, dalam kode koreksi kesalahan atau algoritma iteratif, seseorang sering mengukur Qubit lalu meresetnya untuk digunakan kembali. Operasi reset bersifat deterministik; ia membuang keadaan yang ada dan mendinginkan Qubit kembali ke keadaan dasar.

Contoh perangkat: Pada perangkat keras seperti ibmq_brisbane (127 Qubit) atau perangkat IBM mana pun, semua Qubit dimulai dalam |0〉 secara default saat pekerjaan dijalankan. Jika kamu membutuhkan keadaan awal yang berbeda, kamu akan menerapkan Gate di awal (seperti yang kita lakukan dengan X untuk mendapatkan |1〉). Re-inisialisasi berkelanjutan (untuk koreksi kesalahan kuantum) adalah topik penelitian aktif karena melakukannya dengan cepat sangat menantang. Untungnya, untuk penggunaan dasar, kemampuan untuk memulai fresh dalam |0…0〉 tersedia dan kita telah mendemonstrasikan cara mencapai keadaan awal yang diinginkan lainnya juga.

3. Kriteria 3 – Waktu Koherensi Panjang (Dekoherensi vs Waktu Gate)

Kriteria 3: "Waktu dekoherensi yang relevan cukup panjang, jauh lebih panjang dari waktu operasi gate." Ini menekankan kebutuhan qubit untuk mempertahankan keadaan kuantumnya cukup lama agar operasi yang diperlukan bisa dilakukan. Setiap qubit memiliki waktu T₁ (waktu relaksasi energi, seberapa cepat |1〉 meluruh ke |0〉) dan waktu T₂ (waktu dephasing, seberapa cepat koherensi fase relatif hilang). Agar komputer kuantum bisa bekerja, skala waktu ini harus jauh melebihi durasi operasi gate.

Tujuan Demo: Selidiki koherensi qubit di Qiskit dengan menunjukkan bagaimana dekoherensi mempengaruhi hasil Circuit seiring panjang eksekusi bertambah. Kita akan menggunakan fake backend dengan nilai T1/T2 yang diketahui untuk mensimulasikan efek ini.

Untuk mendemonstrasikan dampak koherensi yang terbatas, kita akan menyimulasikan eksperimen peluruhan T1. Kita akan menyiapkan qubit dalam keadaan |1〉, menunggu beberapa waktu menggunakan instruksi delay, lalu mengukur. Kita mengharapkan probabilitas mengukur |1〉 menurun seiring delay bertambah.

# This part is done for you. We are creating a list of circuits,
# each with a different delay time.

time_delays_ns = [0, 50000, 100000, 150000, 200000, 250000, 300000]  # delay durations in ns

decay_expts = []
for delay in time_delays_ns:
    qc = QuantumCircuit(1, 1)
    qc.x(0)  # initialize qubit to |1>
    if delay > 0:
        qc.delay(delay, 0, unit='ns')  # wait 'delay' nanoseconds
    qc.measure(0, 0)
    decay_expts.append(qc)

decay_expts[1].draw('mpl') # Visualize one of the circuits

Latihan 3: Simulasikan Eksperimen Peluruhan T1

Sekarang, gunakan simulator berisik berbasis FakeVigo (yang memiliki waktu T1 ~50-100 µs) untuk menjalankan Circuit-Circuit ini. Simulator akan secara otomatis menerapkan error T1/T2 selama instruksi delay. Transpile Circuit untuk backend ini dan eksekusi.

from qiskit_ibm_runtime.fake_provider import FakeVigoV2 as FakeVigo
from qiskit_aer import AerSimulator

# --- YOUR CODE HERE ---

# 1. Create a noisy simulator from the FakeVigo backend
###sim_vigo = ...

# 2. Transpile the list of circuits for this simulator
###pm = ...

###isa_decay_expts = ...

# 3. Use the Sampler to run all the transpiled circuits in a single job
###sampler = ...

###job = ...

###result = ...

# --- END YOUR CODE ---

# This part is done for you to analyze and print the results.
for idx, (delay, qc) in enumerate(zip(time_delays_ns, isa_decay_expts)):
    counts = result[idx].data.c.get_counts()
    p1 = counts.get('1', 0) / 1000  # Assuming 1000 shots
    print(f"Delay {delay} ns: P(qubit=1) = {p1:.3f}")

4. Kriteria 4 – Set Gate Kuantum Universal

Kriteria 4: "Sebuah set gate kuantum yang 'universal'." Ini berarti perangkat keras kita harus memungkinkan kita melakukan komputasi kuantum apa pun dengan mengomposisikan sejumlah terbatas gate dasar. Dalam komputasi klasik, NAND bersifat universal; dalam komputasi kuantum, ada banyak pilihan set gate universal (misalnya {H, T, CNOT} atau gate native dari mesin tertentu). Perangkat IBM, misalnya, memiliki set operasi native seperti rotasi single-qubit sewenang-wenang dan CNOT antar qubit tertentu, yang bersama-sama bersifat universal. Tugas Qiskit sering kali adalah mengompilasi gate tingkat tinggi ke dalam gate basis ini.

Tujuan Demo: Ilustrasikan universalitas gate dengan menunjukkan cara Qiskit mendekomposisi gate. Kita akan mengambil gate yang tidak native (seperti gate Toffoli 3-qubit, CCX) dan melihat bagaimana gate tersebut dipecah menjadi gate basis perangkat. Ini menunjukkan bahwa set gate yang disediakan memang universal – ia bisa menghasilkan operasi yang lebih kompleks.

Pertama, mari kita lihat apa saja gate basis untuk backend IBM yang tipikal. Kita akan mengquery konfigurasi sebuah perangkat (atau versi fake-nya). Misalnya, gate basis ibmq_brisbane: Kamu seharusnya mengamati probabilitas P(qubit=1) yang menurun seiring waktu delay bertambah, mengikuti kurva peluruhan eksponensial yang khas dari relaksasi T1. Ini langsung mendemonstrasikan bagaimana waktu koherensi yang terbatas menyebabkan error komputasi jika Circuit berjalan terlalu lama.

Dampak pada algoritma: Jika kamu mencoba algoritma yang lebih panjang (dengan banyak gate berurutan), total waktu eksekusi mungkin mendekati atau melebihi T2, menyebabkan keadaan kehilangan koherensi sebelum selesai. Inilah mengapa meningkatkan waktu koherensi dan membuat gate lebih cepat adalah dua tujuan paling kritis dalam penelitian perangkat keras kuantum.

from qiskit_ibm_runtime.fake_provider import FakeBrisbane
fake_brisbane = FakeBrisbane()
print("Basis gates for ibmq_brisbane:", fake_brisbane.configuration().basis_gates)

Basis gates for ibmq_brisbane: ['ecr', 'id', 'rz', 'sx', 'x']

Output ini mungkin seperti ['id', 'rz', 'sx', 'x', 'ecr']. Ini adalah operasi primitif yang didukung secara native oleh perangkat keras (Identity/no-op, rotasi RZ, gate sqrt(X), gate X, dan controlled-X). Gate lain apa pun harus dikomposisikan dari ini. Set ini diketahui bersifat universal untuk komputasi kuantum (pada dasarnya rotasi single-qubit ditambah gate two-qubit yang menghasilkan entanglement membentuk set universal).

Sekarang, ambil gate Toffoli (CCX) sebagai kasus uji. CCX membalik qubit target hanya jika dua qubit kontrol keduanya bernilai 1. Ini bukan gate native di perangkat keras IBM. Qiskit menyediakan instruksi ccx, tetapi di balik layar akan mendekomposisinya.

Latihan 4: Dekomposisi Gate Toffoli

Lengkapi kode di bawah ini untuk membuat Circuit dengan gate Toffoli (CCX) lalu gunakan Qiskit untuk memecahnya menjadi gate basis native dari backend FakeBrisbane.

from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeBrisbane

# The fake_brisbane backend from the previous cell is reused here.

# --- YOUR CODE HERE ---

# 1. Create a circuit that can accommodate a Toffoli gate
###qc_toffoli = ...

# Apply a CCX gate with controls on qubits 0, 1 and target on qubit 2

# 2. Transpile the circuit to the fake Brisbane backend
###pm = ...

###isa_qc_toffoli = ...

# --- END YOUR CODE ---

print("Toffoli circuit before decomposition:")
print(qc_toffoli)

print("\nToffoli circuit after transpiling to Brisbane basis:")
# The .draw() method will now show the decomposed circuit
print(isa_qc_toffoli.draw(fold=120))

Dalam output yang sudah ditranspile, kamu seharusnya melihat CCX digantikan oleh urutan gate yang lebih dasar seperti rz, sx, dan ecr. Ini membuktikan bahwa gate native sudah cukup untuk mengekspresikan Toffoli.

Universalitas dalam praktik: Latihan di atas menunjukkan bahwa gate 3-qubit yang kompleks dibangun dari gate yang lebih sederhana. Secara umum, unitary multi-qubit apa pun dapat dikomposisikan dari gate 1- dan 2-qubit. Transpiler adalah komponen penting dari stack software kuantum mana pun, karena menjembatani kesenjangan antara algoritma abstrak yang ingin kita jalankan dengan operasi fisik yang sebenarnya dapat dilakukan oleh perangkat kuantum tertentu.

Contoh perangkat: Perangkat ibmq_brisbane menggunakan arsitektur Eagle dengan gate basis seperti yang ditunjukkan di atas. Artinya, algoritma apa pun yang dikirim ke mesin tersebut akan dikonversi menjadi urutan operasi tersebut. Kriteria ini pada dasarnya tentang controllability; kita memiliki cukup kontrol untuk melakukan operasi apa pun yang diperlukan pada qubit kita.

5. Kriteria 5 – Pengukuran Qubit

Kriteria 5: "Kemampuan pengukuran spesifik-qubit." Keadaan setiap qubit harus dapat diukur (biasanya dalam basis komputasi, |0〉 atau |1〉). Dengan kata lain, setelah menjalankan Circuit kuantum, kita perlu membaca setiap qubit sebagai bit klasik 0/1. Kriteria ini tentang memiliki detektor yang andal untuk setiap qubit dan kemampuan memilih qubit mana yang akan diukur.

Tujuan Demo: Tunjukkan cara melakukan pengukuran di Qiskit pada simulator dan perangkat nyata, serta soroti perbedaannya (seperti noise pengukuran). Kita akan mengukur beberapa qubit dalam berbagai keadaan dan memeriksa hasilnya. Kita juga akan mendemonstrasikan bagaimana error readout mungkin muncul dengan membandingkan hasil simulator vs perangkat keras.

Pertama, contoh pengukuran sederhana:

qc_measure = QuantumCircuit(2, 2)
qc_measure.x(0)              # qubit 0 -> |1>, qubit 1 stays |0>
qc_measure.measure([0, 1], [0, 1])
qc_measure.draw('mpl')

sim_backend = AerSimulator()
pm = generate_preset_pass_manager(backend=sim_backend, optimization_level=1)
isa_qc_measure = pm.run(qc_measure)
job = sampler.run([isa_qc_measure], shots=1000)
result = job.result()
counts = result[0].data.c.get_counts()

print("Simulator measurement counts:", counts)

Simulator measurement counts: {'01': 1000}

Kita mengharapkan 1000 hitungan 01 pada simulator. Sekarang, mari kita lihat error pengukuran dalam aksi dengan menyimulasikannya. Kita bisa menambahkan readout error ke simulator Aer kita. Qiskit Aer memungkinkan kita mendefinisikan ReadoutError dan melampirkannya ke qubit dalam noise model.

Latihan 5: Simulasikan Readout Error

Lengkapi kode untuk mendefinisikan model readout error sederhana di mana setiap qubit memiliki peluang 2% untuk diukur secara tidak benar (0 terbaca sebagai 1, atau 1 terbaca sebagai 0). Kemudian, jalankan Circuit pengukuran dengan noise model ini.

from qiskit_aer.noise import NoiseModel, ReadoutError

# --- YOUR CODE HERE ---

# 1. Define a 2% readout error for each single qubit.
# The format is a list of lists of probabilities: [[P(0|0), P(1|0)], [P(0|1), P(1|1)]]
# P(A|B) is the probability of measuring A given the state was |B>.
###ro_error = ...

# 2. Create a new noise model
###noise_model_ro = ...

# 3. Add the readout error to all qubits in the noise model
... # Hint: Use the add_all_qubit_readout_error method

# --- END YOUR CODE ---

sim_backend.set_options(noise_model=noise_model_ro)
pm = generate_preset_pass_manager(backend=sim_backend, optimization_level=1)
isa_qc_measure = pm.run(qc_measure)

# Run the measurement circuit with readout noise
sampler = Sampler(mode=sim_backend)

job = sampler.run([isa_qc_measure], shots=1024)
result = job.result()
counts = result[0].data.c.get_counts()

print("Simulation with 2% readout error:", counts)

Output yang disimulasikan ini akan menunjukkan beberapa hitungan yang salah (seperti 11, 00, 10) mirip dengan yang mungkin dihasilkan oleh perangkat keras nyata, mendemonstrasikan dampak pengukuran yang tidak sempurna.

Contoh perangkat: Pada perangkat nyata seperti ibmq_brisbane, kamu bisa menjalankan Circuit yang sama dan kemungkinan akan melihat hitungan non-nol yang serupa untuk hasil yang salah. Data kalibrasi perangkat mencantumkan readout error untuk setiap qubit. Kemampuan untuk menarget dan membaca qubit tertentu sangat penting, dan memahami karakteristik error-nya adalah kunci untuk mendapatkan hasil yang bermakna. Menjalankan pada perangkat nyata ditunjukkan dalam Latihan 1b: Jalankan di komputer IBM Quantum nyata.

Kriteria Komunikasi Kuantum (Flying Qubit)

DiVincenzo juga mendaftarkan dua kriteria khusus untuk komunikasi kuantum, penting jika membangun komputer kuantum yang terhubung dalam jaringan:

6. Kemampuan untuk saling mengkonversi qubit stasioner dan flying qubit. (Misalnya, memetakan qubit dalam prosesor ke foton yang bisa bergerak.)
7. Kemampuan untuk mengirimkan flying qubit secara akurat antar lokasi. (Misalnya, mengirim qubit foton melalui serat optik tanpa kehilangan informasi kuantum.)

Ini melampaui penggunaan Qiskit standar karena Qiskit terutama menangani qubit stasioner pada chip. Namun, kita bisa mengilustrasikan konsep kriteria ini dengan contoh sederhana: teleportasi kuantum. Teleportasi menunjukkan konversi keadaan qubit stasioner menjadi informasi yang dibawa oleh pasangan terjalin (bagian "flying") dan komunikasi klasik, yang kemudian digunakan untuk merekonstruksi keadaan pada qubit stasioner lain di tempat lain.

Aktivitas yang direkomendasikan: Ikuti modul Quantum Teleportation Qiskit in Classrooms

Modul Quantum Teleportation Qiskit in Classrooms oleh Dr. Katie McCormick akan membimbing kamu melalui salah satu protokol paling menarik dalam informasi kuantum: teleportasi kuantum, di mana keadaan kuantum (sebuah qubit) dikirim dari Alice ke Bob menggunakan entanglement dan hanya dua bit klasik. Kamu akan mempelajari prosedur teleportasi lengkap langkah demi langkah—cara menyiapkan pasangan Bell yang terjalin, melakukan pengukuran basis Bell di sisi Alice, mengirimkan hasil klasik, dan menerapkan gate kuantum yang tepat pada qubit Bob untuk memulihkan keadaan asli dengan sempurna. Sepanjang perjalanan, kamu akan mengeksplorasi mengapa teleportasi informasi qubit tidak melanggar teorema no-cloning atau melampaui kecepatan cahaya. Melalui latihan langsung menggunakan perangkat keras IBM Quantum atau simulator, kamu akan mendapatkan pemahaman praktis tentang pengukuran, entanglement, dan feed-forward control dalam aksi.

Dengan menguasai teleportasi kuantum, kamu akan memahami cara mengkodekan, mengirimkan, dan memulihkan informasi kuantum antara node yang berbeda—meletakkan fondasi untuk jaringan kuantum, sistem repeater, skema komunikasi aman, dan komputasi kuantum modular yang skalabel.

Kaitannya dengan kriteria 6 & 7: Dalam jaringan kuantum nyata, pasangan terjalin yang dibagikan akan dibuat dengan mendistribusikan "flying" qubit (seperti foton) antara lokasi Alice dan Bob (Kriteria 7: transmisi yang akurat). Protokol teleportasi itu sendiri kemudian berfungsi sebagai cara untuk memetakan keadaan qubit stasioner Alice ke setengah pasangan terjalin miliknya, secara efektif 'mengirimkannya' ke Bob (Kriteria 6: interkonversi). Qiskit memungkinkan kita menyimulasikan logika protokol dengan sempurna, memberikan model konseptual tentang bagaimana kriteria ini dipenuhi dalam arsitektur komunikasi.

Kesimpulan & Ringkasan

Kita telah merancang serangkaian latihan berbasis kode untuk mengilustrasikan kriteria DiVincenzo menggunakan Qiskit. Melalui contoh-contoh langsung ini, kamu mengeksplorasi bagaimana platform komputasi kuantum nyata memenuhi setiap persyaratan:

• Skalabilitas: membangun Circuit pada lebih banyak qubit dan memahami penskalaan noise.
• Inisialisasi: menggunakan reset dan persiapan keadaan untuk memulai komputasi secara andal dalam keadaan yang diketahui.
• Gate Universal: mentranspile operasi kompleks ke gate basis mesin, membuktikan kita bisa melakukan komputasi apa pun.
• Pengukuran: membaca qubit dan menangani readout error yang realistis.
• Koherensi: melihat efek T₁ dan T₂ yang terbatas pada fidelitas algoritma dan kebutuhan operasi untuk cepat relatif terhadap dekoherensi.

Untuk kelengkapan, kita juga menyinggung aspek komunikasi kuantum melalui modul Quantum Teleportation Qiskit in Classrooms, menghubungkan dua kriteria terakhir (flying qubit).

Terakhir, perlu dicatat bagaimana kriteria-kriteria ini bersatu dalam komputer kuantum nyata seperti milik IBM. Perangkat seperti ibmq_brisbane memiliki 127 qubit superkonduktor (Kriteria 1), masing-masing dimulai dalam |0〉 (Kriteria 2), dengan set gate yang terkalibrasi dan kompiler untuk universalitas (Kriteria 4), resonator readout gelombang mikro untuk setiap qubit (Kriteria 5), dan waktu koherensi pada orde ratusan mikrodetik vs operasi nanodetik (Kriteria 3). Untuk eksperimen jaringan kuantum, IBM dan lainnya sedang mengeksplorasi transduksi gelombang mikro-ke-optik untuk flying qubit, dan menjalin entanglement qubit yang berjauhan (Kriteria 6 & 7); itu adalah area penelitian aktif.