Tutoriel : Implémenter un générateur de nombres aléatoires quantique en Q#

Dans ce tutoriel, vous allez apprendre à écrire un programme quantique de base qui Q# tire parti de la nature de la mécanique quantique pour produire un nombre aléatoire.

Dans ce didacticiel, vous allez :

Prérequis

Pour exécuter l’exemple de code dans Copilot dans Azure Quantum, vous devez disposer d’un compte de messagerie Microsoft (MSA).

Pour développer et exécuter l’exemple de code dans Visual Studio Code (VS Code) et Jupyter Notebook, installez les éléments suivants :

• Dernière version de VS Code ou ouvrir VS Code pour le web.

• La dernière version de l’extension Azure Quantum Development Kit (QDK). Pour plus d’informations sur l’installation, consultez Configurer l’extension QDK.

• Extensions Python et Jupyter pour VS Code.

• La dernière qdk bibliothèque Python avec la fonctionnalité supplémentaire jupyter. Pour les installer, ouvrez un terminal et exécutez la commande suivante :

  pip install --upgrade "qdk[jupyter]"
  

Définir le problème

Les ordinateurs classiques ne produisent pas de nombres aléatoires, mais plutôt des nombres pseudorandom. Un générateur de nombres pseudo-random génère une séquence déterministe de nombres en fonction d’une valeur initiale, appelée valeur initiale. Pour obtenir la meilleure approximation possible des valeurs aléatoires, cette valeur seed est souvent l’heure actuelle de l’horloge du processeur.

Les ordinateurs quantiques, d’autre part, peuvent générer des nombres vraiment aléatoires. Cela est dû au fait que la mesure d’un qubit en superposition est un processus probabiliste. Le résultat de la mesure est aléatoire, il n’existe aucun moyen de prédire le résultat. C’est le principe de base des générateurs de nombres aléatoires quantiques.

Un qubit est une unité d’informations quantiques qui peuvent être en superposition. Lorsqu’il est mesuré, un qubit ne peut être qu’à l’état 0 ou dans l’état 1. Toutefois, avant la mesure, l’état du qubit représente la probabilité de lire un 0 ou un 1 avec une mesure.

Pour commencer, prenez un qubit dans un état basique, par exemple zéro. La première étape du générateur de nombres aléatoires consiste à utiliser une opération Hadamard pour placer le qubit dans une superposition égale. La mesure de cet état entraîne un zéro ou un avec une probabilité de 50 % de chaque résultat, un bit vraiment aléatoire.

Il n’existe aucun moyen de savoir ce que vous obtiendrez après la mesure du qubit en superposition, et le résultat est une valeur différente chaque fois que le code est appelé. Mais comment pouvez-vous utiliser ce comportement pour générer des nombres aléatoires plus grands ?

Supposons que vous répétiez le processus quatre fois, ce qui générerait cette suite de chiffres binaires :

$${0, 1, 1, 0}$$

Si vous concaténez (ou combinez) ces bits dans une chaîne binaire, vous pouvez obtenir un nombre plus grand. Dans cet exemple, la séquence de bits ${0110}$ est équivalente à 6 en décimal.

$${0110_{\ binary} \equiv 6_{\ decimal}}$$

Si vous répétez ce processus plusieurs fois, vous pouvez combiner plusieurs bits pour former un grand nombre. À l’aide de cette méthode, vous pouvez créer un nombre à utiliser comme mot de passe sécurisé, car vous pouvez être sûr qu’aucun pirate n’a pu déterminer les résultats de la séquence de mesures.

Définir la logique du générateur de nombres aléatoires

Décrivons la logique d’un générateur de nombres aléatoires :

1. Définissez max comme le nombre maximal à générer.
2. Définissez le nombre de bits aléatoires à générer. Pour ce faire, calculez le nombre de bits, nBitsvous devez exprimer des entiers jusqu’à max.
3. Générez une chaîne de bits aléatoires dont la longueur est nBits.
4. Si la chaîne de bits représente un nombre supérieur à max, revenez à l’étape 3.
5. Sinon, l’opération est terminée. Retournez le nombre généré sous la forme d’un entier.

À titre d’exemple, nous allons définir max sur 12. Autrement dit, 12 est le plus grand nombre que vous souhaitez utiliser comme mot de passe.

Vous avez besoin de ${\lfloor ln(12) / ln(2) + 1 \rfloor}$, ou de 4 bits pour représenter un nombre compris entre 0 et 12. Nous pouvons utiliser la fonction BitSizeIintégrée, qui prend n’importe quel entier et retourne le nombre de bits requis pour le représenter.

Mettons que vous générez la chaîne de bits ${1101_{\ binary}}$, qui est équivalente à $ ${13_{\ decimal}}$. Comme 13 est supérieur à 12, vous devez répéter le processus.

Ensuite, vous générez la chaîne de bits ${0110_{\ binary}}$, qui est équivalente à ${6_{\ decimal}}$. Étant donné que 6 est inférieur à 12, le processus est terminé.

Le générateur de nombres aléatoires quantiques retourne le numéro 6 comme mot de passe. Dans la pratique, définissez un nombre plus grand comme valeur maximale, car les nombres inférieurs sont faciles à craquer en essayant juste tous les mots de passe possibles. En fait, pour augmenter la difficulté de deviner ou de craquer votre mot de passe, vous pouvez utiliser le code ASCII pour convertir le binaire en texte et générer un mot de passe en utilisant des chiffres, des symboles et un mélange de lettres majuscules et minuscules.

Écrire un générateur de bits aléatoire

La première étape consiste à écrire une Q# opération qui génère un bit aléatoire. Cette opération sera l’un des blocs de construction du générateur de nombres aléatoires.

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

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

    // At this point the qubit `q` has 50% chance of being measured in the
    // |0〉 state and 50% chance of being measured in the |1〉 state.
    // Measure the qubit value using the `M` operation, and store the
    // measurement value in the `result` variable.
    let result = M(q);

    // Reset qubit to the |0〉 state.
    // Qubits must be in the |0〉 state by the time they are released.
    Reset(q);

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

Examinons à présent le nouveau code.

• Vous définissez l’opération GenerateRandomBit, qui ne prend aucune entrée et produit une valeur de type Result. Le type Result représente le résultat d’une mesure et peut avoir deux valeurs : Zero ou One.
• Vous allouez un qubit unique avec le use mot clé. Lorsqu’il est alloué, un qubit est toujours dans l’état |0〉.
• Vous utilisez l’opération H pour placer le qubit dans une superposition égale.
• Vous utilisez l’opération M pour mesurer le qubit, renvoyer la valeur mesurée (Zero ou One).
• Vous utilisez l’opération Reset pour réinitialiser le qubit à l’état |0〉.

En plaçant le qubit en superposition avec l’opération H et en le mesurant avec l’opération M, le résultat est une valeur différente chaque fois que le code est appelé.

Visualiser le Q# code avec la sphère Bloch

Dans la sphère Bloch, le pôle nord représente la valeur classique 0 et le pôle sud représente la valeur classique 1. Toute superposition peut être représentée par un point sur la sphère (représentée par une flèche). Plus l’extrémité de la flèche est proche d’un pôle, plus la probabilité est élevée que le qubit soit réduit à la valeur classique attribuée à ce pôle lors de la mesure. Par exemple, l’état qubit représenté par la flèche de la figure suivante a une probabilité plus élevée de donner la valeur 0 si vous la mesurez.

Vous pouvez utiliser cette représentation pour visualiser ce que fait le code :

1. Tout d’abord, commencez par un qubit initialisé dans l’état |0〉 et appliquez une H opération pour créer une superposition égale dans laquelle les probabilités pour 0 et 1 sont identiques.

   

2. Ensuite, mesurez le qubit et enregistrez la sortie :

   

Étant donné que le résultat de la mesure est aléatoire et que les probabilités de mesurer 0 et 1 sont identiques, vous avez obtenu un bit complètement aléatoire. Nous pouvons appeler cette opération plusieurs fois pour créer des entiers. Par exemple, si vous appelez l’opération trois fois pour obtenir trois bits aléatoires, vous pouvez générer des nombres de 3 bits aléatoires (c’est-à-dire, un nombre aléatoire compris entre 0 et 7).

Écrire un générateur de nombres aléatoires complet

1. Tout d’abord, vous devez importer les espaces de noms requis de la Q# bibliothèque standard dans le programme. Le Q# compilateur charge automatiquement de nombreuses fonctions et opérations courantes, mais pour le générateur de nombres aléatoires complet, vous avez besoin de certaines fonctions et opérations supplémentaires à partir de deux Q# espaces de noms : Std.Mathet Std.Convert.

   import Std.Convert.*;
   import Std.Math.*;
   

2. Ensuite, vous définissez l’opération GenerateRandomNumberInRange . Cette opération appelle à plusieurs reprises l’opération GenerateRandomBit pour générer une chaîne de bits.

   /// Generates a random number between 0 and `max`.
   operation GenerateRandomNumberInRange(max : Int) : Int {
       // Determine the number of bits needed to represent `max` and store it
       // in the `nBits` variable. Then generate `nBits` random bits which will
       // represent the generated random number.
       mutable bits = [];
       let nBits = BitSizeI(max);
       for idxBit in 1..nBits {
           bits += [GenerateRandomBit()];
       }
       let sample = ResultArrayAsInt(bits);
   
       // Return random number if it is within the requested range.
       // Generate it again if it is outside the range.
       return sample > max ? GenerateRandomNumberInRange(max) | sample;
   }
   
   

   Prenons un moment pour examiner ce nouveau code.

   • Vous devez calculer le nombre de bits nécessaires pour exprimer des entiers jusqu’à max. La BitSizeI fonction du Std.Math namespace convertit un entier en nombre de bits nécessaires pour le représenter.
   • L’opération SampleRandomNumberInRange utilise une boucle for pour générer des nombres aléatoires jusqu’à générer une valeur inférieure ou égale à max. La boucle for fonctionne exactement de la même façon qu’une boucle for dans d’autres langages de programmation.
   • La variable bits est une variable mutable. Une variable mutable peut changer pendant le calcul. Vous devez utiliser la directive set pour modifier la valeur d’une variable mutable.
   • La ResultArrayAsInt fonction, à partir de l’espace de noms par défaut Std.Convert , convertit la chaîne de bits en entier positif.

3. Enfin, vous ajoutez un point d’entrée au programme. Par défaut, le Q# compilateur recherche une Main opération et commence à y traiter. Elle appelle l’opération GenerateRandomNumberInRange pour générer un nombre aléatoire compris entre 0 et 100.

   operation Main() : Int {
       let max = 100;
       Message($"Sampling a random number between 0 and {max}: ");
   
       // Generate random number in the 0..max range.
       return GenerateRandomNumberInRange(max);
   }
   

   La directive let déclare des variables qui ne changent pas pendant le calcul. Ici, vous définissez la valeur maximale sur 100.

   Pour plus d’informations sur l’opération Main, consultez Points d'entrée.

4. Le code complet du générateur de nombres aléatoires est le suivant :

import Std.Convert.*;
import Std.Math.*;

operation Main() : Int {
    let max = 100;
    Message($"Sampling a random number between 0 and {max}: ");

    // Generate random number in the 0..max range.
    return GenerateRandomNumberInRange(max);
}

/// Generates a random number between 0 and `max`.
operation GenerateRandomNumberInRange(max : Int) : Int {
    // Determine the number of bits needed to represent `max` and store it
    // in the `nBits` variable. Then generate `nBits` random bits which will
    // represent the generated random number.
    mutable bits = [];
    let nBits = BitSizeI(max);
    for idxBit in 1..nBits {
        bits += [GenerateRandomBit()];
    }
    let sample = ResultArrayAsInt(bits);

    // Return random number if it is within the requested range.
    // Generate it again if it is outside the range.
    return sample > max ? GenerateRandomNumberInRange(max) | sample;
}

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

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

    // At this point the qubit `q` has 50% chance of being measured in the
    // |0〉 state and 50% chance of being measured in the |1〉 state.
    // Measure the qubit value using the `M` operation, and store the
    // measurement value in the `result` variable.
    let result = M(q);

    // Reset qubit to the |0〉 state.
    // Qubits must be in the |0〉 state by the time they are released.
    Reset(q);

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

Exécuter le programme de génération de nombres aléatoires

Vous pouvez exécuter le programme dans Copilot dans Azure Quantum, et dans Visual Studio Code en tant qu’application autonome Q# ou à l’aide d’un programme hôte Python.

Contenu connexe

Explorez les autres tutoriels Q# :

• L'intrication quantique montre comment écrire un Q# programme qui manipule et mesure des qubits et illustre les effets de la superposition et de l'intrication.
• L’algorithme de recherche de Grover montre comment écrire un Q# programme qui utilise l’algorithme de recherche de Grover.
• Quantum Fourier Transforms explore comment écrire un Q# programme qui traite directement des qubits spécifiques.
• Les Katas Quantiques sont des tutoriels auto-dirigés et des exercices de programmation visant à enseigner les éléments de l'informatique quantique et de la programmation simultanément.