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 de Hadamard, ou H, met un qubit qui est dans un état pur $\ket{0}$ ou $\ket{1}$ dans un état de superposition égale.

$$ H \ket{0} = \frac1{\sqrt2} \ket{0} + \frac1{\sqrt2} \ket{1}$$ $$ H \ket{1} = \frac1{\sqrt2} \ket{0} - \frac1{\sqrt2} \ket{1}$$

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 entanler deux qubits, vous devez appliquer une opération multi-qubit, qui est une opération qui agit sur les deux qubits en même temps. 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 le qubit de contrôle et l’autre qubit est le target qubit. Si le qubit de contrôle est dans l’état $\ket{1}$ , 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 $\ket{00}$. 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}(\ket{00}+\ket{11})$, appliquez les opérations Hadamard et CNOT.

Voici son fonctionnement :

Choisissez un qubit dans l’état c 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 \ket{0_c} = \frac{1}{\sqrt{2}}(\ket{0_c} + \ket{1_c})$$

Note

Les indices ${}_c$ et ${}_t$ spécifient respectivement le qubit de contrôle et le qubit 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 target qubit est dans l’état $\ket{0_t}$ .

$ \begin{aligned} 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{aligned}$

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 un état Bell

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

Importez le namespace Std.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 Std.Diagnostics.*;
```
Créez l’opération Main qui retourne deux valeurs de type Result, qui sont les résultats de mesure des qubits.
```
import 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 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 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 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 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 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 d’autres pauli $X$ ou $Z$ opérations aux qubits.

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

Note

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

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

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

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

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

$ \begin{aligned} 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{aligned}$

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

import 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{\psi^+}$ and $\ket{\psi^-}$ Bell en appliquant les opérations Pauli $X$ et $Z$ aux qubits.

Pour créer l’état $\ket{\psi^+}=\frac1{\sqrt2}(\ket{01}+\ket{10})$Bell, 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 $\ket{\psi^-}=\frac1{\sqrt2}(\ket{01}-\ket{10})$Bell, appliquez pauli $Z$ au qubit de contrôle et pauli $X$ au target qubit 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 ?