Exercice – Utiliser Copilot pour exécuter un programme quantique

Effectué

Dans cette unité, vous allez apprendre à utiliser Copilot dans Azure Quantum pour explorer l’informatique quantique et la programmation quantique. Copilot est un outil basé sur l’intelligence artificielle qui peut générer du code Q# à partir de vos prompts et engager des conversations sur l’informatique quantique. Vous pouvez également exécuter votre code et demander à Copilot d’expliquer les concepts de l’informatique quantique.

Pour commencer à explorer Copilot et à coder dans Azure Quantum, utilisez un des exemples de la liste déroulante Exemples Quantum.

Exécuter un programme quantique

1. Accédez au code dans Azure Quantum.

2. Sélectionnez Exemples Quantum, puis sélectionnez Générateur de nombres aléatoires. Le code suivant est copié dans la fenêtre de code.

   /// # Sample
   /// Quantum Random Number Generator
   ///
   /// # Description
   /// This program implements a quantum ranndom number generator by setting qubits
   /// in superposition and then using the measurement results as random bits.
   import Microsoft.Quantum.Measurement;
   import Microsoft.Quantum.Intrinsic;
   
       operation Main() : Result[] {
           // Generate 5-bit random number.
           let nBits = 5;
           return GenerateNRandomBits(nBits);
       }
   
       /// # Summary
       /// Generates N random bits.
       operation GenerateNRandomBits(nBits : Int) : Result[] {
           // Allocate N qubits.
           use register = Qubit[nBits];
   
           // Set the qubits into superposition of 0 and 1 using the Hadamard
           // operation `H`.
           for qubit in register {
               H(qubit);
           }
   
           // At this point each has 50% chance of being measured in the |0〉 state
           // and 50% chance of being measured in the |1〉 state.
           // Measure each qubit and reset them all so they can be safely
           // deallocated.
           let results = MeasureEachZ(register);
           ResetAll(register);
           return results;
       }
   

3. Sélectionnez Simulateur en mémoire.

4. Sélectionnez Exécuter.

   • Les résultats sont affichés dans le champ Résultats et un histogramme des résultats est affiché sous la fenêtre de code.
   • Vous pouvez déplacer le curseur pour sélectionner le nombre d’essais afin de spécifier le nombre de fois que le programme est exécuté.
   • Le champ Essais affiche le résultat pour chaque essai.

Pour réexécuter votre programme en utilisant un autre simulateur :

1. Sélectionnez la liste déroulante Simulateur en mémoire, puis sélectionnez Émulateur Quantinuum H-Series.

2. Sélectionnez le nombre d’essais (actuellement limités à 20), puis sélectionnez Exécuter.

   • L’état du travail s’affiche en haut de la fenêtre de code.
   • Un histogramme des résultats s’affiche sous la fenêtre de code. Les résultats de chaque essai ne sont actuellement pas disponibles avec l’émulateur Quantinuum H-Series.

Demander à Copilot

Vous pouvez interroger Copilot dans Azure Quantum sur presque tout ce qui est lié au quantique. Par exemple, posez les questions suivantes à Copilot et regardez ce qui se passe :

• « Expliquer l’opération MResetZ »
• « Écrire du code Q# qui intrique deux qubits »
• « Expliquer l’interférence quantique »
• « Quelle est la différence entre un qubit et un bit classique ? »