Hello World: il tuo primo circuito quantistico

Costruisci uno stato di Bell (due qubit entangled) ed eseguilo in tre modi:

1. Simulazione ideale — risultati perfetti, nessun account richiesto

2. Simulazione con rumore — simula un dispositivo reale, nessun account richiesto

3. Hardware quantistico reale — richiede un account IBM Quantum gratuito (i passaggi di configurazione sono descritti di seguito)

Costruire il circuito

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

Opzione 1: Simulazione ideale (nessun account richiesto)

Utilizza StatevectorSampler — un simulatore locale con risultati perfetti e privi di rumore.

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)

Opzione 2: Simulazione con rumore (nessun account richiesto)

Utilizza FakeManilaV2 — un simulatore locale che imita un vero dispositivo quantistico IBM, incluse le sue caratteristiche di rumore. Il circuito deve prima essere transpilato (adattato) al set di gate e alla connettività dei qubit del dispositivo.

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)

Opzione 3: Hardware quantistico reale

Richiede un account IBM Quantum gratuito. Per configurarne uno:

1. Registrati su quantum.cloud.ibm.com/registration — nessuna carta di credito richiesta per i primi 30 giorni

2. Accedi su quantum.cloud.ibm.com e seleziona la regione us-east (obbligatoria per il piano Open gratuito)

3. Crea un'istanza (piano Open gratuito) su Instances se non ne hai ancora una

4. Crea una chiave API su quantum.cloud.ibm.com (oppure su cloud.ibm.com/iam/apikeys)

5. Copia il tuo CRN (Cloud Resource Name) dalla pagina Instances

Quindi, se non hai ancora salvato qui le tue credenziali, esegui la cella seguente. Sostituisci <your-api-key> con la chiave API del passaggio 4 e <your-crn> con il CRN del passaggio 5. Finché non lo fai, la cella non salva nulla, quindi eseguire tutte le celle non può mai sovrascrivere un account che hai salvato in precedenza.

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

Nota: I job su hardware reale possono richiedere del tempo a seconda dei tempi di attesa in coda. Se la cella è ancora in esecuzione, puoi controllare lo stato del tuo job e vedere i risultati su 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)

Cosa fare dopo?

• Tutorials — guide passo-passo su algoritmi, mitigazione degli errori, transpilazione e altro

• Guides — materiale di riferimento sull'esecuzione di circuiti, primitive e Qiskit Runtime

• Courses — percorsi di apprendimento strutturati dalle basi del calcolo quantistico al calcolo su scala utility

• Modules — moduli concettuali approfonditi su informatica e meccanica quantistica