Distribution de clés quantiques

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é 5 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 motivation

Il existe une infinité de façons de crypter et de décrypter les informations, et des milliers de méthodes ont été étudiées. Nous nous limiterons ici à une méthode de cryptage très ancienne et très simple, appelée "remplacement simple", afin de nous concentrer sur la partie quantique de ce protocole. La partie quantique pourrait être adaptée à de nombreux autres protocoles avec relativement peu de changements.

Remplacement simple

Un chiffrement par simple remplacement est un chiffrement dans lequel une lettre ou un chiffre est remplacé par un autre, de sorte qu'il existe une correspondance 1:1 entre les lettres et les chiffres d'un message et les lettres et les chiffres utilisés dans une séquence chiffrée. Un exemple de la culture populaire est l'énigme de la crypto-citation ou du cryptogramme, dans laquelle une citation ou une phrase est cryptée à l'aide d'un simple remplacement, et le joueur est chargé de la décrypter. Ces problèmes sont faciles à résoudre s'ils sont suffisamment longs. Prenons un exemple :

R WVXRWVW GSZG R'W YVGGVI NZPV GSRH KIVGGB OLMT. GSZG DZB, KVLKOV DROO SZEV ZM VZHRVI GRNV HLOERMT RG. R SLKV R NZWV RG HRNKOV VMLFTS.

Les personnes qui résolvent ces problèmes à la main utilisent généralement des astuces qui impliquent une connaissance de la structure de la langue du message original. Par exemple, en anglais, les seuls mots d'une lettre comme le "R" crypté sont "a" et "I". Les lettres doubles cryptées dans, par exemple, "KIVGGB" ne peuvent prendre que certaines valeurs. Il y a des choses plus subtiles qui donnent des indices, comme le mot le plus courant correspondant au modèle "GSZG" est "ça". Les personnes qui utilisent le code pour résoudre ce problème disposent de beaucoup plus d'options, y compris le simple balayage des possibilités jusqu'à ce qu'un mot anglais soit trouvé, et la mise à jour tout en préservant ce mot. Une méthode simple mais efficace consiste à utiliser la fréquence des lettres, en particulier lorsque le message est suffisamment long pour constituer un échantillon représentatif de l'anglais.

Question d'enregistrement

Si vous le souhaitez, essayez de déchiffrer ceci, même si ce n'est pas indispensable pour la suite du module. Cliquez sur « Répondre » ci-dessous pour voir le message.

• Réponse

  J'ai décidé qu'il valait mieux que ce soit assez long. De cette façon, les gens auront plus de facilité à le résoudre. J'espère avoir été assez simple.

L'exemple ci-dessus est associé à une "clé", une correspondance entre les lettres cryptées et les lettres décryptées. Dans ce cas, la clé est :

• A (non utilisé, appelons-le Z)
• B->Y
• C (non utilisé, appelons-le X)
• D->W
• E->V
• F->U
• ...

etc. Le moins que l'on puisse dire, c'est qu'il ne s'agit pas d'une bonne clé. Les clés dans lesquelles les lettres cryptées et décryptées sont simplement des versions décalées de l'alphabet (comme A->B et B->C) sont appelées "chiffrement par décalage de César".

Notez que ces derniers sont très difficiles s'ils sont courts. En effet, si elles sont très courtes, elles sont indéterminées. Envisager :

URYYP

Il existe plusieurs décryptages possibles, utilisant des clés différentes : HELLO, PETTY, HAPPY, JIGGY, STOOL. Pouvez-vous en citer d'autres?

Mais si vous envoyez de nombreux messages de ce type, le cryptage finira par être déchiffré. Il ne faut donc pas utiliser trop souvent la même "clé". En fait, le mieux est de n'utiliser une certaine substitution qu'une seule fois. Non pas dans un seul message, mais pour un seul personnage! Cela signifie que vous disposerez d'un schéma ou d'une clé de cryptage pour chaque caractère utilisé dans le message, dans l'ordre. Si vous voulez envoyer un message à un ami en utilisant ce message, vous et votre ami aurez besoin d'un bloc de papier (dans l'ancien temps) sur lequel cette clé en constante évolution est écrite. Vous ne l'utiliserez qu'une seule fois. C'est ce qu'on appelle un "tampon à usage unique".

Le masque à usage unique

Voyons comment cela fonctionne à l'aide d'un exemple. On pourrait le faire entièrement avec des lettres, mais il est courant de convertir des lettres en chiffres, par exemple en attribuant A=0, B=1, C=2…. Supposons que nous soyons des amis impliqués dans des activités clandestines et que nous partagions une tablette. Dans l'idéal, nous partagerions de nombreux coussinets, mais celui d'aujourd'hui l'est :

EDGRPOJNCUWQZVMK.

Ou encore, la conversion des nombres en fonction de leur position dans l'alphabet :

4,3,6,17,15, 14, 9, 13, 2, 20, 22, 16, 25, 21, 12, 10.

Supposons que je veuille partager avec vous le message :

"J'aime le quantum!"

Ou, de manière équivalente :

8, 11, 14, 21, 4, 16, 20, 0, 13, 19, 20, 12

Nous ne voulons pas envoyer le code ci-dessus; il s'agit d'une simple substitution, qui n'est pas du tout sûre. Nous voulons combiner cela avec notre clé d'une manière ou d'une autre. Une méthode courante est l'addition modulo 26. Nous ajoutons la valeur du message à la valeur de la clé, mod 26, jusqu'à ce que nous atteignions la fin du message. Nous envoyons donc

8+4 (mod 26) = 12, 11+3 (mod 26) = 14, 14+6 (mod 26) = 20, 21+17 (mod 26) = 12.

= 12, 14, 20, 12, 19, 4, 3, 13, 15, 13, 16, 2

Notez que si quelqu'un intercepte ce message et ne possède PAS la clé, le décryptage est totalement impossible! Même les deux "u" de "quantum" ne sont pas codés avec le même nombre! Le premier est un 3 et le second un 16... dans le même mot!

Je vous l'envoie donc, et vous avez la même clé que moi. Vous défaites l'addition modulo 26 que vous savez que j'ai effectuée :

12, 14, 20, 12, 19, 4, 3, 13, 15, 13, 16, 2

\N-( 4+x1 ) (mod 26), ( 3+x2 ) (mod 26), ( 6+x3 ) (mod 26), ( 17+x4 ) (mod 26),.

De telle sorte que le message x1, x2, x3, x4… doit être

8, 11, 14, 21.

Enfin, en convertissant ces données en texte, nous obtenons

"J'aime le quantique".

Il s'agit d'un tampon à usage unique.

Notez que si la clé est plus courte que le message, nous commençons à répéter notre encodage. Il s'agirait d'un problème de décryptage difficile à résoudre, mais pas impossible s'il est répété suffisamment de fois. Vous avez donc besoin d'une touche longue (ou "pad").

Nous espérons que l'activité ci-dessus montre clairement qu'un pavé numérique à usage unique est une forme de cryptage incassable, sous réserve de quelques hypothèses, comme par exemple :

• La clé est de la même longueur que le message envoyé, ou plus longue
• La clé est vraiment aléatoire
• La clé n'est utilisée qu'une seule fois et est ensuite jetée

C'est donc une excellente chose. Nous disposons d'un cryptage inviolable... à moins que quelqu'un n'obtienne notre clé. Si quelqu'un obtient notre clé, tout est décrypté. Cette différence entre un cryptage inviolable et la révélation de tous nos secrets rend le partage d'une clé sécurisée extrêmement important. L'objectif de la distribution de clés quantiques est de tirer parti des contraintes que la nature a imposées à l'information quantique pour sécuriser une clé partagée/un tampon à usage unique.

Utilisation des états quantiques comme clé

Supposons que nous travaillions avec des qubits (en soulignant que les qubits ont deux états propres). On pourrait utiliser des systèmes quantiques avec un plus grand nombre d'états quantiques, mais les ordinateurs quantiques de pointe sur IBM® utilisent des qubits. Il n'est pas difficile d'encoder nos A, B, C, en séquences de 0’s et 1’s. Il suffit donc de partager une clé de 0’s et 1’s et d'effectuer une addition modulo 2 sur chaque bit stockant une lettre.

Vérifiez votre compréhension

Si nous ne nous intéressons qu'aux lettres anglaises, de combien de bits avons-nous besoin?

• Réponse
  $$2^4=16\\ 2^5 = 32 \rightarrow 5 \text{ bits}$$

Nos amis, Alice et Bob, souhaitent partager une clé quantique de telle sorte que personne d'autre ne puisse l'intercepter (du moins à leur insu). Ils doivent pouvoir s'envoyer des états quantiques les uns aux autres. Faire cela avec une grande fidélité et sans bruit ni erreur n'est PAS trivial. Mais il y a deux approches que nous devrions être en mesure de comprendre à ce stade :

1. Un câble à fibre optique permet d'envoyer de la lumière... ce qui est très quantique. Les photons uniques peuvent être détectés avec une grande fidélité sur plusieurs kilomètres de câble à fibres optiques. Il ne s'agit pas d'un canal quantique parfait et exempt d'erreurs, mais il pourrait être très performant.
2. Nous pourrions utiliser la téléportation quantique, décrite dans un module précédent. En d'autres termes, Alice et Bob pourraient partager des qubits intriqués et un état pourrait être envoyé d'Alice à Bob à l'aide du protocole de téléportation.

Pour ce module, nous ne voulons pas vous demander d'avoir des configurations optiques de haute fidélité pour le partage des photons, nous utiliserons donc la deuxième méthode pour le partage des états quantiques. Mais cela ne veut pas dire qu'il s'agit de la solution la plus réaliste pour le partage de clés quantiques à longue distance.

Nous allons maintenant étudier un protocole élaboré pour la première fois par Charles Bennett et Gilles Brassard en 1984 pour le partage d'états mesurés dans différentes bases entre Alice et Bob. Nous utiliserons un régime de mesures astucieux pour construire une clé qui sera utilisée lors d'un cryptage ultérieur. En d'autres termes, nous distribuons une clé quantique entre deux parties qui souhaitent communiquer, d'où la "distribution quantique de clés" (QKD).

Étape 1 du QKD : bits aléatoires et bases aléatoires d'Alice

Alice commence par générer une séquence aléatoire de 0 et de 1. Elle choisira ensuite au hasard une base dans laquelle préparer un état quantique, sur la base de chaque bit aléatoire, en utilisant le tableau ci-dessous (tableau que Bob possède également) :

Par exemple, supposons qu'Alice ait généré un 0 au hasard et qu'elle ait choisi la base X au hasard. Elle préparerait ensuite un état quantique $|\psi\rangle = |+\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. On peut certainement tirer parti du hasard quantique pour générer un ensemble aléatoire de 0 et de 1, ainsi qu'un choix de base aléatoire. Pour l'instant, supposons simplement qu'un ensemble aléatoire a été généré, comme suit :

Cet ensemble de bits aléatoires, de bases et d'états résultants se poursuivrait dans une longue séquence, afin d'obtenir une clé suffisamment longue.

QKD étape 2 : les bases aléatoires de Bob

Bob fait également un choix aléatoire de bases. Cependant, alors qu'Alice utilisait le choix de la base pour préparer son état, Bob effectuera des mesures dans ces bases. Si Bob effectue une mesure dans la même base que celle dans laquelle Alice a préparé l'état, nous pouvons prédire le résultat de la mesure de Bob. Si Bob choisit une base différente de celle qu'Alice a utilisée pour la préparation, nous ne pouvons pas connaître le résultat de la mesure de Bob.

Dans le tableau ci-dessous, considérez la première colonne. Alice a préparé l'état $\vert +\rangle,$ qui est un état propre de X. Comme Bob a également choisi au hasard de mesurer dans la base X, il n'y a qu'un seul résultat possible pour l'état mesuré par Bob : $\vert +\rangle.$ Dans la deuxième colonne, cependant, ils ont choisi des bases différentes. L'état envoyé par Alice est $\vert -\rangle = \frac{1}{\sqrt{2}}(\vert 0\rangle-\vert 1 \rangle).$. Cet état a 50 % de chances d'être mesuré par Bob dans l'état $\vert 0\rangle$, et 50 % de chances d'être mesuré dans l'état $\vert 1\rangle.$. La ligne indiquant ce que nous savons, a priori, des mesures de Bob ne peut donc pas être remplie pour la colonne 2. Mais Bob effectuera une mesure et obtiendra un état propre de (dans cette colonne) Z. Dans la ligne inférieure, nous indiquons ce que ces mesures ont donné.

QKD étape 3 : Discussion publique sur les bases

Alice et Bob peuvent maintenant se communiquer la base qu'ils ont choisie dans chaque cas. Pour toutes les colonnes dans lesquelles ils ont choisi la même base, chacun sait avec certitude quel était l'état de l'autre. Bob peut convertir l'état et la base en 0 ou en 1 selon la convention partagée par les deux parties. Nous pouvons réécrire le tableau ci-dessus pour n'indiquer que les cas où les bases d'Alice et de Bob correspondent :

Alice a transmis avec succès la chaîne de bits 00100... à Bob. Si les amis se sont mis d'accord à l'avance pour utiliser des chaînes de 5 bits comme nombres dans leur bloc de données à usage unique, ces cinq premiers bits leur donneront le nombre suivant $4 = 0\times2^4+0\times2^3+1\times2^2+0\times2^1+0\times2^0.$

Étape 4 du QKD : vérifier et envoyer le secret

Avant d'aller plus loin, Alice et Bob doivent choisir un sous-ensemble de leurs bits classiques à comparer. Étant donné qu'ils n'ont conservé que les mesures des qubits qui ont été préparés et mesurés en utilisant la même base, toutes les valeurs mesurées devraient concorder. Si un très faible pourcentage ne concordait pas, cela pourrait être imputable au bruit quantique ou à des erreurs. Mais si beaucoup ne sont pas d'accord, c'est que quelque chose ne va pas!

Nous n'aborderons pas ici la question de savoir quelle fraction de la clé doit être utilisée pour la vérification. Pour l'instant, nous supposons que cette vérification se déroule correctement; nous y reviendrons dans la section ci-dessous consacrée aux écoutes clandestines.

Les amis s'envoient ensuite un message crypté en utilisant des canaux classiques. Ils utilisent ensuite les chiffres de leur bloc de données à usage unique pour crypter/décrypter des messages secrets, sans jamais transmettre le bloc de données à usage unique d'un endroit à l'autre. Pour la section suivante sur l'écoute clandestine, il convient de garder à l'esprit que tout ce partage de la clé a lieu avant la révélation du secret crypté par les canaux classiques.

Alice et Bob ont communiqué leur base de choix par des canaux classiques, qui ne pourraient donc pas être interceptés? Oui. Mais connaître la base de mesure utilisée ne permet pas de savoir quel bit ils ont envoyé ou obtenu. Cela n'est possible que si l'on connaît également les bits de départ d'Alice. Mais vous seriez alors dans l'ordinateur d'Alice, où les secrets sont stockés, et la communication secrète de ces secrets n'a plus lieu d'être. L'interception de la communication classique ne brise donc pas le cryptage. Mais qu'en est-il de l'interception d'informations dans le canal quantique?

Résistance du QKD à l'écoute clandestine

Alice et Bob ont une amie, Eve, qui a la réputation d'écouter aux portes. Eve souhaite intercepter la clé quantique d'Alice et de Bob, afin de pouvoir l'utiliser pour décrypter les messages envoyés entre les deux. Cela se produirait nécessairement entre la préparation des états par Alice et la mesure des états par Bob, puisque la mesure effondre l'état quantique. En particulier, cela signifie que l'écoute doit avoir lieu avant qu' il y ait eu partage ou comparaison des bases.

Eve doit deviner quelle base a été utilisée pour coder chaque bit. Là encore, si elle n'est pas en mesure d'accéder à l'ordinateur d'Alice, elle ne dispose d'aucun élément sur lequel fonder sa supposition, et celle-ci sera aléatoire. Supposons que le départ d'Alice soit le même que précédemment, et supposons également que le choix aléatoire de la base de mesure par Bob soit le même que précédemment. Complétons ce qu'Eve obtient si elle effectue des mesures sur le canal quantique. Comme précédemment, si Eve choisit la même base qu'Alice, nous savons ce qu'elle obtiendra. Dans le cas contraire, elle pourrait obtenir l'un des deux résultats, chacun ayant une probabilité de 50 %.

Comme Eve ne sait pas si elle s'est alignée sur la base d'Alice ou non, elle ne sait pas ce qu'elle doit transmettre à Bob pour qu'il s'aligne sur les états originaux d'Alice. Lorsque Eve mesure, par exemple, $|0\rangle,$ tout ce qu'elle sait avec certitude est qu'Alice n'a pas préparé l'état $|1\rangle$ pour ce qubit. Mais Alice aurait pu préparer $|0\rangle,$ $|+\rangle,$ ou $|-\rangle.$. Tout pourrait être cohérent avec la mesure d'Eve. Eve doit donc faire un choix. Elle peut envoyer exactement l'état qu'elle a mesuré ou essayer de deviner les cas dans lesquels sa mesure ne correspond pas à l'état propre envoyé par Alice. Nous inclurons un mélange dans notre table :

À ce stade, il est raisonnable de se demander : "Pourquoi Eve ne fait-elle pas simplement une copie de l'état quantique d'Alice, en garde une pour la mesurer et transmet l'autre à Bob?" La réponse est le théorème du "non-clonage". De manière informelle, cela signifie qu'il n'existe pas d'opération unitaire (mécanique quantique) permettant de faire une seconde copie d'un état quantique arbitraire, tout en préservant la première copie. La preuve est relativement simple et est laissée à titre d'exercice guidé. Mais pour l'instant, il faut comprendre que les lois fondamentales de la nature interdisent à Eve de faire des copies de l'état quantique, ce qui constitue l'une des principales forces du QKD.

Comme auparavant, Alice et Bob s'appellent et comparent leurs bases. Ils réduiront ce tableau aux cas où les deux amis ont choisi les mêmes bases :

Alice et Bob ont à nouveau communiqué une chaîne de bits... mais les chaînes ne correspondent pas. Les bits de l'extrême gauche et du milieu sont inversés. Si l'on examine le tableau précédent, on constate que ce décalage est dû à l'interférence d'Eve. Il est important de noter que nous pouvons effectuer des statistiques sur la correspondance entre nos chaînes de bits dès maintenant, tout en établissant la clé, bien avant de partager notre secret crypté. Alice et Bob sont libres d'utiliser autant de bits de leur tampon à usage unique qu'ils le souhaitent pour vérifier la sécurité de leur canal. Si un seul bit ou un très faible pourcentage de bits ne correspond pas, cela peut être dû à du bruit ou à des erreurs. Mais une fraction substantielle des discordances indique la présence d'écoutes clandestines. La signification de "substantiel" ici dépend un peu du bruit dans la configuration utilisée; ce que cela signifie pour les ordinateurs quantiques IBM® sera discuté plus loin lorsque nous mettrons en œuvre ce protocole. Si des erreurs excessives sont détectées, Alice et Bob ne partagent pas le secret et peuvent commencer à chasser l'espion.

Avertissements

Il est extrêmement difficile de prouver la sécurité. En fait, le protocole vaguement décrit ici a été proposé en 1984 et n'a été prouvé sûr que 16 ans plus tard Shor & Preskill, 2000. Il existe de nombreuses subtilités qui dépassent le cadre de cette introduction. Mais nous en citerons brièvement quelques-unes pour montrer que le sujet est plus complexe que ce qui est illustré ici.

• Canaux sécurisés : Lorsque Alice envoie ses qubits par l'intermédiaire d'un dispositif quantique (un canal) et, en particulier, lorsqu'elle reçoit des réponses classiques de quelqu'un, nous avons supposé que ce quelqu'un était en fait Bob. Si Eve a infiltré ce dispositif de telle sorte que toutes les communications d'Alice se déroulent en fait avec Eve, et que toutes les communications de Bob se déroulent en fait avec Eve, alors Eve a effectivement obtenu une clé et peut apprendre des secrets. Il faut d'abord garantir des "canaux sécurisés", un processus avec un ensemble différent de protocoles que nous n'avons pas abordé ici.
• Hypothèses sur Eve : Pour prouver véritablement la sécurité, nous ne pouvons pas faire d'hypothèses sur le comportement d'Ève; elle pourrait toujours décevoir nos attentes. Ici, pour donner des exemples concrets, nous faisons des hypothèses. Par exemple, nous pouvons supposer que les états qu'Eve transmet à Bob sont toujours exactement ceux qu'elle a obtenus lors de la mesure. On peut aussi supposer qu'elle choisit au hasard un état expérimentalement cohérent avec sa mesure. Plus fondamentalement, le langage utilisé ici suppose qu'Eve effectue réellement une mesure, par opposition au stockage de l'état dans un autre système quantique et à l'envoi d'un qubit aléatoire à Bob. Ces hypothèses sont utiles pour comprendre le protocole, mais elles signifient que nous ne prouvons rien en toute généralité.
• Amplification de la confidentialité : Alice et Bob ne sont pas tenus d'utiliser la clé quantique telle qu'elle a été transmise. Ils peuvent, par exemple, appliquer une fonction de hachage à la clé partagée. Cela permettrait d'exploiter le fait que l'espion a une connaissance incomplète de la clé pour produire une clé partagée plus courte, mais sûre.

Expérience 1 : QKD sans espion

Mettons en œuvre le protocole ci-dessus en l'absence d'un espion. Nous commencerons par utiliser un simulateur, simplement pour comprendre le déroulement des opérations.

Tout d'abord, une remarque sur les simulateurs quantiques : La plupart des problèmes quantiques impliquant plus de 30 qubits ne peuvent pas être simulés par la plupart des ordinateurs. Aucun ordinateur classique, superordinateur ou GPU ne peut simuler l'ensemble des comportements d'un ordinateur quantique de 127 qubits. En général, la motivation pour utiliser de véritables ordinateurs quantiques est que les nombreux qubits intriqués ne peuvent pas être simulés. Dans ce cas, il n'y a pas d'intrication des qubits, à moins d'utiliser le système de téléportation pour déplacer l'information. Dans ce cas, la motivation pour utiliser de véritables ordinateurs quantiques est différente : il s'agit du théorème de non-clonage. Un ordinateur classique simulant un qubit pourrait envoyer des informations sur un état quantique d'Alice à Bob, mais si ces informations classiques étaient interceptées, elles pourraient facilement être dupliquées, et Eve pourrait en conserver une copie parfaite, tout en en envoyant une autre à Bob. Cela n'est pas possible avec des états quantiques réels.

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écuter votre travail sur IBM ordinateurs quantiques à l'aide des primitives Runtime
• Étape 4 : Post-traitement des résultats

Modèles Qiskit étape 1 : mappez votre problème sur un circuit quantique

Dans ce cas, la mise en correspondance de notre problème avec les circuits quantiques se réduit à la simple préparation des états d'Alice, puis à l'inclusion des mesures de Bob. Nous commençons par la sélection d'un bit aléatoire et d'une base aléatoire.

# Qiskit patterns step 1: Map your problem to quantum circuit
# Import some generic packages

import numpy as np
from qiskit import QuantumCircuit

# Set up a random number generator and a quantum circuit. We choose to start with 20 bits, though
# any number <30 should be fine.

rng = np.random.default_rng()
bit_num = 20
qc = QuantumCircuit(bit_num, bit_num)

# QKD step 1: Random bits and bases for Alice
# generate Alice's random bits

abits = np.round(rng.random(bit_num))

# generate Alice's random measurement bases. Here we will associate a "0" with the Z basis, and a
# "1" with the X basis.

abase = np.round(rng.random(bit_num))

# Alice's state preparation. Check that this creates states according to table 1

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# QKD step 2: Random bases for Bob
# generate Bob's random measurement bases.

bbase = np.round(rng.random(bit_num))

# Note that if Bob measures in Z no gates are necessary, since IBM Quantum computers
# measure in Z by default.
# If Bob measures in the X basis, we implement a hadamard gate qc.h to facilitate the measurement.

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(m, m)

Visualisons les bits, les bases et le circuit. Notez que les bases correspondent parfois, parfois non.

print("Alice's bits are ", abits)
print("Alice's bases are ", abase)
print("Bob's bases are ", bbase)
qc.draw("mpl")

Output:

Alice's bits are  [1. 1. 0. 1. 0. 1. 1. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 0. 0.]
Alice's bases are  [0. 0. 0. 1. 1. 0. 0. 0. 0. 1. 1. 1. 1. 1. 0. 1. 1. 0. 1. 0.]
Bob's bases are  [0. 1. 1. 0. 1. 0. 1. 1. 0. 0. 1. 1. 0. 0. 1. 0. 1. 1. 0. 0.]

Modèles Qiskit, étape 2 : optimisation du 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. Bien que nous utilisions momentanément un simulateur, il est important d'utiliser un modèle de bruit raisonnable dans la simulation, et il est bon de garder le flux de travail aussi proche que possible de ce que nous utiliserons plus tard pour les vrais ordinateurs quantiques.

Le code ci-dessous vous 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_brisbane

Nous sélectionnons ci-dessous un simulateur et un modèle de bruit.

# 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

# Load the qiskit runtime sampler
from qiskit_ibm_runtime import SamplerV2 as Sampler


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)

# Qiskit patterns 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)

Modèles Qiskit, étape 3 : Exécuter

Utilisez l'échantillonneur pour exécuter votre travail, avec le circuit comme argument.

# This required 5 s to run on a Heron r2 processor on 10-28-24
sampler = Sampler(mode=backend)
job = sampler.run([qc_isa], shots=1)
# job = sampler_sim.run([qc], shots = 1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

Modèles Qiskit, étape 4 : post-traitement

Nous interprétons ici nos résultats et en extrayons des informations utiles. Nous pourrions essayer de visualiser la sortie de notre échantillonneur, mais nous avons utilisé l'échantillonneur d'une manière peu conventionnelle. Plutôt que d'effectuer de nombreuses mesures de notre circuit et d'élaborer des statistiques sur les états, nous avons effectué une seule mesure (celle de Bob). Tout qubit dont l'état a été préparé et mesuré sur la même base devrait avoir un résultat déterministe, de sorte qu'une seule mesure est nécessaire. Ces qubits dont les états ont été préparés et mesurés dans différentes bases (qui auraient des résultats probabilistes et nécessiteraient de nombreuses mesures pour être interprétés) ne seront pas utilisés pour construire notre clé à usage unique.

Extrayons de cette chaîne de bits une liste de résultats de mesures. Veillez à inverser l'ordre si vous comparez avec le tableau de bits d'Alice que nous avons utilisé pour générer le circuit.

# Get an array of bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))

# Reverse the order to match our input. See "little endian" notation.

bbits = bmeas_ints[::-1]

print(bbits)

Output:

[1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0]

Comparons les bases de mesure choisies au hasard par Alice et Bob. Il s'agit de l'étape 3 de notre protocole QKD (discussion publique des bases). Chaque fois qu'ils choisissent la même base pour un qubit, nous ajoutons les bits associés à ce qubit à une liste de bits permettant de générer des nombres dans un tampon à usage unique. Lorsque les bases ne correspondent pas, les résultats sont rejetés. Vérifions également que les deux listes de bits concordent, ou qu'il n'y a pas eu de pertes dues au bruit ou à d'autres facteurs.

# QKD step 3: Public discussion of bases

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    # Check whether bases matched.
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        # If bits match when bases matched, increase count of matching bits
        if int(abits[n]) == bbits[n]:
            match_count += 1

print(agoodbits)
print(bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

[1, 0, 1, 0, 0, 0, 1, 0]
[1, 0, 1, 0, 0, 0, 1, 0]
fidelity =  1.0
loss =  0.0

Alice et Bob disposent chacun d'une liste de bits, et ils correspondent avec une fidélité de 100 %. Ils peuvent les utiliser pour générer des nombres dans un pavé à usage unique. Ils peuvent ensuite l'utiliser à l'étape 4 du QKD : envoi et décryptage d'un secret. Le nombre actuel de bits est trop faible pour décrypter quoi que ce soit. Nous y reviendrons après avoir abordé la question des écoutes.

Vérifiez votre compréhension

Supposons que vous ayez besoin de chiffres suffisamment grands pour faciliter le déplacement des lettres de l'alphabet anglais sur toute la longueur de cet alphabet, voire plus, bien qu'il existe certainement d'autres schémas d'encodage. (a) Combien de lettres un message peut-il contenir pour être décrypté à l'aide des bits de la clé ci-dessus? (b) Votre réponse doit-elle être en accord avec celle de vos camarades de classe? Pourquoi ?

• Réponse

  (a) La réponse dépend du nombre de bases choisies au hasard qui coïncident entre Alice et Bob. Étant donné que la probabilité que les bases coïncident est d'environ 50-50 pour chaque qubit, nous nous attendons à ce que près de 10 de nos bits soient exploitables. 9 ou 11, ce sera tout à fait courant. Même 4 ou 15 ne sont pas à exclure. Il faut 5 bits pour effectuer un décalage d'une longueur supérieure ou égale à celle de l'alphabet anglais, ce qui signifie que vous pouvez décaler une lettre tous les 5 bits dont vous disposez. Si Alice et Bob partagent au moins 5 bits, vous pouvez coder une seule lettre. Si vous en avez au moins 10, vous pouvez coder 2 lettres, et ainsi de suite.

  (b) Il n'est pas nécessaire qu'elle donne son accord, pour les raisons exposées au point (a).

Expérience 2 : QKD avec un espion

Nous mettrons en œuvre exactement le même protocole que précédemment. Cette fois, nous allons insérer une autre série de mesures, effectuées par Eve, entre Alice et Bob.

from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister

# Qiskit patterns step 1: Mapping your problem to a quantum circuit
# QKD step 1: Random bits and bases for Alice

bit_num = 20
qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Alice's random bits and bases, as before

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation, as before

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# Eavesdropping happens here!
# Generate Eve's random measurement bases

ebase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if ebase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns 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)

# Qiskit patterns step 3: Execute
job = sampler_sim.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

L'étape 4 (post-traitement) des modèles Qiskit est simple dans ce cas. Il n'est pas nécessaire de visualiser la distribution des mesures, puisque nous n'avons effectué qu'une seule mesure. Eve dispose des bits suivants :

keys = counts.keys()
key = list(keys)[0]
emeas = list(key)
emeas_ints = []
for n in range(bit_num):
    emeas_ints.append(int(emeas[n]))
ebits = emeas_ints[::-1]

print(ebits)

Output:

[0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1]

Eve doit maintenant reconstruire les états à envoyer à Bob. Comme décrit dans l'introduction, elle n'a aucun moyen de savoir si elle a correctement deviné les bases d'encodage, et ne peut donc pas préparer exactement les mêmes états que ceux qui ont été envoyés. Elle peut supposer que chaque choix de base est correct et encoder exactement ce qu'elle a mesuré, ou elle peut supposer qu'elle a mal choisi la base et choisir l'un des états propres de la base opposée. Ici, nous supposons que c'est le premier cas, pour des raisons de simplicité. Pour ce faire, nous construisons un tout nouveau circuit quantique, en répétant les étapes du modèle Qiskit comme auparavant.

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# Qiskit patterns step 1: Mapping your problem onto a quantum circuit
# QKD step 1: Eve uses her measurements to prepare best guess states to send on to Bob

qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Eve's state preparation

for n in range(bit_num):
    if ebits[n] == 0:
        if ebase[n] == 1:
            qc.h(n)
    if ebits[n] == 1:
        if ebase[n] == 0:
            qc.x(n)
        if ebase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

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


# Qiskit patterns step 3: Execute

job = sampler_sim.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

print(bbits)

Output:

[0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1]

Comparons maintenant les bits d'Alice et de Bob :

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1
print(agoodbits)
print(bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

[1, 1, 0, 0, 0, 1, 1]
[1, 1, 0, 0, 0, 0, 1]
fidelity =  0.8571428571428571
loss =  0.1428571428571429

Auparavant, les bits des clés d'Alice et de Bob correspondaient parfaitement. Maintenant, grâce à l'interférence d'Eve, nous voyons que les bits d'Alice et de Bob sont différents dans 14 % des cas qui devraient correspondre parce qu'Alice et Bob ont choisi les mêmes bases. Cela devrait être facile à détecter pour Alice et Bob. Toutefois, le fait de s'appuyer sur un tel pourcentage d'erreurs signifie qu'il y a une limite au bruit que nous pouvons tolérer dans le canal quantique.

Expérience 3 : Comparaison entre QKD avec et sans écoute clandestine sur un véritable ordinateur quantique

Faisons-le sur un véritable ordinateur quantique. Nous pouvons ainsi tirer parti du théorème de non-clonage. Dans le même temps, les ordinateurs quantiques réels sont bruyants et présentent des taux d'erreur plus élevés que les ordinateurs classiques. Comparons donc la perte de fidélité de nos bits de clé avec et sans écoute, afin de nous assurer que la différence est détectable lors de l'utilisation d'un véritable ordinateur quantique. Nous commencerons par l'absence d'écoute :

from qiskit_ibm_runtime import SamplerV2 as Sampler

# This calculation was run on an Eagle r3 processor on 11-7-24 and
# required 3 sec to run, with 127 qubits.
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

bit_num = 127
qc = QuantumCircuit(bit_num, bit_num)

# QKD step 1: Generate Alice's random bits and bases

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(m, m)


# Qiskit patterns step 2: Transpilation

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

# Load the Runtime primitive and session
sampler = Sampler(mode=backend)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing
# Extract Bob's bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

# Compare Alice's and Bob's measurement bases and collect usable bits

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1

# Print some results

print("Alice's bits = ", agoodbits)
print("Bob's bits = ", bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

Alice's bits =  [0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1]
Bob's bits =  [0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1]
fidelity =  0.9682539682539683
loss =  0.031746031746031744

Sans écoute, nous avons obtenu une fidélité de 100 % sur cet ensemble de 127 bits d'essai, ce qui nous a permis d'obtenir 55 bases appariées et des bits de clé utilisables. Maintenant, répétons cette expérience avec Eve à l'écoute :

from qiskit_ibm_runtime import SamplerV2 as Sampler

# This calculation was run on an Eagle r3 processor on 11-7-24 and
# required 2 s to run, with 127 qubits.
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

bit_num = 127
qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# QKD step 1: Generate Alice's random bits and bases

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)


# Eavesdropping happens here!
# Generate Eve's random measurement bases

ebase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if ebase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

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

sampler = Sampler(mode=backend)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing
# Extract Eve's bits

keys = counts.keys()
key = list(keys)[0]
emeas = list(key)
emeas_ints = []
for n in range(bit_num):
    emeas_ints.append(int(emeas[n]))
ebits = emeas_ints[::-1]

# print(ebits)

# Restart process
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

# QKD step 1: Eve uses her measurements above to prepare best guess states to send on to Bob

qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)


# Eve's state preparation

for n in range(bit_num):
    if ebits[n] == 0:
        if ebase[n] == 1:
            qc.h(n)
    if ebits[n] == 1:
        if ebase[n] == 0:
            qc.x(n)
        if ebase[n] == 1:
            qc.x(n)
            qc.h(n)

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

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

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit Patterns step 4: Post-processing
# Extract Bob's bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

# Compare Alice's and Bob's bases, when they are the same, keep the bits.

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1

# Print some results

print("Alice's bits = ", agoodbits)
print("Bob's bits = ", bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

Alice's bits =  [1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1]
Bob's bits =  [1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1]
fidelity =  0.7619047619047619
loss =  0.23809523809523814

Dans ce cas, nous avons constaté une perte de fidélité de près de 23 % dans les bits partagés en raison de l'écoute clandestine! C'est très détectable! Il est à noter que le transfert d'informations quantiques sur de longues distances pourrait encore introduire des bruits et des erreurs supplémentaires. Garantir la détection des écoutes, même en présence de bruit, et même lorsque Eve utilise toutes les astuces à sa disposition, est un domaine complexe qui dépasse le cadre de cette introduction.

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

• L'information quantique ne peut être copiée ou "clonée".
• Vous pouvez répéter le même processus de préparation pour obtenir un ensemble d'états quantiques qui sont tous identiques, ou presque.
• Une clé de cryptage/décryptage (un tampon à usage unique) peut être partagée entre deux amis à l'aide d'états quantiques.
• Deux amis choisissant au hasard une base de mesure signifie que la moitié du temps ils choisiront différemment, et devront jeter l'information sur ces qubits.
• Le choix aléatoire de la base de mesure garantit également qu'un espion ne peut pas connaître l'état initial préparé et ne peut donc pas recréer l'état envoyé. Cela permet de s'assurer que les écoutes seront détectées.

Questions vrai/faux

1. T/F Dans la distribution quantique des clés, les deux partenaires communicants mesurent chaque qubit dans la même base.
2. T/F Les lois de la nature empêchent une personne qui intercepte des informations quantiques en QKD de copier l'état quantique qu'elle intercepte.
3. T/F Un tampon à usage unique est une clé de cryptage/décryptage de messages sécurisés dans laquelle un schéma de codage particulier n'est utilisé qu'une seule fois, pour un seul élément d'information (comme une lettre de l'alphabet).

Questions du MC

1. Sélectionnez l'option qui complète le mieux l'énoncé. Comme décrit dans ce module, un tampon à usage unique est un ensemble de clés de cryptage/décryptage utilisé...

• a. Une seule fois pour une information unique, comme une lettre.
• b. Une seule fois par message.
• c. Une seule fois pendant une période déterminée, par exemple une journée.
• d. Jusqu'à ce qu'il y ait des preuves d'écoute.

2. Supposons qu'Alice et Bob choisissent leurs bases de mesure au hasard. Ils mesurent. Ils partagent ensuite leurs bases de mesure et ne conservent que les éléments d'information des cas où ils ont utilisé la même base. Jusqu'à une certaine fluctuation aléatoire, quel pourcentage environ de leurs qubits devrait produire des bits d'information utilisables?

• a. 100 %
• b. Réduction de 50 %
• c. 25 %
• d. 12.5%
• e. 0 %

3. Après qu'Alice et Bob ont sélectionné des cas dans lesquels ils ont utilisé les mêmes bases de mesure, quel pourcentage de ces bits d'information devrait correspondre, si le bruit et les erreurs quantiques étaient négligeables?

• a. 100 %
• b. Réduction de 50 %
• c. 25 %
• d. 12.5%
• e. 0 %

4. Supposons qu'Alice ait choisi ses bases de mesure au hasard. Eve choisit également ses bases au hasard, et elle écoute (mesures). Elle transmet à Bob les états qui correspondent à ses mesures. Alice et Bob comparent leurs choix de bases et ne conservent que les qubits qu'ils ont mesurés/préparés dans les mêmes bases. Jusqu'à une certaine fluctuation aléatoire, quel est le pourcentage approximatif de ces mesures de qubits conservés qui correspondront, selon Alice et Bob?

• a. 100 %
• b. 75 %
• c. Réduction de 50 %
• d. 25 %
• e. 12.5%
• f. 0 %

Questions à débattre

1. Supposons que tous les choix de base soient aléatoires pour tous les participants, Alice, Bob et Eve. Supposons qu'après avoir écouté, Eve envoie à Bob un état préparé dans la même base que celle dans laquelle elle a mesuré, et qui est cohérent avec cette mesure. Convainquez vos partenaires que 12.5 % de tous les qubits initialisés par Alice produiront des erreurs de mesure entre Alice et Bob, indiquant une écoute clandestine (en ignorant les erreurs quantiques et le bruit). Conseil 1 : Puisqu'il n'y a pas de base préférentielle, si vous considérez un seul choix initial pour Alice, le ratio pour ce choix devrait être le même que le ratio pour la somme de tous les choix. Conseil 2 : Il n'est pas toujours suffisant de compter le nombre de façons dont une chose peut se produire, étant donné que certains résultats peuvent se produire avec des probabilités différentes.

2. Supposons à nouveau que tous les choix de base sont aléatoires pour tous les participants, Alice, Bob et Eve. Mais maintenant, considérez qu'Eve est libre d'envoyer n'importe quel état qu'elle souhaite après sa mesure. Elle peut même essayer d'envoyer des états qui ne correspondent pas à ses propres mesures. Discutez avec vos partenaires/voisins pour savoir si vous pensez qu'il existe un choix de bases qui pourrait réduire le pourcentage moyen de qubits qui indiquent à Alice et Bob qu'ils sont sur écoute.