Construis et exécute ton premier programme quantique

Introduction

Dans la vidéo suivante, Olivia Lanes te guide à travers le contenu de cette leçon. Tu peux aussi ouvrir la vidéo YouTube de cette leçon dans une fenêtre séparée.

Bienvenue dans Utilise un ordinateur quantique aujourd'hui ! L'objectif de ce cours est que tu exécutes du code sur un vrai ordinateur quantique dans le plus court délai possible, sans aucun prérequis. Commençons.

Cette première leçon est une introduction pratique et progressive à l'informatique quantique, qui convient aussi bien aux débutants curieux qu'aux responsables pressés. Tu apprendras ce que sont les circuits quantiques et tu écriras un petit programme quantique qui crée de l'enchevêtrement, puis tu l'exécuteras sur un vrai ordinateur quantique IBM®. Tu as également la possibilité d'exécuter le même programme sur un simulateur, si tu choisis de ne pas utiliser un vrai ordinateur quantique.

Tu peux exécuter ce notebook de haut en bas dans un environnement Google Colab vierge, ou l'exécuter localement.

Configuration

Pour exécuter ce notebook dans Google Colab, tu as besoin d'un compte Google afin de pouvoir ouvrir des notebooks et exécuter des cellules dans le navigateur.

Pour exécuter le programme sur un vrai ordinateur quantique IBM, tu auras également besoin d'un compte IBM Quantum® Platform (gratuit). Tu peux ouvrir une instance avec le plan Open pour bénéficier de 10 minutes de temps de processeur d'unité quantique (QPU) par fenêtre glissante de 28 jours, ce qui est en réalité assez généreux ! Si tu rencontres des problèmes avec ton compte, consulte la page Support.

Tu peux également exécuter ce notebook localement après avoir installé Qiskit en suivant les instructions sur IBM Quantum Platform.

Installation et imports

Dans Colab, nous installons les dépendances à l'intérieur du notebook pour que tout le monde utilise les mêmes outils. La cellule suivante installe Qiskit avec le module de visualisation ainsi que deux extensions : Aer (simulateurs rapides) et le client IBM Runtime (pour les exécutions sur ordinateur quantique).

Ensuite, nous avons plusieurs imports. La classe QuantumCircuit est l'endroit où nous définissons nos bits quantiques, ou qubits, et les opérations sur ces qubits. Voici notre premier terme quantique : un qubit est la brique élémentaire du calcul quantique, tout comme un bit est la brique élémentaire du calcul classique. Nous en apprendrons davantage sur les propriétés spéciales des qubits au fil de la création de notre circuit. Ensuite, plot_histogram servira à visualiser les résultats de notre circuit quantique. AerSimulator nous permet de simuler le circuit quantique sur un ordinateur classique. Cependant, les simulateurs ne peuvent pas exécuter des circuits quantiques à la même échelle que de vrais ordinateurs quantiques ; c'est pourquoi nous avons besoin de vrais ordinateurs quantiques. Les simulateurs peuvent être utiles pour tester, déboguer ou à des fins pédagogiques, ou si tu as épuisé tes 10 minutes gratuites de temps QPU. Les preset_passmanagers aident à optimiser les circuits pour qu'ils s'exécutent efficacement sur le matériel, ce qui devient vraiment important à mesure que nos circuits se complexifient. Sampler et QiskitRuntimeService sont nécessaires pour exécuter réellement le circuit sur l'ordinateur quantique. Nous y reviendrons plus tard.

# 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

Nous allons ensuite effectuer une vérification rapide de l'environnement. Nous confirmons les versions et validons les imports.

Si quelque chose échoue ici, c'est généralement un problème d'installation de dépendance ; le résoudre maintenant évite des erreurs déconcertantes par la suite.

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

Une petite parenthèse : utilise le Composer

Avant d'écrire du code, il est utile de visualiser les circuits. Le Composer d'IBM Quantum te permet de construire des circuits en faisant glisser des gates sur des fils. C'est une excellente façon de comprendre ce que fait un circuit sans être distrait par la syntaxe.

Ouvre le Composer ici.

Une fois chargé, lance le tutoriel guidé depuis le menu : Help | Build your first circuit. Avance à ton propre rythme. Au fil du tutoriel, observe comment chaque gate modifie ce que tu t'attends à mesurer.

Le tutoriel explique étape par étape comment construire le circuit « Hello World ». Celui-ci est représenté sous la forme d'un diagramme de circuit, où les qubits sont représentés par des lignes horizontales et les gates agissant sur ces qubits par des boîtes ou d'autres symboles sur ces lignes. Ce circuit nous introduit à quelques caractéristiques clés des qubits et des ordinateurs quantiques :

Premièrement, la boîte rouge étiquetée « H » est une gate Hadamard, qui crée un état de superposition du qubit 0. Contrairement à un bit, qui ne peut être qu'à l'état 1 ou 0, un état de qubit peut inclure les deux possibilités à la fois, avec certains poids (appelés amplitudes) associés à chacune. La superposition ne signifie pas que tu verras jamais les deux résultats en une seule mesure ; elle signifie que l'état est configuré de sorte que l'un ou l'autre résultat peut se produire lors de la mesure.

Deuxièmement, les cercles et la ligne verticale reliant les deux qubits forment une gate CNOT, qui génère de l'enchevêtrement entre les deux qubits. L'enchevêtrement est un type particulier de lien entre les qubits. Lorsque des qubits sont enchevêtrés, les résultats des mesures peuvent être fortement corrélés d'une manière qui ne correspond pas à ce que l'on attendrait de simples tirages au sort indépendants, ni d'aucune corrélation classique. Lorsque deux qubits sont enchevêtrés, mesurer l'un te donnera instantanément le résultat de la mesure de l'autre.

Une autre idée clé que tu verras dans le tutoriel est celle des shots. Parce que la mesure est le moment où un qubit cesse de se comporter comme un état quantique et te donne une lecture classique, un état de superposition s'effondrera de façon probabiliste vers un 0 ou un 1 lors de la mesure. Ainsi, pour étudier cette superposition, tu dois la mesurer de nombreuses fois en exécutant le même circuit afin d'accumuler des statistiques. C'est ce qu'on appelle des shots.

Vérifie ta compréhension

Réfléchis à chaque question ci-dessous, puis clique pour révéler la réponse.

Peut-on observer directement une superposition à partir d'une seule mesure ?

Réponse

Non. Une seule mesure retourne toujours une valeur classique : soit 0, soit 1. L'idée de « mélange » n'apparaît que dans les statistiques observées après de nombreuses exécutions, appelées aussi shots.

En termes simples, qu'est-ce que l'enchevêtrement t'apporte ?

Réponse

Il te donne des résultats liés. Mesurer un qubit te renseigne sur l'autre. Ce lien est plus fort que l'aléatoire indépendant et plus fort que ce que peut expliquer toute corrélation purement classique ou aléatoire partagée.

Si un qubit est en superposition, que vois-tu lors d'une seule mesure, et pourquoi as-tu besoin de nombreux shots ?

Réponse

Lors d'une seule mesure, tu ne vois qu'un seul résultat classique : soit 0, soit 1. Tu as besoin de nombreux shots parce que la « superposition » se manifeste comme une distribution de probabilité, que tu ne peux estimer qu'en accumulant des statistiques sur des exécutions répétées.

Regarde l'histogramme de mesure de ton circuit Hello World dans le Composer. Que vois-tu ? Pourquoi est-ce une signature de l'enchevêtrement ?

Réponse

Tu vois une probabilité de 50% d'être dans l'état $|00\rangle$ et une probabilité de 50% d'être dans l'état $|11\rangle$. Cela signifie que si tu mesures l'un à 0, l'autre sera 0, et si tu mesures l'un à 1, l'autre sera également 1. C'est une corrélation entre les deux qubits qui peut être expliquée par l'enchevêtrement.

Crée et exécute un programme quantique avec Qiskit

Bon, revenons au code. Nous allons générer le même état enchevêtré que dans le Composer (appelé l'état de Bell $\Phi^+$ (phi-plus)), mais cette fois, nous allons écrire le code à la main. Nous devons développer cette compétence car, à mesure que nous passerons à plus de qubits et à des circuits plus complexes, le Composer ne pourra plus nous aider.

Pour construire le circuit Bell state, nous utilisons une gate $H$ (Hadamard) pour mettre le premier qubit dans une superposition égale. Ensuite, nous appliquons une gate $CX$ (NOT contrôlé), qui enchevêtre les deux états ensemble. Les deux qubits sont maintenant corrélés d'une façon qui n'a pas d'équivalent classique.

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

Fonction utilitaire pour exécuter les circuits

Définissons maintenant une fonction utilitaire qui gère le processus d'exécution d'un circuit quantique et de récupération des résultats de mesure. Cette fonction s'occupe de transpiler le circuit pour correspondre au jeu d'instructions du Backend, de l'exécuter via une primitive Sampler, et d'extraire les comptages depuis les résultats.

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

Exécution sur un QPU et visualisation des résultats

Enfin, nous exécutons le circuit sur une unité de traitement quantique (QPU) IBM dans le cloud pour 1000 shots et nous traçons les résultats. Les QPU IBM sont des systèmes physiques susceptibles de capter du bruit, ce qui fait que les gates sont légèrement imparfaites, les mesures peuvent parfois être erronées, et l'étalonnage du dispositif dérive avec le temps.

L'exécution sur de vrais ordinateurs quantiques introduit également des considérations pratiques. Les jobs peuvent se retrouver dans une file d'attente, car de nombreuses personnes peuvent utiliser le même dispositif. Tu dois également choisir un nombre de shots qui équilibre les considérations statistiques (plus de shots égale un meilleur rapport signal/bruit) avec les contraintes de temps et de coût.

Suis les instructions dans les commentaires du code de la prochaine cellule. Après avoir exécuté la cellule, tu devrais voir un histogramme avec des comptages approximativement égaux pour les chaînes de bits $00$ et $11$, avec quelques occurrences de $01$ ou $10$ dues au bruit. La cellule suivante dans ce notebook exécute le même circuit sur un simulateur, si tu choisis de ne pas exécuter sur 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)

Exécution sur un simulateur et visualisation des résultats

Un simulateur est une version « monde parfait » de l'informatique quantique. Ici, nous exécutons le circuit sur un simulateur pour 1000 shots et nous traçons les résultats. Tu devrais voir des comptages approximativement égaux pour les états $00$ et $11$, sans aucune occurrence de $01$ ou $10$, ce qui est la signature de la corrélation parfaite du Bell state.

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

plot_histogram(counts)

Vérifie ta compréhension

Quelles sont les deux gates qui créent le Bell state ici ?

Réponse

Une gate H sur le qubit 0, suivie d'une gate CX avec le qubit 0 comme contrôle et le qubit 1 comme cible.

Sur un simulateur idéal, quelles deux chaînes de bits devraient dominer l'histogramme ?

Réponse

00 et 11 devraient dominer.

Pourquoi un simulateur parfait n'aurait-il pas toujours exactement le même nombre de comptages 00 que de comptages 11 ?

Réponse

Même si un simulateur est « parfait » et produit un Bell state parfait, il simule toujours un processus intrinsèquement aléatoire, donc des fluctuations statistiques se produiront quand même. C'est comme lancer une pièce 1000 fois : même s'il y a exactement 50% de chances que la pièce tombe sur face ou sur pile, cela ne veut pas dire que tu obtiendras toujours exactement 500 faces et 500 piles.

Pourquoi un vrai ordinateur quantique pourrait-il afficher des résultats 01 ou 10 alors que le simulateur n'en a pas affiché ?

Réponse

Parce que les vrais dispositifs ont du bruit. Les gates et les mesures ne sont pas parfaites, ce qui peut introduire des erreurs occasionnelles.

Quelle est une différence pratique entre les simulateurs et les vrais ordinateurs quantiques, en dehors du bruit ?

Réponse

Les ordinateurs quantiques peuvent impliquer un temps d'attente dans la file, une disponibilité limitée et des contraintes spécifiques au dispositif qui influencent la façon dont les circuits s'exécutent.

Conclusion

Nous avons commencé par configurer Qiskit dans un environnement Colab vierge, ce qui correspond exactement au démarrage de nombreux workflows de notebooks réels. Nous avons ensuite fait un voyage dans l'informatique quantique à l'aide du Composer. Nous avons ensuite construit un circuit simple à deux qubits qui produit le Bell state $\Phi^+$ et utilisé un échantillonnage répété, puis visualisé l'enchevêtrement comme une corrélation dans l'histogramme des mesures de qubits. Nous avons également vu comment les vrais ordinateurs quantiques introduisent du bruit et des erreurs.

Objectif d'apprentissage

Maintenant que nous avons vu comment créer le Bell state $\Phi^+$, essaie de modifier le code pour créer l'un des trois autres Bell states. En particulier, l'état $\Psi^-$ sera utilisé dans une prochaine leçon, donc si tu arrives à le créer, tu auras une longueur d'avance.