Exercice – Créer une intrication quantique avec Q#

7 minutes

Dans l’unité précédente, vous avez découvert le concept d’intrication de quantum et les états de Bell.

Dans cette unité, vous utilisez Azure Quantum Development Kit (QDK) pour écrire Q# du code qui crée des états Bell enchevêtrés entre deux qubits. Pour créer votre premier état Bell, vous appliquez deux opérations quantiques : l’opération Hadamard et l’opération Controlled-NOT (CNOT).

Tout d’abord, comprenons comment ces opérations fonctionnent et pourquoi elles créent des états enchevêtrés.

L’opération Hadamard

Rappelez-vous que l’opération Hadamard, ou H, place un qubit dans un état pur $|0\rangle$ ou $|1\rangle$ dans un état de superposition égal.

$$ H |0\rangle=\frac1{\sqrt2}|0\rangle + \frac1{\sqrt2}|1\rangle$$$$ H |1\rangle=\frac1{\sqrt2}|0\rangle – \frac1{\sqrt2}|1\rangle$$

La première étape de création de votre état Bell consiste à effectuer une opération Hadamard sur l’un des qubits.

Opération Controlled-NOT (CNOT)

Lorsque deux qubits sont enchevêtrés, l’état de l’un dépend de l’état de l’autre. Par conséquent, pour enchevêtrer deux qubits, vous avez besoin d’opérations qui agissent sur les deux qubits en même temps. Il s’agit d’une opération multi-qubit. L’opération Controlled-NOT ou CNOT est une opération multi-qubit qui permet de créer un entanglement.

L’opération CNOT prend deux qubits comme entrée. L’un des qubits est appelé qubit de contrôle et l’autre qubit est appelé qubit target . Si le qubit de contrôle est dans l’état $|1\rangle$ , l’opération CNOT retourne l’état du target qubit. Sinon, CNOT ne fait rien.

Par exemple, dans les états à deux qubits suivants, le qubit de contrôle est le qubit le plus à gauche et le target qubit est le qubit le plus à droite.

Entrée vers `CNOT`	Sortie de `CNOT`
$\ket{00}$	$\ket{00}$
$\ket{01}$	$\ket{01}$
$\ket{10}$	$\ket{11}$
$\ket{11}$	$\ket{10}$

Dans Q#, l’opération CNOT agit sur un tableau de deux qubits, et elle retourne le deuxième qubit uniquement si le premier qubit est One.

Entanglement avec des opérations Hadamard et CNOT

Supposons que vous disposez d’un système à deux qubits dans l’état $|00\rangle$. Dans cet état, les qubits ne sont pas enchevêtrés. Pour placer ces qubits dans l’état Bell enchevêtré $\ket{\phi^+}=\frac1{\sqrt2}(|00\rangle+|11\rangle), $appliquez les opérations Hadamard et CNOT.

Voici son fonctionnement :

Choisissez un qubit dans l’état $|00\rangle$ pour être le qubit de contrôle et l’autre qubit pour être le target qubit. Ici, nous choisissons le qubit le plus à gauche pour être le contrôle et le qubit le plus à droite pour être le target.
Placez uniquement le qubit de contrôle dans un état de superposition égal. Pour ce faire, appliquez une opération H uniquement au qubit de contrôle :

$$H |0_c\rangle=\frac{1}{\sqrt{{2}}(|0_c\rangle+|1_c\rangle)$$

Note

Les indices ${}_c$ et ${}_t$ spécifient le contrôle et les qubits, respectivement target.
Appliquez une opération CNOT à la paire qubit. Rappelez-vous que le qubit de contrôle est dans un état de superposition et que le qubit target est dans l’état 0_t$|\rangle$.

$$ \begin{align*} CNOT \frac{{1}{\sqrt{2}}(\ket{0_c}+\ket{1_c})\ket{{0}_t &= CNOT \frac{{1}{\sqrt2}(\ket{0_c 0_t}+|\ket{1_c 0_t})\ &=\frac{1}{\sqrt2}(CNOT \ket{0_c 0_t} + CNOT \ket{1_c 0_t})\ &=\frac{{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 1_t}) \end{align*}$$

L’état $\frac{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 1_t})$ est enchevêtré. Cet état enchevêtré particulier est l’un des quatre états Bell, $\ket{\phi^{+}}$.

Note

Dans l’informatique quantique, les opérations sont souvent appelées portes. Par exemple, la porte H et la porte CNOT.

Créer un enchevêtrement quantique dans Q#

Pour créer un état Bell avec Q# du code, procédez comme suit dans Visual Studio Code (VS Code) :

Ouvrez VS Code.
Ouvrez le menu Fichier , puis choisissez Nouveau fichier texte pour créer un fichier.
Enregistrez le fichier en tant que Main.qs.

Créer l’état Bell $\ket{\phi^+}$

Pour créer l’état $\ket{\phiBell ^+}$ dans Q#, procédez comme suit :

Importez le namespace Microsoft.Quantum.Diagnostics à partir de la bibliothèque standard Q# pour pouvoir utiliser la fonction DumpMachine. Cette fonction affiche des informations sur les états qubit lorsque vous appelez la fonction dans votre code. Pour importer l’espace de noms, copiez le code suivant Q# dans votre fichier Main.qs :
```
import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;
```
Conseil

Vous pouvez utiliser Std au lieu de Microsoft.Quantum pour importer à partir de la bibliothèque standard. Par exemple, import Std.Diagnostics.* équivaut à import Microsoft.Quantum.Diagnostics.*.

Créez l’opération Main qui retourne deux valeurs de type Result, qui sont les résultats de mesure des qubits.

import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

operation Main() : (Result, Result) {
    // Your code goes here
}

À l’intérieur de l’opération Main , allouez deux qubits à entremêler, q1 et q2.

import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());
}

Appliquez la porte Hadamard, Hau qubitq1 de contrôle. Cela ne place que ce qubit dans un état de superposition. Ensuite, appliquez la porte CNOT, CNOT, aux deux qubits pour entrelacer les deux qubits. Le premier argument CNOT est le qubit de contrôle et le deuxième argument est le qubit target.
```
import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());

    H(q1);
    CNOT(q1, q2);
}
```
Utilisez la DumpMachine fonction pour afficher l’état des qubits après les avoir entangles. Notez que DumpMachine ne réalise pas de mesure sur les qubits, donc DumpMachine n'affecte pas les états des qubits.
```
import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());

    H(q1);
    CNOT(q1, q2);

    DumpMachine();
}
```

Utilisez l’opération M pour mesurer les qubits et stocker les résultats dans m1 et m2. Utilisez ensuite l’opération Reset pour réinitialiser les qubits.

import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

operation Main() : (Result, Result) {

    use (q1, q2) = (Qubit(), Qubit());

    H(q1);
    CNOT(q1, q2);
    DumpMachine();

    let (m1, m2) = (M(q1), M(q2));
    Reset(q1);
    Reset(q2);

}

Retourne les résultats de mesure des qubits avec l’instruction return . Voici le programme final dans votre fichier Main.qs :

import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());

    H(q1);
    CNOT(q1, q2);

    DumpMachine();

    let (m1, m2) = (M(q1), M(q2));
    Reset(q1);
    Reset(q2);

    return (m1, m2);
}

Pour exécuter votre programme sur le simulateur intégré, choisissez l'option Exécuter au-dessus de l’opération Main, ou appuyez sur Ctrl + F5. Votre sortie s’affiche dans la console de débogage.
Les résultats de mesure sont corrélés, donc à la fin du programme, vous obtenez un résultat ou (Zero, Zero)(One, One) avec une probabilité égale. Réexécutez le programme plusieurs fois et observez la sortie pour vous convaincre de la corrélation.
Pour visualiser le schéma de circuit, choisissez la lentille de code Circuit au-dessus de l’opération Main. Le diagramme du circuit montre la porte Hadamard appliquée au premier qubit et la porte CNOT appliquée aux deux qubits.

Créer d’autres états Bell

Pour créer d’autres états Bell, appliquez des opérations Pauli $X$ ou $Z$ supplémentaires aux qubits.

Par exemple, pour créer l’état de Bell $\ket{\phi^-}=\frac1{\sqrt2}(|00\rangle-|11\rangle)$, appliquez l’opération de Pauli $Z$ au qubit de contrôle après avoir appliqué la porte de Hadamard, mais avant d’appliquer la porte CNOT. L’opération $Z$ retourne l’état $\ket{+}$ à $\ket{-}$.

Note

Les états $\frac{{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ et $\frac{1}{\sqrt{{2}}(|0\rangle -|1\rangle)$ sont également appelés $\ket{+}$ et $\ket{{-}$, respectivement.

Voici comment créer l’état $\ket{\phi^-}$ :

Créez deux qubits dans l’état $|00\rangle$.
Placez le qubit de contrôle dans un état de superposition avec l’opération $H$ :

$$H |0_c\rangle=\frac{{1}{\sqrt{2}}(|0_c\rangle+|1_c\rangle) =\ket{+_c}$$
Appliquez l’opération $Z$ au qubit de contrôle.

$$Z \frac{{1}{\sqrt{{2}}(|0_c\rangle+|1_c\rangle)=\frac{1}{\sqrt{{2}}(|0_c\rangle-|1_c\rangle)=\ket{{-}_c$$
Appliquez l’opération $CNOT$ au qubit de contrôle et au qubit target, qui se trouve dans l’état $|0_t\rangle$.

$$ \begin{align*} CNOT \frac{{1}{\sqrt{2}}(\ket{0_c}-\ket{1_c})\ket{{0}_t = CNOT \frac{{1}{\sqrt2}(\ket{0_c 0_t}-|\ket{1_c 0_t})\ &=\frac{1}{\sqrt2}(CNOT \ket{0_c 0_t} - CNOT \ket{1_c 0_t})\ &=\frac{{1}{\sqrt2}(\ket{0_c 0_t}-\ket{1_c 1_t}) \end{align*}$$

Pour créer l’état $\ket{\phi^-}$ Bell dans Q#, remplacez le code dans votre fichier Main.qs par le code suivant :

import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;
    
operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());
    
    H(q1);
    Z(q1); // Apply the Pauli Z operation to the control qubit
    CNOT(q1, q2);
    
    DumpMachine();
    
    let (m1, m2) = (M(q1), M(q2));
    Reset(q1);
    Reset(q2);

    return (m1, m2);
}

De même, vous pouvez créer les états $\ket{\psiBell ^+}$ et $\ket{\psi^-}$ en appliquant les opérations Pauli $X$ et $Z$ aux qubits.

Pour créer l’état $\ket{\psiBell ^+}=\frac1{\sqrt2}(|01\rangle+|10\rangle)$, appliquez la porte Pauli $X$ au target qubit après avoir appliqué la porte Hadamard au qubit de contrôle. Ensuite, appliquez la porte CNOT.
Pour créer l’état de Bell $\ket{\psi^-}=\frac1{\sqrt2}(|01\rangle-|10\rangle)$, appliquez la matrice de Pauli $Z$ au qubit de contrôle et la matrice de Pauli $X$ au targetqubit associé après avoir appliqué la porte Hadamard au qubit de contrôle. Ensuite, appliquez la porte CNOT.

Dans l’unité suivante, vous allez apprendre à utiliser l’enchevêtrement pour envoyer des informations quantiques, un processus appelé téléportation quantique.

Commentaires

Cette page a-t-elle été utile ?