Exercice Partie 1 - Créer un générateur de bits aléatoires quantiques

Effectué

Dans l’unité précédente, vous avez découvert les composants fondamentaux d’un programme Q#. Maintenant, vous êtes prêt à écrire votre premier programme quantique. Dans cette unité, vous écrivez un programme quantique qui génère un bit vraiment aléatoire.

Vous générez votre générateur de nombres aléatoires quantiques en deux étapes. Cette unité est la première étape, qui consiste à générer un bit aléatoire unique. Pour générer un bit aléatoire, vous allouez un qubit dans l’état $\ket{0}$, placez ce qubit dans un état de superposition, puis mesurez le qubit pour produire une valeur de bit aléatoire de 0 ou 1.

Créer le fichier de programme Q#

1. Ouvrez Visual Studio Code.
2. Ouvrez le menu Fichier , puis choisissez Nouveau fichier texte pour créer un fichier.
3. Enregistrez le fichier sous le nom Main.qs.

Écrivez votre code Q# pour le générateur de bits aléatoires dans le Main.qs fichier.

Définir l’opération Main

L’opération Main est le point d’entrée de votre programme. Copiez le code suivant dans votre Main.qs fichier :

operation Main(): Result{

    // Your code goes here

}

Allouer un qubit

Pour commencer, allouez un qubit avec l’instruction use . Dans Q#, chaque qubit que vous allouez avec use commence dans l'état $\ket{0}$ par défaut. Pour allouer un qubit unique, copiez le code suivant dans votre programme :

operation Main(): Result{

    // Allocate a qubit
    use q = Qubit();
}

Placer le qubit dans un état de superposition

À ce stade, vous ne pouvez pas générer un bit aléatoire à partir du qubit, car le qubit est dans l’état $\ket{0}$. Si vous mesurez l’état de ce qubit, la mesure retourne une valeur de bit de 0 chaque fois.

Pour générer un bit aléatoire à partir de la mesure qubit, vous devez d’abord placer le qubit dans une superposition de l’état $\ket{0}$ et de l’état $\ket{1}$. Pour placer le qubit dans un état de superposition, appliquez une opération Hadamard au qubit. L’opération Hadamard transforme le qubit de l’état $\ket{0}$ en une superposition égale des états $\ket{0}$ et $\ket{1}$.

$$ H \ket{0} = \frac{1}{\sqrt{2}} (\ket{0} + \ket{1}) $$

Pour appliquer une opération Hadamard à votre qubit en Q#, utilisez l’opération H :

operation Main(): Result{

    use q = Qubit();
    H(q);
}

Remarque

Lorsque vous appliquez une opération quantique à un qubit en Q#, l’opération ne retourne pas de valeur. Au lieu de cela, les opérations affectent l’état du qubit.

Mesurer le qubit

Étant donné que le qubit est maintenant dans un état de superposition égal, lorsque vous mesurez le qubit, vous avez une chance de 50% que la mesure retourne un 0 et une chance de 50% qu'elle retourne un 1.

Pour mesurer la valeur qubit en Q#, utilisez l’opération M et stockez la valeur de mesure dans la result variable :

operation Main(): Result{

    use q = Qubit();
    H(q);
    let result = M(q);
}

Réinitialiser le qubit

Dans Q#, un qubit doit être dans l’état $\ket{0}$ avant de pouvoir libérer le qubit. Utilisez l’opération Reset pour réinitialiser le qubit à l’état $\ket{0}$.

operation Main(): Result{

    use q = Qubit();
    H(q);
    let result = M(q);
    Reset(q);
}

Retourner le résultat de la mesure

Enfin, retournez le résultat de mesure avec l’instruction return . Ce résultat est un bit aléatoire, soit 0 ou 1 avec une probabilité égale. Copiez le code suivant dans votre Main.qs fichier :

operation Main(): Result{

    use q = Qubit();
    H(q);
    let result = M(q);
    Reset(q);
    return result;
}

Exécuter votre programme de générateur de bits aléatoires

Vous avez créé un programme Q# appelé Main.qs qui alloue un qubit, place le qubit dans un état de superposition égal, mesure le qubit, réinitialise le qubit, puis retourne le résultat de mesure. Voici un récapitulatif de votre code Q# :

operation Main() : Result {
    // Allocate a qubit.
    use q = Qubit();

    // Set the qubit into superposition of 0 and 1 using the Hadamard 
    H(q);

    // Measure the qubit and store the result.
    let result = M(q);

    // Reset qubit to the |0〉 state.
    Reset(q);

    // Return the result of the measurement.
    return result;
}

Remarque

Le // symbole représente des commentaires facultatifs qui expliquent chaque étape du programme. Les commentaires sont ignorés par le compilateur.

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 sur la console de débogage dans le terminal.

Le résultat est soit Zero , Onechacun avec une chance de 50%. La valeur de mesure de ce bit sur un ordinateur quantique est vraiment aléatoire. Exécutez le programme plusieurs fois pour voir comment le résultat change.

Dans l’unité suivante, vous combinez plusieurs bits aléatoires pour implémenter la deuxième partie de votre générateur de nombres aléatoires quantiques.