Exercice : créer différents états de superposition avec Q#

  • 12 minutes

Dans les unités précédentes, vous avez découvert la superposition et la notation Dirac. Assez de théorie pour l’instant ! Nous allons écrire du code pour explorer la superposition en Q#.

Dans cette unité, vous créez des états de superposition quantique en Q# et explorez le rôle de probabilité dans les résultats de mesure. Vous utilisez également la fonction dans Q# pour examiner comment l’état DumpMachine d’un système change pendant un calcul quantique.

Créer un fichier Q#

  1. Ouvrez Visual Studio Code (VS Code).
  2. Ouvrez le menu Fichier , puis choisissez Nouveau fichier texte pour créer un fichier.
  3. Enregistrez le fichier en tant que Main.qs.

Prise en main de la superposition

Commençons par un programme Q# simple qui utilise un qubit dans un état de superposition pour générer une valeur de bit aléatoire, 0 ou 1. Dans notre code, nous utilisons la DumpMachine fonction pour voir l’état du qubit à différents points du programme.

  1. Copiez et collez le code suivant dans le fichier Main.qs :

    import Std.Diagnostics.*;

operation Main() : Result {
    use q = Qubit();
    Message("Initialized qubit:");
    DumpMachine(); // First dump
    Message(" ");
    H(q);
    Message("Qubit after applying H:");
    DumpMachine(); // Second dump
    Message(" ");
    let randomBit = M(q);
    Message("Qubit after the measurement:");
    DumpMachine(); // Third dump
    Message(" ");
    Reset(q);
    Message("Qubit after resetting:");
    DumpMachine(); // Fourth dump
    Message(" ");
    return randomBit;
}

  2. Pour exécuter votre programme sur le simulateur intégré, choisissez la lentille de code Run au-dessus de l’opération Main ou appuyez sur la combinaison de touches Ctrl + F5. Votre sortie s’affiche dans la console de débogage.

  3. Examinez la console de débogage pour rechercher le résultat de votre mesure, soit ZeroOne.

La DumpMachine fonction crée une table d’informations qui décrit l’état du système quantique, qui, dans ce cas, est un qubit unique. Les informations provenant de DumpMachine incluent l'amplitude de probabilité, la probabilité de mesure et la phase en radians pour chaque état de base.

Votre code appelle la DumpMachine fonction quatre fois :

  • Après avoir alloué le qubit
  • Après avoir placé le qubit dans un état de superposition
  • Après avoir mesuré l’état du qubit
  • Après avoir réinitialisé le qubit

Examinons la sortie de chaque appel vers DumpMachine:

  • Qubit initialisé : Lorsque vous allouez un qubit avec l’instruction use , le qubit démarre toujours dans l’état $|0\rangle$.

    Initialized qubit:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

  • Qubit après l’application de H : Après avoir appliqué l’opération H , le qubit est dans un état de superposition égal, $|\psi\rangle=\frac1{\sqrt2} |0\rangle + \frac1{\sqrt2} |1\rangle$.

    Qubit after applying H:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
   |1⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

  • Qubit après la mesure : Après avoir mesuré le qubit, le résultat est soit Zero ou One, et le qubit est entièrement dans l’état que vous avez mesuré.

    Qubit after the measurement:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |1⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

    Remarque

    Votre sortie depuis DumpMachine après la mesure peut différer de l’exemple de sortie, car vous avez une chance de 50 % de mesurer chaque état. Les probabilités des résultats sont déterministes, mais le résultat d’une mesure individuelle n’est pas.

  • Qubit après la réinitialisation : L’opération Reset réinitialise le qubit à l’état $|0\rangle$ afin qu’elle puisse être utilisée à nouveau pour les calculs futurs.

    Qubit after resetting:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Explorer d’autres états de superposition

Maintenant que vous savez comment inspecter l’état d’un système qubit avec DumpMachine, examinons d’autres opérations qui placent le système dans différents types d’états de superposition.

Le générateur de bits aléatoires actuel produit soit Zero, soit One avec une probabilité de 50%. Dans l’exemple suivant, les probabilités ne sont pas égales.

Générateur de bits aléatoires asymétriques

Supposons que vous souhaitez créer un générateur de bits aléatoires asymétrique, ce qui signifie que la probabilité d’obtention de Zero est différente de la probabilité d’obtention de One.

Par exemple, vous souhaitez obtenir le résultat Zero avec la probabilité $P$ et le résultat One avec la probabilité $1 - P$. Voici un état de qubit valide qui produit un générateur de bits aléatoires :

$$|\psi\rangle=\sqrt{P}|0\rangle+\sqrt{1 - P}|1\rangle$$

Pour cet état $|\psi\rangle$, $\alpha=\sqrt{P}$ et $\beta=\sqrt{1 - P}$ sont respectivement les amplitudes de probabilité des états de base $|0\rangle$ et $|1\rangle$, respectivement.

Pour obtenir cet état, vous pouvez appliquer séquentiellement l’opérateur $R_y(2\cos^{-1}\sqrt{P})$ à un qubit qui commence à l’état $|0\rangle$. Pour obtenir ce résultat en Q#, utilisez Ry de la bibliothèque standard.

Conseil

Pour en savoir plus sur la logique mathématique sous-jacente aux opérations à qubit unique, consultez le tutoriel sur les portes à qubit unique dans Quantum Kata.

Pour créer un état de superposition asymétrique dans Q#, procédez comme suit :

  1. Remplacez tout le code dans Main.qs par l’exemple suivant, puis enregistrez le fichier. Cet exemple choisit $\alpha$ pour être environ $\frac13$.

    import Std.Diagnostics.*;
import Std.Math.*;

operation Main() : Result {
    use q = Qubit();
    let P = 0.333333; // P is 1/3
    Ry(2.0 * ArcCos(Sqrt(P)), q);
    Message("The qubit is in the desired state.");
    DumpMachine(); // Dump the state of the qubit 
    Message("Your skewed random bit is:");
    let skewedrandomBit = M(q);
    Reset(q);
    return skewedrandomBit;
}

  2. Pour exécuter votre programme sur le simulateur intégré, choisissez la lentille de code Exécuter au-dessus de l’opération Main ou appuyez sur 'Ctrl + F5'. Votre sortie s’affiche dans la console de débogage.

  3. Examinez la sortie de DumpMachine et le résultat de votre mesure. Par exemple, la sortie est similaire à ce qui suit :

    The qubit is in the desired state.

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.5773+0.0000𝑖 |    33.3333% |   0.0000
   |1⟩ |  0.8165+0.0000𝑖 |    66.6667% |   0.0000

Your skewed random bit is:

One

Notez que la probabilité d’un Zero résultat de mesure est d’environ 33,33% et que la probabilité d’un One résultat est d’environ 66,67%. Ce générateur de bits aléatoires est biaisé vers One.

Remarque

Votre sortie de résultat de mesure peut différer de l’exemple de sortie, car le générateur de bits aléatoires est probabiliste. Les probabilités des résultats sont déterministes, mais le résultat d’une mesure individuelle n’est pas.

Superposition de plusieurs qubits

Jusqu’à présent, nous n’avons considéré que des systèmes à qubit unique. Mais un bon ordinateur quantique a besoin de beaucoup de qubits pour effectuer des calculs utiles. Comment fonctionnent les états quantiques et la superposition lorsque notre système a plusieurs qubits ?

Prenons l’exemple d’un système de trois qubits. Chaque qubit peut avoir une valeur de 0 ou 1 lorsque vous les mesurez, de sorte qu’il existe huit états possibles que vous pouvez trouver le système dans :

$$|000\rangle,|001\rangle,|010\rangle,|011\rangle,|100\rangle,|101\rangle, |110\rangle,|111\rangle $$

Il existe huit états possibles pour ce système, car chaque qubit peut être indépendamment un état 0 ou 1 lorsque nous prenons une mesure. En général, le nombre d’états possibles est égal à $2^n$, où $n$ est le nombre de qubits.

Tout comme avec un qubit unique, un état de superposition arbitraire pour le système de 3 qubits est représenté sous la forme d’une somme pondérée de ces huit états, où les pondérations sont les amplitudes de probabilité :

$$|\psi\rangle=\alpha_0|000\rangle+\alpha_1|001\rangle+\alpha_2|010\rangle+\alpha_3|011\rangle+\alpha_4|100\rangle+\alpha_5|101\rangle+\alpha_6 |110\rangle+\alpha_7|111\rangle$$

Une fois de plus, les amplitudes $\alpha_i$ sont des nombres complexes qui répondent à la condition $\sum\limits_{i=0}^{i=7}|\alpha_i|^2=1$.

Par exemple, vous pouvez placer des qubits dans une superposition uniforme en appliquant H à chaque qubit. Vous pouvez ensuite utiliser cette superposition uniforme pour créer un générateur de nombres aléatoires quantiques qui génère des nombres à trois bits au lieu de nombres un bits :

État de base Nombre
$\ket{000}$ 0
$\ket{001}$ 4
$\ket{010}$ 2
$\ket{011}$ 6
$\ket{100}$ 1
$\ket{101}$ 5
$\ket{110}$ 3
$\ket{111}$ 7

Remarque

La façon standard d’écrire des chaînes de bits consiste à avoir le plus petit chiffre à droite et le chiffre le plus grand à gauche, comme avec des nombres décimaux réguliers. Dans Q# (et de nombreux autres langages de programmation quantique), l’ordre est inversé afin que le chiffre le plus petit soit à gauche et que le plus grand chiffre se trouve à droite. Étant donné que la DumpMachine fonction affiche des états quantiques dans l’ordre standard, les entiers décimaux auxquels les états correspondent ne sont pas classés séquentiellement de 0 à $n-1$.

Pour créer ce type de générateur de nombres aléatoires, procédez comme suit :

  1. Remplacez votre code dans Main.qs par l’exemple suivant, puis enregistrez le fichier :

    import Std.Diagnostics.*;
import Std.Convert.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register in a uniform superposition: ");
    DumpMachine();
    let result = MeasureEachZ(qubits);
    Message("Measuring the qubits collapses the superposition to a basis state.");
    DumpMachine();
    ResetAll(qubits);
    return ResultArrayAsInt(result);
}

  2. Pour exécuter votre programme sur le simulateur intégré, choisissez la lentille de code Exécuter au-dessus de l’opération Main ou appuyez sur 'Ctrl + F5'. Votre sortie s’affiche dans la console de débogage.

  3. Examinez la sortie de DumpMachine et le résultat de votre mesure. Par exemple, la sortie est similaire à ce qui suit :

    The qubit register in a uniform superposition: 

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |000⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |001⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |010⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |011⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |100⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |101⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |110⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |111⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000

Measuring the qubits collapses the superposition to a basis state.

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |011⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

6

    Remarque

    Votre sortie a probablement un résultat différent de celui de l’exemple de sortie, car le générateur de nombres aléatoires est probabiliste. Les probabilités des résultats sont déterministes, mais le résultat d’une mesure individuelle n’est pas.

Pour utiliser plusieurs qubits, votre code Q# a les modifications suivantes :

  • La variable qubits représente maintenant un tableau Qubit avec une longueur de trois.
  • Les opérations ApplyToEach et MeasureEachZ appliquent des opérations quantiques à plusieurs qubits avec une seule ligne de code. Les bibliothèques Q# offrent de nombreuses fonctions et opérations qui simplifient la programmation quantique pour vous.
  • La fonction ResultArrayAsInt de la Std.Convert bibliothèque transforme le tableau binaire Result en entier décimal.

La sortie DumpMachine montre que l’acte de mesure réduit l’état de superposition en un des huit états de base possibles, comme avec un qubit unique. Par exemple, si vous obtenez le résultat 6, cela signifie que l’état du système est réduit à $|011\rangle$.

Examinons maintenant plus en détail comment le système change à mesure que nous mesurons chaque qubit. Le code précédent a utilisé l’opération MeasureEachZ pour mesurer les trois qubits à la fois. Au lieu de cela, nous allons utiliser une for boucle pour mesurer les qubits un par un, et utiliser DumpMachine pour afficher l’état du système après chaque mesure.

  1. Remplacez le code dans Main.qs par l’exemple suivant, puis enregistrez le fichier :

    import Std.Diagnostics.*;
import Std.Convert.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register is in a uniform superposition: ");
    DumpMachine();
    mutable results = [];
    for q in qubits {
        Message(" ");
        results += [M(q)];
        DumpMachine();
    }
    ResetAll(qubits);
    Message("Your random number is: ");
    return ResultArrayAsInt(results);
}

  2. Pour exécuter votre programme sur le simulateur intégré, choisissez la lentille de code Exécuter au-dessus de l’opération Main ou appuyez sur 'Ctrl + F5'. Votre sortie s’affiche dans la console de débogage.

  3. Examinez la sortie de DumpMachine et le résultat de votre mesure.

La sortie montre comment chaque mesure consécutive change l’état quantique et donc les probabilités d’obtenir chaque résultat. Par exemple, examinons chaque partie de la sortie dans le cas où votre résultat est 5:

  • Préparation de l’état : le système est dans un état de superposition égal après l’application H à chaque qubit.

    The qubit register is in a uniform superposition: 

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |000⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |001⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |010⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |011⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |100⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |101⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |110⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |111⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000

  • Première mesure : le résultat est One pour la première mesure. Les seuls états possibles dans lesquels le système peut se retrouver sont ceux où le bit le plus à gauche est 1. Les amplitudes des états où le qubit le plus à gauche est 0 ont disparu, et les probabilités des états possibles restants passent de 12,5% à 25,0% afin que la somme des probabilités reste de 100%.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |100⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |101⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |110⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |111⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000

  • Deuxième mesure : Le résultat est Zero pour la deuxième mesure. Les seuls états possibles dans lesquels le système peut finir sont les états où les deux bits les plus à gauche sont égaux à 10. Maintenant, nous sommes laissés avec seulement deux résultats possibles lorsque nous mesurons le troisième qubit, avec une probabilité de 50% pour chaque résultat.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |100⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
 |101⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

  • Troisième mesure : Dans la troisième mesure, le résultat est One. Le système est entièrement mesuré et n’est donc plus dans un état de superposition, comme prévu.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |101⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Your random number is: 

5

Avec Q#, vous pouvez créer un système de qubits, placer les qubits dans un état de superposition et examiner la façon dont le système change lorsque vous appliquez des opérations quantiques ou prenez des mesures.