Costruisci ed esegui il tuo primo programma quantistico

Introduzione

Nel video seguente, Olivia Lanes ti guida attraverso i contenuti di questa lezione. In alternativa, puoi aprire il video YouTube di questa lezione in una finestra separata.

Benvenuto in Usa un computer quantistico oggi! L'obiettivo di questo corso è farti eseguire del codice su un vero computer quantistico nel minor tempo possibile, senza alcuna conoscenza pregressa richiesta. Cominciamo.

Questa prima lezione è un'introduzione pratica e delicata al quantum computing, adatta sia ai principianti curiosi sia ai professionisti impegnati. Imparerai a conoscere i Circuit quantistici e scriverai un piccolo programma quantistico che crea entanglement, per poi eseguirlo su un vero computer quantistico IBM®. Hai anche la possibilità di eseguire lo stesso programma su un simulatore, qualora tu scelga di non utilizzare un vero computer quantistico.

Puoi eseguire questo notebook dall'inizio alla fine in un nuovo runtime Google Colab, oppure eseguirlo in locale.

Configurazione

Per eseguire questo notebook in Google Colab, avrai bisogno di un account Google per poter aprire i notebook ed eseguire le celle nel browser.

Per eseguire su un vero computer quantistico IBM, avrai bisogno anche di un (gratuito) account IBM Quantum® Platform. Puoi aprire un'istanza utilizzando l'Open Plan per ottenere 10 minuti di tempo del processore quantistico (QPU) per ogni finestra mobile di 28 giorni, il che è davvero molto! Se hai problemi con il tuo account, consulta la pagina di supporto.

Puoi anche eseguire questo notebook in locale dopo aver installato Qiskit seguendo le istruzioni su IBM Quantum Platform.

Installazione e importazioni

In Colab, installiamo le dipendenze all'interno del notebook affinché tutti utilizzino gli stessi strumenti. La cella successiva installa Qiskit con il modulo di visualizzazione più due componenti aggiuntivi: Aer (simulatori veloci) e il client IBM Runtime (per l'esecuzione su computer quantistici).

Successivamente, abbiamo una serie di importazioni. La classe QuantumCircuit è il luogo in cui definiamo i nostri bit quantistici, o qubit, e le operazioni su di essi. Questo è il nostro primo termine quantistico: un Qubit è il blocco costitutivo di base del quantum computing, proprio come il bit è il blocco costitutivo del calcolo classico. Impareremo di più sulle proprietà speciali dei Qubit man mano che creiamo il nostro Circuit. Successivamente, plot_histogram verrà utilizzato per visualizzare i risultati del nostro Circuit quantistico. AerSimulator ci consente di simulare il Circuit quantistico su un computer classico. I simulatori, tuttavia, non possono eseguire Circuit quantistici alla stessa scala dei veri computer quantistici; ecco perché abbiamo bisogno di veri computer quantistici. Questo può essere utile per test, debug o scopi didattici; oppure se hai esaurito i tuoi 10 minuti gratuiti di tempo QPU. I preset_passmanagers aiutano a ottimizzare i Circuit per essere eseguiti in modo efficiente sull'hardware, il che diventa molto importante man mano che i nostri Circuit diventano più complessi. Sampler e QiskitRuntimeService sono necessari per eseguire effettivamente il Circuit sul computer quantistico. Ulteriori dettagli in seguito.

# 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

Successivamente effettueremo un rapido controllo dell'ambiente. Verifichiamo le versioni e confermiamo le importazioni.

Se qualcosa fallisce qui, di solito si tratta di un problema di installazione delle dipendenze; risolverlo ora evita errori confusi in seguito.

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

Una breve digressione: usa il Composer

Prima di scrivere codice, è utile visualizzare i Circuit graficamente. Il Composer di IBM Quantum ti permette di costruire Circuit trascinando Gate sui fili. È un ottimo modo per capire cosa fa un Circuit senza distrarti con la sintassi.

Apri il Composer qui.

Una volta caricato, avvia il tutorial guidato dal menu: Help | Build your first circuit. Seguilo al tuo ritmo. Man mano che procedi, presta attenzione a come ogni Gate cambia ciò che ti aspetti di misurare.

Il tutorial guida passo dopo passo nella costruzione del Circuit "Hello World". Viene visualizzato in quello che si chiama diagramma di Circuit, dove i Qubit sono rappresentati da linee orizzontali e i Gate che agiscono su quei Qubit sono rappresentati da riquadri o altri simboli sulle linee. Questo Circuit ci introduce ad alcune caratteristiche chiave dei Qubit e dei computer quantistici:

In primo luogo, il riquadro rosso etichettato "H" è un Hadamard Gate, che crea uno stato di sovrapposizione del Qubit 0. A differenza di un bit, che può essere solo nello stato 1 o 0, uno stato Qubit può includere entrambe le possibilità contemporaneamente, con certi pesi (chiamati ampiezze) associati a ciascuna. La sovrapposizione non significa che vedrai mai entrambi i risultati in una singola misurazione; significa che lo stato è configurato in modo che entrambi gli esiti possano verificarsi quando misuri.

In secondo luogo, i cerchi e la linea verticale che collegano i due Qubit costituiscono un CNOT Gate, che genera entanglement tra i due Qubit. L'entanglement è un tipo speciale di collegamento tra Qubit. Quando i Qubit sono entangled, i risultati delle misurazioni possono essere fortemente correlati in un modo che non corrisponde a ciò che ci aspetteremmo da normali lanci di moneta indipendenti, o da qualsiasi correlazione classica. Quando due Qubit sono entangled, misurarne uno ti dirà istantaneamente il risultato della misurazione dell'altro.

Un'altra idea chiave che vedrai nel tutorial sono gli shots. Poiché la misurazione è il momento in cui un Qubit smette di comportarsi come uno stato quantistico e ti fornisce una lettura classica, uno stato di sovrapposizione collasserà probabilisticamente su uno 0 o un 1 quando viene misurato. Quindi, per conoscere quella sovrapposizione, devi misurarla molte volte eseguendo lo stesso Circuit per accumulare statistiche. Questi sono chiamati shots.

Verifica la tua comprensione

Rifletti su ogni domanda qui sotto, poi clicca per rivelare la risposta.

Puoi vedere una sovrapposizione direttamente da una singola misurazione?

Risposta

No. Una singola misurazione restituisce sempre un valore classico: 0 o 1. L'idea di "miscela" emerge solo nelle statistiche che vedi dopo molte esecuzioni, dette anche shots.

In parole semplici, cosa ti offre l'entanglement?

Risposta

Ti offre risultati collegati. Misurare un Qubit ti dice qualcosa sull'altro. Questo collegamento è più forte della casualità indipendente e più forte di qualsiasi correlazione puramente classica o casualità condivisa possa spiegare.

Se un Qubit è in sovrapposizione, cosa vedi in una singola misurazione e perché hai bisogno di molti shots?

Risposta

In una singola misurazione vedi solo un risultato classico: 0 o 1. Hai bisogno di molti shots perché la "sovrapposizione" si manifesta come una distribuzione di probabilità, che puoi stimare solo raccogliendo statistiche su esecuzioni ripetute.

Osserva l'istogramma delle misurazioni del tuo Circuit Hello World nel Composer. Cosa vedi? Perché questa è una firma dell'entanglement?

Risposta

Mostra una probabilità del 50% di trovarsi nello stato $|00\rangle$ e una probabilità del 50% di trovarsi nello stato $|11\rangle$. Ciò significa che se misuri uno come 0, l'altro sarà 0, e se misuri uno come 1, anche l'altro sarà 1. Questa è una correlazione tra i due Qubit che può essere spiegata dall'entanglement.

Crea ed esegui un programma quantistico usando Qiskit

Bene, torniamo alla programmazione. Genereremo lo stesso stato entangled che abbiamo creato nel Composer (chiamato stato di Bell $\Phi^+$ (phi-plus)) ma questa volta scriveremo il codice a mano. Dobbiamo sviluppare questa competenza perché, man mano che scaliamo a più Qubit e Circuit più complessi, il Composer non sarà in grado di aiutarci.

Per costruire il Circuit dello stato di Bell, usiamo un Gate $H$ (Hadamard) per mettere il primo Qubit in una sovrapposizione uguale. Poi applichiamo un Gate $CX$ (controlled-NOT), che entangles i due stati insieme. I due Qubit sono ora correlati in un modo che non ha un equivalente classico.

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

Funzione di supporto per l'esecuzione dei Circuit

Definiamo ora una funzione di supporto che gestisce il processo di esecuzione di un Circuit quantistico e il recupero dei risultati di misurazione. Questa funzione si occupa di trascompilare il Circuit per adattarlo all'instruction set del Backend, di eseguirlo tramite una primitiva Sampler, e di estrarre i conteggi dai risultati.

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

Esecuzione su una QPU e visualizzazione dei risultati

Infine, eseguiamo il Circuit su un'unità di elaborazione quantistica (QPU) IBM nel cloud per 1000 shots e visualizziamo i risultati. Le QPU IBM sono sistemi fisici che possono raccogliere rumore, quindi i Gate sono leggermente imperfetti, le misurazioni possono talvolta essere errate e la calibrazione del dispositivo varia nel tempo.

L'esecuzione su veri computer quantistici introduce anche considerazioni pratiche. I job possono mettersi in coda, perché molte persone potrebbero utilizzare lo stesso dispositivo. Devi anche scegliere un numero di shots che bilanci le considerazioni statistiche (più shots equivale a un rapporto segnale-rumore più alto) con i vincoli di tempo e costo.

Segui le istruzioni nei commenti del codice della prossima cella. Dopo aver eseguito la cella, dovresti vedere un istogramma con conteggi approssimativamente uguali per le stringhe di bit $00$ e $11$, con alcune occorrenze di $01$ o $10$ dovute al rumore. La cella successiva in questo notebook esegue lo stesso Circuit su un simulatore, qualora tu scelga di non eseguire su una 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)

Esecuzione su un simulatore e visualizzazione dei risultati

Un simulatore è una versione "mondo perfetto" del quantum computing. Qui eseguiamo il Circuit su un simulatore per 1000 shots e visualizziamo i risultati. Dovresti vedere conteggi approssimativamente uguali per gli stati $00$ e $11$, senza occorrenze di $01$ o $10$, il che è la firma della correlazione perfetta dello stato di Bell.

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

plot_histogram(counts)

Verifica la tua comprensione

Quali sono i due Gate che creano lo stato di Bell qui?

Risposta

Un Gate H sul Qubit 0, seguito da un Gate CX con il Qubit 0 come controllo e il Qubit 1 come target.

Su un simulatore ideale, quali due stringhe di bit dovrebbero dominare l'istogramma?

Risposta

00 e 11 dovrebbero dominare.

Perché un simulatore perfetto non avrebbe sempre esattamente lo stesso numero di conteggi 00 e 11?

Risposta

Anche se un simulatore è "perfetto" e porta a uno stato di Bell perfetto, sta comunque simulando un processo intrinsecamente casuale, quindi si verificheranno comunque fluttuazioni statistiche. È come lanciare una moneta 1000 volte: anche se c'è esattamente una probabilità 50-50 che la moneta cada su testa o croce, non significa che otterrai sempre esattamente 500 teste e 500 croci.

Perché un vero computer quantistico potrebbe mostrare alcuni risultati 01 o 10 anche se il simulatore non lo ha fatto?

Risposta

Perché i dispositivi reali hanno rumore. Gate e misurazioni non sono perfetti, e questo può introdurre errori occasionali.

Qual è una differenza pratica tra simulatori e veri computer quantistici, oltre al rumore?

Risposta

I computer quantistici possono comportare tempi di attesa in coda, disponibilità limitata e vincoli specifici del dispositivo che influenzano il modo in cui i Circuit vengono eseguiti.

Conclusione

Abbiamo iniziato configurando Qiskit in un nuovo ambiente Colab, esattamente come iniziano molti flussi di lavoro reali con notebook. Abbiamo poi intrapreso un viaggio nel quantum computing usando il Composer. Abbiamo quindi costruito un semplice Circuit a due Qubit che produce lo stato di Bell $\Phi^+$ e utilizzato il campionamento ripetuto, visualizzando l'entanglement come correlazione nell'istogramma delle misurazioni dei Qubit. Abbiamo anche visto come i veri computer quantistici introducano rumore ed errori.

Obiettivo di apprendimento

Ora che abbiamo visto come creare lo stato di Bell $\Phi^+$, prova a modificare il codice per creare uno degli altri tre stati di Bell. In particolare, lo stato $\Psi^-$ verrà utilizzato in una lezione futura, quindi se riesci a capire come crearlo, sarai in vantaggio.