Téléportation quantique

Pour ce module Qiskit in Classrooms, les étudiants doivent disposer d'un environnement Python fonctionnel avec les paquets 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 paquets ci-dessus, voir le guide d' installation de Qiskit. Afin d'exécuter des tâches sur de véritables ordinateurs quantiques, les étudiants devront créer un compte sur IBM Quantum® en suivant les étapes du guide Configurer votre compte IBM Cloud.

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

# 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'

Regardez la présentation du module par le Dr. Katie McCormick ci-dessous, ou cliquez ici pour la regarder sur YouTube.

Introduction et contexte

La téléportation quantique est une technique de physique quantique qui permet de transférer des informations quantiques d'un endroit à un autre sans déplacer physiquement des particules. Contrairement au concept de science-fiction de la téléportation, ce processus n'implique pas de transporter de la matière. Elle repose sur le principe de l'intrication quantique, selon lequel deux particules sont liées quelle que soit la distance. Grâce à une série de mesures précises et à une communication classique, l'état quantique d'une particule peut être recréé dans une autre particule éloignée, ce qui permet de "téléporter" l'information quantique. Dans ce module, nous verrons comment cela fonctionne mathématiquement, puis nous mettrons en œuvre la téléportation quantique sur un véritable ordinateur quantique. Pour en savoir plus sur l'information quantique et sur la téléportation, nous recommandons le cours de John Watrous sur les fondements de l'information quantique, et en particulier la section sur la téléportation

Les bits classiques peuvent être à l'état 0 ou 1. Les bits quantiques (qubits) peuvent se trouver 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 fera "s'effondrer" dans les états $|0\rangle$ ou $|1\rangle$. Les paramètres $a$ et $b$ sont liés à la probabilité de chaque résultat de mesure selon la formule suivante

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

Une autre caractéristique essentielle 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é. Il est un peu difficile de comprendre en quoi l'intrication diffère des simples corrélations classiques. Expliquons d'abord notre notation. Appelons deux qubits appartenant à l'ami 0 (Alice) et à l'ami 1 (Bob), et chacun dans l'état $|0\rangle$

ou

parfois abrégé en simple

Notez que le qubit ayant le numéro le plus bas (ou la lettre) est le plus à droite. Il s'agit d'une convention appelée notation "little-endian", utilisée dans l'ensemble de Qiskit. Si l'état des deux qubits des amis 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. Il n'y a pas de différence avec le cas classique. Cependant, en informatique quantique, nous pouvons combiner ce phénomène avec la superposition pour obtenir des états tels que

Dans un tel état, on ne sait pas encore si Alice et Bob ont des qubits dans l'état 0 ou 1, ni même s'ils sont déterminés par la nature, et pourtant nous savons qu'ils mesureront le même état pour leur qubit. Par exemple, si Bob mesure que son qubit est dans l'état $|0\rangle,$, cela ne peut se produire que si la mesure a réduit l'état de deux qubits à l'un des deux états possibles, à savoir $|00\rangle.$. Le qubit d'Alice se trouve donc également dans l'état $|0\rangle$.

L'enchevêtrement de qubits de cette manière ne nécessite pas que les qubits restent physiquement proches les uns des autres. En d'autres termes, nous pourrions enchevêtrer des qubits, les séparer sur une grande distance et utiliser leur enchevêtrement pour envoyer des informations. Un état intriqué comme celui ci-dessus est une unité de base de l'intrication et est parfois appelé "e-bit", un seul bit d'intrication. Ces e-bits peuvent être considérés comme des ressources dans la communication quantique, puisque chaque e-bit partagé entre des partenaires distants peut être utilisé, comme nous le décrivons ici, pour déplacer des informations d'un endroit à un autre.

La première pensée de nombreuses personnes qui découvrent ce sujet pour la première fois est celle d'une violation de la relativité : pouvons-nous utiliser ce système pour envoyer des informations plus rapidement que la lumière? Il faut donc continuer à questionner et à sonder les règles scientifiques, mais cela ne nous permettra malheureusement pas d'envoyer des informations plus vite que la lumière, pour des raisons qui deviendront évidentes au cours de ce module. Spoiler : étonnamment, ce n'est PAS dû à la vitesse à laquelle cet effondrement se propage, qui semble se produire plus vite que la lumière [1].

Nous commençons avec deux collaborateurs, Alice et Bob, qui se trouvent initialement au même endroit et peuvent travailler ensemble sur les mêmes qubits. Ces collaborateurs enchevêtreront leurs qubits. Ensuite, ils s'éloigneront l'un de l'autre pour se rendre dans deux lieux géographiques différents, en emportant avec eux leurs qubits respectifs. Alice obtient alors des informations quantiques sur un nouveau qubit Q. Nous ne faisons aucune hypothèse sur les informations contenues dans Q. L'état de Q pourrait être un secret inconnu d'Alice; il pourrait être inconnu de tous. Mais Alice est chargée de transmettre les informations sur Q à Bob. Elle utilisera pour cela la téléportation quantique.

Pour ce faire, nous devons connaître certaines opérations quantiques ou "portes".

Opérateurs quantiques (portes)

N'hésitez pas à sauter cette section si vous êtes déjà familiarisé avec les portes quantiques. Si vous souhaitez mieux comprendre ces portes, consultez les bases de l'information quantique, en particulier les deux premières leçons, sur IBM Quantum Learning.

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

Ce module peut être suivi avec des connaissances très limitées en algèbre linéaire, mais il est parfois utile de visualiser les portes de la mécanique quantique à l'aide de matrices et de vecteurs. Nous présentons donc ici les formes matricielles/vectorielles des portes/états quantiques.

Les états que nous avons déjà présentés sont choisis (en partie par convention et en partie par contraintes) pour avoir des formes vectorielles :

De cette manière, un état arbitraire $|\psi\rangle = a|0\rangle+b|1\rangle$ peut être écrit comme suit

Il est possible de choisir comment étendre la notation aux états à qubits multiples, mais le choix ci-dessous est tout à fait standard :

En gardant à l'esprit ce choix de notation vectorielle, nous pouvons présenter les portes quantiques dont nous avons besoin, leurs effets sur les états quantiques et leurs formes matricielles.

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

Un circuit avec une porte de Hadamard est réalisé comme suit :

from qiskit import QuantumCircuit

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

Output:

Porte CNOT Controlled-NOT : Cette porte utilise deux qubits : un de contrôle et un de cible. Vérifie l'état d'un qubit de contrôle qui n'est pas modifié. Mais si le qubit de contrôle est dans l'état $|1\rangle$, la porte change 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, on suppose que le qubit $A$ (qubit le plus à droite) est le contrôle et que le qubit $B$ (qubit le plus à gauche) est la cible. Ci-dessous, la notation utilisée est la suivante $CNOT(q_{control},q_{target})|BA\rangle.$

Il arrive parfois que le CNOT soit écrit avec l'ordre du contrôle et de la cible simplement sous-entendu. Mais il n'y a pas d'ambiguïté de ce type dans le code ou dans les schémas de circuit.

Une porte CNOT se présente différemment dans un circuit, puisqu'elle nécessite deux qubits. Voici comment il est mis en œuvre :

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

Output:

Vérifiez votre compréhension

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 la question de l'ordre des qubits se pose soudainement. Les textes traitant de l'ordonnancement des qubits $|q_0,q_1,...\rangle$ présentent une forme matricielle différente pour leurs portes CNOT. Vérifiez, par une multiplication matricielle explicite, que la matrice CNOT ci-dessus a bien 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$

$X$ Porte : équivaut à une opération NOT. Porte à qubit unique.

Dans Qiskit, la création d'un circuit avec une porte $X$ ressemble à ceci :

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

Output:

$Z$ Porte : Ajoute une "phase" à un état (un préfacteur qui, dans le cas des états propres Z $|0\rangle$ et $|1\rangle$, est soit 1, soit -1, respectivement). Porte à qubit unique.

Dans Qiskit, la création d'un circuit avec une porte $Z$ ressemble à ceci :

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

Output:

théorie

Décrivons le protocole de la téléportation quantique à l'aide des mathématiques. Puis, dans la section suivante, nous réaliserons cette configuration à l'aide d'un ordinateur quantique.

Alice et Bob mélangent leurs qubits : Au départ, le qubit d'Alice et le qubit de Bob sont chacun, séparément, dans l'état $|0\rangle$ (une bonne hypothèse et aussi l'initialisation correcte pour les ordinateurs quantiques IBM® ). Nous pouvons l'écrire sous la forme $|0\rangle_B|0\rangle_A$ ou simplement $|00\rangle$. Calculons ce qui se passe lorsque Alice et Bob agissent avec la porte de Hadamard sur le qubit d'Alice, puis une porte CNOT avec le qubit d'Alice comme contrôle et celui de Bob comme cible :

Notez que les qubits d'Alice et de Bob sont désormais intriqués. Bien qu'il ne soit pas encore déterminé par la nature si leurs deux qubits sont dans l'état $|0\rangle$ ou $|1\rangle$, on sait que leurs qubits sont dans le même état.

Alice et Bob se séparent : Les deux amis déplacent leurs qubits vers de nouveaux emplacements, éventuellement très éloignés l'un de l'autre. Cela s'accompagne de nombreuses mises en garde : il n'est pas trivial de déplacer des informations quantiques sans les perturber. Mais il peut être déplacé, et vous le ferez d'ailleurs dans ce module. Mais il faut garder à l'esprit que nous nous attendons à rencontrer des erreurs lorsque nous déplaçons beaucoup d'informations quantiques.

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

À ce stade, Q est simplement adjacent au qubit d'Alice (A). Il n'y a pas eu d'intrication, de sorte que l'état quantique des trois qubits ensemble peut être écrit comme suit :

L'objectif est de déplacer les informations sur Q de l'endroit où se trouve Alice vers l'endroit où se trouve Bob. À ce stade, nous ne formulons aucune revendication ou exigence concernant le secret ou la rapidité du transfert d'informations. Nous explorons simplement la manière dont l'information peut passer d'Alice à Bob.

Comme l'information commence par Q, nous supposerons que Q est le plus petit nombre de qubits, de sorte que la notation "little endian" fait que Q est le qubit le plus à droite dans les calculs ci-dessous.

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

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

Vérifiez votre compréhension

Compte tenu de l'expression ci-dessus décrivant 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 comprendre cela, il faut rappeler 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}$

Alice peut maintenant mesurer les qubits A et Q. Elle ne peut pas contrôler le résultat de cette mesure, puisque 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.$ Notez que chaque résultat a des implications différentes pour le qubit de Bob. Par exemple, si Alice constate que ses qubits se trouvent à l'adresse $|0\rangle_A|0\rangle_Q,$, l'état quantique à 3 qubits s'est effondré à l'adresse $(\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. Elles sont regroupées dans le tableau ci-dessous.

Pour tous les résultats de mesure possibles sur les qubits d'Alice, le qubit de Bob est laissé dans un état ressemblant vaguement à l'état secret de Q à l'origine. Dans le cas où Alice mesure $|0\rangle_C|0\rangle_A$ (première ligne du tableau), le qubit de Bob est laissé exactement dans l'état secret! Dans les autres cas, il y a quelque chose d'anormal dans l'État. Les coefficients ( $\alpha$ 's) sont intervertis, ou il y a un signe "-" là où il devrait y avoir un signe "+", ou les deux. Afin de modifier le qubit de Bob pour le rendre exactement égal à l'état secret, Alice doit appeler Bob (en utilisant un moyen de communication classique) et lui demander d'effectuer des opérations supplémentaires sur son qubit, comme indiqué dans le tableau. Par exemple, dans la troisième ligne, les coefficients sont intervertis. Si Alice appelle Bob et lui demande d'appliquer une porte $X$ à son qubit, elle transforme un $|0\rangle$ en $|1\rangle$ et vice-versa, et l'état secret apparaît.

Il devrait maintenant être clair que nous ne pouvons pas utiliser cette configuration pour envoyer des informations à une vitesse supérieure à celle de la lumière. Nous pourrions 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 que nous l'appelions pour lui dire : "Nous avons mesuré $|0\rangle_A|0\rangle_Q$, vous n'avez donc rien à faire."

Dans l'expérience de pensée, les qubits sont souvent physiquement séparés et transportés dans un nouvel endroit. IBM® les ordinateurs quantiques utilisent des qubits à l'état solide sur une puce qui ne peut être séparée. Ainsi, au lieu de déplacer Alice et Bob dans des lieux différents, nous séparerons les informations sur la puce elle-même en utilisant des "portes de permutation" pour déplacer les informations d'un qubit à l'autre.

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

IBM Quantum recommande d'aborder les problèmes d'informatique quantique à l'aide d'un cadre que nous appelons "modèles Qiskit". Il se compose des étapes suivantes.

• Étape 1 : Tracer un circuit quantique à partir de votre problème
• Étape 2 : Optimiser votre circuit pour qu'il fonctionne sur du matériel quantique réel
• Étape 3 : Exécutez votre tâche sur les ordinateurs quantiques d’ IBM à l’aide des primitives d’ IBM Quantum
• Étape 4 : Post-traitement des résultats

Étape 1 : Cartographiez votre problème dans un circuit quantique

Tous les calculs que nous avons effectués ci-dessus concernaient l'étape 1. Nous allons le mettre en œuvre maintenant, en construisant notre circuit quantique à l'aide de Qiskit! Nous commençons par créer un circuit quantique avec trois qubits, et nous entremêlons les deux qubits d'Alice et de Bob. Nous considérerons qu'il s'agit des qubits 1 et 2, et nous réserverons le qubit 0 à 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")

Output:

C'est tout ce que nous avons à faire pour que l'état d'Alice soit téléporté à Bob. Cependant, rappelons que lorsque nous mesurons un état quantique $\alpha_0 |0\rangle+\alpha_1|1\rangle$, nous trouvons soit $|0\rangle$, soit $|1\rangle.$. Donc, à la fin de tout cela, Bob possède certainement l'état secret d'Alice, mais nous ne pouvons pas facilement le vérifier par une mesure. Pour qu'une mesure nous indique que nous avons fait cela correctement, nous devons faire un tour de passe-passe. Nous disposions d'un opérateur appelé "U" pour "unitaire" que nous avons utilisé pour préparer l'état secret d'Alice. Nous pouvons 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$, l'inverse de U transformera l'état $\alpha_0 |0\rangle+\alpha_1|1\rangle$ de Bob en $|0\rangle.$. Cette dernière partie ne serait pas nécessairement réalisée si l'objectif était simplement de déplacer de l'information quantique. Ceci est fait uniquement pour que nous nous contrôlions nous-mêmes.

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

Output:

Ainsi, si nous avons procédé correctement, notre mesure sur le qubit de Bob devrait donner un état $|0\rangle$. Bien entendu, ces mesures sont probabilistes. Par conséquent, s'il existe ne serait-ce qu'une petite chance de mesurer que le qubit de Bob est dans l'état $|1\rangle$, une seule mesure pourrait aboutir à $|1\rangle.$. Il faudrait vraiment effectuer de nombreuses mesures pour s'assurer que la probabilité d'obtenir $|0\rangle$ est assez élevée.

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

Cette étape prend les opérations que nous voulons effectuer et les exprime en termes de fonctionnalité d'un ordinateur quantique spécifique. Il permet également de faire correspondre notre problème à la configuration de l'ordinateur quantique.

Nous commencerons par charger plusieurs paquets nécessaires pour communiquer avec les ordinateurs quantiques IBM. Nous devons également sélectionner un backend sur lequel nous allons travailler. Nous pouvons soit choisir le backend le moins occupé, soit sélectionner un backend spécifique dont nous connaissons les propriétés.

Le code ci-dessous permet de sauvegarder vos données d'identification lors de la première utilisation. Veillez à supprimer ces informations du bloc-notes après l'avoir enregistré dans votre environnement, afin que vos informations d'identification ne soient pas accidentellement partagées lorsque vous partagez le bloc-notes. Voir Configurer votre compte IBM Cloud et Initialiser le service dans un environnement non fiable pour plus d'informations.

# Load IBM Quantum Compute Service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load IBM Quantum Compute 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)

Output:

ibm_sherbrooke

Nous activons explicitement la logique sur les mesures.

from qiskit.circuit import IfElseOp

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

Nous devons maintenant "transpiler" le circuit quantique. Cela implique de nombreuses sous-étapes et constitue 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. Nous devons écrire les portes de notre circuit en termes de portes que l'ordinateur quantique peut mettre en œuvre. Nous pouvons effectuer ce processus, ainsi que d'autres, à l'aide d'un gestionnaire de laissez-passer prédéfini. Le réglage de optimization = 3 (le plus haut niveau d'optimisation) garantit que la correspondance entre notre circuit quantique abstrait et les instructions données à l'ordinateur quantique est aussi efficace que notre prétraitement peut l'être.

# 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 « échantillonneur » est une primitive conçue pour échantillonner les états possibles résultant d'un circuit quantique et pour recueillir des statistiques sur les états susceptibles d'être mesurés et sur leur probabilité respective. Nous importons ici l'échantillon « IBM Quantum » :

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

sampler = Sampler(mode=backend)

Tous les calculs effectués sur un ordinateur quantique ne peuvent pas être raisonnablement simulés sur des ordinateurs classiques. Cette simple téléportation peut certainement l'être, mais il n'est pas du tout surprenant que nous puissions classiquement sauvegarder des informations à un endroit ou à un autre. Nous recommandons vivement d'effectuer ces calculs à l'aide d'un véritable ordinateur quantique IBM. Mais si vous avez épuisé votre utilisation mensuelle gratuite, ou si vous devez faire quelque chose en classe et que vous ne pouvez pas attendre dans la file d'attente, ce module peut être complété à l'aide d'un simulateur. Pour ce faire, il suffit d'exécuter la cellule ci-dessous et de décommenter les lignes associées dans les étapes "Exécuter".

# 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

Utilisez l'échantillonneur pour exécuter votre travail, 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)

Output:

Vérifiez votre compréhension

Parmi les états ci-dessus, lesquels indiquent que la téléportation a réussi, et comment peut-on le déterminer?

• Réponse

  Les états $|000\rangle,$ $|001\rangle,$ $|010\rangle,$ $|011\rangle$ sont tous compatibles avec une téléportation réussie. En effet, nous avons 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 sur le qubit de Bob, cette porte supplémentaire devrait ramener le qubit de Bob à l'état $|0\rangle$. Ainsi, tout état supérieur avec le qubit de Bob (qubit 0, également mesuré à la 0e composante du registre classique, et donc le plus haut/le plus à droite) dans l'état $|0\rangle$ indique un succès.

Ce graphique montre tous les résultats des mesures pour les trois qubits, sur 5 000 essais ou "tirs". Nous avons souligné précédemment qu'Alice mesurerait tous les états possibles des qubits A et Q avec la même probabilité. Nous avons attribué les qubits 0-2 du circuit à Q, A et B, dans cet ordre. En notation little-endian, le qubit de Bob est le plus à gauche/le plus bas. Les quatre barres de gauche correspondent donc au fait que le qubit de Bob se trouve à l'adresse $|0\rangle$ et que les deux autres qubits se trouvent dans toutes les combinaisons possibles avec une probabilité à peu près égale. Notez que la quasi-totalité (généralement ~95%) des mesures donnent le qubit de Bob dans l'état $|0\rangle$, ce qui signifie que notre configuration a réussi! Il y a une poignée de tirs (~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 large mesure que les ordinateurs classiques. Et la correction quantique des erreurs est encore un domaine émergent.

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

L'aspect le plus intéressant de la téléportation quantique est sans doute le fait qu'un état quantique peut être téléporté instantanément sur de longues distances (bien que la communication classique des portes supplémentaires ne soit pas instantanée). Comme nous l'avons déjà dit, nous ne pouvons pas séparer les qubits du processeur et les déplacer. Mais nous pouvons déplacer l'information d'un qubit à l'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 précédentes, mais nous allons maintenant créer un circuit plus grand avec suffisamment de qubits pour couvrir l'ensemble du processeur.

Étape 1 : Cartographiez votre problème dans un circuit quantique

Cette fois, les qubits correspondant à Alice et Bob changent. Nous ne nommerons donc pas un qubit "A" et un autre "B". Nous allons plutôt numéroter les qubits et utiliser des variables pour représenter la position actuelle des informations sur les qubits appartenant à Alice et Bob. Toutes les autres étapes, à l'exception des portes d'échange, sont 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")

Output:

Vous pouvez voir dans le schéma du circuit que les étapes logiques sont les mêmes. La seule différence est que nous avons utilisé les portes de permutation pour amener l'état du qubit d'Alice du qubit 6 ( $A_5$ ) au qubit 1 ( $A_0$ ), juste à côté de Q. Et nous avons utilisé des portes de permutation pour amener l'état initial de Bob du qubit 7 ( $B_0$ ) au qubit 12 ( $B_5$ ). Notez que l'état du 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 que l'état du qubit 12 n'est pas égal à l'état secret jusqu'à ce que les portes conditionnelles $X$ et $Z$ soient appliquées.

Étape 2 : Optimisez votre circuit

Normalement, lorsque nous utilisons le gestionnaire de passes pour transpiler et optimiser nos circuits, il est logique de définir optimization_level = 3, car nous voulons que nos circuits soient aussi efficaces que possible. Dans ce cas, il n'y a aucune raison informatique de transférer les états des qubits 6 et 7 vers les qubits 1 et 12. C'était juste une démonstration de téléportation à distance. Si nous demandons au gestionnaire de passes d'optimiser notre circuit, il se rendra compte qu'il n'y a pas de raison logique pour ces portes d'échange, il les supprimera et effectuera les opérations de porte sur les qubits adjacents. Pour ce cas particulier, nous utilisons donc 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())

Output:

105

La fonction plot_circuit_layout permet de visualiser l'emplacement de ces qubits sur le processeur quantique.

Étape 3 : Exécuter

Comme précédemment, nous recommandons de l'exécuter sur de véritables ordinateurs quantiques IBM. Si votre consommation mensuelle gratuite est atteinte, vous pouvez décommenter les cellules du simulateur pour les faire fonctionner 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)

Output:

Étape 4 : Post-traitement classique

Nous constatons à nouveau que les probabilités des résultats possibles pour les qubits d'Alice sont relativement 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é que nous ayons correctement téléporté l'état secret à travers le processeur de Q à Bob (qubits 0 à 12). Toutefois, nous constatons qu'il y a maintenant une probabilité plus élevée de ne pas mesurer $|0\rangle$ pour Bob. Il s'agit là d'une leçon importante pour l'informatique quantique : plus il y a de portes, en particulier des portes à qubits multiples comme les portes de permutation, plus il y a de bruit et d'erreurs.

Questions

Les enseignants peuvent demander des versions de ces cahiers avec les corrigés et des conseils sur le placement dans les programmes d'études communs en répondant à cette enquête rapide sur la façon dont les cahiers sont utilisés.

Concepts essentiels

• Les qubits peuvent être intriqués, ce qui signifie que la 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 de 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'enchevêtrements et de mesures, nous pouvons transférer un état (qui peut stocker des informations) d'un qubit à l'autre. Ce transfert peut même se faire sur de longues distances, 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, une communication classique peut être nécessaire pour modifier les états téléportés. Cela empêche la téléportation quantique de déplacer 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 sensibles au bruit et aux erreurs que les ordinateurs classiques. Il faut s'attendre à une erreur de quelques pourcents.
• Plus on ajoute de portes en séquence (en particulier des portes à 2 qubits), plus on peut s'attendre à des erreurs et à du bruit.

Questions vrai/faux

1. T/F La téléportation quantique peut être utilisée pour envoyer des informations plus rapidement que la lumière.
2. T/F Les données modernes suggèrent que l'effondrement d'un état quantique se propage plus vite que la lumière.
3. T/F Dans Qiskit, les qubits sont classés par état, le qubit le moins élevé se trouvant à droite, comme dans l'exemple suivant $|q_3,q_2,q_1, q_0\rangle$

Questions du MC

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 limite de la tolérance expérimentale, dans les expériences menées jusqu'à présent.
• b. Le Qubit B est affecté au bout d'un certain temps $d/c$, ce qui signifie que l'état quantique "s'effondre" à peu près à la vitesse de la lumière, dans les limites de la tolérance expérimentale.
• c. La Qubit B n'est affectée qu'après une communication classique, ce qui signifie qu'elle se produit dans un temps plus long que $d/c$.
• d. Aucune des réponses ci-dessus

2. Rappelons que la probabilité de mesure est liée aux amplitudes des é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 de l'échantillonnage fini (de la même manière qu'en jouant à pile ou face, on peut obtenir deux fois de suite le résultat "face"). L'histogramme de mesure ci-dessous pourrait correspondre à l'un des états quantiques suivants? Sélectionnez 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 que les qubits A et B sont intriqués? Sélectionnez toutes les phrases qui s'appliquent.

• 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, nous avons 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 de nombreux autres états intriqués que l'on pourrait utiliser pour un protocole similaire. Lequel des états ci-dessous pourrait produire un histogramme de mesure de 2 qubits comme le suivant? Sélectionnez 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 à débattre

1. Décrivez le protocole de téléportation quantique, du début à la fin, à votre partenaire/groupe. Voyez s'ils ont quelque chose à ajouter ou s'ils ont des questions à poser.

2. Y a-t-il quelque chose d'unique dans l'état initial intriqué 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? Sinon, quels autres états intriqués aurions-nous pu utiliser?