Buuin at patakbuhin ang iyong unang quantum program

Panimula

Sa sumusunod na video, gagabayan ka ni Olivia Lanes sa nilalaman ng aralin na ito. Bilang alternatibo, maaari mong buksan ang YouTube video para sa araling ito sa hiwalay na window.

Maligayang pagdating sa Use a quantum computer today! Ang layunin ng kursong ito ay para makapagpatakbo ka ng code sa isang tunay na quantum computer sa pinakamabilis na panahong posible, nang walang kinakailangang prior background. Magsimula na tayo.

Ang unang araling ito ay isang banayad at hands-on na panimula sa quantum computing na nakakatulong sa mga curious na baguhan at sa mga abalang lider. Matututo ka tungkol sa quantum circuits at magsusulat ng maliit na quantum program na lumilikha ng entanglement, at patakbuhin ito sa isang tunay na IBM® quantum computer. Mayroon ka ring opsyon na patakbuhin ang parehong programa sa isang simulator, kung pipiliin mong laktawan ang pagpapatakbo sa tunay na quantum computer.

Maaari mong patakbuhin ang notebook na ito mula sa itaas hanggang sa ibaba sa isang sariwang Google Colab runtime, o lokal na patakbuhin ito.

Setup

Para patakbuhin ang notebook na ito sa Google Colab, kailangan mo ng Google account para mabuksan ang mga notebook at ma-execute ang mga cell sa browser.

Para tumakbo sa isang tunay na IBM quantum computer, kakailanganin mo rin ng (libreng) IBM Quantum® Platform account. Maaari kang magbukas ng instance gamit ang Open Plan para makakuha ng 10 minuto ng quantum processor unit (QPU) time bawat 28-day rolling window, na talagang marami na! Kung may problema ka sa iyong account, tingnan ang Support page.

Maaari mo ring patakbuhin ang notebook na ito nang lokal pagkatapos i-install ang Qiskit sa pamamagitan ng pagsunod sa mga tagubilin sa IBM Quantum Platform.

Installation at imports

Sa Colab, ini-install natin ang mga dependency sa loob ng notebook para gumamit ang lahat ng parehong tools. Ang susunod na cell ay nag-i-install ng Qiskit kasama ang visualization module at dalawang add-on: Aer (mabibilis na simulator) at ang IBM Runtime client (para sa pagpapatakbo sa quantum computer).

Susunod, mayroon tayong ilang imports. Ang QuantumCircuit class ay kung saan natin tinutukoy ang ating quantum bits, o qubits, at tinutukoy ang mga operasyon sa mga qubits na iyon. Ito ang ating unang quantum term: ang isang qubit ay ang basic na building block ng quantum computation, gaya ng bit ay ang building block ng classical computation. Marami pa tayong matututuhan tungkol sa mga espesyal na katangian ng qubits habang ginagawa natin ang ating circuit. Susunod, ang plot_histogram ay gagamitin para i-visualize ang mga resulta ng ating quantum circuit. Ang AerSimulator, ay nagbibigay-daan sa atin na i-simulate ang quantum circuit sa isang classical computer. Ngunit ang mga simulator ay hindi maaaring magpatakbo ng quantum circuits sa parehong sukat tulad ng tunay na quantum computer; kaya kailangan natin ang tunay na quantum computer. Maaari itong maging kapaki-pakinabang para sa pagsusuri, debugging, o mga educational na layunin; o kung naubos mo na ang iyong 10 libreng minuto ng QPU time. Ang preset_passmanagers ay tumutulong sa pag-optimize ng mga circuit para tumakbo nang mabisa sa hardware, na nagiging napakahalaga habang nagiging mas kumplikado ang ating mga circuit. Ang Sampler at QiskitRuntimeService ay kinakailangan para talagang patakbuhin ang circuit sa quantum computer. Higit pa rito mamaya.

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

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

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

Susunod ay magsasagawa tayo ng mabilis na environment check. Kinukumpirma natin ang mga bersyon at kinukumpirma ang mga imports.

Kung may bumagsak dito, kadalasan ito ay isyu ng dependency install; ang pag-aayos ngayon ay umiiwas sa nakakalitong mga error mamaya.

import sys

import qiskit
import qiskit_aer
import qiskit_ibm_runtime

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

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

Isang maikling side quest: gamitin ang Composer

Bago tayo magsulat ng code, kapaki-pakinabang na makita ang mga circuit nang biswal. Ang IBM Quantum Composer ay nagbibigay-daan sa iyong bumuo ng mga circuit sa pamamagitan ng pag-drag ng mga gate sa mga wire. Magandang paraan ito para matutunan kung ano ang ginagawa ng circuit nang hindi nadi-distract sa syntax.

Buksan ang Composer dito.

Pagka-load nito, ilunsad ang guided tutorial mula sa menu: Help | Build your first circuit. Lakaran ito sa sarili mong takbo. Habang nagsasagawa, pansinin kung paano binabago ng bawat gate kung ano ang inaasahan mong sukatin.

Ang tutorial ay dumadaan sa pagbuo ng "Hello World" circuit. Ito ay biswal sa tinatawag na circuit diagram, kung saan ang mga qubit ay kinakatawan ng mga horizontal line at ang mga gate na umaaksyon sa mga qubit na iyon ay kinakatawan ng mga kahon o iba pang simbolo sa mga linya. Ang circuit na ito ay nagpapakilala sa atin sa ilang pangunahing katangian ng qubits at quantum computers:

Una, ang pulang kahon na may label na "H" ay isang Hadamard gate, na lumilikha ng superposition state ng qubit 0. Hindi tulad ng bit, na maaari lamang nasa state 1 o 0, ang isang qubit state ay maaaring magsama ng parehong posibilidad nang sabay-sabay, na may ilang weights (tinatawag na amplitudes) na nakalakip sa bawat isa. Ang superposition ay hindi nangangahulugan na makikita mo ang parehong resulta sa isang sukat; ibig sabihin nito ay naka-set up ang state nang sa gayon ay maaaring mangyari ang alinmang resulta kapag sinukat mo ito.

Pangalawa, ang mga bilog at vertical line na nag-uugnay sa dalawang qubits ay isang CNOT gate, na bumubuo ng entanglement sa pagitan ng dalawang qubits. Ang entanglement ay isang espesyal na uri ng link sa pagitan ng qubits. Kapag ang mga qubit ay entangled, ang mga resulta ng mga sukat ay maaaring lubhang correlated sa paraang hindi tumutugma sa inaasahan natin mula sa karaniwang independent coin flips, o mula sa anumang classical correlation. Kapag ang dalawang qubits ay entangled, ang pagsukat ng isa ay agad na magsasabi sa iyo ng resulta ng pagsukat ng isa pa.

Ang isa pang pangunahing ideya na makikita mo sa tutorial ay shots. Dahil ang measurement ay ang sandali kung kailan tumigil ang qubit sa pag-uugali tulad ng quantum state at nagbibigay sa iyo ng classical readout, ang isang superposition state ay probabilistic na bumagsak sa alinman sa 0 o 1 kapag sinukat ito. Kaya, para matutunan ang tungkol sa superposition na iyon, kailangan mong sukatin ito nang maraming beses sa pamamagitan ng pagpapatakbo ng parehong circuit para mag-ipon ng mga statistic. Tinatawag itong shots.

Suriin ang iyong pang-unawa

Pag-isipan ang bawat tanong sa ibaba, pagkatapos ay i-click para mabunyag ang sagot.

Maaari mo bang makita ang isang superposition nang direkta mula sa isang sukat?

Sagot

Hindi. Ang isang sukat ay palaging nagbabalik ng classical value: alinman sa 0 o 1. Ang ideya ng "mixture" ay lumalabas lamang sa mga statistic na makikita mo pagkatapos ng maraming runs, na tinatawag ding shots.

Sa simpleng wika, ano ang ibinibigay sa iyo ng entanglement?

Sagot

Nagbibigay ito sa iyo ng linked outcomes. Ang pagsukat ng isang qubit ay nagsasabi sa iyo ng tungkol sa isa pa. Ang link na ito ay mas malakas kaysa sa independent randomness at mas malakas kaysa sa anumang puro classical correlation o shared randomness na maaaring ipaliwanag.

Kung ang isang qubit ay nasa superposition, ano ang nakikita mo sa isang sukat, at bakit kailangan mo ng maraming shots?

Sagot

Sa isang sukat ay isang classical na resulta lamang ang nakikita mo: alinman sa 0 o 1. Kailangan mo ng maraming shots dahil ang "superposition" ay lumalabas bilang probability distribution, na maaari mo lamang tantyahin sa pamamagitan ng pagkolekta ng mga statistic sa paulit-ulit na runs.

Tingnan ang measurement histogram ng iyong Hello World circuit sa Composer. Ano ang nakikita mo? Bakit ito ay isang signature ng entanglement?

Sagot

Nagpapakita ito sa iyo ng 50% chance na nasa state $|00\rangle$ at 50% chance na nasa state $|11\rangle$. Ibig sabihin nito, kung sukatin mo ang isa na 0, ang isa pa ay magiging 0 at kung sukatin mo ang isa na 1, ang isa pa ay magiging 1 din. Ito ay correlation sa pagitan ng dalawang qubits na maipapaliwanag ng entanglement.

Lumikha at magpatakbo ng quantum program gamit ang Qiskit

Okay, balik sa coding. Bubuo tayo ng parehong entangled state na ginawa natin sa Composer (tinatawag na $\Phi^+$ (phi-plus) Bell state) ngunit sa pagkakataong ito, isusulat natin ang code nang manu-mano. Kailangan nating buuin ang skill na ito dahil habang tumataas ang bilang ng mga qubit at nagiging mas kumplikado ang circuits, ang Composer ay hindi na makakatulong sa atin.

Para buuin ang Bell state circuit, gumagamit tayo ng $H$ (Hadamard) gate para ilagay ang unang qubit sa pantay na superposition. Pagkatapos ay nag-aaplay tayo ng $CX$ (controlled-NOT) gate, na nag-e-entangle sa dalawang state. Ngayon ang dalawang qubit ay correlated sa paraang walang classical equivalent.

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

bell.draw("mpl")

Helper function para sa pagpapatakbo ng circuits

Ngayon ay tukuyin natin ang isang helper function na humahawak sa proseso ng pagpapatakbo ng quantum circuit at pagkuha ng measurement results. Inaalagaan ng function na ito ang transpiling ng circuit para tumugma sa instruction set ng backend, pagpapatakbo nito sa pamamagitan ng Sampler primitive, at pagkuha ng counts mula sa mga resulta.

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

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

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

    sampler = Sampler(mode=backend)

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

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

Patakbuhin sa QPU at i-visualize ang mga resulta

Sa wakas, pinapatakbo natin ang circuit sa isang IBM quantum processing unit (QPU) sa cloud para sa 1000 shots at iplot ang mga resulta. Ang IBM QPUs ay mga physical system na maaaring kumuha ng noise, kaya ang mga gate ay bahagyang hindi perpekto, ang mga sukat ay maaaring maling minsan, at ang device calibration ay nagbabago sa paglipas ng panahon.

Ang pagpapatakbo sa tunay na quantum computers ay nagpapakilala rin ng mga praktikal na konsiderasyon. Ang mga trabaho ay maaaring umupo sa queue, dahil maraming tao ang maaaring gumagamit ng parehong device. Kailangan mo ring pumili ng shot count na nagba-balanse sa mga statistical na konsiderasyon (mas maraming shots ay nangangahulugang mas mataas na signal-to-noise ratio) sa mga oras/gastos na limitasyon.

Sundin ang mga tagubilin sa code comments ng susunod na cell. Pagkatapos patakbuhin ang cell, dapat mong makita ang isang histogram na may halos pantay na counts para sa $00$ at $11$ bitstrings, na may ilang occurrences ng $01$ o $10$ dahil sa noise. Ang sumusunod na cell sa notebook na ito ay nagpapatakbo ng parehong circuit sa isang simulator, kung pipiliin mong laktawan ang pagpapatakbo sa QPU.

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

# Load saved credentials
service = QiskitRuntimeService()

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

ibm_pittsburgh

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

Patakbuhin sa simulator at i-visualize ang mga resulta

Ang isang simulator ay isang "perfect world" na bersyon ng quantum computing. Dito pinapatakbo natin ang circuit sa isang simulator para sa 1000 shots at iplot ang mga resulta. Dapat mong makita ang halos pantay na counts para sa $00$ at $11$ states, na walang occurrences ng $01$ o $10$, na siyang signature ng perpektong correlation ng Bell state.

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

plot_histogram(counts)

Suriin ang iyong pang-unawa

Ano ang dalawang gate na lumilikha ng Bell state dito?

Sagot

Isang H gate sa qubit 0, na sinundan ng CX gate na may qubit 0 bilang control at qubit 1 bilang target.

Sa isang ideal simulator, aling dalawang bitstrings ang dapat mangibabaw sa histogram?

Sagot

Ang 00 at 11 ang dapat mangibabaw.

Bakit hindi laging eksaktong pareho ang bilang ng 00 counts at 11 counts ng isang perpektong simulator?

Sagot

Kahit na ang isang simulator ay "perpekto" at humahantong sa isang perpektong Bell state, sini-simulate pa rin nito ang isang inherently random na proseso, kaya magaganap pa rin ang statistical fluctuations. Para itong pagpitik ng coin nang 1000 beses: kahit na may eksaktong 50-50 na pagkakataon na lumapag ang coin sa heads o tails, hindi ibig sabihin nito na palagi kang makakakuha ng eksaktong 500 instances ng heads at 500 ng tails.

Bakit maaaring magpakita ang isang tunay na quantum computer ng ilang 01 o 10 na resulta kahit na hindi ito ginawa ng simulator?

Sagot

Dahil ang mga tunay na device ay may noise. Ang mga gate at sukat ay hindi perpekto, at maaari itong magpakilala ng paminsan-minsang mga error.

Ano ang isang praktikal na pagkakaiba sa pagitan ng simulators at tunay na quantum computers bukod sa noise?

Sagot

Ang mga quantum computer ay maaaring may queue time, limitadong availability, at mga device-specific na hadlang na nakakaapekto sa kung paano tumatakbo ang mga circuit.

Konklusyon

Nagsimula tayo sa pamamagitan ng pag-set up ng Qiskit sa isang sariwang Colab environment, na siyang eksaktong paano nagsisimula ang maraming real-world notebook workflows. Sinundan natin iyon ng isang paglalakbay sa quantum computing gamit ang Composer. Pagkatapos ay bumuo tayo ng simpleng two-qubit circuit na gumagawa ng $\Phi^+$ Bell state at gumamit ng paulit-ulit na sampling at biswal na ipinakita ang entanglement bilang correlation sa qubit measurement histogram. Nakita rin natin kung paano ang tunay na quantum computers ay nagpapakilala ng noise at mga error.

Layunin sa pag-aaral

Ngayong nakapaglakad na tayo sa kung paano lumikha ng $\Phi^+$ Bell state, tingnan kung maaari mong i-edit ang code para lumikha ng isa pa sa tatlong Bell states. Sa partikular, ang $\Psi^-$ state ay gagamitin sa isang paparating na aralin, kaya kung malalaman mo kung paano ito gawin, mauuna ka na sa laro.