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#. Vous êtes désormais prêt à écrire votre premier programme quantique, un programme quantique permettant de générer des nombres vraiment aléatoires.

Vous créez votre générateur de nombres aléatoires quantiques en deux phases. Dans cette unité, vous créez la première phase, qui consiste à générer un bit aléatoire unique.

Créer le programme Q#

1. Ouvrez Visual Studio Code et sélectionnez Fichier > Nouveau fichier texte pour créer un fichier.
2. Enregistrez le fichier sous le nom Main.qs. Ce fichier contient le code Q# de votre programme.

Définir l’opération Main

L’opération Main est le point d’entrée de votre programme.

operation Main(): Result{

    // Your code goes here

}

Allouer un qubit

Vous commencez par allouer un qubit avec le mot clé use. En Q#, chaque qubit que vous allouez commence par défaut dans l’état $\ket{0}$.

operation Main(): Result{

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

}

Placer le qubit en superposition

Le qubit est dans l’état $\ket{0}$, ce qui n’est pas très utile pour la génération de nombres aléatoires. Vous devez placer le qubit en superposition. Pour ce faire, vous appliquez l’opération Hadamard, H, au qubit. L’opération Hadamard change l’état du qubit, et le place dans une superposition égale de $\ket{0}$ et $\ket{1}$.

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

Dans la mesure où le qubit est dans une superposition égale, quand vous le mesurez, vous avez 50 % de chances d’obtenir 0, et 50 % de chances d’obtenir 1.

operation Main(): Result{

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

Mesurer le qubit

À ce stade, le qubit q a 50 % de chances d’être mesuré dans l’état |0〉 et 50 % de chances d’être mesuré dans l’état |1〉. Ainsi, si vous mesurez le qubit, vous obtenez un bit aléatoire, 0 ou 1, avec une probabilité égale de 50 %. La valeur de ce bit est vraiment aléatoire. Il n’existe aucun moyen de connaître à l’avance le résultat de la mesure.

Pour mesurer la valeur du qubit, utilisez l’opération M, puis stockez la valeur de la mesure dans la variable result.

operation Main(): Result{

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

Réinitialiser le qubit

En Q#, tous les qubits doivent être à l’état $\ket{0}$ au moment où ils sont libérés. Vous utilisez Reset(q) pour réinitialiser le qubit à l’état zéro.

operation Main(): Result{

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

Retourner le résultat de la mesure

Enfin, vous retournez le résultat de la mesure avec le mot clé return. Ce résultat est un bit aléatoire, 0 ou 1, avec une probabilité égale.

operation Main(): Result{

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

Programme final

Votre fichier Main.qs doit ressembler à ceci. Le programme alloue un qubit, le place en superposition, mesure le qubit, réinitialise le qubit, puis retourne le résultat de la mesure.

Remarque

Le symbole // représente les commentaires facultatifs permettant d’expliquer chaque étape du programme.

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;
}

Exécuter le programme

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

Le résultat est One ou Zero, ce qui représente un bit vraiment aléatoire. Vous pouvez réexécuter le programme pour voir un résultat différent.

Dans l’unité suivante, vous implémentez la deuxième phase de votre générateur de nombres quantiques aléatoires : la combinaison de plusieurs bits aléatoires pour former un plus grand nombre.