Note

Cette page a été générée à partir de tutorials/circuits/1_getting_started_with_qiskit.ipynb.

Exécuter en mode interactif dans le `IBM Quantum lab <https://quantum-computing.ibm.com/jupyter/tutorial/circuits/1_getting_started_with_qiskit.ipynb> `_.

Démarrer avec Qiskit

Ici, nous vous présentons une vue d’ensemble de l’utilisation de Qiskit. Le package fondamental de Qiskit est Terra qui fournit les éléments de base nécessaires à la programmation des ordinateurs quantiques. L’unité fondamentale de Qiskit est le circuit quantique. Un workflow de base en utilisant Qiskit se compose de deux étapes : Build et Execute. Build vous permet de construire différents circuits quantiques qui représentent le problème que vous êtes en train de résoudre, et Execute qui vous permet de les exécuter sur différents backends. Après que les travaux ont été exécutés, les données sont collectées et traitées en fonction du résultat souhaité.

import numpy as np
from qiskit import *
%matplotlib inline

Les bases des circuits

Construction du circuit

L’élément de base dont vous aurez besoin pour un premier programme est le QuantumCircuit (circuit quantique). Nous commençons par créer un QuantumCircuit constitué de 3 qubits.

# Create a Quantum Circuit acting on a quantum register of three qubits
circ = QuantumCircuit(3)

Aprés avoir créé le circuit avec ses registres, vous pouvez ajouter les portes (« opérations ») pour manipuler les registres. En parcourant les tutoriels vous trouverez davantage de portes et de circuits; ci-dessous un exemple de circuit quantique qui crée un état GHZ avec 3 qubits

\[|\psi\rangle = \left(|000\rangle+|111\rangle\right)/\sqrt{2}.\]

Pour créer un tel état, nous démarrons avec un registre quantique de 3 qubits. Par défaut, chaque qubit du registre est initialisé à \(|0\rangle\). Pour créer l’état GHZ, on applique les portes suivantes: - Une porte Hadamard \(H\) sur le qubit 0, qui le place dans un état de superposition \(\left(|0\rangle+|1\rangle\right)/\sqrt{2}\). - Une opération « controlled-Not » (NON-contrôlé ou C-not) (\(C_{X}\)) entre le qubit 0 et le qubit 1. - Une opération « controlled-Not » (C-not) entre le qubit 0 et le qubit 2.

Dans un calculateur quantique parfait, l’état produit en lançant ce circuit serait l’état GHZ ci-dessus.

Dans Qiskit, les opérations peuvent être ajoutées au circuit une par une, comme montré ci-dessous.

# Add a H gate on qubit 0, putting this qubit in superposition.
circ.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state.
circ.cx(0, 1)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 2, putting
# the qubits in a GHZ state.
circ.cx(0, 2)

<qiskit.circuit.instructionset.InstructionSet at 0x2452282f708>

Visualisation du circuit

Vous pouvez visualiser le circuit en utilisant Qiskit QuantumCircuit.draw(), qui dessinera le circuit de la façon dont on le voit dans de nombreux ouvrages.

circ.draw('mpl')

Dans le circuit, les qubits sont mis dans un ordre où le qubit 0 sera en haut et le qubit 2 en bas. Le circuit est lu de gauche à droite (ce qui signifie que les portes appliquées en premiers sont celles de gauche et ainsi de suite).

Lorsqu’on représente l’état d’un système à plusieurs qubits, l’ordre des produits tensoriels utilisé dans Qiskit est différent de celui de la plupart des manuels de physique. Supposons qu’il y a :math:` n ` qubits, et que le qubit :math:` j ` est étiqueté comme :math:` Q_{j}`. Qiskit utilise un ordre dans lequel le qubit :math:` n ^ { mathrm{th}} ` est sur le côté gauche du produit tensoriel, de sorte que les vecteurs de base sont marqués comme :math:` Q_{n-1}otimes cdots otimes Q_1otimes Q_0 `.

Par exemple, si le qubit zéro est dans l’état 0, le qubit 1 est dans l’état 0, le qubit 2 dans l’état 1, Qiskit représentera cet état par \(|100\rangle\), tandis que de nombreux manuels de physiques l’auraient représenté par \(|001\rangle\).

Cette différence d’affichage affecte la façon dont les opérations multi-qubits sont représentées en tant que matrices. Par exemple, Qiskit représente une opération (Non-contrôlé) controlled-X (\(C_{X}\)) avec un qubit 0 étant le qubit de contrôle et un qubit 1 qui est la cible par

\[\begin{split}C_X = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\\end{pmatrix}.\end{split}\]

Simuler des circuits en utilisant Qiskit Aer

Qiskit Aer est notre module pour simuler les circuits quantiques. Il fournit plusieurs plateformes différentes pour effectuer une simulation. Il y a aussi une implémentation simple, Python uniquement, appelée BasicAer dans Terra qui peut être utilisée comme alternative libre à Aer dans les exemples suivants.

Environnement de simulation de vecteur d’état

L’environnement le plus commun dans Qiskit Aer et le statevector_simulator (simulateur de vecteur d’état). Ce simulateur retourne l’état quantique, qui est un vecteur complexe de dimensions \(2^n\), où:math:2^n est le nombre de qubits (Soyez prudent en l’utilisant car il peut vite devenir trop grand pour tourner sur votre machine).

Pour exécuter le circuit ci-dessus en utilisant le simulateur de vecteur d’état, vous devez d’abord importer Aer et ensuite paramétrer l’environnement d’exécution sur statevector_simulator.

# Import Aer
from qiskit import Aer

# Run the quantum circuit on a statevector simulator backend
backend = Aer.get_backend('statevector_simulator')

Maintenant que vous avez choisi votre environnement, il est temps de compiler et d’exécuter le circuit quantique. Dans Qiskit, nous utilisons la fonction execute pour cela. execute retourne un objet job qui encapsule l’information à propos de la tâche lancée sur la plateforme d’exécution.

Astuce: Vous pouvez obtenir les paramètres ci-dessus dans Jupyter. Placez simplement le curseur sur une fonction et pressez Shift+Tab.

# Create a Quantum Program for execution
job = execute(circ, backend)

Quand vous lancez un programme, un objet job est créé qui aura les deux méthodes utiles suivantes : job.status() et job.result(), qui retourneront respectivement l’état du job et un objet résultat.

Note: Les tâches tournent de façon asynchrone, mais quand la méthode result est appelée, on bascule en mode synchrone et on attend que la tâche en court soit finie avant de passer à la suivante.

result = job.result()

L’objet result contient les données et Qiskit fournit la méthode result.get_statevector(circ) pour retourner le vecteur d’état du circuit quantique.

outputstate = result.get_statevector(circ, decimals=3)
print(outputstate)

[0.707+0.j 0.   +0.j 0.   +0.j 0.   +0.j 0.   +0.j 0.   +0.j 0.   +0.j
 0.707+0.j]

Qiskit fournit aussi une boite à outil de visualisation qui permet d’afficher ces résultats.

Below, we use the visualization function to plot the real and imaginary components of the state density matrix \(\rho\).

from qiskit.visualization import plot_state_city
plot_state_city(outputstate)

Environnement unitaire

Qiskit Aer inclut également un (simulateur unitaire) unitary_simulator qui fonctionne comme si tous les éléments du circuit étaient des opérations unitaires. Cet environnement calcule la matrice \(2^n \times 2^n\) représentant les portes du circuit quantique.

# Run the quantum circuit on a unitary simulator backend
backend = Aer.get_backend('unitary_simulator')
job = execute(circ, backend)
result = job.result()

# Show the results
print(result.get_unitary(circ, decimals=3))

[[ 0.707+0.j  0.707-0.j  0.   +0.j  0.   +0.j  0.   +0.j  0.   +0.j
   0.   +0.j  0.   +0.j]
 [ 0.   +0.j  0.   +0.j  0.   +0.j  0.   +0.j  0.   +0.j  0.   +0.j
   0.707+0.j -0.707+0.j]
 [ 0.   +0.j  0.   +0.j  0.707+0.j  0.707-0.j  0.   +0.j  0.   +0.j
   0.   +0.j  0.   +0.j]
 [ 0.   +0.j  0.   +0.j  0.   +0.j  0.   +0.j  0.707+0.j -0.707+0.j
   0.   +0.j  0.   +0.j]
 [ 0.   +0.j  0.   +0.j  0.   +0.j  0.   +0.j  0.707+0.j  0.707-0.j
   0.   +0.j  0.   +0.j]
 [ 0.   +0.j  0.   +0.j  0.707+0.j -0.707+0.j  0.   +0.j  0.   +0.j
   0.   +0.j  0.   +0.j]
 [ 0.   +0.j  0.   +0.j  0.   +0.j  0.   +0.j  0.   +0.j  0.   +0.j
   0.707+0.j  0.707-0.j]
 [ 0.707+0.j -0.707+0.j  0.   +0.j  0.   +0.j  0.   +0.j  0.   +0.j
   0.   +0.j  0.   +0.j]]

Environnement OpenQASM

Les simulateurs précédents sont utiles car ils fournissent une information sur l’état de sortie d’un circuit idéal et la représentation matricielle de ce circuit. Toutefois, une expérience réelle se termine par la mesure de chaque qubit (habituellement sur une base calculatoire \(|0\rangle, |1\rangle\)). Sans mesure, on ne peut récupérer l’information à propos de l’état. Mais la mesure provoque l’effrondrement du système quantique en un système de bits classiques.

Par exemple, supposons qu’on crée une mesure individuelle de chaque qubit dans un état GHZ à 3 qubits

\[|\psi\rangle = (|000\rangle +|111\rangle)/\sqrt{2},\]

et notons \(xyz\) la chaîne de bits résultante. Rappelons que, dans la convention de nommage des qubits utilisée par Qiskit, \(x\) correspond à la sortie du qubit 2, \(y\) à la sortie du qubit 1 et \(z\) à la sortie du qubit 0.

Note: Cette représentation de la chaîne de bits place le bit le plus significatif (MSB) à gauche, et le bit le moins significatif (LSB) sur la droite. Il s’agit de l’ordre standard des bits binaires. Nous commandons les qubits de la même façon (le qubit représentant le MSB a l’index 0), c’est pourquoi Qiskit utilise un ordre de produit tensoriel non standard.

Rappelons que la probabilité d’obtenir un résultat \(xyz\) est définie par

\[\mathrm{Pr}(xyz) = |\langle xyz | \psi \rangle |^{2}\]

et que pour un état GHZ la probabilité d’obtenir 000 ou 111 est de 1/2.

Pour simuler un circuit qui inclut la mesure, nous avons besoin d’ajouter les mesures aux circuits précédents et d’utiliser un environnement Aer différent.

# Create a Quantum Circuit
meas = QuantumCircuit(3, 3)
meas.barrier(range(3))
# map the quantum measurement to the classical bits
meas.measure(range(3), range(3))

# The Qiskit circuit object supports composition using
# the addition operator.
qc = circ + meas

#drawing the circuit
qc.draw()

        ┌───┐           ░ ┌─┐
q_0: |0>┤ H ├──■────■───░─┤M├──────
        └───┘┌─┴─┐  │   ░ └╥┘┌─┐
q_1: |0>─────┤ X ├──┼───░──╫─┤M├───
             └───┘┌─┴─┐ ░  ║ └╥┘┌─┐
q_2: |0>──────────┤ X ├─░──╫──╫─┤M├
                  └───┘ ░  ║  ║ └╥┘
 c_0: 0 ═══════════════════╩══╬══╬═
                              ║  ║
 c_1: 0 ══════════════════════╩══╬═
                                 ║
 c_2: 0 ═════════════════════════╩═
                                   

Ce circuit ajoute un registre classique, et 3 mesures qui sont utilisés pour faire correspondre la mesure des qubits à leur bits classiques.

Pour simuler ce circuit, nous utilisons qasm_simulator de Qiskit Aer. Chaque exécution (« tir » ou « shoot » en anglais) de ce circuit aboutira soit à une séquence 000, soit à 111. Pour obtenir une statistique de la distribution des résultats (par exemple, estimer \(\mathrm{Pr}(000)\)), nous devrons exécuter le circuit plusieurs fois. Le nombre de fois où le circuit sera testé peut être spécifier dans la fonction execute èè, via le mot-clé ``shots.

# Use Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')

# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit
# to be 1024, which is the default.
job_sim = execute(qc, backend_sim, shots=1024)

# Grab the results from the job.
result_sim = job_sim.result()

Une fois que vous avez un objet résultat, vous pouvez obtenir le comptage (counts) via la fonction get_counts(circuit). Cela vous donne le résultat sous forme d’agrégats binaires du circuit testé.

counts = result_sim.get_counts(qc)
print(counts)

{'000': 510, '111': 514}

Approximativement 50% du temps, le résultat sera 000. Qiskit fournit également une fonction plot_histogram qui vous permet de visualiser le résultat.

from qiskit.visualization import plot_histogram
plot_histogram(counts)

Les probabilités estimées des résultats \(\mathrm{Pr}(000)\) et \(\mathrm{Pr}(111) sont calculées en prenant l'agrégat comptage (counts) et en le divisant par le nombres de "tirs" (le nombre de fois que le circuit a été testé). Essayez de modifier la valeur du mot-clé \) dans la fonction execute et voyez comment cela affecte la probabilité estimée.

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.14.0
Terra	0.11.0
Aer	0.3.4
Ignis	0.2.0
Aqua	0.6.1
IBM Q Provider	0.4.4
System information
Python	3.7.4 (default, Aug 9 2019, 18:34:13) [MSC v.1915 64 bit (AMD64)]
OS	Windows
CPUs	2
Memory (Gb)	7.9987335205078125
Tue Dec 10 15:25:10 2019 Eastern Standard Time

This code is a part of Qiskit

© Copyright IBM 2017, 2019.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.