Hello World: primul tău circuit cuantic

Construiește o stare Bell (doi qubiți entanglați) și rulează-o în trei moduri:

1. Simulare ideală — rezultate perfecte, nu e nevoie de cont

2. Simulare cu zgomot — simulează un dispozitiv real, fără cont necesar

3. Hardware cuantic real — necesită un cont IBM Quantum gratuit (pași de configurare mai jos)

Construiește circuitul

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

qc.draw(output="mpl")

Opțiunea 1: Simulare ideală (fără cont necesar)

Folosește StatevectorSampler — un simulator local cu rezultate perfecte, fără zgomot.

from qiskit.primitives import StatevectorSampler

result = StatevectorSampler().run([qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
counts

from qiskit.visualization import plot_histogram
plot_histogram(counts)

Opțiunea 2: Simulare cu zgomot (fără cont necesar)

Folosește FakeManilaV2 — un simulator local care imită un dispozitiv cuantic IBM real, inclusiv caracteristicile sale de zgomot. Circuitul trebuie mai întâi transpilat (adaptat) la setul de porți și conectivitatea qubiților dispozitivului.

from qiskit.primitives import BackendSamplerV2
from qiskit_ibm_runtime.fake_provider import FakeManilaV2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

backend = FakeManilaV2()
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

result = BackendSamplerV2(backend=backend).run([isa_qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
counts

plot_histogram(counts)

Opțiunea 3: Hardware cuantic real

Necesită un cont IBM Quantum gratuit. Pentru a-l configura:

1. Înregistrează-te la quantum.cloud.ibm.com/registration — nu ai nevoie de card de credit în primele 30 de zile

2. Conectează-te la quantum.cloud.ibm.com și selectează regiunea us-east (obligatorie pentru planul Open gratuit)

3. Creează o instanță (planul Open gratuit) la Instances dacă nu ai deja una

4. Creează o cheie API la quantum.cloud.ibm.com (sau la cloud.ibm.com/iam/apikeys)

5. Copiază CRN-ul tău (Cloud Resource Name) de pe pagina Instances

Apoi, dacă nu ți-ai salvat încă credențialele aici, rulează celula de mai jos. Înlocuiește <your-api-key> cu cheia API de la pasul 4 și <your-crn> cu CRN-ul de la pasul 5. Până când o faci, celula nu salvează nimic, așa că rularea tuturor celulelor nu poate suprascrie niciodată un cont salvat anterior.

from qiskit_ibm_runtime import QiskitRuntimeService

token = "<your-api-key>"
instance = "<your-crn>"

if token.startswith("<") or instance.startswith("<"):
    print("Paste your API key and CRN above first; nothing was saved.")
else:
    QiskitRuntimeService.save_account(
        channel="ibm_quantum_platform",
        token=token,
        instance=instance,
        set_as_default=True,
        overwrite=True,
    )
    print("Account saved.")

Notă: Job-urile pe hardware real pot dura ceva timp în funcție de timpii de așteptare în coadă. Dacă celula încă rulează, poți verifica starea job-ului și vedea rezultatele la quantum.cloud.ibm.com/workloads.

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)
print(f"Running on {backend.name}")

pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

result = SamplerV2(mode=backend).run([isa_qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
counts

plot_histogram(counts)

Ce urmează?

• Tutoriale — ghiduri pas cu pas despre algoritmi, atenuarea erorilor, transpilare și altele

• Ghiduri — material de referință despre rularea circuitelor, primitive și Qiskit Runtime

• Cursuri — trasee de învățare structurate, de la noțiunile de bază ale calculului cuantic până la calculul cuantic la scară utilitară

• Module — module conceptuale mai aprofundate în informatică și mecanică cuantică