Construiește și rulează primul tău program cuantic

Introducere

În videoclipul următor, Olivia Lanes te ghidează prin conținutul acestei lecții. Alternativ, poți deschide videoclipul de pe YouTube pentru această lecție într-o fereastră separată.

Bun venit la Folosește un calculator cuantic astăzi! Scopul acestui curs este să rulezi cod pe un calculator cuantic real în cel mai scurt timp posibil, fără nicio experiență anterioară necesară. Hai să începem.

Această primă lecție este o introducere practică și accesibilă în calculul cuantic, potrivită atât pentru curioși la început de drum, cât și pentru lideri ocupați. Vei afla despre circuitele cuantice și vei scrie un mic program cuantic care creează entanglement, și îl vei rula pe un calculator cuantic IBM® real. Ai și opțiunea de a rula același program pe un simulator, dacă alegi să omiți rularea pe un calculator cuantic real.

Poți rula acest notebook de sus în jos într-un runtime Google Colab nou, sau îl poți rula local.

Configurare

Pentru a rula acest notebook în Google Colab, vei avea nevoie de un cont Google ca să poți deschide notebook-uri și executa celule în browser.

Pentru a rula pe un calculator cuantic IBM real, vei avea nevoie și de un (gratuit) cont IBM Quantum® Platform. Poți deschide o instanță folosind Open Plan pentru a obține 10 minute de timp de procesor cuantic (QPU) per fereastră mobilă de 28 de zile, ceea ce este destul de mult! Dacă ai probleme cu contul tău, consultă pagina de suport.

Poți de asemenea rula acest notebook local după ce instalezi Qiskit urmând instrucțiunile de pe IBM Quantum Platform.

Instalare și importuri

În Colab, instalăm dependențele în interiorul notebook-ului ca toată lumea să ruleze aceleași instrumente. Celula următoare instalează Qiskit cu modulul de vizualizare plus două extensii: Aer (simulatoare rapide) și clientul IBM Runtime (pentru rulări pe calculatorul cuantic).

În continuare, avem o serie de importuri. Clasa QuantumCircuit este locul unde definim biții cuantici, sau qubiții, și definim operații asupra acelor qubiți. Acesta este primul nostru termen cuantic: un qubit este blocul de bază al calculului cuantic, la fel cum un bit este blocul de bază al calculului clasic. Vom afla mai multe despre proprietățile speciale ale qubiților pe măsură ce construim circuitul nostru. În continuare, plot_histogram va fi folosit pentru a vizualiza rezultatele circuitului nostru cuantic. AerSimulator ne permite să simulăm circuitul cuantic pe un calculator clasic. Dar simulatoarele nu pot rula circuite cuantice la aceeași scară ca și calculatoarele cuantice reale; de aceea avem nevoie de calculatoare cuantice reale. Acest lucru poate fi util pentru testare, depanare sau în scopuri educaționale; sau dacă ți-ai epuizat cele 10 minute gratuite de timp QPU. preset_passmanagers ajută la optimizarea circuitelor pentru a rula eficient pe hardware, ceea ce devine cu adevărat important pe măsură ce circuitele noastre devin mai complexe. Sampler și QiskitRuntimeService sunt necesare pentru a rula efectiv circuitul pe calculatorul cuantic. Mai multe despre asta mai târziu.

# 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

Apoi vom face o verificare rapidă a mediului. Confirmăm versiunile și confirmăm importurile.

Dacă ceva eșuează aici, de obicei este o problemă de instalare a dependențelor; rezolvând-o acum prevenim erori confuze mai târziu.

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

O scurtă misiune secundară: folosește Composer-ul

Înainte să scriem cod, este util să vedem circuitele vizual. IBM Quantum Composer îți permite să construiești circuite trăgând porți pe fire. Este o modalitate excelentă de a înțelege ce face un circuit fără a te distrage cu sintaxa.

Deschide Composer-ul aici.

Odată ce se încarcă, lansează tutorialul ghidat din meniu: Help | Build your first circuit. Parcurge-l în ritmul tău. Pe parcurs, acordă atenție modului în care fiecare poartă schimbă ce te aștepți să măsori.

Tutorialul parcurge construirea circuitului „Hello World". Acesta este vizualizat în ceea ce se numește o diagramă de circuit, unde qubiții sunt reprezentați prin linii orizontale, iar porțile care acționează asupra acelor qubiți sunt reprezentate prin cutii sau alte simboluri pe linii. Acest circuit ne introduce în câteva caracteristici cheie ale qubiților și calculatoarelor cuantice:

În primul rând, cutia roșie etichetată „H" este o poartă Hadamard, care creează o stare de suprapunere a qubitului 0. Spre deosebire de un bit, care poate fi doar în starea 1 sau 0, starea unui qubit poate include ambele posibilități deodată, cu anumite ponderi (numite amplitudini) asociate fiecăreia. Suprapunerea nu înseamnă că vei vedea vreodată ambele rezultate într-o singură măsurătoare; înseamnă că starea este configurată astfel încât oricare rezultat poate apărea atunci când măsori.

În al doilea rând, cercurile și linia verticală care conectează cei doi qubiți reprezintă o poartă CNOT, care generează entanglement între cei doi qubiți. Entanglement-ul este un tip special de legătură între qubiți. Când qubiții sunt entanglați, rezultatele măsurătorilor pot fi puternic corelate într-un mod care nu corespunde cu ceea ce ne-am aștepta de la aruncări de monedă independente ordinare, sau de la orice corelație clasică. Când doi qubiți sunt entanglați, măsurarea unuia îți va spune instantaneu rezultatul măsurării celuilalt.

O altă idee cheie pe care o vei vedea în tutorial este shots (rulări). Deoarece măsurarea este momentul în care un qubit încetează să se comporte ca o stare cuantică și îți dă o citire clasică, o stare de suprapunere se va prăbuși probabilistic fie pe 0, fie pe 1 când este măsurată. Deci, pentru a afla despre acea suprapunere, trebuie să o măsori de multe ori rulând același circuit pentru a acumula statistici. Acestea se numesc shots.

Verifică-ți înțelegerea

Gândește-te la fiecare întrebare de mai jos, apoi apasă pentru a dezvălui răspunsul.

Poți vedea o suprapunere direct dintr-o singură măsurătoare?

Răspuns

Nu. O singură măsurătoare returnează întotdeauna o valoare clasică: fie 0, fie 1. Ideea de „amestec" apare doar în statisticile pe care le observi după multe rulări, numite și shots.

În termeni simpli, ce îți oferă entanglement-ul?

Răspuns

Îți oferă rezultate legate. Măsurarea unui qubit îți spune ceva despre celălalt. Această legătură este mai puternică decât aleatorietatea independentă și mai puternică decât orice corelație pur clasică sau aleatorie partajată poate explica.

Dacă un qubit se află în suprapunere, ce observi într-o singură măsurătoare și de ce ai nevoie de multe shots?

Răspuns

Într-o singură măsurătoare observi doar un rezultat clasic: fie 0, fie 1. Ai nevoie de multe shots deoarece „suprapunerea" se manifestă ca o distribuție de probabilitate, pe care o poți estima doar colectând statistici din rulări repetate.

Uită-te la histograma de măsurare a circuitului tău Hello World în Composer. Ce observi? De ce acesta este un semn distinctiv al entanglement-ului?

Răspuns

Îți arată o probabilitate de 50% de a fi în starea $|00\rangle$ și o probabilitate de 50% de a fi în starea $|11\rangle$. Asta înseamnă că dacă măsori unul ca 0, celălalt va fi 0, și dacă măsori unul ca 1, celălalt va fi și el 1. Aceasta este o corelație între cei doi qubiți care poate fi explicată prin entanglement.

Creează și rulează un program cuantic folosind Qiskit

Bine, înapoi la programare. Vom genera aceeași stare entanglată ca în Composer (numită starea Bell $\Phi^+$ (phi-plus)), dar de data aceasta vom scrie codul de mână. Trebuie să dezvoltăm această abilitate deoarece, pe măsură ce scalăm la mai mulți qubiți și circuite mai complexe, Composer-ul nu ne va putea ajuta.

Pentru a construi circuitul stării Bell, folosim o poartă $H$ (Hadamard) pentru a pune primul qubit într-o suprapunere egală. Apoi aplicăm o poartă $CX$ (controlled-NOT), care entanglează cele două stări împreună. Cei doi qubiți sunt acum corelați într-un mod care nu are echivalent clasic.

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

Funcție ajutătoare pentru rularea circuitelor

Acum să definim o funcție ajutătoare care gestionează procesul de rulare a unui circuit cuantic și de recuperare a rezultatelor măsurătorilor. Această funcție se ocupă de transpilarea circuitului pentru a corespunde setului de instrucțiuni al backend-ului, rularea lui printr-o primitivă Sampler și extragerea numărătorilor din rezultate.

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

Rulează pe un QPU și vizualizează rezultatele

În final, rulăm circuitul pe o unitate de procesare cuantică (QPU) IBM în cloud pentru 1000 de shots și reprezentăm grafic rezultatele. QPU-urile IBM sunt sisteme fizice care pot capta zgomot, astfel că porțile sunt ușor imperfecte, măsurătorile pot fi uneori greșite, iar calibrarea dispozitivului se modifică în timp.

Rularea pe calculatoare cuantice reale introduce și considerații practice. Joburile pot sta în coadă, deoarece mulți oameni pot folosi același dispozitiv. Trebuie de asemenea să alegi un număr de shots care echilibrează considerațiile statistice (mai multe shots înseamnă un raport semnal-zgomot mai bun) cu constrângerile de timp/cost.

Urmează instrucțiunile din comentariile codului din celula următoare. După rularea celulei, ar trebui să vezi o histogramă cu numărători aproximativ egale pentru șirurile de biți $00$ și $11$, cu câteva apariții ale $01$ sau $10$ din cauza zgomotului. Celula următoare din acest notebook rulează același circuit pe un simulator, dacă alegi să omiți rularea pe un 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)

Rulează pe un simulator și vizualizează rezultatele

Un simulator este o versiune a calculului cuantic în „lumea perfectă". Aici rulăm circuitul pe un simulator pentru 1000 de shots și reprezentăm grafic rezultatele. Ar trebui să vezi numărători aproximativ egale pentru stările $00$ și $11$, fără apariții ale $01$ sau $10$, ceea ce este semnătura corelației perfecte a stării Bell.

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

plot_histogram(counts)

Verifică-ți înțelegerea

Care sunt cele două porți care creează starea Bell aici?

Răspuns

O poartă H pe qubit 0, urmată de o poartă CX cu qubit 0 ca control și qubit 1 ca țintă.

Pe un simulator ideal, care două șiruri de biți ar trebui să domine histograma?

Răspuns

00 și 11 ar trebui să domine.

De ce un simulator perfect nu ar avea întotdeauna exact același număr de numărători pentru 00 ca pentru 11?

Răspuns

Chiar dacă un simulator este „perfect" și duce la o stare Bell perfectă, el simulează în continuare un proces inerent aleator, deci fluctuațiile statistice vor apărea în continuare. Este ca și cum ai arunca o monedă de 1000 de ori: chiar dacă există o șansă exactă de 50-50 ca moneda să cadă pe cap sau pajură, asta nu înseamnă că vei obține întotdeauna exact 500 de cazuri de cap și 500 de pajură.

De ce un calculator cuantic real ar putea arăta câteva rezultate de 01 sau 10, deși simulatorul nu a arătat?

Răspuns

Deoarece dispozitivele reale au zgomot. Porțile și măsurătorile nu sunt perfecte, iar asta poate introduce erori ocazionale.

Care este o diferență practică între simulatoare și calculatoarele cuantice reale, în afară de zgomot?

Răspuns

Calculatoarele cuantice pot implica timp de așteptare în coadă, disponibilitate limitată și constrângeri specifice dispozitivului care afectează modul în care rulează circuitele.

Concluzie

Am început prin configurarea Qiskit într-un mediu Colab nou, ceea ce este exact modul în care încep multe fluxuri de lucru cu notebook-uri din lumea reală. Am continuat cu o călătorie în calculul cuantic folosind Composer-ul. Apoi am construit un circuit simplu cu doi qubiți care produce starea Bell $\Phi^+$ și am folosit eșantionarea repetată, vizualizând entanglement-ul ca o corelație în histograma de măsurare a qubiților. Am văzut de asemenea cum calculatoarele cuantice reale introduc zgomot și erori.

Obiectiv de învățare

Acum că am parcurs modul de a crea starea Bell $\Phi^+$, încearcă să editezi codul pentru a crea una dintre celelalte trei stări Bell. În special, starea $\Psi^-$ va fi folosită într-o lecție viitoare, deci dacă reușești să o creezi, vei fi cu un pas înaintea celorlalți.