Démarrage rapide : Créer votre premier Q# programme

Article
10/29/2024

Découvrez comment écrire un programme de base Q# qui illustre l’inanglement, un concept clé de l’informatique quantique.

Lorsque deux qubits ou plus sont enchevêtrés, ils partagent des informations quantiques , ce qui signifie que tout ce qui arrive à un qubit arrive également à l’autre. Dans ce guide de démarrage rapide, vous créez un état enchevêtré à deux qubits particulier appelé paire Bell. Dans une paire Bell, si vous mesurez un qubit dans l’état $\ket{0}$ , vous savez que l’autre qubit est également dans l’état $\ket{0}$ sans la mesurer. Pour plus d’informations, consultez l’enchevêtrement Quantum.

Dans ce guide de démarrage rapide, vous :

Créez un fichier Q# .
Allouez une paire de qubits.
Entangle les qubits.

Prérequis

La dernière version de Visual Studio Code.
Extension QDK (Azure Quantum Development Kit). Pour plus d’informations sur l’installation, consultez Configurer le Kit de développement Quantum.

Créez un fichier Q#

Ouvrez Visual Studio Code.
Sélectionnez Fichier>nouveau fichier texte.
Enregistrez le fichier sous le nom Main.qs. L’extension .qs désigne un Q# programme.

Écrire votre Q# code

Dans votre Main.qs fichier, suivez ces étapes pour entangler et mesurer une paire de qubits.

Importer une bibliothèque quantique

Le QDK inclut la Q# bibliothèque standard avec des fonctions et des opérations prédéfinies pour vos programmes quantiques. Pour les utiliser, vous devez d’abord importer la bibliothèque appropriée.

Dans votre programme, utilisez une import instruction pour ouvrir la Microsoft.Quantum.Diagnostics bibliothèque. Cela vous permet d’accéder à toutes ses fonctions et opérations, notamment DumpMachine(), que vous utilisez ultérieurement pour afficher l’état enchevêtré.

    import Microsoft.Quantum.Diagnostics.*;

Définir une opération

Après avoir importé les bibliothèques pertinentes, définissez votre opération quantique et ses valeurs d’entrée et de sortie. Pour ce guide de démarrage rapide, votre opération est Main. C’est là que vous allez écrire le code restant Q# pour allouer, manipuler et mesurer deux qubits.

Mainne prend aucun paramètre et retourne deux Result valeurs, soit OneZero , qui représentent les résultats des mesures qubit :

    operation Main() : (Result, Result) {
        // Your entanglement code goes here.
}

Allouer deux qubits

L’opération est actuellement vide. L’étape Main suivante consiste donc à allouer deux qubits et q1 q2. Dans Q#, vous allouez des qubits à l’aide du use mot clé :

        // Allocate two qubits, q1 and q2, in the 0 state.
        use (q1, q2) = (Qubit(), Qubit());

Remarque

Dans Q#, les qubits sont toujours alloués dans l’état $\ket{0}$ .

Placer un qubit en superposition

Les qubits q1 et q2 sont dans l’état $\ket{0}$ . Pour préparer les qubits pour l’enchevêtrement, vous devez placer l’un d’entre eux dans une superposition même, où il a une probabilité de 50 % d’être mesuré en tant que $\ket{0}$ ou $\ket{1}$.

Vous placez un qubit dans la superposition en appliquant hadamard, Hopération :

        // Put q1 into an even superposition.
        H(q1);

L’état résultant est q1 $\frac{{1}{\sqrt{2}}(\ket{{0}+\ket{1}),$ qui est une superposition égale de $\ket{0}$ et .$\ket{{1}$

Entangler les qubits

Vous êtes maintenant prêt à entasser les qubits à l’aide de l’opération contrôlée-NOT. CNOT CNOT est une opération de contrôle qui prend deux qubits, l’un agissant comme le contrôle et l’autre comme cible.

Pour ce guide de démarrage rapide, vous définissez q1 en tant que qubit de contrôle et q2 en tant que qubit cible. Cela signifie CNOT retourner l’état du q2 moment où l’état est q1 $\ket{1}$.

        // Entangle q1 and q2, making q2 depend on q1.
        CNOT(q1, q2);

L’état résultant des deux qubits est la paire $\frac{{1}{\sqrt{2}}Bell (\ket{00}+\ket{{11})$.

Conseil

Si vous souhaitez découvrir comment les opérations Hadamard et CNOT transforment l’état des qubits, consultez Création d’un entanglement avec des opérations quantiques.

Afficher l’état enchevêtré

Avant de mesurer les qubits, il est important de vérifier que votre code précédent les entasse correctement. Vous pouvez utiliser l’opération DumpMachine , qui fait partie de la Microsoft.Quantum.Diagnostics bibliothèque, pour générer l’état actuel de votre Q# programme :

        // Show the entangled state of the qubits.
        DumpMachine();

Mesurer les qubits

Maintenant que vous avez vérifié que les qubits sont enchevêtrés, vous pouvez utiliser l’opération M pour les mesurer. Mesurer q1 et q2 réduire leurs états quantiques dans Zero ou One avec même la probabilité.

Dans Q#, vous utilisez le let mot clé pour déclarer une nouvelle variable. Pour stocker les résultats de mesure des q1 variables m1 et q2m2les déclarer respectivement :

        // Measure q1 and q2 and store the results in m1 and m2.
        let (m1, m2) = (M(q1), M(q2));

Réinitialiser les qubits

Avant d’être libérés à la fin de chaque Q# programme, les qubits doivent être dans l’état $\ket{0}$ . Pour ce faire, utilisez l’opération Reset :

        // Reset q1 and q2 to the 0 state.
        Reset(q1);
        Reset(q2);

Retourner les résultats de la mesure

Enfin, pour terminer l’opération Main et observer l’état enchevêtré, retournez les résultats de mesure et m1 m2:

        // Return the measurement results.
        return (m1, m2);

Conseil

Si vous souhaitez en savoir plus sur une fonction ou une Q# opération, pointez dessus.

Capture d’écran des détails qui s’affichent lorsque vous pointez sur l’opération « H » dans Visual Studio Code.

Exécuter votre Q# code

Félicitations ! Vous avez écrit un Q# programme qui entangle deux qubits et crée une paire Bell.

Votre programme final Q# doit ressembler à ceci :

import Microsoft.Quantum.Diagnostics.*;

operation Main() : (Result, Result) {  
    // Allocate two qubits, q1 and q2, in the 0 state.
    use (q1, q2) = (Qubit(), Qubit());
    
    // Put q1 into an even superposition.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q1);
    
    // Entangle q1 and q2, making q2 depend on q1.
    CNOT(q1, q2);
    
    // Show the entangled state of the qubits.
    DumpMachine();
    
    // Measure q1 and q2 and store the results in m1 and m2.
    let (m1, m2) = (M(q1), M(q2));
    
    // Reset q1 and q2 to the 0 state.
    Reset(q1);
    Reset(q2);
    
    // Return the measurement results.
    return (m1, m2);
}

Pour exécuter votre programme et afficher le résultat des deux qubits, sélectionnez Exécuter au-dessus de l’opération Main ou appuyez sur Ctrl+F5

Capture d’écran du Q# fichier dans Visual Studio Code montrant où rechercher la commande « Exécuter ».

Vous pouvez exécuter le programme plusieurs fois, chacun avec un résultat différent dans la console de débogage. Cela illustre la nature probabiliste des mesures quantiques et l’enchevêtrement des qubits.

Par exemple, si le résultat est Zero, votre console de débogage doit ressembler à ceci :

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
  |00⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
  |11⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

Result: "(Zero, Zero)"

Étape suivante

Pour en savoir plus sur l’enchevêtrement quantique avec Q#, consultez Tutoriel : Explorer l’enchevêtrement quantique avec Q#. Ce tutoriel s’étend sur les concepts abordés dans ce guide de démarrage rapide et vous aide à écrire un programme d’inanglement plus avancé.

Partager via