Pengenalan Hands-On kepada Kriteria DiVincenzo dengan Qiskit 2

Pengenalan

Ahli fizik David DiVincenzo menggariskan lima keperluan utama untuk sebarang pelaksanaan fizikal komputer kuantum, ditambah dua kriteria tambahan untuk komunikasi kuantum. Dalam notebook ini, kita akan mengalami setiap kriteria DiVincenzo melalui demonstrasi Qiskit yang praktikal. Daripada menyelami teori secara mendalam, setiap bahagian menerangkan secara ringkas satu kriteria dan kemudian menyediakan latihan kod menggunakan Qiskit 2. Kamu akan dapat menjalankan Circuit pada simulator dan peranti IBM Quantum sebenar untuk meneroka setiap prinsip secara hands-on.

Lima Kriteria DiVincenzo untuk Pengiraan Kuantum:

1. Sistem fizikal yang boleh diskala dengan Qubit yang dicirikan dengan baik.
2. Keupayaan untuk memulakan Qubit kepada keadaan fiducial yang mudah (cth. |00…0〉).
3. Masa dekoherensi yang panjang (koherensi Qubit jauh lebih lama daripada masa operasi Gate).
4. Satu set universal Gate kuantum (mampu melakukan operasi unitary sewenang-wenangnya).
5. Keupayaan pengukuran khusus Qubit (membaca keadaan setiap Qubit).

(DiVincenzo juga menghuraikan dua kriteria untuk komunikasi kuantum: keupayaan untuk saling menukar Qubit pegun dan "terbang", serta menghantar Qubit terbang antara lokasi dengan tepat. Kami menyertakan ini dalam aktiviti yang disyorkan di penghujung notebook ini.)

Setiap bahagian berikut sepadan dengan satu kriteria. Kita akan menggunakan Qiskit untuk menggambarkan konsep dengan kod dan eksperimen interaktif yang boleh kamu cuba. Contohnya, kita akan melihat bagaimana menambah bilangan Qubit dan kedalaman Circuit mempengaruhi hasil (Kriteria 1), cara menetapkan semula dan menyediakan keadaan Qubit (Kriteria 2), cara mengukur Qubit pada simulator berbanding peranti sebenar (Kriteria 4), bagaimana Qiskit menggubah Gate universal (Kriteria 3), dan bagaimana koherensi terhad (T₁, T₂) memberi kesan kepada pengiraan (Kriteria 5). Pada akhirnya, kamu akan mempunyai intuisi yang lebih mendalam tentang apa yang setiap kriteria DiVincenzo bermaksud dalam amalan dan bagaimana Qiskit membolehkan eksperimen dengan mereka.

# 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 Boleh Diskala dan Dicirikan dengan Baik

Kriteria 1: "Sistem fizikal yang boleh diskala dengan Qubit yang dicirikan dengan baik." Ini bermakna kita memerlukan platform perkakasan kuantum di mana kita boleh meningkatkan bilangan Qubit dan masih mengawalnya dengan boleh dipercayai. Sifat setiap Qubit (aras tenaga, kadar ralat, sambungan, dan lain-lain) mestilah difahami dengan baik. Pada dasarnya, kita mahu membina Circuit yang lebih besar tanpa sistem runtuh. Dalam amalan, apabila kita meningkatkan bilangan Qubit atau kedalaman Circuit, ralat dan dekoherensi terkumpul, jadi menunjukkan skalabiliti juga bermakna memahami bagaimana peningkatan saiz mempengaruhi prestasi.

Matlamat Demo: Gunakan Qiskit untuk menunjukkan kesan peningkatan skala Circuit (dalam bilangan Qubit atau kedalaman Gate) terhadap ketepatan output. Kita akan mensimulasikan senario ideal berbanding bising untuk melihat bagaimana sistem yang lebih besar atau Circuit yang lebih dalam tewas kepada dekoherensi dan ralat.

Pertama, mari bina keadaan terbelit kecil (keadaan GHZ) pada 3 Qubit, kemudian yang lebih besar pada 5 Qubit, sebagai ujian skala yang mudah. Keadaan GHZ n Qubit ialah $\frac{1}{\sqrt{2}}(|0...0\rangle + |1...1\rangle)$. Dalam simulasi ideal, mengukur GHZ n-Qubit menghasilkan hanya dua kemungkinan (semua 0 atau semua 1) dengan kebarangkalian yang sama. Kita akan membandingkan output ideal dengan output bising apabila kita meningkatkan 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 dijangka (kes ideal): GHZ 3-Qubit secara ideal menghasilkan kira-kira 50% 000 dan 50% 111 dalam kiraan. GHZ 5-Qubit menghasilkan ~50% 00000 dan 50% 11111. Tiada rentetan bit lain muncul kerana keadaan secara idealnya sepenuhnya koheren dan terbelit. Kamu sepatutnya melihat dua bar tinggi pada histogram untuk setiap Circuit yang sepadan dengan hasil semua-sifar dan semua-satu.

Seterusnya, mari lihat apa yang berlaku dalam persekitaran bising. Kita akan menggunakan keupayaan model hingar Qiskit Aer untuk meniru ralat peranti sebenar. Contohnya, kita boleh mengambil sifat Backend IBM untuk mencipta model hingar yang termasuk ralat Gate, masa Gate terhad, kelonggaran Qubit (T₁), dephasing (T₂), dan ralat bacaan. Di sini, kita akan menggunakan fake backend yang mewakili peranti IBM Quantum Brisbane untuk menjana model hingar, dan menjalankan semula Circuit GHZ melaluinya.

Latihan 1a: Simulasi dengan Hingar

Lengkapkan kod di bawah untuk mensimulasikan Circuit GHZ pada simulator bising berdasarkan Backend FakeBrisbane. Ini akan menunjukkan kepada kamu bagaimana prestasi merosot apabila sistem diskala dalam persekitaran hingar yang realistik.

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 pada komputer IBM Quantum sebenar

Kod di bawah menjalankan Circuit GHZ pada komputer IBM Quantum sebenar. Ini akan menunjukkan kepada kamu bagaimana prestasi merosot pada peranti sebenar.

# 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 dijangka (bising berbanding ideal): Dengan hingar, sama ada disimulasikan atau pada peranti sebenar, keadaan GHZ adalah kurang sempurna. Kamu akan melihat hasil tambahan selain semua-0 dan semua-1. Untuk 3 Qubit, daripada 100% dalam 000/111, sebahagian kebarangkalian bocor ke dalam rentetan bit lain (cth. 001, 010, dan lain-lain) akibat ralat Gate atau dekoherensi yang membalikkan beberapa Qubit. Untuk 5 Qubit, kesannya lebih ketara; Circuit yang lebih besar (lebih banyak Qubit dan Gate CNOT) mengumpul lebih banyak ralat, jadi puncak semua-0 dan semua-1 lebih rendah, dan banyak hasil lain muncul. Trend ini menggambarkan cabaran skalabiliti: apabila kita meningkatkan skala, mengekalkan ketepatan tinggi menjadi lebih sukar tanpa pembetulan ralat.

Pandangan: Komputer kuantum yang boleh diskala perlu mengekalkan korelasi kuantum apabila sistem berkembang. Contoh kita menunjukkan bagaimana peningkatan bilangan Qubit/kedalaman Gate menyebabkan ketepatan output menurun apabila hingar wujud. Kriteria yang tinggal akan berkaitan dengan memastikan Qubit tersebut berkelakuan baik (ralat rendah, boleh dimulakan, dan lain-lain) apabila kita meningkatkan skala.

2. Kriteria 2 – Permulaan Qubit

Kriteria 2: "Keupayaan untuk memulakan keadaan Qubit kepada keadaan fiducial yang mudah, seperti |000…〉." Semua Qubit harus bermula secara boleh dipercayai dalam keadaan rujukan yang diketahui (biasanya keadaan asas |0〉 untuk setiap Qubit). Permulaan adalah penting supaya algoritma bermula dengan permulaan yang bersih. Dalam amalan, pada peranti kuantum IBM setiap Qubit secara automatik ditetapkan semula kepada |0〉 pada permulaan setiap pelaksanaan Circuit. Qiskit juga menyediakan arahan untuk menetapkan semula Qubit atau menyediakan keadaan tersuai semasa pengiraan.

Matlamat Demo: Tunjukkan cara memulakan Qubit dalam Qiskit, baik pada permulaan mahupun di pertengahan Circuit. Kita akan menunjukkan penggunaan arahan reset dan kaedah penyediaan keadaan.

Latihan 2: Sediakan Keadaan Tertentu

Dalam blok kod di bawah, lengkapkan QuantumCircuit untuk menyediakan keadaan $|10\rangle$. Ini bermakna Qubit 0 sepatutnya berada dalam keadaan $|0\rangle$ dan Qubit 1 dalam keadaan $|1\rangle$. Gunakan Gate dan arahan yang sesuai 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 sepatutnya melihat 10 (binari untuk qubit1=1, qubit0=0) dengan kebarangkalian 100% daripada simulasi, bermakna Qubit 1 berjaya disediakan dalam |1〉 dan Qubit 0 dalam |0〉.

Sekarang, untuk penyediaan keadaan yang lebih umum, Qiskit membenarkan permulaan kepada keadaan sewenang-wenangnya menggunakan kaedah initialize. Contohnya, mari sediakan satu Qubit dalam keadaan $|+\rangle = (|0\rangle+|1\rangle)/\sqrt{2}$, iaitu keadaan superposisi, dan sepasang 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 dijangka: Keadaan |+〉 Qubit tunggal, apabila diukur, akan menghasilkan 0 dan 1 dengan kebarangkalian kira-kira 50% masing-masing. Pengukuran keadaan Bell sepatutnya memberikan kira-kira 50% 00 dan 50% 11. Jika kamu melihat ini, ia mengesahkan permulaan kita kepada keadaan tersebut berjaya.

Permulaan pertengahan Circuit: reset Qiskit boleh digunakan di tengah-tengah Circuit untuk memulakan semula Qubit kepada |0〉 secara langsung. Contohnya, dalam kod pembetulan ralat atau algoritma berulang, seseorang sering mengukur Qubit dan kemudian menetapkan semula untuk digunakan semula. Operasi reset adalah deterministik; ia membuang sebarang keadaan sedia ada dan menyejukkan Qubit kembali ke keadaan asas.

Contoh peranti: Pada perkakasan seperti ibmq_brisbane (127 Qubit) atau mana-mana peranti IBM, semua Qubit bermula dalam |0〉 secara lalai apabila kerja dijalankan. Jika kamu memerlukan keadaan permulaan yang berbeza, kamu akan menggunakan Gate pada permulaan (seperti yang kita lakukan dengan X untuk mendapat |1〉). Permulaan semula berterusan (untuk pembetulan ralat kuantum) adalah topik penyelidikan aktif kerana melakukannya dengan cepat adalah mencabar. Syukurlah, untuk kegunaan asas, keupayaan untuk bermula segar dalam |0…0〉 tersedia dan kita menunjukkan cara mencapai keadaan permulaan lain yang dikehendaki juga.

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

Kriteria 3: "Masa dekoherensi yang relevan perlu panjang, jauh lebih panjang daripada masa operasi gate." Ini berkaitan dengan keperluan Qubit untuk mengekalkan keadaan kuantumnya cukup lama untuk menjalankan operasi yang diperlukan. Setiap Qubit mempunyai masa T₁ (masa relaksasi tenaga, seberapa cepat |1〉 meluruh ke |0〉) dan masa T₂ (masa dephasing, seberapa cepat koherensi fasa relatif hilang). Supaya komputer kuantum berfungsi, skala masa ini perlu melebihi tempoh operasi gate dengan ketara.

Tujuan Demo: Kaji koherensi Qubit dalam Qiskit dengan menunjukkan bagaimana dekoherensi mempengaruhi keputusan Circuit apabila panjang pelaksanaan bertambah. Kita akan gunakan fake backend dengan masa T1/T2 yang diketahui untuk mensimulasikan kesan ini.

Untuk menunjukkan kesan koherensi terhad, kita akan simulasi eksperimen luruhan T1. Kita akan sediakan Qubit dalam keadaan |1〉, tunggu beberapa waktu menggunakan arahan delay, kemudian ukur. Kita jangkakan kebarangkalian untuk mengukur |1〉 akan berkurang apabila kelewatan 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 Luruhan T1

Sekarang, gunakan simulator bermasalah berdasarkan FakeVigo (yang mempunyai masa T1 ~50-100 µs) untuk menjalankan Circuit-Circuit ini. Simulator akan secara automatik menerapkan ralat T1/T2 semasa arahan delay. Transpile Circuit-Circuit untuk Backend ini dan laksanakannya.

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 Universal Gate Kuantum

Kriteria 4: "Set 'universal' Gate kuantum." Ini bermaksud perkakasan kita mestilah membolehkan kita melakukan sebarang pengiraan kuantum dengan menggabungkan set terhad Gate asas. Dalam pengiraan klasik, NAND adalah universal; dalam kuantum, terdapat pelbagai pilihan set Gate universal (cth. {H, T, CNOT} atau Gate natif mesin tertentu). Peranti IBM, misalnya, mempunyai set operasi natif seperti putaran Qubit tunggal sewenang-wenangnya dan CNOT antara Qubit tertentu, yang bersama-sama adalah universal. Tugas Qiskit sering adalah untuk menyusun Gate peringkat tinggi ke dalam Gate asas ini.

Tujuan Demo: Ilustrasikan keuniversalan Gate dengan menunjukkan cara Qiskit menguraikan Gate. Kita akan ambil Gate bukan natif (seperti Gate Toffoli 3-Qubit, CCX) dan lihat cara ia dipecahkan kepada Gate asas peranti. Ini menunjukkan bahawa set Gate yang disediakan memang universal – ia boleh menghasilkan operasi yang lebih kompleks.

Pertama, mari lihat apakah Gate asas untuk Backend IBM tipikal. Kita akan tanya konfigurasi peranti (atau versi palsunya). Sebagai contoh, Gate asas ibmq_brisbane: Anda perlu perhatikan kebarangkalian P(qubit=1) berkurang apabila masa kelewatan bertambah, mengikut lengkung luruhan eksponen yang mencirikan relaksasi T1. Ini secara langsung menunjukkan bagaimana masa koherensi terhad membawa kepada ralat pengiraan jika Circuit berjalan terlalu lama.

Kesan pada algoritma: Jika anda cuba algoritma yang lebih panjang (dengan banyak Gate berurutan), jumlah masa pelaksanaan mungkin menghampiri atau melebihi T2, menyebabkan keadaan kehilangan koherensi sebelum tamat. Itulah sebabnya meningkatkan masa koherensi dan mempercepatkan Gate adalah dua daripada matlamat paling kritikal dalam penyelidikan perkakasan 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']

Ini mungkin mengeluarkan sesuatu seperti ['id', 'rz', 'sx', 'x', 'ecr']. Ini adalah operasi primitif yang disokong secara natif oleh perkakasan (Identity/no-op, putaran RZ, Gate sqrt(X), Gate X, dan controlled-X). Sebarang Gate lain mesti disusun daripada ini. Set ini diketahui universal untuk pengiraan kuantum (pada dasarnya putaran Qubit tunggal ditambah Gate dua-Qubit penyambung membentuk set universal).

Sekarang, ambil Gate Toffoli (CCX) sebagai kes ujian. CCX membalikkan Qubit sasaran hanya jika dua Qubit kawalan kedua-duanya adalah 1. Ia bukan Gate natif pada perkakasan IBM. Qiskit menyediakan arahan ccx, tetapi di sebaliknya ia akan menguraikannya.

Latihan 4: Uraikan Gate Toffoli

Lengkapkan kod di bawah untuk membina Circuit dengan Gate Toffoli (CCX) dan kemudian gunakan Qiskit untuk memecahkannya kepada Gate asas natif 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 di-transpile, anda patut melihat CCX digantikan oleh urutan Gate yang lebih asas seperti rz, sx, dan ecr. Ini membuktikan bahawa Gate natif adalah mencukupi untuk menyatakan Toffoli.

Keuniversalan dalam amalan: Latihan di atas menunjukkan bahawa Gate 3-Qubit yang kompleks dibina daripada yang lebih mudah. Secara umum, sebarang unitary berbilang-Qubit boleh disusun daripada Gate 1- dan 2-Qubit. Transpiler adalah komponen penting dalam mana-mana tindanan perisian kuantum, kerana ia merapatkan jurang antara algoritma abstrak yang ingin kita jalankan dan operasi fizikal yang boleh dilakukan oleh peranti kuantum tertentu.

Contoh peranti: Peranti ibmq_brisbane menggunakan seni bina Eagle dengan Gate asas yang ditunjukkan di atas. Ini bermaksud sebarang algoritma yang dihantar ke mesin tersebut akan ditukar kepada urutan operasi tersebut. Kriteria ini pada asasnya berkaitan dengan kebolehkawalan; kita mempunyai cukup kenop kawalan untuk melakukan sebarang operasi yang diperlukan pada Qubit kita.

5. Kriteria 5 – Pengukuran Qubit

Kriteria 5: "Keupayaan pengukuran khusus Qubit." Keadaan setiap Qubit mestilah boleh diukur (biasanya dalam asas pengiraan, |0〉 atau |1〉). Dengan kata lain, selepas menjalankan Circuit kuantum, kita perlu membaca setiap Qubit sebagai bit klasik 0/1. Kriteria ini berkaitan dengan mempunyai pengesan yang boleh dipercayai untuk setiap Qubit dan keupayaan untuk memilih Qubit mana yang hendak diukur.

Tujuan Demo: Tunjukkan cara melakukan pengukuran dalam Qiskit pada simulator dan peranti sebenar, serta tonjolkan perbezaannya (seperti hingar pengukuran). Kita akan ukur beberapa Qubit dalam pelbagai keadaan dan periksa hasilnya. Kita juga akan tunjukkan bagaimana ralat pembacaan mungkin muncul dengan membandingkan keputusan simulator dengan perkakasan.

Pertama, contoh pengukuran mudah:

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 jangkakan 1000 kiraan 01 pada simulator. Sekarang, mari lihat ralat pengukuran dalam tindakan dengan mensimulasikannya. Kita boleh tambah ralat pembacaan pada simulator Aer kita. Qiskit Aer membolehkan kita menentukan ReadoutError dan melampirkannya pada Qubit dalam model hingar.

Latihan 5: Simulasikan Ralat Pembacaan

Lengkapkan kod untuk menentukan model ralat pembacaan mudah di mana setiap Qubit mempunyai 2% peluang diukur dengan salah (0 dibaca sebagai 1, atau 1 dibaca sebagai 0). Kemudian, jalankan Circuit pengukuran dengan model hingar 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 kiraan yang salah (seperti 11, 00, 10) serupa dengan apa yang mungkin dihasilkan oleh perkakasan sebenar, menunjukkan kesan pengukuran yang tidak sempurna.

Contoh peranti: Pada peranti sebenar seperti ibmq_brisbane, anda boleh menjalankan Circuit yang sama dan berkemungkinan akan melihat kiraan bukan sifar yang serupa untuk keputusan yang salah. Data penentukuran peranti menyenaraikan ralat pembacaan untuk setiap Qubit. Keupayaan untuk mensasarkan dan membaca Qubit tertentu adalah penting, dan memahami ciri ralat mereka adalah kunci untuk mendapatkan keputusan yang bermakna. Menjalankan pada peranti sebenar telah ditunjukkan dalam Latihan 1b: Jalankan pada komputer IBM Quantum sebenar.

Kriteria Komunikasi Kuantum (Flying Qubits)

DiVincenzo juga menyenaraikan dua kriteria khusus untuk komunikasi kuantum, penting jika membina komputer kuantum berjejaring:

6. Keupayaan untuk saling menukar Qubit pegun dan Qubit terbang. (Cth. memetakan Qubit dalam pemproses kepada foton yang boleh bergerak.)
7. Keupayaan untuk menghantar Qubit terbang antara lokasi dengan setia. (Cth. menghantar Qubit foton melalui gentian tanpa kehilangan maklumat kuantum.)

Ini melampaui penggunaan Qiskit standard kerana Qiskit terutamanya berkaitan dengan Qubit pegun pada cip. Namun, kita boleh ilustrasikan konsep kriteria ini dengan contoh mudah: teleportasi kuantum. Teleportasi menunjukkan penukaran keadaan Qubit pegun kepada maklumat yang dibawa oleh pasangan belitan ("bahagian terbang") dan komunikasi klasik, yang kemudian digunakan untuk membina semula keadaan pada Qubit pegun lain di tempat lain.

Aktiviti yang disyorkan: Ikuti modul Quantum Teleportation Qiskit in Classrooms

Modul Quantum Teleportation Qiskit in Classrooms oleh Dr. Katie McCormick akan membimbing anda melalui salah satu protokol paling memukau dalam maklumat kuantum: teleportasi kuantum, di mana keadaan kuantum (sebuah Qubit) dihantar dari Alice kepada Bob menggunakan belitan dan hanya dua bit klasik. Anda akan mempelajari prosedur teleportasi penuh langkah demi langkah — cara menyediakan pasangan Bell yang belit, melakukan pengukuran asas Bell di pihak Alice, menghantar keputusan klasik, dan menerapkan Gate kuantum yang betul pada Qubit Bob untuk memulihkan keadaan asal dengan sempurna. Sepanjang perjalanan, anda akan meneroka mengapa teleportasi maklumat Qubit tidak melanggar teorem tiada-pengklonan atau melebihi kelajuan cahaya. Melalui latihan langsung menggunakan perkakasan atau simulator IBM Quantum, anda akan mendapat pemahaman praktikal tentang pengukuran, belitan, dan kawalan suap-depan dalam tindakan.

Dengan menguasai teleportasi kuantum, anda akan memahami cara mengekod, menghantar, dan memulihkan maklumat kuantum antara nod yang berbeza — meletakkan asas untuk rangkaian kuantum, sistem pengulang, skim komunikasi selamat, dan pengiraan kuantum modular yang boleh diskala. Bagaimana ini berkaitan dengan kriteria 6 & 7: Dalam rangkaian kuantum sebenar, pasangan yang belit akan dicipta dengan mengedarkan Qubit "terbang" (seperti foton) antara lokasi Alice dan Bob (Kriteria 7: penghantaran setia). Protokol teleportasi itu sendiri kemudian berfungsi sebagai cara untuk memetakan keadaan Qubit pegun Alice ke atas separuh pasangan belitannya, secara efektifnya 'menghantar' ia kepada Bob (Kriteria 6: penukaran). Qiskit membolehkan kita mensimulasikan logik protokol dengan sempurna, memberikan model konseptual tentang bagaimana kriteria ini dipenuhi dalam seni bina komunikasi.

Kesimpulan & Ringkasan

Kita telah mereka bentuk siri latihan berfokus kod untuk mengillustrasikan kriteria DiVincenzo menggunakan Qiskit. Melalui contoh-contoh langsung ini, anda meneroka bagaimana platform pengiraan kuantum sebenar memenuhi setiap keperluan:

• Kebolehskalan: membina Circuit pada lebih banyak Qubit dan memahami penskalaan hingar.
• Permulaan: menggunakan tetapan semula dan penyediaan keadaan untuk memulakan pengiraan secara boleh dipercayai dalam keadaan yang diketahui.
• Gate Universal: mentranspile operasi kompleks kepada Gate asas mesin, membuktikan kita boleh melakukan sebarang pengiraan.
• Pengukuran: membaca Qubit dan menangani ralat pembacaan yang realistik.
• Koherensi: melihat kesan T₁, T₂ terhad pada kesetiaan algoritma dan keperluan operasi untuk pantas berbanding dekoherensi.

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

Akhir sekali, ada baiknya kita perhatikan bagaimana kriteria-kriteria ini bersatu dalam komputer kuantum sebenar seperti milik IBM. Peranti seperti ibmq_brisbane mempunyai 127 Qubit superkonduktor (Kriteria 1), setiap satu bermula dalam |0〉 (Kriteria 2), dengan set Gate yang ditentukur dan pengkompil untuk keuniversalan (Kriteria 4), resonator pembacaan gelombang mikro untuk setiap Qubit (Kriteria 5), dan masa koherensi dalam urutan ratusan mikrodetik berbanding operasi dalam nanodetik (Kriteria 3). Untuk eksperimen rangkaian kuantum, IBM dan lain-lain sedang meneroka transduksi gelombang mikro-ke-optik untuk Qubit terbang, dan membelit Qubit yang berjauhan (Kriteria 6 & 7); itu adalah bidang penyelidikan aktif.

Dengan melengkapkan latihan-latihan dalam buku nota ini, anda bukan sahaja melihat definisi kriteria DiVincenzo, tetapi juga menyentuhnya melalui kod; membina intuisi tentang apa yang setiap keperluan bermaksud untuk perkakasan kuantum sebenar dan algoritma. Jangan teragak-agak untuk memperluaskan eksperimen ini, dan selamat melakukan pengiraan kuantum!