Téléportation quantique

Pour ce module Qiskit en classe, les étudiant·e·s doivent disposer d'un environnement Python fonctionnel avec les packages suivants installés :

• qiskit v2.1.0 ou plus récent
• qiskit-ibm-runtime v0.40.1 ou plus récent
• qiskit-aer v0.17.0 ou plus récent
• qiskit.visualization
• numpy
• pylatexenc

Pour configurer et installer les packages ci-dessus, consulte le guide Installer Qiskit. Pour pouvoir lancer des jobs sur de vrais ordinateurs quantiques, les étudiant·e·s devront créer un compte IBM Quantum® en suivant les étapes du guide Configurer ton compte IBM Cloud.

Ce module a été testé et a utilisé 14 secondes de temps QPU. Il s'agit d'une estimation uniquement. Ton utilisation réelle peut varier.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-aer qiskit-ibm-runtime

# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

Regarde la présentation du module par Dr. Katie McCormick ci-dessous, ou clique ici pour la visionner sur YouTube.

---

Introduction et contexte

La téléportation quantique est une technique de physique quantique qui permet le transfert d'information quantique d'un endroit à un autre sans déplacer physiquement des particules. Contrairement au concept de téléportation de la science-fiction, ce processus ne consiste pas à transporter de la matière. Il repose plutôt sur le principe de l'intrication quantique, où deux particules deviennent liées quelle que soit la distance qui les sépare. Grâce à une série de mesures précises et de communications classiques, l'état quantique d'une particule peut être recréé dans une autre particule à un endroit distant, « téléportant » ainsi efficacement l'information quantique. Dans ce module, on verra comment cela fonctionne mathématiquement, puis on implémentera la téléportation quantique sur un vrai ordinateur quantique. L'introduction ici sera brève ; pour en savoir plus sur l'information quantique et pour plus d'explications sur la téléportation, on recommande le cours de John Watrous sur les Bases de l'information quantique, et en particulier la section sur la Téléportation.

Les bits classiques peuvent être dans les états 0 ou 1. Les bits quantiques (qubits) peuvent être dans des états quantiques notés $|0\rangle$ et $|1\rangle$, ainsi que dans des combinaisons linéaires de ces états, appelées « superpositions », telles que $|\psi\rangle = \alpha_0|0\rangle +\alpha_1|1\rangle$, avec $\alpha_0,\alpha_1 \in \mathbb{C},$ et $|\alpha_0|^2+|\alpha_1|^2 = 1.$ Bien que les états puissent exister dans cette superposition, une mesure de l'état le « fait s'effondrer » soit dans l'état $|0\rangle$, soit dans l'état $|1\rangle$. Les paramètres $a$ et $b$ sont liés à la probabilité de chaque résultat de mesure selon

$$P_0 = |\alpha_0|^2$$ $$P_1 = |\alpha_1|^2$$

D'où la contrainte que $|\alpha_0|^2+|\alpha_1|^2 = 1.$

Une autre caractéristique clé est que les bits quantiques peuvent être « intriqués », ce qui signifie que la mesure d'un qubit peut affecter le résultat de la mesure d'un autre qubit intriqué. Comprendre en quoi l'intrication est différente des simples corrélations classiques est un peu délicat. Expliquons d'abord notre notation. Appelons deux qubits appartenant à l'ami·e 0 (Alice) et à l'ami·e 1 (Bob), chacun dans l'état $|0\rangle$

$$|0\rangle_B|0\rangle_A$$

ou

$$|0\rangle_1|0\rangle_0$$

parfois abrégé simplement en

$$|00\rangle$$

Note que le qubit avec le numéro (ou la lettre) le plus bas se trouve le plus à droite. C'est une convention appelée notation « petit-boutiste » (little-endian), utilisée dans tout Qiskit. Si l'état à deux qubits des ami·e·s est $|00\rangle$ et qu'ils mesurent l'état de leurs qubits respectifs, ils trouveront chacun un 0. De même, si les qubits étaient dans l'état $|11\rangle$, chacune de leurs mesures donnerait un 1. Cela ne diffère pas du cas classique. Cependant, en informatique quantique, on peut combiner ceci avec la superposition pour obtenir des états tels que

$$\frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$$

Dans un tel état, le fait qu'Alice et Bob aient des qubits dans l'état 0 ou 1 n'est pas encore connu, pas même encore déterminé par la nature, et pourtant on sait qu'ils mesureront le même état pour leur qubit. Par exemple, si Bob mesure son qubit dans l'état $|0\rangle$, la seule façon pour que cela se produise est que la mesure ait fait s'effondrer l'état à deux qubits sur l'un des deux états possibles, spécifiquement sur $|00\rangle$. Cela laisse le qubit d'Alice également dans l'état $|0\rangle$.

L'intrication des qubits de cette façon n'exige pas que les qubits restent physiquement proches l'un de l'autre. En d'autres termes, on pourrait intriquer des qubits, les séparer ensuite d'une grande distance, et utiliser leur intrication pour envoyer de l'information. Un état intriqué comme celui ci-dessus est une unité de base de l'intrication, parfois appelée « e-bit », un seul bit d'intrication. Ces e-bits peuvent être considérés comme des ressources en communication quantique, car chaque e-bit partagé entre des partenaires distants peut être utilisé, comme on l'explique ici, pour déplacer de l'information d'un endroit à un autre.

La première pensée de beaucoup de personnes qui découvrent cela pour la première fois concerne la violation de la relativité : peut-on utiliser ceci pour envoyer de l'information plus vite que la lumière ? N'hésite pas à continuer de questionner et sonder les règles scientifiques, mais malheureusement cela ne permettra pas d'envoyer de l'information plus vite que la lumière, pour des raisons qui deviendront claires au fil de ce module. Spoiler : étonnamment, ce n'est PAS dû à la vitesse à laquelle cet effondrement se propage, qui semble effectivement se produire plus vite que la lumière [1]. On commence avec deux collaborateur·rice·s, Alice et Bob, qui se trouvent initialement au même endroit et peuvent travailler ensemble sur les mêmes qubits. Ces collaborateur·rice·s vont intriquer leurs qubits. Puis ils se sépareront pour aller dans deux emplacements géographiques différents, emportant chacun leurs qubits respectifs. Alice obtiendra alors de l'information quantique sur un nouveau qubit Q. On ne fait aucune hypothèse sur l'information contenue dans Q. L'état de Q pourrait être un secret inconnu d'Alice ; il pourrait être inconnu de tout le monde. Mais Alice a pour tâche de transférer l'information de Q à Bob. Elle le fera en utilisant la téléportation quantique.

Pour accomplir cela, on aura besoin de connaître certaines opérations quantiques ou « portes ».

Opérateurs quantiques (portes)

N'hésite pas à passer cette section si tu es déjà familier·ère avec les portes quantiques. Si tu veux mieux comprendre ces portes, consulte Bases de l'information quantique, notamment les deux premières leçons, sur IBM Quantum Learning.

Pour ce protocole de téléportation, on utilisera principalement deux types de portes quantiques : la porte Hadamard et la porte CNOT. Quelques autres joueront un rôle moindre : la porte $X$, la porte $Z$ et la porte SWAP.

Ce module peut être complété avec des bases très limitées en algèbre linéaire, mais visualiser les portes quantiques à l'aide de matrices et de vecteurs peut parfois être utile. On présente donc ici les formes matricielles/vectorielles des portes/états quantiques.

Les états qu'on a déjà présentés sont choisis (en partie par convention et en partie par contraintes) pour avoir les formes vectorielles suivantes :

$$|0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix}$$ $$|1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}$$

Ainsi, un état arbitraire $|\psi\rangle = a|0\rangle+b|1\rangle$ peut s'écrire

$$|\psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}$$

Il y a un certain choix dans la façon d'étendre la notation aux états multi-qubits, mais le choix ci-dessous est assez standard :

$$|00\rangle = \begin{pmatrix}1 \\ 0 \\ 0 \\ 0\end{pmatrix},|01\rangle = \begin{pmatrix}0 \\ 1 \\ 0 \\ 0\end{pmatrix}, |10\rangle = \begin{pmatrix}0 \\ 0 \\ 1 \\0\end{pmatrix},|11\rangle = \begin{pmatrix}0 \\ 0 \\ 0 \\ 1\end{pmatrix}.$$

Avec ce choix de notation vectorielle à l'esprit, on peut introduire les portes quantiques nécessaires, leurs effets sur les états quantiques, et leurs formes matricielles.

Porte H (Hadamard) : Crée un état de superposition. Porte à un qubit.

$$H|0\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right),$$ $$H|1\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right)$$ $$H=\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}$$

Un circuit avec une porte Hadamard se construit comme suit :

from qiskit import QuantumCircuit

qc = QuantumCircuit(1)
qc.h(0)
qc.draw("mpl")

Porte CNOT (NOT contrôlé) : Cette porte utilise deux qubits : un contrôle et une cible. Elle vérifie l'état du qubit de contrôle qui n'est pas modifié. Mais si le qubit de contrôle est dans l'état $|1\rangle$, la porte modifie l'état du qubit cible ; si l'état du qubit de contrôle est $|0\rangle$, aucun changement n'est effectué. Dans la notation ci-dessous, supposons que le qubit $A$ (le plus à droite) est le contrôle, et que le qubit $B$ (le plus à gauche) est la cible. Ci-dessous, la notation utilisée est $CNOT(q_{control},q_{target})|BA\rangle.$

$$CNOT(A,B)|00\rangle = |00\rangle, \\ CNOT(A,B)|01\rangle = |11\rangle, \\ CNOT(A,B)|10\rangle = |10\rangle, \\ CNOT(A,B)|11\rangle = |01\rangle$$

Il peut arriver que CNOT soit écrit avec l'ordre du contrôle et de la cible simplement implicite. Mais il n'y a pas d'ambiguïté de ce type dans le code ou dans les diagrammes de circuits.

$$CNOT=\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}$$

Une porte CNOT a un aspect légèrement différent dans un circuit, car elle nécessite deux qubits. Voici comment elle est implémentée :

qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.draw("mpl")

Vérifie ta compréhension

Lis la question ci-dessous, réfléchis à ta réponse, puis clique sur le triangle pour révéler la solution.

La plupart des portes ont la même forme matricielle dans Qiskit que partout ailleurs. Mais la porte CNOT agit sur deux qubits, et c'est là que les conventions d'ordre des qubits deviennent un enjeu. Les textes qui ordonnent les qubits $|q_0,q_1,...\rangle$ montreront une forme matricielle différente pour leurs portes CNOT. Vérifie par multiplication matricielle explicite que la matrice CNOT ci-dessus a l'action correcte sur l'état $|01\rangle.$

Réponse :

$CNOT|01\rangle =\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}\begin{pmatrix}0 \\ 1 \\ 0 \\0\end{pmatrix} = \begin{pmatrix}0 \\ 0 \\ 0 \\1\end{pmatrix} = |11\rangle$

Porte $X$ : Équivalent à une opération NOT. Porte à un qubit.

$$X|0\rangle = |1\rangle,\\X|1\rangle=|0\rangle$$ $$X=\begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}$$

Dans Qiskit, créer un circuit avec une porte $X$ ressemble à ceci :

qc = QuantumCircuit(1)
qc.x(0)
qc.draw("mpl")

Porte $Z$ : Ajoute une « phase » à un état (un préfacteur, qui dans le cas des états propres $|0\rangle$ et $|1\rangle$ de Z vaut respectivement 1 ou -1). Porte à un qubit.

$$Z|0\rangle = |0\rangle,\\Z|1\rangle=-|1\rangle$$ $$Z=\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$$

Dans Qiskit, créer un circuit avec une porte $Z$ ressemble à ceci :

qc = QuantumCircuit(1)
qc.z(0)
qc.draw("mpl")

Théorie

Posons le protocole de téléportation quantique à l'aide des mathématiques. Ensuite, dans la section suivante, on réalisera ce dispositif sur un ordinateur quantique.

Alice et Bob intriquent leurs qubits : Initialement, le qubit d'Alice et celui de Bob sont chacun séparément dans l'état $|0\rangle$ (une hypothèse raisonnable et également l'initialisation correcte pour les ordinateurs quantiques IBM®). On peut écrire cela comme $|0\rangle_B|0\rangle_A$ ou simplement $|00\rangle$. Calculons ce qui se passe quand Alice et Bob appliquent la porte Hadamard sur le qubit d'Alice, puis une porte CNOT avec le qubit d'Alice comme contrôle et celui de Bob comme cible :

$$\begin{aligned} CNOT(A,B)H_A |0\rangle_B|0\rangle_A &= CNOT(A,B)|0\rangle_B\frac{1}{\sqrt{2}}\left(|0\rangle_A+|1\rangle_A\right)\\ &=\frac{1}{\sqrt{2}}\left(CNOT(A,B)|0\rangle_B|0\rangle_A+CNOT(A,B)|0\rangle_B|1\rangle_A\right)\\ &=\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right) \end{aligned}$$

Note que maintenant les qubits d'Alice et de Bob sont intriqués. Bien qu'il ne soit pas encore déterminé par la nature si leurs qubits sont dans l'état $|0\rangle$ ou $|1\rangle$, on sait qu'ils seront dans le même état. Alice et Bob se séparent : Les deux ami·e·s déplacent leurs qubits vers de nouveaux emplacements, possiblement très éloignés l'un de l'autre. Cela comporte beaucoup de mises en garde : il n'est pas trivial de déplacer de l'information quantique sans la perturber. Mais cela peut être fait, et tu le feras dans ce module. Garde toutefois à l'esprit qu'on s'attend à rencontrer quelques erreurs lorsqu'on déplace beaucoup d'information quantique.

Q est introduit : L'état secret est préparé sur le qubit Q :

$$|\psi\rangle_Q = \alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q$$

À ce stade, Q est simplement adjacent au qubit d'Alice (A). Il n'y a pas encore eu d'intrication, donc l'état quantique des trois qubits ensemble peut s'écrire :

$$|\psi\rangle_{AB}|\psi\rangle_Q = \frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right).$$

L'objectif est de déplacer l'information de Q depuis l'emplacement d'Alice jusqu'à l'emplacement de Bob. À ce stade, on ne fait aucune affirmation ni exigence concernant le secret ou la vitesse du transfert d'information. On explore simplement comment l'information peut se déplacer d'Alice à Bob. Comme l'information commence sur Q, on supposera que Q reçoit le numéro le plus bas parmi les numéros de qubits, de sorte que la notation petit-boutiste (little endian) place Q comme le qubit le plus à droite dans les mathématiques ci-dessous.

Alice intrigue les qubits A et Q : Alice agit maintenant avec une porte CNOT avec son propre qubit comme contrôle et Q comme cible, puis applique une porte Hadamard à Q. Calculons l'état à trois qubits après cette opération :

$$\begin{aligned} H_Q CNOT(A,Q)|\psi\rangle_{AB}|\psi\rangle_Q &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right)\\ &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|0\rangle_A|1\rangle_Q\right)+\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|1\rangle_A|1\rangle_Q\right)\right)\\ &= H_Q \frac{1}{\sqrt{2}}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q+\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right)\\ &= \frac{1}{2}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_0 |0\rangle_B|0\rangle_A|1\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|0\rangle_Q-\alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q\right)\\ &+\frac{1}{2}\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_0 |1\rangle_B|1\rangle_A|1\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|0\rangle_Q - \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right) \end{aligned}$$

Comme A et Q se trouvent au même endroit, regroupons les termes ci-dessus selon les résultats des mesures sur les qubits A et Q :

$$\begin{aligned} |\psi\rangle = \frac{1}{2}\left((\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|0\rangle_A|0\rangle_Q + (\alpha_0 |0\rangle_B-\alpha_1 |1\rangle_B)|0\rangle_A|1\rangle_Q + (\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|0\rangle_Q+ (-\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|1\rangle_Q \right)\\ \end{aligned}$$

Vérifie ta compréhension

Lis la question ci-dessous, réfléchis à ta réponse, puis clique sur le triangle pour révéler la solution.

Étant donné l'expression ci-dessus pour les états des trois qubits, quelle est la probabilité qu'une mesure des qubits A et Q donne $|0\rangle_A|0\rangle_Q?$

Réponse :

25 %. Pour le voir, rappelle-toi que l'état de Bob doit être normalisé, donc $|_A \langle0|_Q\langle0| \frac{1}{2} |0\rangle_A|0\rangle_Q (\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}|(\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}$

Maintenant, Alice peut mesurer les qubits A et Q. Elle ne peut pas contrôler le résultat de cette mesure, car les mesures quantiques sont probabilistes. Ainsi, lorsqu'elle mesure, il y a 4 résultats possibles et tous les 4 sont également probables : $|0\rangle_A|0\rangle_Q,$ $|0\rangle_A|1\rangle_Q,$ $|1\rangle_A|0\rangle_Q,$ et $|1\rangle_A|1\rangle_Q.$ Note que chaque résultat a des implications différentes pour le qubit de Bob. Par exemple, si Alice trouve ses qubits dans l'état $|0\rangle_A|0\rangle_Q$, cela a fait s'effondrer l'ensemble de l'état quantique à 3 qubits en $(\alpha_0|0\rangle_B+\alpha_1|1\rangle_B)|0\rangle_A|0\rangle_Q.$ D'autres résultats de mesure pour Alice donnent des états différents pour Bob. Ceux-ci sont rassemblés dans le tableau ci-dessous.

Résultat d'Alice	État de Bob	Instruction à Bob	Résultat
$\vert 0\rangle_A \vert 0\rangle_Q$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$	Aucune	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 0\rangle_A \vert 1\rangle_Q$	$\alpha_0\vert 0\rangle_B-\alpha_1\vert 1\rangle_B$	$Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 0\rangle_Q$	$\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 1\rangle_Q$	$-\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$ puis $Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
Pour tous les résultats de mesure possibles sur les qubits d'Alice, le qubit de Bob se retrouve dans un état ressemblant vaguement à l'état secret initialement sur Q. Dans le cas où Alice mesure $	0\rangle_C	0\rangle_A$(la première ligne du tableau), le qubit de Bob se retrouve exactement dans l'état secret ! Dans les autres cas, il y a quelque chose d'incorrect dans l'état. Les coefficients ($\alpha$) sont inversés, ou il y a un signe « - » là où il devrait y avoir un « + », ou les deux. Pour modifier le qubit de Bob afin de le rendre exactement égal à l'état secret, Alice doit appeler Bob (utiliser un moyen de communication classique) et lui dire d'effectuer des opérations supplémentaires sur son qubit, comme indiqué dans le tableau. Par exemple, à la troisième ligne, les coefficients sont inversés. Si Alice appelle Bob et lui dit d'appliquer une porte$X$à son qubit, cela transforme$	0\rangle$en$

On voit maintenant clairement pourquoi on ne peut pas utiliser ce dispositif pour envoyer de l'information plus vite que la lumière. On pourrait avoir de la chance et mesurer $|0\rangle_A|0\rangle_Q$, ce qui signifie que Bob a exactement l'état secret, instantanément. Mais Bob ne le sait pas jusqu'à ce qu'on l'appelle et lui dise « Nous avons mesuré $|0\rangle_A|0\rangle_Q$, donc tu n'as rien à faire. »

Dans l'expérience de pensée, les qubits sont souvent physiquement séparés et transportés vers un nouvel emplacement. Les ordinateurs quantiques IBM® utilisent des qubits à l'état solide sur une puce qui ne peuvent pas être séparés. Donc, au lieu de déplacer Alice et Bob vers des emplacements différents, on va séparer l'information sur la puce elle-même en utilisant ce qu'on appelle des « portes SWAP » pour déplacer l'information d'un qubit à un autre.

Expérience 1 : Téléportation de base

IBM Quantum recommande d'aborder les problèmes d'informatique quantique en utilisant un cadre appelé « Qiskit patterns ». Il comprend les étapes suivantes.

• Étape 1 : Transformer ton problème en circuit quantique
• Étape 2 : Optimiser ton circuit pour l'exécution sur du vrai matériel quantique
• Étape 3 : Exécuter ton job sur les ordinateurs quantiques IBM en utilisant les Runtime Primitives
• Étape 4 : Post-traiter les résultats

Étape 1 : Transformer ton problème en circuit quantique

Toutes les mathématiques faites ci-dessus décrivaient l'étape 1. On va l'implémenter maintenant, en construisant notre circuit quantique avec Qiskit ! On commence par créer un circuit quantique avec trois qubits, et en intriquant les deux qubits d'Alice et de Bob. On les prendra comme qubits 1 et 2, et on réservera le qubit 0 pour l'état secret.

# Step 1: Map your problem to a quantum circuit

# Import some general packages
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np

# Define registers
secret = QuantumRegister(1, "Q")
Alice = QuantumRegister(1, "A")
Bob = QuantumRegister(1, "B")

cr = ClassicalRegister(3, "c")

qc = QuantumCircuit(secret, Alice, Bob, cr)

# We entangle Alice's and Bob's qubits as in our work above. We apply a Hadamard gate and then a CNOT gate.
# Note that the second argument in the CNOT gate is the target.
qc.h(Alice)
qc.cx(Alice, Bob)

# Inserting a barrier changes nothing about the logic. It just allows us to force gates to be positioned in "layers".
qc.barrier()

# Now we will use random variables to create the secret state. Don't worry about the "u" gate and the details.
np.random.seed(42)  # fixing seed for repeatability
theta = np.random.uniform(0.0, 1.0) * np.pi  # from 0 to pi
varphi = np.random.uniform(0.0, 2.0) * np.pi  # from 0 to 2*pi

# Assign the secret state to the qubit on the other side of Alice's (qubit 0), labeled Q
qc.u(theta, varphi, 0.0, secret)
qc.barrier()

# Now entangle Q and Alice's qubits as in the discussion above.
qc.cx(secret, Alice)
qc.h(secret)
qc.barrier()

# Now Alice measures her qubits, and stores the outcomes in the "classical registers" cr[]
qc.measure(Alice, cr[1])
qc.measure(secret, cr[0])

# Now we insert some conditional logic. If Alice measures Q in a "1" we need a Z gate, and if Alice measures A in a "1" we need an X gate (see the table).
with qc.if_test((cr[1], 1)):
    qc.x(Bob)
with qc.if_test((cr[0], 1)):
    qc.z(Bob)

qc.draw(output="mpl")

C'est tout ce qu'on doit faire pour téléporter l'état d'Alice vers Bob. Cependant, rappelle-toi que lorsqu'on mesure un état quantique $\alpha_0 |0\rangle+\alpha_1|1\rangle$, on trouve soit $|0\rangle$, soit $|1\rangle$. Donc à la fin de tout cela, Bob a définitivement l'état secret d'Alice, mais on ne peut pas facilement le vérifier avec une mesure. Pour qu'une mesure nous indique qu'on a fait cela correctement, on doit employer une astuce. On avait un opérateur étiqueté « U » pour « unitaire » qu'on a utilisé pour préparer l'état secret d'Alice. On peut appliquer l'inverse de U à la fin de notre Circuit. Si U a transformé l'état $|0\rangle$ d'Alice en $\alpha_0 |0\rangle+\alpha_1|1\rangle$, alors l'inverse de U transformera le $\alpha_0 |0\rangle+\alpha_1|1\rangle$ de Bob en $|0\rangle$. Cette dernière étape ne serait donc pas forcément effectuée si l'objectif était simplement de déplacer de l'information quantique. Elle est uniquement faite pour nous permettre de nous vérifier.

# Add the inverse of U and measure Bob's qubit.
qc.barrier()

qc.u(theta, varphi, 0.0, Bob).inverse()  # inverse of u(theta,varphi,0.0)
qc.measure(Bob, cr[2])  # add measurement gate

qc.draw(output="mpl")

Donc, si on a fait cela correctement, notre mesure sur le qubit de Bob devrait donner un état $|0\rangle$. Bien sûr, ces mesures sont probabilistes. Donc, même s'il y a une faible chance de mesurer le qubit de Bob dans l'état $|1\rangle$, une seule mesure pourrait donner $|1\rangle$. On voudrait vraiment effectuer de nombreuses mesures pour s'assurer que la probabilité de $|0\rangle$ est assez élevée.

Étape 2 : Optimiser le problème pour l'exécution quantique

Cette étape prend les opérations qu'on veut effectuer et les exprime en termes des fonctionnalités d'un ordinateur quantique spécifique. Elle mappe également notre problème sur la disposition de l'ordinateur quantique.

On commencera par charger plusieurs packages nécessaires pour communiquer avec les ordinateurs quantiques IBM. On doit également sélectionner un backend sur lequel exécuter. On peut soit choisir le backend le moins occupé, soit sélectionner un backend spécifique dont on connaît les propriétés.

Il y a du code ci-dessous pour enregistrer tes identifiants lors de la première utilisation. Assure-toi de supprimer ces informations du notebook après les avoir enregistrées dans ton environnement, pour que tes identifiants ne soient pas accidentellement partagés quand tu partages le notebook. Consulte Configurer ton compte IBM Cloud et Initialiser le service dans un environnement non fiable pour plus de conseils.

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load the Qiskit Runtime service

# Syntax for first saving your token.  Delete these lines after saving your credentials.
# QiskitRuntimeService.save_account(channel='ibm_quantum_platform', instance = '<YOUR_IBM_INSTANCE_CRN>', token='<YOUR-API_KEY>', 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_brisbane".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_brisbane")
print(backend.name)

ibm_sherbrooke

On active explicitement la logique sur les mesures.

from qiskit.circuit import IfElseOp

backend.target.add_instruction(IfElseOp, name="if_else")

On doit maintenant « transpiler » le circuit quantique. Cela implique de nombreuses sous-étapes et c'est un sujet fascinant. Pour donner un exemple de sous-étape : tous les ordinateurs quantiques ne peuvent pas implémenter directement toutes les portes logiques de Qiskit. On doit écrire les portes de notre circuit en termes de portes que l'ordinateur quantique peut implémenter. On peut effectuer ce processus, et d'autres, en utilisant un pass manager prédéfini. Régler optimization = 3 (le niveau d'optimisation le plus élevé) garantit que le mapping de notre circuit quantique abstrait vers les instructions données à l'ordinateur quantique est aussi efficace que notre pré-traitement peut le rendre.

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

Un « Sampler » est une primitive conçue pour échantillonner les états possibles résultant d'un circuit quantique, et collecter des statistiques sur les états qui pourraient être mesurés et avec quelle probabilité. On importe ici le Sampler de Qiskit Runtime :

# Load the Runtime primitive and session
from qiskit_ibm_runtime import SamplerV2 as Sampler

sampler = Sampler(mode=backend)

Toutes les computations sur un ordinateur quantique ne peuvent pas être raisonnablement simulées sur des ordinateurs classiques. Cette simple téléportation le peut définitivement, mais il n'est pas du tout surprenant qu'on puisse classiquement enregistrer de l'information à un endroit ou à un autre. On recommande fortement d'effectuer ces calculs en utilisant un vrai ordinateur quantique IBM. Mais au cas où tu aurais épuisé ton utilisation mensuelle gratuite, ou si quelque chose doit être complété en classe et ne peut pas attendre dans la file d'attente, ce module peut être complété en utilisant un simulateur. Pour ce faire, exécute simplement la cellule ci-dessous et décommente les lignes associées dans les étapes « Execute ».

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

# Load the Aer simulator and generate a noise model based on the currently-selected backend.
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel

noise_model = NoiseModel.from_backend(backend)

# Define a simulator using Aer, and use it in Sampler.
backend_sim = AerSimulator(noise_model=noise_model)
sampler_sim = BackendSamplerV2(backend=backend_sim)

# Alternatively, load a fake backend with generic properties and define a simulator.
# backend_gen = GenericBackendV2(num_qubits=18)
# sampler_gen = BackendSamplerV2(backend=backend_gen)

Étape 3 : Exécuter

Utilise le Sampler pour lancer ton job, avec le circuit comme argument.

job = sampler.run([qc_isa])
# job = sampler_sim.run([qc_isa])
res = job.result()
counts = res[0].data.c.get_counts()

Étape 4 : Post-traitement et analyse

Traçons les résultats et interprétons-les.

# This required 5 s to run on a Heron r2 processor on 10-28-24
from qiskit.visualization import plot_histogram

plot_histogram(counts)

Vérifie ta compréhension

Lis la question ci-dessous, réfléchis à ta réponse, puis clique sur le triangle pour révéler la solution.

Lequel des états ci-dessus indique une téléportation réussie, et comment peut-on le savoir ?

Réponse :

Les états $|000\rangle,$ $|001\rangle,$ $|010\rangle,$ $|011\rangle$ sont tous compatibles avec une téléportation réussie. C'est parce qu'on a ajouté une porte pour annuler la préparation initiale de l'état secret. Si l'état secret a été téléporté avec succès vers le qubit de Bob, cette porte supplémentaire devrait ramener le qubit de Bob à l'état $|0\rangle$. Donc tout état ci-dessus avec le qubit de Bob (qubit 0, également mesuré dans la 0ème composante du registre classique, et donc le plus haut/à droite) dans l'état $|0\rangle$ indique un succès.

Ce graphique montre tous les résultats de mesure pour les trois qubits, sur 5 000 essais ou « shots ». On a souligné plus tôt qu'Alice mesurerait tous les états possibles pour les qubits A et Q avec une probabilité égale. On a assigné les qubits 0-2 dans le circuit à Q, A et B, dans cet ordre. En notation petit-boutiste (little-endian), le qubit de Bob est le plus à gauche/le plus bas. Donc les quatre barres de gauche correspondent au qubit de Bob dans l'état $|0\rangle$, et les deux autres qubits dans toutes les combinaisons possibles avec une probabilité à peu près égale. Note que presque toutes (généralement ~95 %) les mesures donnent le qubit de Bob dans l'état $|0\rangle$, ce qui signifie que notre dispositif a réussi ! Il y a une poignée de shots (~5 %) qui ont donné le qubit de Bob dans l'état $|1\rangle$. Cela ne devrait logiquement pas être possible. Cependant, tous les ordinateurs quantiques modernes souffrent de bruit et d'erreurs dans une bien plus grande mesure que les ordinateurs classiques. Et la correction d'erreurs quantiques est encore un domaine émergent.

Expérience 2 : Téléportation à travers un processeur

Sans doute, la partie la plus intéressante de la téléportation quantique est qu'un état quantique peut être téléporté sur de longues distances instantanément (bien que la communication classique des portes supplémentaires ne soit pas instantanée). Comme déjà indiqué, on ne peut pas détacher des qubits du processeur et les déplacer. Mais on peut déplacer l'information d'un qubit à un autre, jusqu'à ce que les qubits impliqués dans la téléportation se trouvent de part et d'autre du processeur. Répétons les étapes qu'on a suivies ci-dessus, mais on va maintenant créer un circuit plus grand avec suffisamment de qubits pour couvrir le processeur.

Étape 1 : Transformer ton problème en circuit quantique

Cette fois, les qubits correspondant à Alice et Bob vont changer. On ne nommera donc pas un seul qubit « A » et un autre « B ». On numérotera plutôt les qubits et on utilisera des variables pour représenter la position actuelle de l'information sur les qubits appartenant à Alice et Bob. Toutes les autres étapes sauf les portes SWAP sont comme décrites précédemment.

# Step 1: Map

# Define registers
qr = QuantumRegister(13, "q")

qc = QuantumCircuit(qr, cr)

# Define registers
secret = QuantumRegister(1, "Q")
ebitsa = QuantumRegister(6, "A")
ebitsb = QuantumRegister(6, "B")
# q = ClassicalRegister(1, "q meas")
# a = ClassicalRegister(1, "a")
# b = ClassicalRegister(1, "b")
cr = ClassicalRegister(3, "c")
qc = QuantumCircuit(secret, ebitsa, ebitsb, cr)

# We'll start Alice in the middle of the circuit, then move information outward in both directions.
Alice = 5
Bob = 0
qc.h(ebitsa[Alice])
qc.cx(ebitsa[Alice], ebitsb[Bob])

# Starting with Bob and Alice in the center, we swap their information onto adjacent qubits, until the information is on distant qubits.

for n in range(Alice):
    qc.swap(ebitsb[Bob], ebitsb[Bob + 1])
    qc.swap(ebitsa[Alice], ebitsa[Alice - 1])
    Alice = Alice - 1
    Bob = Bob + 1

qc.barrier()

# Create a random state for Alice (qubit zero)
np.random.seed(42)  # fixing seed for repeatability
# theta = np.random.uniform(0.0, 1.0) * np.pi    #from 0 to pi
theta = 0.3
varphi = np.random.uniform(0.0, 2.0) * np.pi  # from 0 to 2*pi

qc.u(theta, varphi, 0.0, secret)

# Entangle Alice's two qubits
qc.cx(secret, ebitsa[Alice])
qc.h(secret)

qc.barrier()

# Make measurements of Alice's qubits and store the results in the classical register.
qc.measure(ebitsa[Alice], cr[1])
qc.measure(secret, cr[0])

# Send instructions to Bob's qubits based on the outcome of Alice's measurements.
with qc.if_test((cr[1], 1)):
    qc.x(ebitsb[Bob])
with qc.if_test((cr[0], 1)):
    qc.z(ebitsb[Bob])

qc.barrier()

# Invert the preparation we did for Carl's qubit so we can check whether we did this correctly.
qc.u(theta, varphi, 0.0, ebitsb[Bob]).inverse()  # inverse of u(theta,varphi,0.0)
qc.measure(ebitsb[Bob], cr[2])  # add measurement gate

qc.draw("mpl")

On peut voir dans le diagramme du circuit que les étapes logiques sont les mêmes. La seule différence est qu'on a utilisé les portes SWAP pour amener l'état du qubit d'Alice du qubit 6 ($A_5$) jusqu'au qubit 1 ($A_0$), juste à côté de Q. Et on a utilisé des portes SWAP pour amener l'état initial de Bob du qubit 7 ($B_0$) jusqu'au qubit 12 ($B_5$). Note que l'état sur le qubit 12 n'est même pas lié à l'état secret de Q jusqu'à ce que des mesures soient effectuées sur les qubits distants 0 et 1, et l'état sur le qubit 12 n'est pas égal à l'état secret tant que les portes conditionnelles $X$ et $Z$ n'ont pas été appliquées.

Étape 2 : Optimiser ton circuit

Normalement, lorsqu'on utilise le pass manager pour transpiler et optimiser nos circuits, il est logique de régler optimization_level = 3, parce qu'on veut que nos circuits soient aussi efficaces que possible. Dans ce cas, il n'y a aucune raison computationnelle de transférer des états des qubits 6 et 7 vers les qubits 1 et 12. C'était juste quelque chose qu'on a fait pour démontrer la téléportation sur une distance. Si on demande au pass manager d'optimiser notre Circuit, il réalisera qu'il n'y a aucune raison logique à ces portes SWAP, et il les supprimera et effectuera les opérations de porte sur des qubits adjacents. Donc pour ce cas particulier, on utilise optimization_level = 0.

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pmzero = generate_preset_pass_manager(target=target, optimization_level=0)

qc_isa_zero = pmzero.run(qc)

print(qc_isa_zero.depth())

105

On peut visualiser l'emplacement de ces qubits sur le processeur quantique en utilisant la fonction plot_circuit_layout.

Étape 3 : Exécuter

Comme précédemment, on recommande d'exécuter sur de vrais ordinateurs quantiques IBM. Si ton utilisation mensuelle gratuite a été atteinte, n'hésite pas à décommenter les cellules du simulateur pour exécuter sur un simulateur.

# This required 5 s to run on a Heron r2 processor on 10-28-24
job = sampler.run([qc_isa_zero])
# job = sampler_sim.run([qc_isa_zero])
counts = job.result()[0].data.c.get_counts()

from qiskit.visualization import plot_histogram

plot_histogram(counts)

Étape 4 : Post-traitement classique

On voit encore que les probabilités des résultats possibles pour les qubits d'Alice sont assez uniformes. Il y a une forte préférence pour trouver le qubit de Bob dans $|0\rangle$ après avoir inversé le code secret, ce qui signifie qu'il y a une forte probabilité qu'on ait correctement téléporté l'état secret à travers le processeur de Q à Bob (qubits 0 à 12). Cependant, on note qu'il y a maintenant environ plus de chances de ne pas mesurer $|0\rangle$ pour Bob. C'est une leçon importante en informatique quantique : plus tu as de portes en séquence, notamment des portes multi-qubits comme les portes SWAP, plus tu rencontreras de bruit et d'erreurs.

Questions

Les enseignant·e·s peuvent demander des versions de ces notebooks avec les corrigés et des conseils sur leur placement dans les programmes courants en remplissant cette courte enquête sur la façon dont les notebooks sont utilisés.

Concepts critiques

• Les qubits peuvent être intriqués, ce qui signifie qu'une mesure d'un qubit affecte ou même détermine l'état d'un autre qubit.
• L'intrication diffère des corrélations classiques ; par exemple, les qubits A et B pourraient être dans une superposition d'états comme $\alpha_0|00\rangle+\alpha_1|11\rangle.$ L'état de A ou B pourrait être indéterminé par la nature, et pourtant A et B pourraient toujours être garantis d'être dans le même état.
• Grâce à une combinaison d'intrications et de mesures, on peut transférer un état (qui peut stocker de l'information) d'un qubit à un autre. Ce transfert peut même être effectué sur de longues distances, et c'est ce qu'on appelle la téléportation quantique.
• La téléportation quantique repose sur des mesures quantiques, qui sont probabilistes. Ainsi, la communication classique peut être nécessaire pour ajuster les états téléportés. Cela empêche la téléportation quantique de déplacer de l'information plus vite que la lumière. La téléportation quantique ne viole ni la relativité ni la causalité.
• Les ordinateurs quantiques modernes sont plus susceptibles au bruit et aux erreurs que les ordinateurs classiques. Attends-toi à quelques pourcents d'erreur.
• Plus tu ajoutes de portes en séquence (en particulier des portes à 2 qubits), plus tu peux t'attendre à des erreurs et du bruit.

Questions vrai/faux

1. V/F La téléportation quantique peut être utilisée pour envoyer de l'information plus vite que la lumière.
2. V/F Les preuves modernes suggèrent que l'effondrement d'un état quantique se propage plus vite que la lumière.
3. V/F Dans Qiskit, les qubits sont ordonnés dans les états avec le qubit au numéro le plus bas à droite, comme dans $|q_3,q_2,q_1, q_0\rangle$

Questions QCM

1. Les qubits A et B sont intriqués, puis séparés par une grande distance $d$. Le qubit A est mesuré. Quelle affirmation est correcte concernant la vitesse à laquelle l'état du qubit B est affecté ?

• a. Le qubit B est affecté instantanément, dans la tolérance expérimentale, dans les expériences réalisées jusqu'à présent.
• b. Le qubit B est affecté après un temps $d/c$, ce qui signifie que l'état quantique « s'effondre » à environ la vitesse de la lumière, dans la tolérance expérimentale.
• c. Le qubit B n'est affecté qu'après qu'une communication classique ait eu lieu, ce qui signifie que cela se passe dans un temps supérieur à $d/c$.
• d. Aucune des réponses ci-dessus

2. Rappelle-toi que la probabilité de mesure est liée aux amplitudes dans les états quantiques. Par exemple, si un qubit est initialement dans l'état $\alpha_0|0\rangle+\alpha_1 |1\rangle,$ la probabilité de mesurer l'état $|0\rangle$ est $|\alpha_0|^2.$ Tous les ensembles de mesures ne correspondront pas exactement à ces probabilités, en raison d'un échantillonnage fini (tout comme lancer une pièce pourrait donner deux fois pile de suite). L'histogramme de mesure ci-dessous pourrait correspondre à lequel des états quantiques suivants ? Sélectionne la meilleure option.

• a. $|0\rangle$
• b. $\frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right)$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$
• d. $\frac{4}{5}|0\rangle+\frac{3}{5}|1\rangle$
• e. $\frac{3}{5}|0\rangle+\frac{4}{5}|1\rangle$

3. Lequel des états suivants montre les qubits A et B intriqués ? Sélectionne tout ce qui s'applique.

• a. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)$
• b. $\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)$
• d. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|0\rangle_A\right)$
• e. $|0\rangle_B|0\rangle_A$

4. Dans ce module, on a préparé un état intriqué : $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right).$ Mais il existe beaucoup d'autres états intriqués qu'on pourrait utiliser pour un protocole similaire. Lequel des états ci-dessous pourrait donner un histogramme de mesure à 2 qubits comme celui qui suit ? Sélectionne la meilleure réponse.

• a. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)$
• b. $\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)$
• d. $\frac{4}{5}|0\rangle_B|1\rangle_A+\frac{3}{5}|1\rangle_B|0\rangle_A$
• e. $|0\rangle_B|0\rangle_A$

Questions de discussion

1. Décris le protocole de téléportation quantique, du début à la fin, à ton/ta partenaire/groupe. Vois s'ils ont quelque chose à ajouter, ou s'ils ont des questions.

2. Y a-t-il quelque chose d'unique dans l'état intriqué initial entre Alice et Bob : $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)?$ Si oui, qu'est-ce qui est unique ? Si non, quels autres états intriqués aurions-nous pu utiliser ?