{
"cells": [
{
"cell_type": "markdown",
"id": "4046fd82",
"metadata": {},
"source": [
"---\n",
"title: \"Commencez à utiliser Qiskit en classe\"\n",
"description: \"Découvrez les bases de l'informatique quantique et comment exécuter votre premier circuit quantique avec Qiskit.\"\n",
"---\n",
"\n",
"{/* cspell:ignore checkmark ccnot */}\n",
"\n",
"\n",
"\n",
"# Commencez à utiliser Qiskit en classe\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a84d2a96-7885-4f6c-b34a-f2d386d4e120",
"metadata": {},
"source": [
"Pour ce module Qiskit en classe, les étudiants doivent disposer d'un environnement Python fonctionnel avec les paquets suivants installés :\n",
"\n",
"* `qiskit` v2.1.0 ou plus récent\n",
"* `qiskit-ibm-runtime` v0.40.1 ou plus récent\n",
"* `qiskit-aer` v0.17.0 ou plus récent\n",
"* `qiskit.visualization`\n",
"* `numpy`\n",
"* `pylatexenc`\n",
"\n",
"Pour configurer et installer les paquets ci-dessus, voir le guide d' [installation de Qiskit](/docs/guides/install-qiskit).\n",
"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®](/docs/guides/cloud-setup).\n",
"\n",
"Ce module a été testé et a utilisé 2 secondes de temps QPU sur un processeur Heron v2. Il s'agit uniquement d'une estimation. L'utilisation réelle peut varier.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d611274c-5988-45b7-98bf-01c57edc0b02",
"metadata": {},
"outputs": [],
"source": [
"# Uncomment and modify this line as needed to install dependencies\n",
"#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'"
]
},
{
"cell_type": "markdown",
"id": "9a7cc00a-e11d-46e7-9737-1ec7a3fa9951",
"metadata": {},
"source": [
"\n",
"\n",
"## Présentation\n",
"\n",
"Dans les modules Qiskit en classe, vous aurez l'occasion d'utiliser un ordinateur quantique pour explorer divers concepts de l'informatique quantique et des domaines connexes tels que la mécanique quantique, l'informatique, la chimie, etc. Ce module sert de prérequis aux autres - il présente les principes fondamentaux de l'informatique quantique et explique comment utiliser Qiskit pour exécuter des circuits quantiques.\n",
"\n",
"Nous vous donnerons d'abord un bref aperçu du fonctionnement d'un ordinateur classique, puis nous vous montrerons comment ces concepts sont adaptés au paradigme de l'informatique quantique. Enfin, nous vous montrerons comment assembler ces concepts pour construire et exécuter votre premier circuit quantique.\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "742678ad-9e14-4691-bc6f-5900c7f45f9b",
"metadata": {},
"source": [
"\n",
"\n",
"## Ordinateurs classiques\n",
"\n",
"Vous connaissez sans doute les principes de base du fonctionnement des ordinateurs classiques, mais nous allons ici mettre en évidence quelques-unes de leurs principales caractéristiques, afin de pouvoir ensuite les comparer aux ordinateurs quantiques.\n",
"\n",
"\n",
"\n",
"### Les unités de base de l'information : les bits\n",
"\n",
"Les ordinateurs classiques traitent des informations classiques, et l'unité fondamentale de l'information classique est le *bit.* Un seul bit peut stocker la réponse à une question \"oui/non\". Les deux états binaires d'un bit sont généralement représentés par \"0\" et \"1\".\n",
"\n",
"\n",
"\n",
"#### Révision des nombres binaires\n",
"\n",
"La combinaison de bits permet de stocker davantage d'informations. Par exemple, si vous voulez stocker un nombre de 0 à 15, vous pouvez le faire avec quatre bits de la manière suivante :\n",
"\n",
"| | | | |\n",
"| :------- | :------: | :-------: | --------: |\n",
"| 0 = 0000 | 4 = 0100 | 8 = 1000 | 12 = 1100 |\n",
"| 1 = 0001 | 5 = 0101 | 9 = 1001 | 13 = 1101 |\n",
"| 2 = 0010 | 6 = 0110 | 10 = 1010 | 14 = 1110 |\n",
"| 3 = 0011 | 7 = 0111 | 11 = 1011 | 15 = 1111 |\n",
"\n",
"En général, pour convertir un nombre binaire de $N$ bits en un nombre familier, base-10, vous multipliez le bit le moins significatif (le plus à droite) par $2^0 = 1$, le bit suivant à gauche par $2^1 = 2$, puis le suivant par $2^2 = 4$, et ainsi de suite, jusqu'à ce que vous atteigniez le bit le plus significatif (le plus à gauche), que vous multipliez par $2^{N-1}$.\n",
"\n",
"Cela signifie que $N$ bits peuvent se trouver dans l'un des $2^N$ états possibles.\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"De combien de bits auriez-vous besoin pour représenter le nombre 86? Écrivez la chaîne de bits qui code ce nombre en binaire.\n",
"\n",
"\n",
" \n",
" Rappelez-vous que $N$ bits vous permet de représenter les nombres $0$ à $2^N - 1$, de sorte que l'utilisation de six bits nous amènerait à $2^6 - 1 = 63$. Ce n'est pas tout à fait suffisant. Nous ajoutons un bit supplémentaire pour atteindre $2^7 - 1 = 127$. Décomposons maintenant 86 en puissances de 2 :\n",
"\n",
" $$\n",
" \\begin{aligned}\n",
" 86 &= 64 + 16 + 4 + 2 \\\\\n",
" &= 2^6 \\times 1 + 2^5 \\times 0 + 2^4 \\times 1 + 2^3 \\times 0 + 2^2 \\times 1 + 2^1 \\times 1 + 2^0 \\times 0 \\\\\n",
" &= 1010110\n",
" \\end{aligned}\n",
" $$\n",
" \n",
"\n",
"\n",
"\n",
"\n",
"### Opérations fondamentales : portes logiques\n",
"\n",
"Or, un ordinateur doit être capable de *faire* quelque chose avec les bits pour pouvoir, eh bien, calculer. Les portes binaires sont les opérations qui constituent les éléments fondamentaux de tous les algorithmes et codes les plus compliqués.\n",
"\n",
"\n",
"\n",
"### Porte à un seul bit :\n",
"\n",
"\n",
"\n",
"#### N'EST PAS\n",
"\n",
"Lorsque vous n'avez qu'un seul bit, il n'y a qu'une seule façon de transformer son état : inverser l'état de 0 à 1 ou de 1 à 0. C'est ce que nous appelons la porte \"NOT\". L'effet de cette porte - et des autres portes dont nous parlerons plus loin - peut être représenté par une \"table de vérité\", avec des colonnes pour les états d'entrée et de sortie des qubits. La table de vérité pour la porte NOT est la suivante\n",
"\n",
"| Entrée | Sortie |\n",
"| :----- | -----: |\n",
"| 0 | 1 |\n",
"| 1 | 0 |\n",
"\n",
"\n",
"\n",
"### Portes à plusieurs bits :\n",
"\n",
"\n",
"\n",
"#### ET\n",
"\n",
"AND est une porte à deux bits qui prend deux bits en entrée et produit un seul bit en sortie. Il émet 1 si les deux bits d'entrée sont à 1, et 0 dans le cas contraire :\n",
"\n",
"| Entrée | Sortie |\n",
"| :----- | -----: |\n",
"| 00 | 0 |\n",
"| 01 | 0 |\n",
"| 10 | 0 |\n",
"| 11 | 1 |\n",
"\n",
"\n",
"\n",
"#### OU\n",
"\n",
"Le OU est une autre porte à deux bits avec un seul bit de sortie. Il émet 1 si l *'un des* bits est à 1 :\n",
"\n",
"| Entrée | Sortie |\n",
"| :----- | -----: |\n",
"| 00 | 0 |\n",
"| 01 | 1 |\n",
"| 10 | 1 |\n",
"| 11 | 1 |\n",
"\n",
"\n",
"\n",
"#### OU X\n",
"\n",
"XOR signifie \"OU exclusif\" et ressemble à la porte OU, mais il produit 1 si *un seul* des bits d'entrée est à 1. Il produit 0 s'ils sont tous les deux 1 ou tous les deux 0 :\n",
"\n",
"| Entrée | Sortie |\n",
"| :----- | -----: |\n",
"| 00 | 0 |\n",
"| 01 | 1 |\n",
"| 10 | 1 |\n",
"| 11 | 0 |\n",
"\n",
"\n",
"\n",
"### Mesures :\n",
"\n",
"En général, lorsque l'on apprend l'informatique classique, on n'accorde pas beaucoup d'attention au processus de lecture de l'état des bits. En effet, il n'est pas très complexe d'un point de vue conceptuel. Vous pouvez mesurer les bits à tout moment avant, pendant ou après un calcul, et cela n'affecte pas le résultat. Ce n'est pas le cas de l'informatique quantique, comme nous le verrons plus loin.\n",
"\n",
"\n",
"\n",
"### Circuits :\n",
"\n",
"En combinant les portes ci-dessus, vous pouvez effectuer toutes les opérations que vous souhaitez sur un ordinateur. Prenons un exemple simple : En utilisant les portes AND et XOR, vous pouvez construire le circuit demi-ordre, qui calcule la somme de deux bits. Ceci est représenté dans un schéma de circuit logique, où les fils représentent les bits et les portes opérant sur les bits sont représentées par des symboles sur les fils correspondants :\n",
"\n",
"\n",
"\n",
"Les deux bits sont donc copiés et passent à la fois par une porte ET et une porte XOR. Le résultat de la porte XOR est le \"bit de somme\" (S), qui reste à la place des uns du nombre binaire, et le résultat de la porte AND est le \"bit de report\" (C), qui est la valeur du chiffre le plus significatif suivant dans le nombre binaire. Voici la table de vérité :\n",
"\n",
"| $A$ | $B$ | Somme ( $A \\oplus B$ ) | Portage ( $A \\wedge B$ ) |\n",
"| --- | --- | ---------------------- | ------------------------ |\n",
"| 0 | 0 | 0 | 0 |\n",
"| 0 | 1 | 1 | 0 |\n",
"| 1 | 0 | 1 | 0 |\n",
"| 1 | 1 | 0 | 1 |\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"Vérifiez que la table de vérité ci-dessus donne la solution correcte pour un circuit additionneur. Autrement dit, pour chacune des quatre options de A et B, vérifiez que $A+B=S+2 \\times C$.\n",
"\n",
"\n",
" \n",
" $$\n",
" \\begin{aligned}\n",
" 0+0 &= 0+0 = 0 ~\\checkmark \\\\\n",
" 0+1 &= 1+0 = 1 ~\\checkmark \\\\\n",
" 1+0 &= 1+0 = 1 ~\\checkmark \\\\\n",
" 1+1 &= 0+2 = 2 ~\\checkmark \\\\\n",
" \\end{aligned}\n",
" $$\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a324a959-5edc-4aaf-91ad-6bef9ab7c435",
"metadata": {},
"source": [
"\n",
"\n",
"## Ordinateurs quantiques\n",
"\n",
"\n",
"\n",
"### Bits $\\rightarrow$ qubits\n",
"\n",
"Tout comme les bits sont les unités fondamentales de l'information classique, les bits *quantiques*, ou \"qubits\", sont les unités fondamentales de l'information quantique. Comme le bit classique, l'état d'un qubit peut être soit 0, soit 1, ce que nous désignons généralement par $\\vert 0\\rangle$ et $\\vert 1\\rangle$. Mais contrairement au bit classique, un bit quantique peut également se trouver dans une *superposition* de l'état $\\vert 0\\rangle$ et de l'état $\\vert 1\\rangle$ en même temps. En général, un qubit peut être dans n'importe quel état $\\vert \\psi\\rangle$ de la forme :\n",
"\n",
"$$\n",
"\\vert \\psi\\rangle = c_0 \\vert 0\\rangle + c_1 \\vert 1\\rangle\n",
"$$\n",
"\n",
"où $c_0$ et $c_1$ sont des amplitudes complexes avec $\\vert c_0 \\vert ^2+\\vert c_1\\vert ^2=1$.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "11563bfb-93d4-4a6a-9bd9-b52665ab4517",
"metadata": {},
"source": [
"\n",
"\n",
"#### La phase quantique\n",
"\n",
"Comme $c_0$ et $c_1$ sont complexes, ils peuvent tous deux être écrits sous la forme $c_i = \\vert c_i\\vert e^{i\\phi_i}$, où $\\phi_i$ est appelé la *phase*. Si l'on multiplie l'ensemble de l'état par le même facteur de phase global, rien ne change physiquement - c'est ce que l'on appelle une phase globale, qui n'a aucune conséquence observable.\n",
"\n",
"C'est pourquoi il est conventionnel de \"factoriser\" $e^{i\\phi_0}$, en donnant :\n",
"\n",
"$\\vert \\psi\\rangle = \\vert c_0\\vert \\vert 0\\rangle + \\vert c_1\\vert e^{i\\phi}\\vert 1\\rangle$\n",
"\n",
"où $\\phi = \\phi_1-\\phi_0$ est la phase *relative* de l'état quantique, qui *a* des conséquences observables.\n",
"\n",
"Cette phase joue un rôle très important dans l'informatique quantique, et vous explorerez ses différentes conséquences dans les modules suivants de Qiskit in the Classroom.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "c35a8265-2d19-4743-99ac-39192e46f59a",
"metadata": {},
"source": [
"\n",
"\n",
"#### Qubits multiples\n",
"\n",
"Alors que l'état de plusieurs bits peut simplement être exprimé comme une chaîne de 0s et 1s, l'état de plusieurs qubits est un peu plus compliqué en raison des principes de *superposition* et d' *enchevêtrement*.\n",
"\n",
"Rappelons que $N$ bits peuvent se trouver dans l'un des $2^N$ états possibles, allant des nombres binaires 000...000 à 111...111. Mais aujourd'hui, grâce au principe de superposition, les *qubits du* site $N$ peuvent se trouver dans une superposition de *tous* ces états à la fois!\n",
"\n",
"Cela peut s'exprimer comme suit\n",
"\n",
"$$\n",
"\\psi_N = \\sum_{i=0}^{2^N-1} c_i \\vert i\\rangle\n",
"$$\n",
"\n",
"où, comme dans le cas classique, l'état $\\vert i\\rangle$ correspond à l'état dans lequel chaque qubit se trouve dans la bonne combinaison de 0s et 1s pour donner le nombre binaire $i$. C'est ce qu'on appelle les \"états de base de calcul\" du système quantique. Par exemple, un état à trois qubits peut être écrit comme une superposition de ses huit états de base de calcul :\n",
"\n",
"$$\n",
"\\psi_3 = c_0 \\vert 000\\rangle + c_1 \\vert 001\\rangle + c_2 \\vert 010\\rangle + c_3 \\vert 011\\rangle + c_4 \\vert 100\\rangle + c_5 \\vert 101\\rangle + c_6 \\vert 110\\rangle + c_7 \\vert 111\\rangle\n",
"$$\n",
"\n",
"Chaque qubit du système est désigné par un index allant de $0$ à $N-1$. La convention consiste à lire les états des qubits de droite à gauche, de sorte que l'état du qubit $0$ est l'état le plus à droite et l'état du qubit $N-1$ est le plus à gauche. C'est ce que l'on appelle la notation \"little-endian\", qui peut sembler contre-intuitive à première vue, puisque nous avons l'habitude de lire de gauche à droite.\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"À première vue, il peut sembler contre-intuitif d'ordonner les qubits de droite à gauche comme dans la notation little-endian, mais c'est en fait une chose très logique à faire! Expliquez pourquoi. (Rappelons notre discussion ci-dessus sur la conversion des nombres binaires en nombres base-10.)\n",
"\n",
"\n",
" \n",
" Si l'on ordonne les qubits de droite à gauche, de sorte que le qubit 0 soit le plus à droite et le qubit N-1 le plus à gauche, il est logique d'associer le qubit $0$ au bit de poids faible, qui est multiplié par $2^0$ et le qubit $N-1$ au bit de poids fort, qui est multiplié par $2^{N-1}$.\n",
" \n",
"\n",
"\n",
"\n",
"\n",
"#### Enchevêtrement\n",
"\n",
"Comme nous l'avons mentionné précédemment, une autre caractéristique clé des qubits est qu'ils peuvent être *enchevêtrés* les uns avec les autres. Prenons l'exemple d'un état à deux qubits, où $c_0 = c_3 = \\frac{1}{\\sqrt{2}}$ et $c_1 = c_2 = 0$ :\n",
"\n",
"$\\vert \\psi\\rangle = \\frac{1}{\\sqrt{2}}(\\vert 00\\rangle + \\vert 11\\rangle)$\n",
"\n",
"Ainsi, l'état du qubit 0 peut être $\\vert 0\\rangle$ ou $\\vert 1\\rangle$ avec la même probabilité, et il en va de même pour l'état du qubit 1. Mais ces probabilités ne sont plus indépendantes les unes des autres. Si nous constatons que l'état du qubit 0 est $\\vert 0\\rangle$, nous *savons que* le qubit 1 sera également $\\vert 0\\rangle$. Cela est vrai quelle que soit la distance qui sépare les deux qubits, c'est pourquoi la mesure d'un état intriqué est parfois qualifiée d'\"action magique à distance\"\n",
"\n",
"L'enchevêtrement peut également prendre d'autres formes. Par exemple, l'État\n",
"\n",
"$\\vert \\psi\\rangle = \\frac{1}{\\sqrt{2}}(\\vert 01\\rangle + \\vert 10\\rangle)$\n",
"\n",
"produit des résultats opposés à chaque fois : si un qubit est mesuré à l'adresse $\\vert 0\\rangle$, l'autre est garanti d'être trouvé dans l'état $\\vert 1\\rangle$.\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"L'état $\\vert \\psi\\rangle = \\vert 11\\rangle$ est-il enchevêtré? Pourquoi ?\n",
"\n",
"\n",
" \n",
" Il n'est pas enchevêtré. Si les résultats sont toujours les mêmes lorsque vous mesurez les deux qubits, c'est uniquement parce que chaque qubit est toujours fixé dans l'état $\\vert 1\\rangle$. Le résultat de la mesure d'un qubit ne dépend pas réellement de l'autre - les deux sont simplement toujours $\\vert 1\\rangle$.\n",
"\n",
" En général, si vous pouvez décrire l'état de chaque qubit séparément et les multiplier ensemble comme ceci :\n",
"\n",
" $\\vert \\psi\\rangle = \\vert \\psi_1\\rangle \\vert \\psi_0\\rangle $\n",
"\n",
" On parle alors d'« état produit » et il *n'est pas* intriqué.\n",
" \n",
"\n",
"\n",
"\n",
"\n",
"#### Notation vectorielle\n",
"\n",
"Il est souvent utile d'utiliser des vecteurs et des matrices pour voir comment l'état quantique se transforme sous l'effet de différentes opérations. Dans cette représentation, nos états quantiques seront des vecteurs, et nos portes quantiques (discutées dans la section suivante) seront des matrices qui transforment les vecteurs.\n",
"\n",
"Pour un qubit unique, la forme vectorielle des états est choisie comme suit : $\\vert 0\\rangle = \\begin{pmatrix}1 \\\\ 0\\end{pmatrix}$ $\\vert 1\\rangle = \\begin{pmatrix}0 \\\\ 1\\end{pmatrix}$ De cette manière, un état arbitraire $\\vert \\psi\\rangle = a\\vert 0\\rangle+b\\vert 1\\rangle$ peut être écrit comme suit $\\vert \\psi\\rangle =\\begin{pmatrix}a \\\\ b\\end{pmatrix}$\n",
"\n",
"Pour un état qubitaire général, $n$, nous aurons besoin d'un vecteur à $2^n$ dimensions, avec des états de base ordonnés, comme on peut s'y attendre, en valeurs binaires croissantes :\n",
"\n",
"$$\n",
"\\vert 0 \\dots 000\\rangle = \\begin{pmatrix}1 \\\\ 0 \\\\ 0 \\\\ \\vdots \\\\ 0\\end{pmatrix}, \\vert 0 \\dots 001 \\rangle = \\vert 1 \\dots 110\\rangle = \\begin{pmatrix}0 \\\\ \\vdots \\\\ 0 \\\\ 1 \\\\ 0\\end{pmatrix}, \\vert 1 \\dots 111 \\rangle = \\begin{pmatrix}0 \\\\ \\vdots \\\\ 0 \\\\ 0\\\\ 1\\end{pmatrix}\n",
"$$\n",
"\n",
"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.\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"Il existe quatre états de base de calcul pour un système à deux qubits. Écrivez chacun d'entre eux dans les notations ket et vectorielles.\n",
"\n",
"\n",
" \n",
" $$\n",
" \\vert 00\\rangle = \\begin{pmatrix}1 \\\\ 0 \\\\ 0 \\\\ 0\\end{pmatrix}, \\vert 01 \\rangle = \\begin{pmatrix}0 \\\\ 1 \\\\ 0 \\\\ 0\\end{pmatrix}, \\dots, \\vert 10\\rangle = \\begin{pmatrix}0 \\\\ 0 \\\\ 1 \\\\ 0\\end{pmatrix}, \\vert 11 \\rangle = \\begin{pmatrix}0 \\\\ 0 \\\\ 0\\\\ 1\\end{pmatrix}\n",
" $$\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "52f971a7-4a5e-4571-927b-23a642fae997",
"metadata": {},
"source": [
"\n",
"\n",
"## Portes $\\rightarrow$ portes quantiques\n",
"\n",
"Tout comme les portes classiques telles que NOT, AND, OR et XOR peuvent être combinées pour construire des circuits classiques arbitraires, les portes quantiques jouent le même rôle dans l'informatique quantique. Les qubits ayant des caractéristiques mécaniques quantiques supplémentaires, les portes quantiques sont d'autant plus riches. Bien que nous puissions encore décrire leur action sur la base des états $|0\\rangle$ et $|1\\rangle$ à l'aide d'une table de vérité, cela ne rend pas compte de l'ensemble de la situation. Pour les portes quantiques, il est souvent plus naturel d'utiliser une représentation matricielle, car elles agissent également sur des superpositions d'états de base.\n",
"\n",
"Nous présentons ci-dessous les portes quantiques les plus courantes et la manière dont elles transforment les qubits avec lesquels elles interagissent. Le cas échéant, nous les relierons à des portes classiques familières.\n",
"\n",
"\n",
"\n",
"### Portes à un seul qubit\n",
"\n",
"**$X$ porte** : C'est l'équivalent quantique d'une opération NOT. Sa table de vérité ressemble exactement à la porte NOT classique :\n",
"\n",
"| Entrée | Sortie |\n",
"| :--------------- | ---------------: |\n",
"| $\\vert 0\\rangle$ | $\\vert 1\\rangle$ |\n",
"| $\\vert 1\\rangle$ | $\\vert 0\\rangle$ |\n",
"\n",
"Et la représentation matricielle :\n",
"\n",
"$X=\\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix}$\n",
"\n",
"Dans Qiskit, la création d'un circuit avec une porte $X$ ressemble à ceci :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "6c215e46-26cb-4e10-a1d7-2eecd2c18294",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"qc = QuantumCircuit(1)\n",
"qc.x(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "3a59abe3-5e75-4ff1-9f5e-9b24fd5c5ea0",
"metadata": {},
"source": [
"Dans ce schéma très simple, le qubit est représenté par un fil, la ligne horizontale noire, et la porte est représentée par une boîte sur ce fil.\n",
"\n",
"**Porte de Hadamard :** Crée un état de superposition. Table de vérité :\n",
"\n",
"| Entrée | Sortie |\n",
"| :--------------- | -------------------------------------------------------------: |\n",
"| $\\vert 0\\rangle$ | $\\frac{1}{\\sqrt{2}}\\left(\\vert 0\\rangle+\\vert 1\\rangle\\right)$ |\n",
"| $\\vert 1\\rangle$ | $\\frac{1}{\\sqrt{2}}\\left(\\vert 0\\rangle-\\vert 1\\rangle\\right)$ |\n",
"\n",
"Représentation matricielle : $H=\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix}$\n",
"\n",
"Un circuit avec une porte de Hadamard est réalisé comme suit :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "1a009015-4ced-47e4-a18d-d0685e4cab47",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"qc = QuantumCircuit(1)\n",
"qc.h(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "9de7658f-e456-4788-81bb-6900c12ef054",
"metadata": {},
"source": [
"**$Z$ porte** : Ajoute un déphasage de $\\Delta \\phi = \\pi$ à l'état $|1\\rangle$ :\n",
"\n",
"| Entrée | Sortie |\n",
"| :--------------- | ----------------: |\n",
"| $\\vert 0\\rangle$ | $\\vert 0\\rangle$ |\n",
"| $\\vert 1\\rangle$ | $-\\vert 1\\rangle$ |\n",
"\n",
"$Z=\\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix}$\n",
"\n",
"Dans Qiskit, la création d'un circuit avec une porte $Z$ ressemble à ceci :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "7bca3c98-884b-4709-bbe8-a9e16cc45698",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(1)\n",
"qc.z(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "c9ee10a5-5f69-4db4-87e9-bc1d3cd051eb",
"metadata": {},
"source": [
"**$T$ porte** : Ajoute un déphasage de $\\Delta \\phi = \\pi/4$ à l'état $|1\\rangle$ :\n",
"\n",
"| Entrée | Sortie |\n",
"| :--------------- | -------------------------: |\n",
"| $\\vert 0\\rangle$ | $\\vert 0\\rangle$ |\n",
"| $\\vert 1\\rangle$ | $e^{i\\pi/4}\\vert 1\\rangle$ |\n",
"\n",
"$T=\\begin{pmatrix} 1 & 0 \\\\ 0 & e^{i\\pi/4} \\end{pmatrix}$\n",
"\n",
"Dans Qiskit, la création d'un circuit avec une porte $T$ ressemble à ceci :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "ac699059-6be5-4a1a-89cb-97b7af412ab8",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(1)\n",
"qc.t(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "52b43ac8-be21-4652-a139-7093fe27fd69",
"metadata": {},
"source": [
"\n",
"\n",
"### Portes multi-qubits\n",
"\n",
"Les portes à deux qubits peuvent ressembler à des portes classiques à deux bits, mais avec une réserve importante : toutes les portes quantiques doivent être réversibles. En termes d'algèbre linéaire, cela signifie qu'ils sont représentés par des matrices unitaires. Ainsi, deux qubits d'entrée correspondent toujours à deux qubits de sortie, et l'opération peut, en principe, être annulée. Cela contraste avec les portes classiques que nous avons vues plus haut, telles que AND ou OR, qui perdent de l'information et sont irréversibles - étant donné une sortie, vous ne pouvez pas déterminer l'entrée de manière unique.\n",
"\n",
"**Porte CNOT (Controlled-NOT) :** Les deux qubits d'entrée sont appelés qubits de contrôle et qubits cibles. Le qubit de contrôle reste inchangé, mais son état détermine ce qui arrive au qubit cible. Si le qubit de contrôle est dans l'état $\\vert 1\\rangle$, une porte $X$ est appliquée à cette cible; si l'état du qubit de contrôle est $\\vert 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})\\vert BA\\rangle.$\n",
"\n",
"$CNOT(A,B)\\vert BA\\rangle_{input} = \\vert BA\\rangle_{output}$\n",
"\n",
"| Entrée | Sortie |\n",
"| :---------------- | ----------------: |\n",
"| $\\vert 00\\rangle$ | $\\vert 00\\rangle$ |\n",
"| $\\vert 01\\rangle$ | $\\vert 11\\rangle$ |\n",
"| $\\vert 10\\rangle$ | $\\vert 10\\rangle$ |\n",
"| $\\vert 11\\rangle$ | $\\vert 01\\rangle$ |\n",
"\n",
"La matrice représentant cette action est donc la suivante :\n",
"\n",
"$CNOT=\\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0\\end{pmatrix}$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "1c4dc48d-3d2b-4b4b-b405-c93504815ba9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(2)\n",
"qc.cx(0, 1)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "be45af7b-a148-4b46-8379-3ac9658f50a9",
"metadata": {},
"source": [
"C'est le premier schéma de circuit que nous voyons avec deux qubits, qui sont représentés par les deux fils. La porte CNOT est mise en œuvre entre les deux qubits, avec $q_0$ comme contrôle et $q_1$ comme cible.\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"La plupart des portes ont la même forme matricielle à Qiskit que partout ailleurs. Mais la porte CNOT agit sur deux qubits, et les conventions d'ordonnancement des qubits deviennent alors un problème. Les textes qui ordonnent les qubits $\\vert q_0,q_1,...\\rangle$ présenteront une forme matricielle différente pour leurs portes CNOT. Vérifier par multiplication matricielle explicite que la matrice CNOT ci-dessus a l'action correcte sur l'état $\\vert 01\\rangle.$\n",
"\n",
"\n",
" \n",
" $CNOT\\vert 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} = \\vert 11\\rangle$\n",
" \n",
"\n",
"\n",
"**Porte SWAP :** Cette porte permute les états de deux qubits. Table de vérité :\n",
"\n",
"| Entrée | Sortie |\n",
"| :---------------- | ----------------: |\n",
"| $\\vert 00\\rangle$ | $\\vert 00\\rangle$ |\n",
"| $\\vert 01\\rangle$ | $\\vert 10\\rangle$ |\n",
"| $\\vert 10\\rangle$ | $\\vert 01\\rangle$ |\n",
"| $\\vert 11\\rangle$ | $\\vert 11\\rangle$ |\n",
"\n",
"La matrice représentant cette action est donc la suivante :\n",
"\n",
"$SWAP=\\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1\\end{pmatrix}$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "118da691-4208-4248-a21f-a5e22815dc2c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(2)\n",
"qc.swap(0, 1)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "78199ae4-93e4-49a2-948a-f41a22187bae",
"metadata": {},
"source": [
"La porte SWAP peut en fait être construite à partir de trois CNOT. Pour voir comment, nous pouvons `decompose()` la porte avec Qiskit :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "5efa09b9-b3e4-43fb-81f3-c33283a992d2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(2)\n",
"qc.swap(0, 1)\n",
"qc.decompose().draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "330362e5-f040-426f-a6d9-d730c917c7f2",
"metadata": {},
"source": [
"Nous voyons ici pour la première fois comment plusieurs portes sont représentées dans un schéma de circuit. Nous le lisons de gauche à droite, de sorte que la porte la plus à gauche est appliquée en premier.\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"Vérifier que la combinaison des CNOT ci-dessus aboutit à une porte SWAP. Vous pouvez le faire avec la multiplication matricielle ou toute autre méthode.\n",
"\n",
"\n",
" \n",
" Avec la multiplication matricielle :\n",
"\n",
" $\\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0\\end{pmatrix} \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0\\end{pmatrix} \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0\\end{pmatrix} = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1\\end{pmatrix} = SWAP ~\\checkmark$\n",
"\n",
" Utiliser une table de vérité pour voir comment les états changent avec chaque CNOT. Dans la dernière colonne, les états doivent être équivalents à la colonne \"sortie\" de la table de vérité SWAP :\n",
"\n",
" | Entrée | CNOT(A,B) | CNOT(B,A) | CNOT(A,B) |\n",
" | :---------------- | :---------------: | :---------------: | ---------------------------: |\n",
" | $\\vert 00\\rangle$ | $\\vert 00\\rangle$ | $\\vert 00\\rangle$ | $\\vert 00\\rangle \\checkmark$ |\n",
" | $\\vert 01\\rangle$ | $\\vert 11\\rangle$ | $\\vert 10\\rangle$ | $\\vert 10\\rangle \\checkmark$ |\n",
" | $\\vert 10\\rangle$ | $\\vert 10\\rangle$ | $\\vert 11\\rangle$ | $\\vert 01\\rangle \\checkmark$ |\n",
" | $\\vert 11\\rangle$ | $\\vert 01\\rangle$ | $\\vert 01\\rangle$ | $\\vert 11\\rangle \\checkmark$ |\n",
" \n",
"\n",
"\n",
"**Porte de Toffoli (ou \"contrôlé-contrôlé-NOT\" (CCNOT)) :** Il s'agit d'une porte à *trois qubits*. Le nom \"contrôlé-contrôlé-NOT\" peut déjà vous indiquer comment il fonctionne : il y a deux qubits de contrôle et un qubit cible, et l'état du qubit cible n'est inversé que si *les deux* qubits de contrôle sont dans l'état $\\vert 1\\rangle$. Nous conservons la convention d'ordre que nous avons utilisée avec le CNOT :\n",
"\n",
"$$\n",
"CCNOT(Control A, Control B, Target C)\\vert CBA\\rangle\n",
"$$\n",
"\n",
"La table de vérité est donc la suivante :\n",
"\n",
"| Entrée | Sortie |\n",
"| :----------------- | -----------------: |\n",
"| $\\vert 000\\rangle$ | $\\vert 000\\rangle$ |\n",
"| $\\vert 001\\rangle$ | $\\vert 001\\rangle$ |\n",
"| $\\vert 010\\rangle$ | $\\vert 010\\rangle$ |\n",
"| $\\vert 011\\rangle$ | $\\vert 111\\rangle$ |\n",
"| $\\vert 100\\rangle$ | $\\vert 100\\rangle$ |\n",
"| $\\vert 101\\rangle$ | $\\vert 101\\rangle$ |\n",
"| $\\vert 110\\rangle$ | $\\vert 110\\rangle$ |\n",
"| $\\vert 111\\rangle$ | $\\vert 011\\rangle$ |\n",
"\n",
"Et la matrice représentant cette action est :\n",
"\n",
"$$\n",
"CCNOT=\\begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\\\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\\\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\end{pmatrix}\n",
"$$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "d1829257-b7a4-49d9-8ac2-3d6230165427",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(3)\n",
"qc.ccx(0, 1, 2)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "aa2e83e5-1197-473c-9f16-4c264b08aca0",
"metadata": {},
"source": [
"La porte de Toffoli peut elle aussi être décomposée en CNOT, de même que d'autres portes. Cependant, elle est beaucoup plus compliquée que la décomposition de la porte SWAP, c'est pourquoi l'exploration et la vérification de cette décomposition feront l'objet d'un exercice facultatif à la fin du module.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "970302ee-eccc-48eb-b255-4a2d7bc8fbbc",
"metadata": {},
"source": [
"\n",
"\n",
"## Mesures\n",
"\n",
"Les mesures jouent un rôle particulier dans l'informatique quantique, qui n'a pas d'analogue dans l'informatique classique. Alors qu'en informatique classique, vous pouvez vérifier vos bits à n'importe quel moment de votre choix au cours d'un algorithme, en informatique quantique, vous devez être très sélectif quant au moment où vous regardez vos qubits, car la mesure effondre leur état et détruit la superposition qui confère aux qubits leur complexité de calcul.\n",
"\n",
"En particulier, étant donné un état quantique $N$ -bit $\\vert \\psi\\rangle = \\sum_{i=0}^{2^N-1} c_i \\vert i\\rangle$, une mesure réduira l'état à l'une des fonctions de base $\\vert i\\rangle$ avec une probabilité égale à $\\vert c_i\\vert ^2$.\n",
"\n",
"Mais cet effet destructeur d'une mesure n'est pas toujours un obstacle. Il s'agit en fait d'une ressource clé dans certains algorithmes et protocoles, tels que la [téléportation quantique](/learning/modules/computer-science/quantum-teleportation) et la [distribution quantique de clés](/learning/modules/computer-science/quantum-key-distribution).\n",
"\n",
"Dans Qiskit, lorsqu'une mesure est effectuée, elle est envoyée à un registre classique où elle est stockée sous la forme d'un bit classique. La création d'un circuit avec une mesure se présente comme suit :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "56dfec5d-556b-486d-9cbf-0700582ec25c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(\n",
" 1, 1\n",
") # the second number is the number of classical bits in the circuit\n",
"qc.measure(0, 0)\n",
"qc.draw(\"mpl\")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "45a53043-fdc8-4df2-b2c8-8b12ded1f400",
"metadata": {},
"source": [
"\n",
"\n",
"## Circuits\n",
"\n",
"Maintenant que nous savons comment fonctionnent les qubits, les portes et les mesures, fabriquons et exécutons notre propre circuit quantique! Pour ce faire, nous allons vous présenter un flux de travail utile appelé Qiskit patterns.\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "a5adf2d9-4de5-4978-b509-05fb7381f238",
"metadata": {},
"source": [
"\n",
"\n",
"### Cadre de modèles Qiskit\n",
"\n",
"Le cadre des modèles Qiskit est une procédure générale permettant d'aborder et de résoudre des problèmes avec un ordinateur quantique. Il se compose de quatre étapes :\n",
"\n",
"1. **Cartographier** notre problème à l'aide de circuits et d'opérateurs quantiques\n",
"2. **Optimisation du** circuit pour le matériel cible\n",
"3. **Exécution** sur le matériel cible\n",
"4. **Post-traitement des** résultats\n",
"\n",
"Pour illustrer ces étapes, nous allons mettre en œuvre une version *quantique* du circuit demi-additionnel présenté ci-dessus.\n",
"\n",
"\n",
"\n",
"#### 1. Cartographie\n",
"\n",
"Le circuit additionneur classique utilise une porte XOR et une porte AND pour calculer les bits de somme et de retenue, respectivement. Nous pouvons adapter ces portes au contexte quantique pour réaliser le demi-additionneur quantique. Tout d'abord, si l'on se souvient que les portes quantiques sont *réversibles*, on ne peut pas simplement écraser les entrées. Au lieu de cela, nous introduisons deux qubits auxiliaires initialisés à $\\vert 0\\rangle$ pour stocker les résultats de la somme et de la retenue. Ainsi, notre état quantique complet sera constitué des qubits $A$ et $B$, ainsi que des qubits de somme et de report, que nous appellerons $S$ et $C$ :\n",
"\n",
"$\\vert \\psi\\rangle = \\vert C S B A\\rangle$\n",
"\n",
"Il nous faut maintenant des portes quantiques qui accomplissent ce que les portes XOR et AND faisaient dans le circuit classique.\n",
"\n",
"**Somme :**\n",
"\n",
"Pour le XOR, nous appliquons deux CNOT, chacun avec les qubits de contrôle $A$ et $B$ et le qubit cible $S$ pour les deux. Si $A$ et $B$ sont différents, l'une des portes CNOT fera basculer $S$ dans l'état $\\vert 1\\rangle$. Si $A$ et $B$ sont tous deux $\\vert 0\\rangle$, rien n'arrive à $S$ et il reste dans l'état $\\vert 0\\rangle$. Si $A$ et $B$ sont tous deux $\\vert 1\\rangle$, l'état de $S$ sera inversé deux fois, ce qui le ramènera à l'état $\\vert 0\\rangle$.\n",
"\n",
"**Porter :**\n",
"\n",
"Pour le bit de report, nous avons besoin de quelque chose qui fonctionne comme une porte ET classique.\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"Reprenez les portes que nous avons étudiées et essayez de deviner quelle porte quantique nous utiliserons à la place de la porte ET classique :\n",
"\n",
"\n",
" \n",
" C'est la porte Toffoli! Rappelons que la porte de Toffoli, ou porte contrôlé-contrôlé-NOT, inverse l'état de la cible si et seulement si le qubit de contrôle 0 ET le qubit de contrôle 1 sont tous les deux $\\vert 1\\rangle$. Ainsi, si le qubit cible commence dans l'état $\\vert 0\\rangle$, il a la même action que la porte ET.\n",
" \n",
"\n",
"\n",
"Nous disposons maintenant de tous les ingrédients nécessaires à la réalisation du circuit quantique :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "0bf14732-29fb-41c7-a4b3-94bd276ebc33",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# qubits: a, b, sum, carry\n",
"qc = QuantumCircuit(4)\n",
"\n",
"# Choose values for A and B:\n",
"a = 0\n",
"b = 0\n",
"\n",
"# Prepare A and B qubits according to selected values:\n",
"if a:\n",
" qc.x(0)\n",
"if b:\n",
" qc.x(1)\n",
"\n",
"# XOR (sum) into qubit 2\n",
"qc.cx(0, 2)\n",
"qc.cx(1, 2)\n",
"\n",
"# AND (carry) into qubit 3\n",
"qc.ccx(0, 1, 3) # a AND b\n",
"\n",
"# measure\n",
"qc.measure_all()\n",
"\n",
"\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "cd129de5-0b73-44db-97ea-f819184e3661",
"metadata": {},
"source": [
"Ci-dessus figure le schéma du circuit demi-additionneur quantique. Comme indiqué précédemment, les fils représentent les qubits $0$ à $3$ ordonnés de haut en bas, et le registre de bits classique est le fil à double ligne du bas. Ensuite, en lisant de gauche à droite, nous voyons comment les portes sont appliquées à chaque qubit en observant où les cases apparaissent sur les fils correspondants. Enfin, les mesures sont indiquées à la fin. Les mesures réduisent les états des qubits à des valeurs définies $0$ ou $1$, et les résultats sont envoyés à un registre classique.\n",
"\n",
"Une subtilité : bien que le schéma soit dessiné de gauche à droite, l'expression matricielle correspondante doit être lue de droite à gauche. En effet, dans la multiplication matricielle, l'opérateur le plus proche du vecteur d'état agit en premier. Ainsi, par exemple, le circuit ci-dessus (sans tenir compte des mesures) s'écrirait comme suit :\n",
"\n",
"$$\n",
"CCNOT(q_0,q_1,q_3)CNOT(q_1, q_2)CNOT(q_0,q_2)\\vert q_3 q_2 q_1 q_0\\rangle\n",
"$$\n",
"\n",
"\n",
"\n",
"#### 2. Optimisation :\n",
"\n",
"Ensuite, nous devons optimiser le circuit pour qu'il fonctionne sur le matériel quantique. Cette optimisation est réalisée par le transpileur, qui traduit le circuit abstrait présenté ci-dessus en instructions compréhensibles par l'ordinateur quantique. Il assigne les qubits logiques ci-dessus à des qubits physiques réels sur le processeur et réécrit les portes en fonction de son propre ensemble de portes optimisées pour fonctionner sur l'ordinateur quantique. Enfin, le transpileur met également en œuvre ce que l'on appelle la \"suppression et l'atténuation des erreurs\" pour tenter de minimiser l'effet des erreurs sur le résultat. Cela n'est pas très important pour notre circuit très simple, mais si vous poursuivez votre voyage dans l'informatique quantique en exécutant des circuits plus compliqués, vous verrez rapidement la valeur de la suppression et de l'atténuation des erreurs. Pour en savoir plus, consultez le cours d'Olivia Lane, Quantum [Computing in Practice (L'informatique quantique en pratique)](/learning/courses/quantum-computing-in-practice/introduction).\n",
"\n",
"Tout d'abord, nous chargeons les paquets nécessaires pour communiquer avec les ordinateurs quantiques IBM® et nous sélectionnons un backend pour l'exécuter. Nous pouvons soit choisir le backend le moins occupé, soit sélectionner un backend spécifique dont nous connaissons les propriétés.\n",
"\n",
"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](/docs/guides/cloud-setup) et [Initialiser le service dans un environnement non fiable](/docs/guides/cloud-setup-untrusted) pour plus d'informations.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bdc5e025-8bf4-4fbc-af80-4404e2577511",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ibm_fez\n"
]
}
],
"source": [
"# Load IBM Quantum Compute Service\n",
"from qiskit_ibm_runtime import QiskitRuntimeService\n",
"\n",
"# Load IBM Quantum Compute Service\n",
"\n",
"# Syntax for first saving your token. Delete these lines after saving your credentials.\n",
"# QiskitRuntimeService.save_account(channel='ibm_quantum_platform',\n",
"# instance = '', token='', overwrite=True, set_as_default=True)\n",
"# service = QiskitRuntimeService(channel='ibm_quantum_platform')\n",
"\n",
"# Load saved credentials\n",
"service = QiskitRuntimeService()\n",
"\n",
"# Use the least busy backend, or uncomment the loading of a specific backend like \"ibm_brisbane\".\n",
"backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)\n",
"# backend = service.backend(\"ibm_brisbane\")\n",
"print(backend.name)"
]
},
{
"cell_type": "markdown",
"id": "4b4fb4cb-7e4a-47f4-a5d5-803b2d513a61",
"metadata": {},
"source": [
"Nous utilisons maintenant le transpileur pour optimiser le circuit. Nous pouvons choisir le niveau d'optimisation de 0 (aucune optimisation) à 3 (optimisation maximale). Pour savoir ce qu'implique chaque niveau, consultez le guide des [niveaux d'optimisation de Set transpiler](/docs/guides/set-optimization). Le circuit qui en résultera sera sensiblement différent du circuit logique que nous avons créé lors de notre étape de mise en correspondance.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "ad106853-7416-4fb9-b8e3-c43bb81c9059",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Transpile the circuit and optimize for running on the quantum computer selected\n",
"# Step 2: Transpile\n",
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)\n",
"\n",
"qc_isa.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "d9c345cf-9a25-4b6f-a5ec-62a6cefe3f27",
"metadata": {},
"source": [
"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 » :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "13a3faee-256d-4038-b0bf-ef1100139a96",
"metadata": {},
"outputs": [],
"source": [
"# Load the IBM Quantum primitive and session\n",
"from qiskit_ibm_runtime import SamplerV2 as Sampler\n",
"\n",
"sampler = Sampler(mode=backend)"
]
},
{
"cell_type": "markdown",
"id": "3d392a16-51ae-4367-8b75-4abf520f6474",
"metadata": {},
"source": [
"Si vous avez épuisé le temps qui vous était imparti sur des ordinateurs quantiques réels ou si vous n'avez pas de connexion internet, vous pouvez préférer utiliser un simulateur. Pour ce faire, exécutez la cellule ci-dessous et décompressez la ligne associée dans l'étape \"Exécuter\".\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "bcc1cab6-73db-4c8e-96b6-af7137ab6bd1",
"metadata": {},
"outputs": [],
"source": [
"# Load the backend sampler\n",
"from qiskit.primitives import BackendSamplerV2\n",
"\n",
"# Load the Aer simulator and generate a noise model based on the currently-selected backend.\n",
"from qiskit_aer import AerSimulator\n",
"from qiskit_aer.noise import NoiseModel\n",
"\n",
"noise_model = NoiseModel.from_backend(backend)\n",
"\n",
"# Define a simulator using Aer, and use it in Sampler.\n",
"backend_sim = AerSimulator(noise_model=noise_model)\n",
"sampler_sim = BackendSamplerV2(backend=backend_sim)\n",
"\n",
"# Alternatively, load a fake backend with generic properties and define a simulator.\n",
"# backend_gen = GenericBackendV2(num_qubits=18)\n",
"# sampler_gen = BackendSamplerV2(backend=backend_gen)"
]
},
{
"cell_type": "markdown",
"id": "6112fb67-3f51-4532-bb30-331b687cb43d",
"metadata": {},
"source": [
"\n",
"\n",
"#### 3. Exécution\n",
"\n",
"Après avoir préparé le circuit, nous pouvons maintenant le faire fonctionner sur l'ordinateur quantique!\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "0609b820-bb46-4a00-b33b-813ce8843ae1",
"metadata": {},
"outputs": [],
"source": [
"job = sampler.run([qc_isa], shots=100)\n",
"# job = sampler_sim.run([qc_isa]) # uncomment if you want to run on a simulator\n",
"res = job.result()\n",
"counts = res[0].data.meas.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "fea26bd9-84c9-402f-bd7e-785754993af9",
"metadata": {},
"source": [
"\n",
"\n",
"#### 4. Post-traitement\n",
"\n",
"Nous sommes maintenant prêts à consulter nos résultats! Nous afficherons un histogramme des 100 échantillons du circuit.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "a4efc93d-ed2e-406f-b335-deeaa661c55b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"counts = {'0000': 90, '0100': 4, '1100': 3, '0010': 3}\n"
]
},
{
"data": {
"text/plain": [
""
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.visualization import plot_histogram\n",
"\n",
"print(\"counts = \", counts)\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "c228359b-7022-426a-ae7f-3599efb2231e",
"metadata": {},
"source": [
"L'histogramme ci-dessus montre les résultats des mesures des quatre qubits à la fin du circuit. Un ordinateur quantique idéal sans bruit aurait mesuré les qubits pour qu'ils aient les mêmes valeurs à chaque fois, mais en réalité, le bruit provoquera des erreurs lors de certains passages.\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"En utilisant la chaîne de bits ayant le plus grand nombre de comptes comme valeurs pour $A$, $B$, $S$, et $C$, vérifiez que le circuit de l'additionneur quantique a fonctionné.\n",
"\n",
"\n",
" \n",
" Nous devons vérifier que $A+B = S+2 \\times C$. Rappelez-vous que l'ordre de la chaîne de bits suit la notation little-endian, et qu'elle est donc lue `CSBA`.\n",
"\n",
" L'histogramme ci-dessus montre que la chaîne de bits `0000` est dominante.\n",
"\n",
" $0 + 0 = 0 + 0 \\times 2 = 0 ~\\checkmark$\n",
" \n",
"\n",
"\n",
"Revenez en arrière et changez les valeurs de $A$ et $B$ en $A=1$ et $B=1$ et suivez à nouveau les étapes des modèles Qiskit pour réexécuter le circuit. Vérifiez que le circuit de l'additionneur fonctionne à nouveau.\n",
"\n",
"\n",
" \n",
" Vous devriez obtenir un histogramme dont la chaîne de bits dominante est `1011`:\n",
"\n",
" $1 + 1 = 0 + 1 \\times 2 = 2 ~\\checkmark$\n",
" \n",
"\n",
"\n",
"L'une des caractéristiques supplémentaires du demi-additionneur *quantique* par rapport au demi-additionneur classique est qu'il peut fonctionner avec des entrées *quantiques*. En d'autres termes, il peut \"ajouter\" les qubits $A$ et $B$ même s'ils sont dans des états de superposition. Dans la section Questions du défi ci-dessous, il vous sera demandé de préparer les qubits dans des superpositions et de voir ce qui se passe!\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ca1d1257-d741-4f46-908b-73cef6bc8fc7",
"metadata": {},
"source": [
"\n",
"\n",
"## Conclusion\n",
"\n",
"Ce module a été conçu pour vous donner une solide compréhension des principes de base de l'informatique quantique en la comparant à l'informatique classique. Nous avons étudié le circuit classique à demi-addition et nous avons montré comment adapter le circuit pour qu'il fonctionne avec des qubits sur un ordinateur quantique. Vous êtes maintenant prêt à explorer les autres modules de Qiskit dans la salle de classe!\n",
"\n",
"\n",
"\n",
"### Concepts essentiels :\n",
"\n",
"* Contrairement aux bits classiques qui ne peuvent prendre que les valeurs 0 et 1, les qubits peuvent également se trouver dans des états de **superposition** de 0 et de 1.\n",
"* Plusieurs qubits peuvent être en superposition sur les chaînes de bits classiquement autorisées, appelées **états de base de calcul.**\n",
"* Plusieurs qubits peuvent être **intriqués** de sorte que l'état de l'un dépende de l'état de l'autre.\n",
"* La convention Qiskit consiste à utiliser la **notation little-endian**, qui place le qubit le moins significatif, $q_0$, dans la position la plus à droite et le qubit le plus significatif, $q_N$, dans la position la plus à gauche.\n",
"* Les **portes quantiques** sont des opérations réversibles représentées par des matrices unitaires qui agissent sur les vecteurs d'état quantique. Dans cette notation, la matrice la plus proche du vecteur (qui est la plus à droite) agit en premier.\n",
"* **Les mesures** effondrent un état de superposition quantique dans l'un de ses états autorisés classiquement, avec une probabilité égale au carré de l'amplitude de l'état de base de calcul correspondant dans la superposition.\n",
"* Les circuits quantiques sont souvent représentés à l'aide de **schémas de circuits quantiques**, où les qubits sont représentés par des fils horizontaux et les portes quantiques apparaissent le long de ces fils, de gauche à droite.\n",
"* Pour exécuter un circuit quantique, nous utilisons les quatre étapes du flux de travail des **modèles Qiskit** : **Map**, **Optimize**, **Execute**, **Post-process**.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "34ccee8d-e9cc-45eb-ab30-8e8160ec9a5b",
"metadata": {},
"source": [
"\n",
"\n",
"## Questions\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "37265ba8-dc01-4aae-941f-6e051c62d7cc",
"metadata": {},
"source": [
"\n",
"\n",
"### Questions vrai/faux\n",
"\n",
"1. Dans un ordinateur classique, un bit ne peut contenir que la valeur 0 ou 1.\n",
"\n",
"2. L'intrication signifie que l'état d'un qubit est indépendant de l'état d'un autre.\n",
"\n",
"3. Les portes quantiques sont généralement des opérations irréversibles.\n",
"\n",
"4. La convention Qiskit place le qubit le moins significatif, $q_0$, à la position la plus à gauche.\n",
"\n",
"5. La mesure d'un état quantique donne toujours exactement le même résultat si elle est répétée plusieurs fois.\n",
"\n",
"6. La porte de Hadamard crée une superposition dans un seul qubit.\n",
"\n",
"7. Les circuits quantiques peuvent inclure des opérations de mesure qui réduisent l'état de superposition à l'un des états classiquement autorisés.\n",
"\n",
"8. Le nombre d'états classiques possibles pour $N$ bits est $2N$.\n",
"\n",
"9. Les probabilités de résultat des mesures quantiques sont données par le carré des amplitudes des états de base classiquement mesurables.\n",
"\n",
"\n",
"\n",
"### Questions à réponse courte\n",
"\n",
"1. Quelles sont les principales différences entre un bit et un qubit?\n",
"\n",
"2. Qu'arrive-t-il à un état quantique lorsqu'il est mesuré?\n",
"\n",
"3. Pourquoi utilise-t-on la notation little-endian dans Qiskit?\n",
"\n",
"4. Quelles sont les quatre étapes du flux de travail des modèles Qiskit?\n",
"\n",
"\n",
"\n",
"### Questions de défi :\n",
"\n",
"1. Dans le module, nous n'avons utilisé l'additionneur que pour ajouter des états classiquement autorisés pour $A$ et $B$. Mais nous pouvons aussi préparer $A$ et $B$ en superpositions! Modifiez le code pour préparer chaque qubit dans une superposition égale de 0 et de 1, puis exécutez le nouveau circuit et obtenez un nouvel histogramme. Que voyez-vous? Expliquez ce qui se passe.\n",
"\n",
"2. Décomposition de la porte de Toffoli. Utilisez `decompose()` pour montrer comment la porte de Toffoli est décomposée en portes à un et deux qubits, puis vérifiez cette construction à l'aide de la multiplication de matrices. N'oubliez pas que si les schémas de circuits se lisent de gauche à droite, les matrices s'appliquent aux états quantiques de droite à gauche!\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"in_page_toc_max_heading_level": 2,
"in_page_toc_min_heading_level": 2,
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 5
}