{
"cells": [
{
"cell_type": "markdown",
"id": "4046fd82",
"metadata": {},
"source": [
"---\n",
"title: \"Superposition avec Qiskit\"\n",
"description: \"Découvrez la superposition et son importance pour les mesures effectuées sur les ordinateurs quantiques.\"\n",
"---\n",
"\n",
"{/* cspell:ignore nflips fliplist qcoin squareroot qnot qsqrtnot qphase qhadamard */}\n",
"\n",
"\n",
"\n",
"# Quantum Coins — un module sur la superposition et l'interférence\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "bc3346f6",
"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é 47 secondes de temps QPU. Il s'agit uniquement d'une estimation. L'utilisation réelle peut varier.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3cf87503",
"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": "fba0059c-4008-4076-95f2-18dab949ca9e",
"metadata": {},
"source": [
"Regardez la présentation du module par le Dr. Katie McCormick ci-dessous, ou cliquez [ici](https://www.youtube.com/watch?v=TZ-sUHK8vVQ\\&list=PLOFEBzvs-Vvrs2fuvsuT039ariYPsua3d\\&index=6) pour la regarder sur YouTube.\n",
"\n",
"***\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "8ef56d8f-1358-4c3e-b1be-f56597a5ee89",
"metadata": {
"jp-MarkdownHeadingCollapsed": true
},
"source": [
"\n",
"\n",
"## Présentation\n",
"\n",
"Dans ce module, nous explorerons l'un des principes fondamentaux au cœur de la théorie quantique : la superposition. Dans notre expérience quotidienne, les objets présentent toujours des caractéristiques précises. Leur emplacement, leur taille, leur forme, leur couleur - tout ce qui les concerne - est déterminé et certain, même si nous, observateurs, ne les avons pas encore mesurés. Dans le monde quantique, ce n'est pas nécessairement le cas. Un objet quantique peut se trouver dans ce que l'on appelle une \"superposition\" de plusieurs états classiquement autorisés. Lorsque la superposition est mesurée, elle s'effondre aléatoirement dans l'un de ces états.\n",
"\n",
"D'une certaine manière, mesurer un état de superposition revient à tirer à pile ou face : il n'y a aucun moyen de savoir à l'avance de quel côté la pièce va tomber. Cet indéterminisme fondamental est un aspect inconfortable de la mécanique quantique que même Einstein a eu du mal à accepter. Il a prononcé la célèbre phrase \"Dieu ne joue pas aux dés\" à propos de ce caractère aléatoire. Mais, comme nous le verrons, Dieu joue aux dés - et à pile ou face.\n",
"\n",
"Nous allons considérer le jeu de pile ou face classique comme une analogie avec la mesure d'un état de superposition. En jouant avec une \"pièce de monnaie quantique\" à l'aide de Qiskit et d'un qubit sur un processeur quantique IBM®, nous découvrirons rapidement les limites de cette analogie.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "bcf4cb9b-7e3a-49f0-9d0d-756fb42eaae3",
"metadata": {},
"source": [
"\n",
"\n",
"### Pièce classique\n",
"\n",
"Commençons par une pièce de monnaie classique. Lancez une pièce et elle tombera soit sur pile, soit sur face, avec 50 $~$ % de chances dans chaque cas. En *principe*, on pourrait calculer le côté sur lequel la pièce tombera si l'on connaissait les conditions initiales précises de la pièce et la force/le couple du retournement, mais en *pratique*, il n'y a aucun moyen de savoir a priori sur quel côté la pièce tombera. C'est pourquoi nous utilisons le jeu de pile ou face comme exemple canonique d'un *état probabiliste classique*, où le résultat est essentiellement aléatoire. Nous pouvons écrire l'état de la pièce avant qu'elle n'atterrisse pour refléter cette probabilité de 50/50 :\n",
"\n",
"$$\n",
"S(coin) = \\frac{1}{2}|up\\rangle + \\frac{1}{2}|down\\rangle\n",
"$$\n",
"\n",
"Ici, les deux termes représentent les deux résultats possibles de la bascule, et leurs coefficients représentent les probabilités de chacun des résultats. Notez que le \" $|\\rangle$ \" (connu sous le nom de \" ket \") est généralement utilisé pour représenter un état quantique, mais ici, nous parlons d'un état probabiliste *classique*. Voir la [leçon 1 : Systèmes simples](/learning/courses/basics-of-quantum-information/single-systems/introduction) dans le cours Les bases de l'information quantique pour en savoir plus sur la façon dont nous représentons l'information classique et quantique.\n",
"\n",
"Si nous devions jouer à pile ou face 1000 fois et noter le nombre de têtes en haut et en bas, nous obtiendrions quelque chose comme ceci :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "f302ea9f-12af-4950-bce3-7416c163272b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# import necessary packages:\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import random\n",
"\n",
"\n",
"nflips = 1000\n",
"fliplist = [random.randint(0, 1) for f in range(nflips)]\n",
"\n",
"\n",
"# bar plots using get_gaussian_probs function\n",
"plt.hist(fliplist)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "6f2bc32b-cb77-40fc-849a-e1b9de46b813",
"metadata": {},
"source": [
"\n",
"\n",
"### Pièce quantique\n",
"\n",
"Nous pouvons créer un état probabiliste similaire en utilisant un qubit sur notre ordinateur quantique. Comme le jeu de pile ou face, un qubit peut également être mesuré dans deux états possibles : $|0\\rangle$ et $|1\\rangle$. Nous créons l'état probabiliste de \"superposition\" en commençant par l'état $|0\\rangle$, puis en appliquant au qubit ce que l'on appelle une porte de Hadamard. Elle se trouve donc dans une superposition égale de $|0\\rangle$ et $|1\\rangle$. Notez que si cet état de superposition peut ressembler et se comporter comme la pièce de monnaie à première vue, nous verrons bientôt qu'il y a beaucoup plus que cela. Le but de ce module est de vous montrer qu'une superposition n'est pas la même chose qu'un jeu de pile ou face classique.\n",
"\n",
"Ainsi, puisque le qubit est dans une superposition égale de 0 et de 1, lorsque nous mesurons le qubit, il y a 50 % de chances que nous mesurions $|0\\rangle$, 50 % de chances que nous mesurions $|1\\rangle$. Nous écrivons cet état un peu différemment du cas probabiliste classique, pour des raisons qui deviendront claires plus tard :\n",
"\n",
"$$\n",
"|\\psi\\rangle = \\frac{1}{\\sqrt{2}} |0\\rangle + \\frac{1}{\\sqrt{2}} |1\\rangle\n",
"$$\n",
"\n",
"Ici, les probabilités de mesurer chacun des deux états **ne sont plus** égales aux coefficients, comme c'était le cas dans l'état probabiliste classique ci-dessus. Au lieu de cela, c'est le **carré** des coefficients qui nous donne les probabilités, et chacun de ces coefficients peut maintenant être complexe, ce qui signifie qu'ils peuvent avoir à la fois des parties réelles et imaginaires.\n",
"\n",
"Malgré ces différences, le résultat de la mesure de cet état est essentiellement le même qu'en tirant à pile ou face.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "57f4c8c7-5524-4fcb-a37f-60a2c10bfa9b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"qcoin = QuantumCircuit(1)\n",
"qcoin.h(0)\n",
"qcoin.measure_all()\n",
"\n",
"qcoin.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "286f964c-08fb-4df7-be8c-b3c6eebdf8da",
"metadata": {},
"source": [
"Ainsi, en réalité, l'application de la porte de Hadamard équivaut à lancer une pièce. Et tout comme nous avons lancé la pièce 1 000 fois pour analyser les statistiques relatives à l'issue du lancer (face ou pile), nous pouvons faire quelque chose de similaire sur Qiskit avec notre « pièce quantique » Nous pouvons utiliser une primitive appelée `Sampler`, qui répète un circuit plusieurs fois afin d'échantillonner les statistiques de l'état résultant.\n",
"\n",
"Tout d'abord, nous chargeons le service de calcul « IBM Quantum » et ses primitives, puis nous sélectionnons un backend sur lequel exécuter le circuit.\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/initialize-account) 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": "3afaafe6",
"metadata": {},
"outputs": [],
"source": [
"# Load IBM Quantum Compute Service\n",
"from qiskit_ibm_runtime import QiskitRuntimeService\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()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "47c48517-5b27-47df-9ea8-18459d4bf720",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ibm_kingston\n"
]
}
],
"source": [
"# Load the Runtime primitive and session\n",
"from qiskit_ibm_runtime import (\n",
" SamplerV2 as Sampler,\n",
" EstimatorV2 as Estimator,\n",
")\n",
"\n",
"# Use the least busy backend\n",
"backend = service.least_busy()\n",
"print(backend.name)"
]
},
{
"cell_type": "markdown",
"id": "a2e39d00-db68-46cb-b4af-7b2559955313",
"metadata": {},
"source": [
"Si vous ne disposez pas de plus de temps sur votre compte, vous pouvez également choisir d'effectuer cette opération sur un simulateur. Il suffit de décommenter le code et d'exécuter la cellule ci-dessous pour y parvenir :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "f85953c3-d67d-4c84-b078-80669e51f9ca",
"metadata": {},
"outputs": [],
"source": [
"## Use a local simulator\n",
"\n",
"# from qiskit_aer import AerSimulator\n",
"\n",
"## Generate a simulator that mimics the real quantum system\n",
"\n",
"# backend_sim = AerSimulator.from_backend(backend)\n",
"\n",
"## Import an estimator, this time from qiskit (we will import from Runtime for real hardware)\n",
"\n",
"# from qiskit.primitives import BackendSamplerV2\n",
"# sampler_sim = BackendSamplerV2(backend = backend_sim)\n",
"# from qiskit.primitives import BackendEstimatorV2\n",
"# estimator_sim = BackendEstimatorV2(backend = backend_sim)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "634fb53f-944c-4c2c-9e98-357acd0281aa",
"metadata": {},
"outputs": [],
"source": [
"## 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",
"\n",
"qc_isa = pm.run(qcoin)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "e7930b08-d235-4c16-8af4-1d258dd80300",
"metadata": {},
"outputs": [],
"source": [
"## Execute\n",
"\n",
"# On real hardware:\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs, shots=1000)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.meas.get_counts()\n",
"\n",
"# or with Aer simulator with noise model from real backend\n",
"# job = sampler_sim.run([qc_isa])\n",
"# counts=job.result()[0].data.meas.get_counts()"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "e3b16bd7-276f-4dca-b56e-3dd88bb17b68",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## Analysis\n",
"from qiskit.visualization import plot_histogram\n",
"\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "61743091-7f5b-4660-875c-6ddf7b61d0ab",
"metadata": {},
"source": [
"Avec 1000 échantillons du circuit ci-dessus, nous obtenons quelque chose qui ressemble fondamentalement à l'histogramme classique d'une pièce de monnaie, à quelques fluctuations statistiques près.\n",
"\n",
"Outre l'échantillonnage des statistiques de la pièce quantique, nous pouvons également utiliser une autre primitive appelée `Estimator` pour mesurer ce qu'on appelle la *valeur d'espérance* d'une *observable* de l'état. Pour illustrer ce qu'est cette valeur attendue, prenons l'exemple classique de la pièce de monnaie. Imaginons que vous utilisiez cette pièce pour jouer : chaque fois que vous la lancez et qu'elle tombe « face vers le haut », vous gagnez un dollar. Mais chaque fois qu'elle tombe « face vers le bas », tu perds un dollar. Si vous souhaitez connaître le montant que vous devriez obtenir à chaque lancer (la valeur attendue de la variable observable « argent »), vous devrez alors effectuer le calcul suivant :\n",
"\n",
"$$\n",
"E(money) = \\frac{1}{2} (+ \\text{1 dollar}) + \\frac{1}{2} (- \\text{1 dollar}) = \\text{0 dollars}\n",
"$$\n",
"\n",
"Comme vous avez autant de chances de gagner un dollar que d'en perdre un, la valeur de l'espérance est de 0 \\$.\n",
"\n",
"De même, avec un état quantique, nous pouvons calculer la valeur d'espérance de l'observable \"Z\", où Z est la matrice de Pauli avec les valeurs +1 et -1 associées aux états $|0\\rangle$ et $|1\\rangle$, respectivement.\n",
"\n",
"$$\n",
"\\langle \\psi|Z|\\psi \\rangle = \\frac{1}{2} \\langle 0 | Z | 0 \\rangle + \\frac{1}{2} \\langle 1 | Z | 1 \\rangle = \\frac{1}{2} (+1) + \\frac{1}{2}(-1) = 0\n",
"$$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "775d62ec-3f26-4238-a1c5-292a6a606581",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.quantum_info import Pauli\n",
"\n",
"qcoin = QuantumCircuit(1)\n",
"qcoin.h(0)\n",
"\n",
"# for Estimator, we do not apply the measurement to the circuit"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "25350a19-390d-450c-89f3-2646d5b6b1a7",
"metadata": {},
"outputs": [],
"source": [
"## 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",
"\n",
"obs = Pauli(\"Z\")\n",
"\n",
"qc_isa = pm.run(qcoin)\n",
"obs_isa = obs.apply_layout(layout=qc_isa.layout)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "47ba8097-c109-4f9f-80a4-44e14ce044a2",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"-0.014799284701239441\n"
]
}
],
"source": [
"## Execute\n",
"\n",
"# On real hardware:\n",
"estimator = Estimator(mode=backend)\n",
"pubs = [(qc_isa, obs_isa)]\n",
"job = estimator.run([[qc_isa, obs_isa]])\n",
"res = job.result()\n",
"\n",
"# On a simulator:\n",
"# job = estimator_sim.run([[qc_isa, obs_isa]])\n",
"# res=job.result()\n",
"\n",
"print(res[0].data.evs)"
]
},
{
"cell_type": "markdown",
"id": "eed36776-de55-40a4-b63e-0aa17f144bff",
"metadata": {},
"source": [
"Nous obtenons une valeur d'espérance de 0, comme prévu (hah). C'est une autre façon de confirmer qu'il y a effectivement une probabilité égale de mesurer ou 0 et 1, et cela semble se comporter comme un jeu de pile ou face.\n",
"\n",
"À ce stade, la \"pièce quantique\" ressemble exactement à la pièce classique. Mais dans la section suivante, nous ferons quelques expériences qui révéleront les différences fondamentales entre les deux.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "7d10d957-2e8d-4c63-b4a4-7744b9e1a0e9",
"metadata": {},
"source": [
"\n",
"\n",
"## Le quantum révélé : une expérience en trois dimensions\n",
"\n",
"Faisons une expérience de pensée : Supposons que vous lanciez une pièce de monnaie en l'air et qu'au lieu de la laisser tomber au sol, vous ayez la coordination nécessaire pour applaudir lorsqu'elle passe entre vos mains et pour la prendre en sandwich entre vos paumes. Maintenant, au lieu que la pièce soit face en haut ou en bas, elle est face à gauche ou à droite.\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"Quelle est la probabilité de chacun de ces résultats, face à gauche ou face à droite?\n",
"\n",
"\n",
" \n",
" La probabilité sera toujours de 50-50. La dimension selon laquelle nous choisissons de mesurer le résultat du jeu de pile ou face ne devrait pas avoir d'importance.\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "907ac0e3-12cb-4444-ad2e-0b33189b43e6",
"metadata": {},
"source": [
"Avec un peu de chance, vous avez répondu que la probabilité de trouver la tête à gauche ou à droite est toujours de 50-50. La dimension selon laquelle le jeu de pile ou face est mesuré ne devrait pas affecter la probabilité des résultats.\n",
"\n",
"Mais en quoi les choses seraient-elles différentes pour notre pièce de monnaie quantique? Vérifions.\n",
"\n",
"Nous pouvons créer notre superposition quantique de la même manière que la dernière fois, avec une porte de Hadamard. Pour mesurer \"tête à gauche ou à droite\" sur notre pièce de monnaie quantique, nous pouvons faire ce que nous avons fait avec la pièce de monnaie classique : mesurer le long d'un axe différent. Nos mesures standard sur l'ordinateur quantique se font le long de l'axe vertical, tout comme la mesure habituelle de la pièce de monnaie classique \"pile ou face\". Mais nous pouvons également demander à notre pièce quantique si elle est face à la gauche ou à la droite, ou, de manière équivalente, si elle est dans les états $|+\\rangle$ ou $|-\\rangle$, qui pointent le long de l'axe $x$. `Sampler` ne contient que des échantillons dans la base de mesure Z, mais nous pouvons utiliser `Estimator` pour obtenir la valeur attendue de X. Les valeurs de X sont +1 et -1 pour les états $|+\\rangle$ ou $|-\\rangle$, respectivement.\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"Si la pièce quantique se comportait comme la pièce classique dans ce cas, nous aurions une probabilité de 50-50 de mesurer l'état $|+\\rangle$ et $|-\\rangle$. Quelle valeur d'espérance de X s'attendrait-on à ce que `Estimator` renvoie, si tel était le cas?\n",
"\n",
"\n",
" \n",
" Lorsque nous appliquons X à l'état $|+\\rangle$, nous obtenons la valeur et +1 et à l'état $|-\\rangle$, nous obtenons -1, de sorte que si nous avions une distribution 50-50, nous obtiendrions une valeur d'espérance de 0.\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "2cc7a79f-527c-4af1-a207-06cfa20ac92c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.9985207100591716\n"
]
}
],
"source": [
"# Step 1: map problem\n",
"\n",
"qcoin_lr = QuantumCircuit(1)\n",
"qcoin_lr.h(0)\n",
"\n",
"obs = Pauli(\"X\")\n",
"\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qcoin_lr)\n",
"obs_isa = obs.apply_layout(layout=qc_isa.layout)\n",
"\n",
"# Step 3: Run the circuit on a real quantum computer\n",
"\n",
"estimator = Estimator(mode=backend)\n",
"pubs = [(qc_isa, obs_isa)]\n",
"job = estimator.run([[qc_isa, obs_isa]])\n",
"res = job.result()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"# job = estimator_sim.run([[qc_isa,obs_isa]])\n",
"# res=job.result()\n",
"\n",
"# Step 4: Return the result in classical form, and analyze.\n",
"\n",
"print(res[0].data.evs)"
]
},
{
"cell_type": "markdown",
"id": "51f97d72-b152-4527-8e42-c066cec33524",
"metadata": {},
"source": [
"La valeur espérée de X pour cet état est de 1. Il n’y a donc **pas** une probabilité de 50-50 de mesurer $|+\\rangle$ et $|-\\rangle$.\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"Que nous apprend cette valeur d'espérance sur l'état $|\\psi\\rangle$? Quelles sont les probabilités de mesurer $|+\\rangle$ et $|-\\rangle$ dans cette base X?\n",
"\n",
"\n",
" \n",
" Puisque la valeur attendue est la même que la valeur de X pour l'état $|+\\rangle$, cela signifie que nous avons une probabilité de 100 % de mesurer l'état $|+\\rangle$ lorsque nous mesurons le long de X.\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "37b04a99-0256-41f4-8bf5-362b3508ca34",
"metadata": {},
"source": [
"Que se passe-t-il ici? Il semble que notre pièce de monnaie quantique puisse avoir des résultats aléatoires et probabilistes dans une dimension, mais parfaitement prévisibles dans une autre. Cela reviendrait à tirer à pile ou face une pièce de monnaie et à garantir qu'à chaque fois qu'elle sera attrapée, en la prenant en sandwich entre deux mains, elle se retrouvera avec la tête tournée vers la droite.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ace0c3e8-e9b7-4fc9-a312-78c0264a171a",
"metadata": {},
"source": [
"\n",
"\n",
"### La phase quantique\n",
"\n",
"La différence essentielle de la pièce de monnaie quantique est qu'elle possède une autre qualité que la pièce de monnaie classique. Rappelez-vous que dans un état probabiliste classique,\n",
"\n",
"$$\n",
"S(coin) = c_1|up\\rangle + c_2|down\\rangle\n",
"$$\n",
"\n",
"chaque coefficient est simplement un nombre réel et positif qui représente la probabilité de mesurer un état particulier. Dans un état quantique,\n",
"\n",
"$$\n",
"|\\psi\\rangle = c_1 |0\\rangle + c_2 |1\\rangle\n",
"$$\n",
"\n",
"les coefficients sont complexes, c'est-à-dire qu'ils contiennent une partie réelle et une partie imaginaire. Chaque coefficient $c_i$ peut être exprimé comme un vecteur bidimensionnel sur le plan complexe, avec la magnitude $|c_i|$ et l'angle $\\phi_i$ qu'il forme avec l'axe réel :\n",
"\n",
"$$\n",
"c_i = |c_i| e^{i \\phi_i}.\n",
"$$\n",
"\n",
"\n",
"\n",
"Nous appelons $\\phi_i$ la phase. La phase nous indique comment deux termes d'un état quantique vont *interférer*, ou comment ils vont s'additionner ou s'annuler comme des ondes. Si deux vagues sont en phase l'une avec l'autre, c'est-à-dire que leurs crêtes et leurs creux s'alignent, elles se combinent pour former une vague deux fois plus haute. C'est ce que nous appelons l'interférence constructive. S'ils sont déphasés, c'est-à-dire que la crête de l'un s'aligne sur le creux de l'autre, et vice-versa, ils interfèrent de manière destructive et s'annulent complètement.\n",
"\n",
"Comme les ondes, les états quantiques peuvent également s'additionner de manière constructive ou destructive. Elle peut être plus difficile à percevoir car, souvent, il ne s'agit pas d'une onde réelle dans l'espace physique. Dans le cas de nos qubits, l'interférence se produit dans l'espace d'information abstrait des qubits. Il convient également de noter que, comme seule la phase *relative* entre les deux ondes a une incidence sur la manière dont elles interfèrent - c'est-à-dire la différence entre les phases $\\Delta \\phi = \\phi_2 - \\phi_1$ des deux coefficients -, nous appliquons généralement une *phase globale* de $-\\phi_1$ à l'ensemble de l'état, de sorte que $c_1$ est purement réel et que la *phase relative* est entièrement prise en compte dans $c_2$.\n",
"\n",
"Pour voir comment la phase peut provoquer des interférences dans notre pièce de monnaie quantique, essayons d'appliquer le Hadamard deux fois au lieu d'une. D'un point de vue classique, cela n'aurait aucun sens : si l'application de la méthode Hadamard équivaut à tirer à pile ou face, on ne peut pas tirer à pile ou face une pièce qui est déjà en train de tirer à pile ou face. Mais voyons ce qu'il advient de la pièce quantique :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "610af24c-d489-4239-b31f-cea67a563b69",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qcoin_0 = QuantumCircuit(1)\n",
"qcoin_0.h(0)\n",
"qcoin_0.h(0)\n",
"qcoin_0.measure_all()\n",
"\n",
"qcoin_0.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "6fd8711d-1bef-4706-a5a9-039531af658b",
"metadata": {},
"source": [
"Avant d'utiliser `Sampler` pour mesurer l'état résultant, réfléchissons à la manière dont ce qubit sera transformé par chaque porte. On commence, comme d'habitude, par $|0\\rangle$. Ensuite, la première transformation de Hadamard transforme l'état en superposition, comme nous l'avons déjà vu :\n",
"\n",
"$$\n",
"H|0\\rangle = \\frac{1}{\\sqrt{2}} |0\\rangle + \\frac{1}{\\sqrt{2}} |1\\rangle.\n",
"$$\n",
"\n",
"Dans ce cas, les deux coefficients sont entièrement réels et positifs, ce qui signifie que la phase est $\\phi=0$.\n",
"\n",
"Le second Hadamard est ensuite appliqué à chaque morceau de l'état de superposition séparément. Nous savons déjà comment la transformation de Hadamard transforme l'état $|0\\rangle$. Mais qu'en est-il de $|1\\rangle$?\n",
"\n",
"$$\n",
"H|1\\rangle = \\frac{1}{\\sqrt{2}} |0\\rangle - \\frac{1}{\\sqrt{2}} |1\\rangle\n",
"$$\n",
"\n",
"Il s'agit à nouveau d'une superposition égale de 0 et de 1, un peu comme si l'on jouait à pile ou face, mais le coefficient de cet état devant $|1\\rangle$ a une phase de $\\phi = \\pi$ pour lui donner le signe négatif.\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"Calculer l'état résultant de l'application du second Hadamard. Autrement dit, calculez : $H(\\frac{1}{\\sqrt{2}} |0\\rangle + \\frac{1}{\\sqrt{2}} |1\\rangle)$. Notez que $H$ est distributif, nous pouvons donc l'appliquer à chacun des termes individuellement.\n",
"\n",
"\n",
" \n",
" $$\n",
" H(\\frac{1}{\\sqrt{2}} |0\\rangle + \\frac{1}{\\sqrt{2}} |1\\rangle) = \\frac{1}{\\sqrt{2}} H|0\\rangle + \\frac{1}{\\sqrt{2}} H|1\\rangle = \\frac{1}{2} [(|0\\rangle + |1\\rangle) + (|0\\rangle - |1\\rangle)] = |0\\rangle\n",
" $$\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "e19dd16b-50b2-435e-b83e-b65af3f642be",
"metadata": {},
"source": [
"Vérifions maintenant notre prédiction avec `Sampler`.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "6390f58c-057a-4ec2-a7ca-4a45410631c0",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## Transpile\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"\n",
"qc_isa = pm.run(qcoin_0)\n",
"\n",
"## Execute\n",
"\n",
"# On real hardware:\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs, shots=1000)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.meas.get_counts()\n",
"\n",
"\n",
"# or with Aer simulator with noise model from real backend\n",
"# job = sampler_sim.run([qc_isa])\n",
"# counts=job.result()[0].data.meas.get_counts()\n",
"\n",
"## Analyze\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "b5ff1950-9401-4461-bb07-0e8e5a44cb13",
"metadata": {},
"source": [
"Le deuxième Hadamard a annulé le premier, et nous sommes revenus à l'état 0 où nous avons commencé! En effet, la transformation de Hadamard transforme les états $|0\\rangle$ et $|1\\rangle$ en états similaires, mais avec des phases opposées. Après le deuxième Hadamard, nous constatons que les termes $|0\\rangle$ interfèrent de manière constructive, mais que les termes $|1\\rangle$ interfèrent de manière destructive et s'annulent mutuellement.\n",
"\n",
"Explorons plus avant : nous pouvons changer la phase à l'aide d'une porte \"PHASE\". Appliquons maintenant un Hadamard pour créer la superposition, appliquons un déphasage de $\\pi$ radians, puis appliquons le second Hadamard :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "ad819e8b-bc89-41d6-b375-428da51220be",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qcoin_pi = QuantumCircuit(1)\n",
"qcoin_pi.h(0)\n",
"qcoin_pi.p(np.pi, 0)\n",
"qcoin_pi.h(0)\n",
"qcoin_pi.measure_all()\n",
"\n",
"qcoin_pi.draw(\"mpl\")"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "06e21f78-e3e2-4fbf-b636-460f3ce5b3c7",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## Transpile\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"\n",
"qc_isa = pm.run(qcoin_pi)\n",
"\n",
"## Execute\n",
"\n",
"# On real hardware:\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs, shots=1000)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.meas.get_counts()\n",
"\n",
"\n",
"# or with Aer simulator with noise model from real backend\n",
"# job = sampler_sim.run([qc_isa])\n",
"# counts=job.result()[0].data.meas.get_counts()\n",
"\n",
"## Analyze\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "35078634-0d0a-43bc-a220-50c927d4c088",
"metadata": {},
"source": [
"Et maintenant, le qubit est mesuré comme étant dans l'état 1 au lieu de 0.\n",
"\n",
"Ainsi, même à partir de ces quelques expériences simples, vous pouvez déjà voir la différence radicale que cette phase peut faire sur un circuit quantique. Il peut être subtil et difficile à percevoir au début. Dans notre première expérience, où nous avons simplement lancé notre pièce de monnaie quantique avec une porte de Hadamard et mesuré le résultat du lancer, nous n'avons rien vu de l'effet de la phase. Ce n'est qu'en creusant davantage que nous avons découvert la différence qu'une phase peut faire. Elle peut faire en sorte que la même porte quantique ait littéralement l'effet inverse sur un qubit.\n",
"\n",
"\n",
"\n",
"#### Essayez vous-même :\n",
"\n",
"Modifiez la cellule de code ci-dessous pour changer la phase de sorte que le deuxième Hadamard crée un état de superposition avec des probabilités de 25 % et 75 % de trouver l'état dans $|0\\rangle$ et $|1\\rangle$, respectivement. Vérifiez votre réponse à l'aide des mathématiques.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "fef281ef",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qcoin_phase = QuantumCircuit(1)\n",
"qcoin_phase.h(0)\n",
"# replace \"x\" below with a phase from 0 to 2*np.pi (this cell won't run if you leave x)\n",
"# qcoin_phase.rz(x, 0)\n",
"qcoin_phase.h(0)\n",
"qcoin_phase.measure_all()\n",
"\n",
"\n",
"## Transpile\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"\n",
"qc_isa = pm.run(qcoin_phase)\n",
"\n",
"## Execute\n",
"\n",
"# On real hardware:\n",
"sampler = Sampler(mode=backend)\n",
"pubs = [qc_isa]\n",
"job = sampler.run(pubs, shots=1000)\n",
"res = job.result()\n",
"\n",
"counts = res[0].data.meas.get_counts()\n",
"\n",
"\n",
"# or with Aer simulator with noise model from real backend\n",
"# job = sampler_sim.run([qc_isa])\n",
"# counts=job.result()[0].data.meas.get_counts()\n",
"\n",
"## Analyze\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "3cd238cb-6346-40f4-af87-fdbd1b806106",
"metadata": {},
"source": [
"\n",
"\n",
"## Une autre analogie (meilleure) avec les pièces de monnaie utilisant la porte d' $\\sqrt{\\text{NOT}}$\n",
"\n",
"Nous savons désormais que le fait de tirer à pile ou face est très différent de la création d'un état de superposition. Existe-t-il une meilleure analogie avec une pièce de monnaie qui rende mieux compte des phénomènes de superposition? Oui Oui, c'est le cas.\n",
"\n",
"Nous allons faire une autre expérience de pensée avec une pièce de monnaie. Imaginez la pièce posée sur la table, la tête en haut. Pour le rendre tête en bas, il suffit de le retourner. Il s'agit de l'équivalent informatique d'une porte \"NOT\".\n",
"\n",
"Supposons que nous voulions construire une opération qui, si elle est appliquée deux fois, serait équivalente à la porte NOT. En d'autres termes, nous voulons une \"racine carrée de NOT\", ou $\\sqrt{\\text{NOT}}$. Nous pouvons y parvenir en considérant la manière dont la porte NOT est physiquement mise en œuvre sur la pièce : il s'agit simplement d'une rotation de 180 degrés autour, par exemple, de l'axe des x. Ainsi, si nous faisions tourner la pièce de 90 degrés autour de l'axe x, elle serait équivalente à une porte $\\sqrt{\\text{NOT}}$.\n",
"\n",
"Imaginons qu'après avoir appliqué la porte $\\sqrt{\\text{NOT}}$, nous voulions savoir si la pièce est pile ou face. Il n'est ni l'un ni l'autre - il se tient sur son bord par rapport à l'axe vertical. Mais maintenant, redéfinissons notre \"mesure\" de la pièce en commençant par l'effondrer le long de l'axe de mesure (en l'écrasant avec la main pour qu'elle repose à plat), puis en vérifiant si elle est face ou non.\n",
"\n",
"Si nous effectuons cette \"mesure\" sur la pièce posée sur sa tranche, alors la pièce \"s'effondrera\" sur pile ou face avec la même probabilité. Comme pour le jeu de pile ou face, il est en principe possible de prédire la direction de la chute de la pièce en fonction des conditions initiales de la pièce et de la manière dont la force de notre main est appliquée à la pièce pour la \"faire tomber\". Mais dans la pratique, il devrait être difficile de prédire quel côté atterrira, de sorte qu'il s'agit essentiellement d'un phénomène aléatoire.\n",
"\n",
"Nous pouvons en fait mesurer cette pièce selon trois axes différents : $x$ $y$, et $z$. Nous constatons que la tranche de la pièce est orientée le long des axes $x$ et $z$, de sorte que la mesure dans ces directions nécessite l'\"effondrement\" de la pièce - par conséquent, le long de ces axes, il y aura une probabilité aléatoire (50:50) de mesurer le haut et le bas. Mais le long de l'axe $y$, il est déjà à plat, sa tête étant orientée dans la direction -y. C'est ce que l'on peut appeler \"la tête en avant\"\n",
"\n",
"Ainsi, alors que les mesures x et z ont donné des résultats aléatoires, la mesure y donnera toujours le même résultat! Si vous vous souvenez de l'expérience de \"pile ou face quantique\" de la section précédente, cela rappelle le comportement de la pièce quantique. Il a été mesuré comme étant 0 ou 1 avec une probabilité de 50/50 dans la direction z, mais toujours $|+\\rangle$ et jamais $|-\\rangle$ le long de X. **Cela suggère qu'une pièce de monnaie immobile, sur sa tranche, est peut-être un meilleur moyen de visualiser l'état de superposition d'un qubit qu'une pièce de monnaie qui s'agite dans l'air.**\n",
"\n",
"Utilisons Qiskit pour voir si notre \"pièce de monnaie quantique\" se comporte de la même manière que notre pièce de monnaie classique lorsqu'une porte $\\sqrt{\\text{NOT}}$ est appliquée. Nous appliquerons $\\sqrt{\\text{NOT}}$ à un qubit à partir de $|0\\rangle$, puis nous utiliserons `Estimator` pour vérifier la valeur d'espérance des trois observables X, Y et Z.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "ab97d4c5-285c-4efd-bc54-efda675e35fa",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qcoin_sx = QuantumCircuit(1)\n",
"qcoin_sx.sx(0)\n",
"\n",
"qcoin_sx.draw(\"mpl\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "28b2db66-c9d3-43a8-bfba-d90f6fd310e6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[-0.01234492]\n",
" [-1.00388865]\n",
" [ 0.00740695]]\n"
]
}
],
"source": [
"obs1 = Pauli(\"X\")\n",
"obs2 = Pauli(\"Y\")\n",
"obs3 = Pauli(\"Z\")\n",
"\n",
"\n",
"# Step 2: Transpile the circuit\n",
"\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qcoin_sx)\n",
"obs1_isa = obs1.apply_layout(layout=qc_isa.layout)\n",
"obs2_isa = obs2.apply_layout(layout=qc_isa.layout)\n",
"obs3_isa = obs3.apply_layout(layout=qc_isa.layout)\n",
"\n",
"\n",
"# Step 3: Run the circuit on a real quantum computer\n",
"\n",
"estimator = Estimator(mode=backend)\n",
"pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]\n",
"job = estimator.run(pubs)\n",
"res = job.result()\n",
"\n",
"# Run the job on the Aer simulator with noise model from real backend\n",
"# pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]\n",
"# job = estimator_sim.run(pubs)\n",
"# res=job.result()\n",
"\n",
"# Step 4: Return the result in classical form, and analyze.\n",
"\n",
"print(res[0].data.evs)"
]
},
{
"cell_type": "markdown",
"id": "f14bd04e-255c-4bdd-a1fa-34c71273a369",
"metadata": {},
"source": [
"Les valeurs de l'espérance sont 0, -1, et 0 pour X, Y et Z, respectivement.\n",
"\n",
"\n",
"\n",
"#### Vérifiez votre compréhension\n",
"\n",
"Compte tenu des valeurs d'espérance, quelles sont les probabilités de mesurer que la pièce quantique est face en haut/en bas (ou gauche/droite ou avant/arrière) pour chacun des trois axes de mesure?\n",
"\n",
"\n",
" \n",
" Il y a une probabilité de 50/50 de mesurer l'un ou l'autre état le long de X et de Z, et l'état est toujours mesuré dans la direction -y le long de Y.\n",
" \n",
"\n",
"\n",
"C'est le même résultat que nous avons obtenu avec notre expérience de pensée en appliquant une rotation de 90 degrés \" $\\sqrt{\\text{NOT}}$ \" à la pièce de monnaie classique. En fait, il existe actuellement une analogie précise entre la pièce de monnaie et l'état du qubit. Nous pouvons visualiser l'état du qubit comme un vecteur pointant dans la direction du côté pile d'une pièce de monnaie, normal à la surface de la pièce. Ainsi, face visible, ou l'état $|0\\rangle$ d'une pièce de monnaie quantique, est équivalent à un vecteur pointant directement vers le haut; face cachée, ou $|1\\rangle$, pointe directement vers le bas. Toute superposition égale des points $|0\\rangle$ et $|1\\rangle$ à l'horizontale. La phase de l'état détermine la direction horizontale exacte - la direction qu'il indique le long de l'équateur est égale à la direction que le coefficient $c_2$ indique dans le plan complexe.\n",
"\n",
"*Toutes les* portes que nous avons vues dans ce cahier peuvent être visualisées comme une rotation (ou une série de rotations) de la pièce de monnaie/du vecteur.\n",
"\n",
"* PAS : 180 degrés autour de l'axe des x\n",
"\n",
"* $\\sqrt{\\text{NOT}}$ : 90 degrés autour de l'axe des x\n",
"\n",
"* PHASE : rotation de $\\phi$ autour de l'axe z\n",
"\n",
"* Hadamard : Celui-ci est un peu plus délicat. Nous avons d'abord comparé ce phénomène à celui d'une pièce de monnaie qui tournerait de manière incontrôlée dans l'air. Mais l'Hadamard est en fait une rotation contrôlée et déterministe de la pièce, comme les autres portes. Le Hadamard s'effectue par une rotation de 90 degrés autour de l'axe des y, puis de 180 degrés autour de l'axe des x.\n",
"\n",
"Il n'y a donc rien d'aléatoire dans un état de superposition quantique ou dans les opérations standard que nous effectuons sur le qubit. Chaque opération est déterministe et réversible. Le seul moment où le hasard entre en jeu, c'est lorsque nous décidons de *mesurer l'* état quantique.\n",
"\n",
"\n",
"\n",
"### L'état du qubit en tant que vecteur de Bloch\n",
"\n",
"Ce vecteur qui pointe dans la direction de la \"tête\" de la pièce est appelé \"vecteur de Bloch\" Formellement, l'état d'un qubit arbitraire (isolé) peut être représenté par un vecteur qui se trouve à la surface d'une sphère de rayon 1 dont les coordonnées sont $(r, \\theta, \\phi)$. Écrit en termes de ces coordonnées, l'état du qubit est :\n",
"\n",
"$|\\psi\\rangle = \\cos{\\frac{\\theta}{2}} |0\\rangle + e^{i \\phi} \\sin{\\frac{\\theta}{2}} |1\\rangle$\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a9e7efad-9561-4613-b2e2-d5201d3cef72",
"metadata": {},
"source": [
"Vérifions maintenant avec Qiskit comment le vecteur de Bloch change lorsque nous appliquons différentes portes à notre qubit à partir de l'état $|0\\rangle$.\n",
"\n",
"\n",
"\n",
"#### N'EST PAS\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "d33d6191-c455-4cac-8947-0d68030278e9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.visualization import plot_bloch_multivector\n",
"\n",
"qnot = QuantumCircuit(1)\n",
"qnot.x(0)\n",
"\n",
"plot_bloch_multivector(qnot)"
]
},
{
"cell_type": "markdown",
"id": "69f06a6c-1a33-48a7-84de-30c49fc11f97",
"metadata": {},
"source": [
"\n",
"\n",
"#### $\\sqrt{\\text{NOT}}$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "8648c4b8-edd1-4e40-9c74-50219c84c928",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qsqrtnot = QuantumCircuit(1)\n",
"qsqrtnot.sx(0)\n",
"\n",
"plot_bloch_multivector(qsqrtnot)"
]
},
{
"cell_type": "markdown",
"id": "f0145781-8534-4f94-bea4-11111dfffdfb",
"metadata": {},
"source": [
"\n",
"\n",
"#### PHASE ( $\\phi = \\pi$ )\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "f2b33aa1-2460-4e66-aa48-cbceef02729e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qphase = QuantumCircuit(1)\n",
"qphase.p(np.pi, 0)\n",
"\n",
"plot_bloch_multivector(qphase)"
]
},
{
"cell_type": "markdown",
"id": "9ca1c439-055e-4c11-a730-2dfa1f6141e4",
"metadata": {},
"source": [
"\n",
"\n",
"#### Hadamard\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "1371f0a1-8279-4dff-987b-050511ba629b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qhadamard = QuantumCircuit(1)\n",
"qhadamard.h(0)\n",
"\n",
"plot_bloch_multivector(qhadamard)"
]
},
{
"cell_type": "markdown",
"id": "f66be32d-6452-4ba0-8dcf-5e248ce37605",
"metadata": {},
"source": [
"\n",
"\n",
"## Conclusion - *qu* 'est-ce qu'un état de superposition?\n",
"\n",
"Nous avons commencé ce module en comparant le caractère aléatoire de la mesure d'un état de superposition quantique à un jeu de pile ou face. Nous avons comparé la \"porte de Hadamard\" qui produit une superposition quantique à l'acte de tirer à pile ou face. Mais, grâce à une série d'expériences, nous avons appris qu'il existe des différences fondamentales entre un jeu de pile ou face classique et une superposition quantique.\n",
"\n",
"Nous avons appris qu'un qubit dans un état de superposition n'a rien d'aléatoire. C'est comme une pièce de monnaie immobile dans un espace tridimensionnel. En fait, une pièce de monnaie libre de tourner en trois dimensions est une analogie très proche d'une façon particulière de visualiser l'état quantique d'un qubit, appelée vecteur de Bloch. Les portes quantiques font tourner ce vecteur de pièce de monnaie/Bloch de manière déterministe et réversible. Ce n'est que lorsque nous **mesurons** le qubit que le hasard est introduit. Nous avons comparé ce processus de mesure à l'écrasement d'une pièce de monnaie afin qu'elle soit à plat dans la direction de l'axe de mesure.\n",
"\n",
"La question de savoir si un état quantique se trouve dans une superposition est en fait une question d'appréciation. Comme vous l'avez probablement déjà rencontré, nous sommes libres de choisir notre système de coordonnées - $x$, $y$, et $z$ peuvent pointer le long de trois directions orthogonales quelconques. Ainsi, si nous avons une superposition de 0 et de 1 dans un système de coordonnées, nous pouvons définir un nouveau système de coordonnées - ou, de manière équivalente, une nouvelle \"base de mesure\" - dans lequel l'état pointe purement dans la direction $+z$, et n'est donc pas dans un état de superposition. Ainsi, lorsque nous disons qu'un qubit est dans une superposition, nous devons également répondre à la question \"superposition de *quoi*?\"\n",
"\n",
"Vous quitterez peut-être ce module avec l'impression que nous venons de lever tous les mystères de la mécanique quantique. Après tout, l'un des aspects supposés les plus \"étranges\", l'état de superposition d'un qubit, est en réalité aussi simple qu'un vecteur tridimensionnel. Mais n'oubliez pas que la pièce de monnaie n'est qu'une analogie, et que même le vecteur de Bloch n'est qu'un outil de visualisation permettant de calculer les probabilités des résultats des mesures. Nous ne pouvons pas dire ce que fait *réellement* un état quantique avant qu'il ne soit mesuré. En effet, le contrôle nécessite une mesure!\n",
"\n",
"Nous aborderons cette énigme de la \"vraie\" nature d'un état quantique et de la manière dont le phénomène quantique de l'intrication peut nous aider à l'élucider, dans le module sur l'inégalité de Bell.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "3425eb14-a8fd-4894-83a8-268a93733795",
"metadata": {},
"source": [
"\n",
"\n",
"## Questions\n",
"\n",
"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](https://ibm.biz/classrooms_instructor_key_request) sur la façon dont les cahiers sont utilisés.\n",
"\n",
"\n",
"\n",
"### Concepts essentiels :\n",
"\n",
"* Alors que la mesure d'un qubit dans une superposition est probabiliste, comme si l'on jouait à pile ou face, l'état de superposition lui-même se comporte différemment que si l'on jouait à pile ou face.\n",
"* La principale différence entre une distribution de probabilité classique et une superposition est que la superposition possède une cohérence de *phase*, ce qui lui permet d'interférer de manière constructive ou destructive.\n",
"* L'état d'un qubit unique et isolé peut être visualisé comme un point sur la \"sphère de Bloch\", où les amplitudes relatives des composantes $|0\\rangle$ et $|1\\rangle$ déterminent l'angle polaire $\\theta$ et les phases relatives entre les deux composantes déterminent l'angle azimutal $\\phi$.\n",
"* Toutes les portes quantiques à qubit unique peuvent être considérées comme des rotations du vecteur sur cette sphère.\n",
"\n",
"\n",
"\n",
"### Questions vrai/faux :\n",
"\n",
"1. T/F Une superposition quantique est fondamentalement la même chose qu'un événement probabiliste en physique classique, comme tirer à pile ou face.\n",
"\n",
"2. T/F La longueur du vecteur de Bloch décrivant l'état d'un qubit isolé est toujours égale à 1.\n",
"\n",
"3. T/F Les portes quantiques à un qubit ne modifient pas la longueur du vecteur de Bloch.\n",
"\n",
"\n",
"\n",
"### Questions du MC :\n",
"\n",
"1. Sélectionnez le vecteur de Bloch correct qui représente l'état $|\\Psi\\rangle = \\sqrt{\\frac{1}{3}}|0\\rangle + e^{i \\pi / 4} \\sqrt{\\frac{2}{3}}|1\\rangle$ :\n",
"\n",
"\n",
"\n",
"2. La sphère de Bloch décrit le qubit : (sélectionner toutes les réponses qui s'appliquent)\n",
"\n",
" a. amplitude\n",
"\n",
" b. intrication avec d'autres qubits\n",
"\n",
" c. phase\n",
"\n",
" d. couleur\n",
"\n",
" e. probabilité des résultats de la mesure\n",
"\n",
"\n",
"\n",
"### Questions à débattre :\n",
"\n",
"1. Pourquoi l'état d'un qubit peut-il être visualisé sur la sphère de Bloch, alors que la distribution de probabilité d'un jeu de pile ou face ne peut l'être?\n",
"\n",
"2. Pourquoi une pièce de monnaie jouant à pile ou face n'est-elle pas la meilleure analogie avec un état de superposition quantique? Quel aspect des superpositions n'est pas pris en compte dans cette analogie?\n",
"\n",
"\n",
"\n",
"### Problèmes difficiles :\n",
"\n",
"1. Utilisez Qiskit pour créer un circuit qui transforme l'état $|0\\rangle$ en état $\\frac{\\sqrt{3}}{2}|0\\rangle + \\frac{1}{2}e^{i \\frac{5\\pi}{6}}|1\\rangle$\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
}