Hands-On na Pagpapakilala sa DiVincenzo Criteria gamit ang Qiskit 2

Panimula

Binalangkas ng pisisistang si David DiVincenzo ang limang pangunahing kinakailangan para sa anumang pisikal na pagpapatupad ng quantum computer, kasama ang dalawang karagdagang criteria para sa quantum communication. Sa notebook na ito, dadanasin natin ang bawat DiVincenzo criterion sa pamamagitan ng praktikal na Qiskit demonstrations. Sa halip na pumunta sa malalim sa teorya, ang bawat seksyon ay maikling nagpapaliwanag ng isang criterion at pagkatapos ay nagbibigay ng code exercises gamit ang Qiskit 2. Magkakaroon ka ng pagkakataong magpatakbo ng circuits sa simulators at tunay na IBM Quantum devices upang tuklasin ang bawat prinsipyo nang hands-on.

DiVincenzo's Five Criteria for Quantum Computation:

1. A scalable physical system with well-characterized qubits.
2. Ability to initialize qubits sa simpleng fiducial state (hal. |00…0〉).
3. Long decoherence times (qubit coherence na mas mahaba kaysa sa gate operation time).
4. A universal set of quantum gates (kayang magsagawa ng arbitrary unitary operations).
5. Qubit-specific measurement capability (basahin ang state ng bawat qubit).

(Inilarawan din ni DiVincenzo ang dalawang criteria para sa quantum communication: ang kakayahang i-interconvert ang stationary at "flying" qubits, at upang tapat na ipadala ang flying qubits sa pagitan ng mga lokasyon. Isama natin ang mga ito sa isang inirerekomendang aktibidad sa dulo ng notebook na ito.)

Ang bawat sa mga sumusunod na seksyon ay tumutugma sa isang criterion. Gagamitin natin ang Qiskit upang ilarawan ang konsepto sa code at interactive experiments na maaari mong subukan. Halimbawa, makikita natin kung paano nakakaapekto ang pag-scale up ng bilang ng qubits at circuit depth sa mga resulta (Criterion 1), kung paano i-reset at ihanda ang qubit states (Criterion 2), kung paano sukatin ang qubits sa simulators vs tunay na devices (Criterion 4), kung paano binubuo ng Qiskit ang universal gates (Criterion 3), at kung paano nakakaapekto ang finite coherence (T₁, T₂) sa computations (Criterion 5). Sa wakas, magkakaroon ka ng mas malalim na intuwisyon sa kung ano ang ibig sabihin ng bawat DiVincenzo criterion sa praktika at kung paano nagbibigay-daan ang Qiskit sa pag-eksperimento sa kanila.

# 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. Criterion 1 – Scalable, Well-Characterized Qubits

Criterion 1: "A scalable physical system with well characterized qubits." Ibig sabihin nito ay kailangan natin ng quantum hardware platform kung saan maaari nating dagdagan ang bilang ng qubits at kontrolin pa rin sila nang maaasahan. Ang mga katangian ng bawat qubit (energy levels, error rates, connectivity, atbp.) ay dapat na maintindihan nang mabuti. Sa esensya, gusto nating bumuo ng mas malalaking circuits nang hindi nasisira ang sistema. Sa praktika, habang nagsa-scale up tayo ng qubit count o circuit depth, ang errors at decoherence ay nag-iipon, kaya ang pagpapakita ng scalability ay nangangahulugan din ng pag-unawa kung paano nakakaapekto ang pagdaragdag ng size sa performance.

Goal of Demo: Gamitin ang Qiskit upang ipakita ang epekto ng pag-scale up ng circuit (sa qubit count o gate depth) sa output fidelity. Sini-simulate natin ang ideal vs noisy scenario upang makita kung paano sumusuko ang isang mas malaking sistema o mas malalim na circuit sa decoherence at errors.

Una, bumuo tayo ng maliit na entangled state (GHZ state) sa 3 qubits, pagkatapos ay isang mas malaking sa 5 qubits, bilang isang simpleng scaling test. Ang GHZ state ng n qubits ay $\frac{1}{\sqrt{2}}(|0...0\rangle + |1...1\rangle)$. Sa isang ideal simulation, ang pagsukat sa n-qubit GHZ ay nagbibigay lamang ng dalawang outcomes (lahat ng 0s o lahat ng 1s) na may pantay na probability. Ihahambing natin ang ideal output sa noisy output habang dinaragdagan natin ang n o circuit depth.

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}

Inaasahang resulta (ideal case): Ang 3-qubit GHZ ay ideal na nagbibigay ng humigit-kumulang 50% 000 at 50% 111 sa counts. Ang 5-qubit GHZ ay nagbibigay ng ~50% 00000 at 50% 11111. Walang ibang bit-strings ang lalabas dahil ang state ay ideal na ganap na coherent at entangled. Dapat mong makita ang dalawang matataas na bar sa histogram para sa bawat circuit na tumutugma sa all-zeros at all-ones outcomes.

Susunod, tingnan natin kung ano ang nangyayari sa noisy environment. Gagamitin natin ang noise model capabilities ng Qiskit Aer upang gayahin ang errors ng tunay na device. Halimbawa, maaari nating kunin ang properties ng IBM backend upang lumikha ng noise model na may kasamang gate errors, finite gate times, qubit relaxation (T₁), dephasing (T₂), at readout errors. Dito, gagamit tayo ng fake backend na kumakatawan sa IBM Quantum Brisbane device upang bumuo ng noise model, at muling patakbuhin ang GHZ circuits sa pamamagitan nito.

Exercise 1a: I-simulate na may Noise

Kumpletuhin ang code sa ibaba upang i-simulate ang GHZ circuits sa noisy simulator batay sa FakeBrisbane backend. Ipapakita nito sa iyo kung paano bumababa ang performance habang nagsa-scale ang sistema sa isang realistic noise environment.

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))

Exercise 1b: Patakbuhin sa tunay na IBM Quantum computer

Ang code sa ibaba ay nagpapatakbo ng GHZ circuits sa tunay na IBM Quantum computer. Ipapakita nito sa iyo kung paano bumababa ang performance sa tunay na device.

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

Inaasahang resulta (noisy vs ideal): Sa noise, simulated man o sa tunay na device, ang GHZ state ay hindi gaanong perpekto. Makikita mo ang karagdagang outcomes higit pa sa all-0s at all-1s. Para sa 3 qubits, sa halip na 100% sa 000/111, ang ilang probability ay tumatagas sa ibang bitstrings (hal. 001, 010, atbp.) dahil sa gate errors o decoherence na nag-flip ng ilang qubits. Para sa 5 qubits, ang epekto ay mas malaki; ang mas malaking circuit (mas maraming qubits at CNOT gates) ay nag-iipon ng higit pang error, kaya ang all-0 at all-1 peaks ay mas mababa, at maraming ibang outcomes ang lumalabas. Ang trend na ito ay naglalarawan sa hamon ng scalability: habang nagsa-scale up tayo, ang pagpapanatili ng mataas na fidelity ay nagiging mas mahirap nang walang error correction.

Insight: Ang isang scalable quantum computer ay kailangang panatilihin ang quantum correlations habang lumalaki ang sistema. Ang ating mga halimbawa ay nagpapakita kung paano ang pagdaragdag ng qubit count/gate depth ay nagiging dahilan upang bumagsak ang outcome fidelity kapag may noise. Ang natitirang criteria ay tutuon sa pagpapanatili ng mga qubits na well-behaved (mababang error, initializable, atbp.) habang nagsa-scale tayo.

2. Criterion 2 – Qubit Initialization

Criterion 2: "The ability to initialize the state of the qubits to a simple fiducial state, such as |000…〉." Ang lahat ng qubits ay dapat na maaasahang magsimula sa isang kilalang reference state (kadalasan ang ground state |0〉 para sa bawat qubit). Ang initialization ay mahalaga upang ang mga algorithms ay magsimula sa malinis na slate. Sa praktika, sa IBM quantum devices ang bawat qubit ay awtomatikong na-reset sa |0〉 sa simula ng bawat circuit execution. Nagbibigay din ang Qiskit ng mga tagubilin upang i-reset ang qubits o ihanda ang custom states sa panahon ng computation.

Goal of Demo: Ipakita kung paano i-initialize ang qubits sa Qiskit, kapwa sa simula at mid-circuit. Ipapakita natin ang paggamit ng reset instruction at state preparation methods.

Exercise 2: Maghanda ng Tiyak na State

Sa code block sa ibaba, kumpletuhin ang QuantumCircuit upang ihanda ang state na $|10\rangle$. Ibig sabihin nito ay ang qubit 0 ay dapat nasa state $|0\rangle$ at ang qubit 1 ay dapat nasa state $|1\rangle$. Gamitin ang angkop na gate at instruction upang makamit ito.

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)

Dapat mong makita ang 10 (binary para sa qubit1=1, qubit0=0) na may 100% probability mula sa simulation, na nangangahulugang matagumpay na naihanda ang qubit 1 sa |1〉 at qubit 0 sa |0〉.

Ngayon, para sa mas pangkalahatang state preparation, pinapayagan ng Qiskit ang initialization sa arbitrary states gamit ang initialize method. Halimbawa, ihanda natin ang isang qubit sa state na $|+\rangle = (|0\rangle+|1\rangle)/\sqrt{2}$, na isang superposition state, at isang pares ng qubits sa Bell state na $(|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}

Inaasahang outcomes: Ang single qubit |+〉 state, kapag nasukat, ay magbibigay ng 0 at 1 na may humigit-kumulang 50% probability bawat isa. Ang Bell state measurement ay dapat magbigay ng humigit-kumulang 50% 00 at 50% 11. Kung makikita mo ang mga ito, kinukumpirma nito na matagumpay ang ating initialization sa mga state na iyon.

Mid-circuit initialization: Maaaring gamitin ang reset ng Qiskit sa gitna ng circuit upang muling i-initialize ang isang qubit sa |0〉 sa fly. Halimbawa, sa error correction codes o iterative algorithms, kadalasan ay sinusukat ng isa ang qubit at pagkatapos ay ire-reset ito para sa muling paggamit. Ang reset operation ay deterministic; ito ay naghuhulog ng anumang umiiral na state at pinapalamig ang qubit pababa sa ground state.

Halimbawa ng device: Sa hardware tulad ng ibmq_brisbane (127 qubits) o anumang IBM device, lahat ng qubits ay nagsisimula sa |0〉 bilang default kapag pinapatakbo ang job. Kung kailangan mo ng iba't ibang panimulang state, mag-aaplay ka ng gates sa simula (gaya ng ginawa natin sa X upang makakuha ng |1〉). Ang patuloy na re-initialization (para sa quantum error correction) ay isang aktibong larangan ng pananaliksik dahil ang mabilis na paggawa nito ay mahirap. Sa kabutihang palad, para sa basic na paggamit, ang kakayahang magsimula nang sariwa sa |0…0〉 ay magagamit at ipinakita din natin kung paano makakuha ng iba pang nais na panimulang states.

3. Criterion 3 – Long Coherence Time (Decoherence vs Gate Time)

Criterion 3: "Long relevant decoherence times, much longer than the gate operation time." Tinatalakay nito ang pangangailangan para sa qubits na panatilihin ang kanilang quantum state nang sapat ang tagal upang maisagawa ang mga kinakailangang operasyon. Ang bawat qubit ay may T₁ time (energy relaxation time, kung gaano kabilis bumababa ang |1〉 sa |0〉) at T₂ time (dephasing time, kung gaano kabilis nawawala ang relative phase coherence). Para gumana ang isang quantum computer, ang mga timescale na ito ay dapat lubos na lumampas sa duration ng gate operations.

Goal of Demo: Imbestigahan ang qubit coherence sa Qiskit sa pamamagitan ng pagpapakita kung paano nakakaapekto ang decoherence sa mga circuit outcomes habang lumalaki ang execution length. Gagamit tayo ng fake backend na may kilalang T1/T2 times upang i-simulate ang epektong ito.

Para ipakita ang epekto ng finite coherence, sini-simulate natin ang T1 decay experiment. Ihahanda natin ang isang qubit sa |1〉 state, maghihintay ng ilang oras gamit ang delay instruction, at pagkatapos ay susukatin. Inaasahan natin na ang probability ng pagsukat sa |1〉 ay bababa habang dumarami ang delay.

# 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

Exercise 3: I-simulate ang T1 Decay Experiment

Ngayon, gumamit ng noisy simulator batay sa FakeVigo (na may T1 times na ~50-100 µs) upang patakbuhin ang circuits na ito. Awtomatiko nitong i-aaplay ng simulator ang T1/T2 errors sa panahon ng delay instructions. I-transpile ang circuits para sa backend na ito at i-execute ang mga ito.

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. Criterion 4 – Universal Set of Quantum Gates

Criterion 4: "A 'universal' set of quantum gates." Ibig sabihin nito ay ang ating hardware ay dapat magpahintulot sa atin na magsagawa ng anumang quantum computation sa pamamagitan ng pagsasama ng finite set ng basic gates. Sa classical computing, ang NAND ay universal; sa quantum, mayroong maraming pagpipilian ng universal gate sets (hal. {H, T, CNOT} o ang native gates ng isang ibinigay na machine). Ang IBM devices, halimbawa, ay may set ng native operations tulad ng arbitrary single-qubit rotations at CNOTs sa pagitan ng ilang qubits, na sama-sama ay universal. Ang trabaho ng Qiskit ay kadalasan ay i-compile ang high-level gates sa basis gates na ito.

Goal of Demo: Ilarawan ang gate universality sa pamamagitan ng pagpapakita kung paano binubuwag ng Qiskit ang gates. Kukunin natin ang non-native gate (tulad ng 3-qubit Toffoli gate, CCX) at makikita kung paano ito binubuwag sa basis gates ng device. Ipinapakita nito na ang ibinigay na gate set ay totoo ngang universal – maaari nitong gawin ang mas kumplikadong operasyon.

Una, tingnan natin kung ano ang basis gates para sa karaniwang IBM backend. I-query natin ang configuration ng device (o ang fake version nito). Halimbawa, ang basis gates ng ibmq_brisbane: Dapat mong obserbahan ang probability P(qubit=1) na bumababa habang tumataas ang delay time, sumusunod sa exponential decay curve na katangian ng T1 relaxation. Ipinapakita nito nang direkta kung paano ang finite coherence time ay humahantong sa computational errors kung tumatakbo ang circuit nang masyadong matagal.

Epekto sa algorithms: Kung subukan mo ang isang mas mahabang algorithm (na may maraming sequential gates), ang total execution time ay maaaring lumapit o lumampas sa T2, na nagiging dahilan upang mawalan ng coherence ang state bago ang dulo. Kaya naman ang pagpapabuti ng coherence times at paggawa ng mas mabilis na gates ay dalawa sa pinakakritikal na layunin sa quantum hardware research.

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']

Maaaring i-output nito ang isang bagay tulad ng ['id', 'rz', 'sx', 'x', 'ecr']. Ito ang primitive operations na natively sinusuportahan ng hardware (Identity/no-op, RZ rotation, sqrt(X) gate, X gate, at controlled-X). Ang anumang ibang gate ay dapat buuin mula sa mga ito. Ang set na ito ay kilala bilang universal para sa quantum computing (sa esensya ang single-qubit rotations kasama ang isang entangling two-qubit gate ay bumubuo ng universal set).

Ngayon, kunin ang Toffoli (CCX) gate bilang test case. Ang CCX ay nag-flip ng target qubit lamang kapag ang dalawang control qubits ay parehong 1. Hindi ito native gate sa IBM hardware. Nagbibigay ang Qiskit ng ccx instruction, ngunit sa loob ay binubuwag nito ito.

Exercise 4: I-decompose ang Toffoli Gate

Kumpletuhin ang code sa ibaba upang bumuo ng circuit na may Toffoli (CCX) gate at pagkatapos ay gamitin ang Qiskit upang buwagin ito sa native basis gates ng FakeBrisbane backend.

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))

Sa transpiled output, dapat mong makita ang CCX na pinalitan ng sequence ng mas basic gates tulad ng rz, sx, at ecr. Pinatunayan nito na ang native gates ay sapat na para ipahayag ang Toffoli.

Universality sa praktika: Ang exercise sa itaas ay nagpapakita na ang isang kumplikadong 3-qubit gate ay binuo mula sa mas simple. Sa pangkalahatan, anumang multi-qubit unitary ay maaaring buuin mula sa 1- at 2-qubit gates. Ang transpiler ay isang mahalagang bahagi ng anumang quantum software stack, dahil bumubuo ito ng tulay sa pagitan ng abstract algorithms na nais nating patakbuhin at ang physical operations na maaaring gawin ng partikular na quantum device.

Halimbawa ng device: Ang ibmq_brisbane device ay gumagamit ng Eagle architecture na may basis gates na ipinakita sa itaas. Ibig sabihin, ang anumang algorithm na ipinapadala sa mga makinang iyon ay ico-convert sa sequences ng mga operasyong iyon. Ang criterion na ito ay tungkol sa controllability; mayroon tayong sapat na control knobs upang gawin ang anumang kinakailangang operasyon sa ating qubits.

5. Criterion 5 – Qubit Measurement

Criterion 5: "A qubit-specific measurement capability." Ang state ng bawat qubit ay dapat na nasusukat (kadalasan sa computational basis, |0〉 o |1〉). Sa madaling salita, pagkatapos magpatakbo ng quantum circuit, kailangan nating basahin ang bawat qubit bilang 0/1 classical bit. Ang criterion na ito ay tungkol sa pagkakaroon ng maaasahang detectors para sa bawat qubit at sa kakayahang pumili kung aling qubits ang susukatin.

Goal of Demo: Ipakita kung paano magsagawa ng measurements sa Qiskit sa simulators at tunay na devices, at i-highlight ang mga pagkakaiba (tulad ng measurement noise). Sukatin natin ang ilang qubits sa iba't ibang states at suriin ang mga resulta. Ipapakita rin natin kung paano maaaring lumitaw ang readout errors sa pamamagitan ng paghahambing ng simulator vs hardware results.

Una, isang simpleng halimbawa ng measurement:

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}

Inaasahan natin ang 1000 counts ng 01 sa simulator. Ngayon, tingnan natin ang measurement error sa aksyon sa pamamagitan ng pag-simulate nito. Maaari tayong magdagdag ng readout error sa ating Aer simulator. Pinapayagan tayo ng Qiskit Aer na tukuyin ang ReadoutError at ilakip ito sa qubits sa noise model.

Exercise 5: I-simulate ang Readout Error

Kumpletuhin ang code upang tukuyin ang isang simpleng readout error model kung saan ang bawat qubit ay may 2% chance na masukat nang mali (ang 0 ay binabasa bilang 1, o ang 1 bilang 0). Pagkatapos, patakbuhin ang measurement circuit gamit ang noise model na ito.

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)

Ang simulated output na ito ay magpapakita ng ilang maling counts (tulad ng 11, 00, 10) na katulad ng maaaring gawin ng tunay na hardware, na nagpapakita ng epekto ng hindi perpektong measurement.

Halimbawa ng device: Sa tunay na device tulad ng ibmq_brisbane, maaari mong patakbuhin ang parehong circuit at malamang na makikita mo ang katulad, non-zero counts para sa maling outcomes. Ang device calibration data ay naglilista ng readout error para sa bawat qubit. Ang kakayahang i-target at basahin ang mga partikular na qubits ay napakahalaga, at ang pag-unawa sa kanilang error characteristics ay susi sa pagkuha ng makabuluhang resulta. Ang pagpapatakbo sa tunay na device ay ipinakita sa Exercise 1b: Run on real IBM Quantum computer.

Quantum Communication Criteria (Flying Qubits)

Naglista din si DiVincenzo ng dalawang criteria na partikular sa quantum communication, na mahalaga kung magtatayo ng networked quantum computer:

6. Ability to interconvert stationary and flying qubits. (Hal., i-map ang isang qubit sa isang processor sa isang photon na maaaring maglakbay.)
7. Ability to faithfully transmit flying qubits between locations. (Hal., magpadala ng photon qubit sa pamamagitan ng isang fiber nang hindi nawawala ang quantum information.)

Ang mga ito ay higit pa sa standard na paggamit ng Qiskit dahil ang Qiskit ay pangunahing nakikipag-ugnayan sa stationary qubits sa isang chip. Gayunpaman, maaari nating ilarawan ang konsepto ng mga criteria na ito sa isang simpleng halimbawa: quantum teleportation. Ang teleportation ay nagpapakita ng pag-convert ng state ng isang stationary qubit sa impormasyong dala ng isang entangled pair (ang "flying" na bahagi) at classical communication, na pagkatapos ay ginagamit upang muling buuin ang state sa isa pang stationary qubit sa ibang lugar.

Inirerekomendang aktibidad: Kunin ang Qiskit in Classrooms Quantum Teleportation module

Ang Qiskit in Classrooms Quantum Teleportation module ni Dr. Katie McCormick ay magagabay sa iyo sa isa sa pinaka-kapana-panabik na protocol sa quantum information: quantum teleportation, kung saan ang quantum state (isang qubit) ay ipinapadala mula kay Alice sa Bob gamit ang entanglement at dalawang classical bits lamang. Matututunan mo ang buong procedure ng teleportation hakbang-hakbang—kung paano ihanda ang entangled Bell pair, magsagawa ng Bell-basis measurement sa panig ni Alice, ipadala ang mga classical results, at i-aplay ang tamang quantum gate sa qubit ni Bob upang perpektong mabawi ang orihinal na state. Sa daan, tutuklasin mo kung bakit ang pag-teleport ng impormasyon ng qubit ay hindi lumalabag sa no-cloning theorem o lumalampas sa bilis ng liwanag. Sa pamamagitan ng hands-on exercises gamit ang IBM Quantum hardware o simulators, magkakaroon ka ng praktikal na pag-unawa sa measurement, entanglement, at feed-forward control sa aksyon.

Sa pag-master ng quantum teleportation, mauunawaan mo kung paano i-encode, i-transmit, at mabawi ang quantum information sa pagitan ng iba't ibang nodes—na naglalatag ng pundasyon para sa quantum networks, repeater systems, secure communication schemes, at scalable modular quantum computing. Paano ito nauugnay sa criteria 6 at 7: Sa isang tunay na quantum network, ang shared entangled pair ay gagawin sa pamamagitan ng pamamahagi ng "flying" qubits (tulad ng photons) sa pagitan ng mga lokasyon ni Alice at Bob (Criterion 7: faithful transmission). Ang teleportation protocol mismo ay nagsisilbi bilang paraan upang i-map ang stationary qubit state ni Alice sa kanyang kalahati ng entangled pair, na epektibong 'pinapadala' ito kay Bob (Criterion 6: interconversion). Pinapayagan tayo ng Qiskit na i-simulate ang logic ng protocol nang perpekto, na nagbibigay ng conceptual model kung paano natutugunan ang mga criteria na ito sa communication architectures.

Konklusyon at Buod

Nagdisenyo tayo ng serye ng code-focused exercises upang ilarawan ang DiVincenzo criteria gamit ang Qiskit. Sa pamamagitan ng hands-on na halimbawang ito, tinuklas mo kung paano natutugunan ng tunay na quantum computing platform ang bawat kinakailangan:

• Scalability: pagbuo ng circuits sa mas maraming qubits at pag-unawa sa noise scaling.
• Initialization: paggamit ng resets at state prep upang maaasahang magsimula ng computations sa kilalang states.
• Universal Gates: pag-transpile ng kumplikadong operasyon sa basis gates ng makina, na nagpapatunay na maaari tayong magsagawa ng anumang computation.
• Measurement: pagbabasa ng qubits at pagharap sa makatotohanang readout errors.
• Coherence: pagtingin sa epekto ng finite T₁, T₂ sa algorithm fidelity at ang pangangailangan para sa operations na maging mabilis kumpara sa decoherence.

Para sa pagiging kumpleto, hinawakan din natin ang quantum communication aspects sa pamamagitan ng Qiskit in Classrooms Quantum Teleportation module, na nag-uugnay sa huling dalawang criteria (flying qubits).

Sa wakas, mahalagang tandaan kung paano nagsasama-sama ang mga criteria na ito sa isang tunay na quantum computer tulad ng sa IBM. Ang isang device tulad ng ibmq_brisbane ay may 127 superconducting qubits (Criterion 1), na ang bawat isa ay nagsisimula sa |0〉 (Criterion 2), na may calibrated gate set at compilers para sa universality (Criterion 4), microwave readout resonators para sa bawat qubit (Criterion 5), at coherence times sa order ng daan-daang microseconds vs nanosecond operations (Criterion 3). Para sa quantum networking experiments, ang IBM at iba pa ay tumutuklas ng microwave-to-optical transduction para sa flying qubits, at pag-eentangle ng malalayong qubits (Criteria 6 at 7); ang mga ito ay aktibong larangan ng pananaliksik.

Sa pamamagitan ng pagkumpleto ng mga ehersisyo sa notebook na ito, hindi ka lang nakakita ng mga kahulugan ng DiVincenzo criteria, kundi nadama mo rin ang mga ito sa pamamagitan ng code; nagtatayo ng intuisyon tungkol sa kung ano ang ibig sabihin ng bawat kinakailangan para sa tunay na quantum hardware at mga algorithm. Huwag mag-atubiling palawakin ang mga eksperimentong ito, at maligayang quantum computing!