Débogage et test de votre code quantique

Article
02/10/2024

Comme pour la programmation classique, il est essentiel de pouvoir vérifier que les programmes quantiques fonctionnent comme prévu et de pouvoir diagnostiquer un comportement incorrect. Cet article décrit les outils proposés par Azure Quantum Development Kit pour tester et déboguer des programmes quantiques.

Débogage de votre Q# programme

L’extension Visual Studio Code Azure Quantum Development Kit (QDK moderne) inclut un débogueur pour Q# les programmes. Vous pouvez définir des points d’arrêt, parcourir votre code et dans chaque fonction ou opération, et suivre non seulement les variables locales, mais également l’état quantique des qubits.

Notes

Le débogueur VS Code fonctionne uniquement avec Q# des fichiers (.qs) et ne fonctionne pas avec Q# les cellules d’un Jupyter Notebook. Pour tester Jupyter Notebook cellules, consultez Test de votre code.

L’exemple suivant illustre les fonctionnalités de base du débogueur. Pour plus d’informations sur l’utilisation des débogueurs VS Code, consultez Débogage.

Dans VS Code, créez et enregistrez un fichier .qs avec le code suivant :

namespace Sample {

    open Microsoft.Quantum.Arrays;
    open Microsoft.Quantum.Convert;

    @EntryPoint()
    operation Superposition() : Result {

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

Définissez un point d’arrêt sur la ligne H(qubit) en cliquant à gauche du numéro de ligne.
Sélectionnez l’icône de débogueur pour ouvrir le volet débogueur, puis sélectionnez Exécuter et déboguer. Les contrôles du débogueur s’affichent en haut de l’écran.
Sélectionnez F5 pour démarrer le débogage et passer au point d’arrêt. Dans le volet Variables du débogueur, développez la catégorie État quantique . Vous pouvez voir que le qubit a été initialisé dans l’état |0> .
Pas à pas détaillé (F11) de l’opération H et du code source de l’opération s’affichent H . À mesure que vous parcourez l’opération, notez que la valeur quantique change à mesure que l’opération H place le qubit en superposition.
Lorsque vous parcourez (F10) l’opération M , la valeur quantique est résolue en |0> ou |1> à la suite de la mesure, et la valeur de la variable result classique s’affiche.
Lorsque vous parcourez l’opération Reset , le qubit est réinitialisé à |0>.

Test de votre code

Bien que le débogueur VS Code Q# ne soit pas disponible pour Q# les cellules d’un Jupyter Notebook, le QDK moderne fournit des expressions et des fonctions qui peuvent vous aider à résoudre les problèmes de votre code.

Expression d’échec

L’expression fail met entièrement fin au calcul, ce qui correspond à une erreur irrécupérable qui arrête le programme.

Prenons cet exemple simple qui valide une valeur de paramètre :

import qsharp 
# import qsharp package to acccess the %%qsharp magic command

%%qsharp 
// use the %%qsharp magic command to change the cell type from Python to Q#

function PositivityFact(value : Int) : Unit {

    if value <= 0 {

            fail $"{value} isn't a positive number.";
    }   
}
PositivityFact(0);

Error: program failed: 0 isn't a positive number.
Call stack:
    at PositivityFact in line_2
Qsc.Eval.UserFail

  × runtime error
  ╰─▶ program failed: 0 isn't a positive number.
   ╭─[line_2:5:1]
 5 │ 
 6 │             fail $"{value} isn't a positive number.";
   ·             ────────────────────┬───────────────────
   ·                                 ╰── explicit fail
 7 │     }   
   ╰────

Ici, l’expression fail empêche le programme de continuer à s’exécuter avec des données non valides.

Fact(), fonction

Vous pouvez implémenter le même comportement que l’exemple précédent à l’aide de la Fact() fonction de l’espace Microsoft.Quantum.Diagnostics de noms . La Fact() fonction évalue une condition classique donnée et lève une exception si elle a la valeur false.

import qsharp 
# import qsharp package to acccess the %%qsharp magic command

%%qsharp
// use the %%qsharp magic command to change the cell type from Python to Q#

    function PositivityFact(value : Int) : Unit {

    Fact(value > 0, "Expected a positive number."); 

    }
    PositivityFact(4);

Error: program failed: Expected a positive number.
Call stack:
    at Microsoft.Quantum.Diagnostics.Fact in diagnostics.qs
    at PositivityFact in line_4
Qsc.Eval.UserFail

  × runtime error
  ╰─▶ program failed: Expected a positive number.
    ╭─[diagnostics.qs:29:1]
 29 │         if (not actual) {
 30 │             fail message;
    ·             ──────┬─────
    ·                   ╰── explicit fail
 31 │         }
    ╰────

DumpMachine(), fonction

DumpMachine() est une Q# fonction qui vous permet de vider des informations sur l’état actuel de la target machine sur la console et de continuer à exécuter votre programme.

Notes

Avec la publication d’Azure Quantum Development Kit, la fonction utilise désormais l’ordre DumpMachine() big-endian pour sa sortie.

import qsharp

%%qsharp

open Microsoft.Quantum.Diagnostics;

operation MultiQubitDumpMachineDemo() : Unit {
    use qubits = Qubit[2];
    X(qubits[1]);
    H(qubits[1]);
    
    DumpMachine();

    R1Frac(1, 2, qubits[0]);
    R1Frac(1, 3, qubits[1]);
    
    DumpMachine();
    
    ResetAll(qubits);
      }

MultiQubitDumpMachineDemo();

Basis State
(|𝜓ₙ…𝜓₁⟩)	Amplitude	Measurement Probability	Phase
|00⟩	0.7071+0.0000𝑖	 50.0000%	↑	0.0000
|10⟩	−0.7071+0.0000𝑖	 50.0000%	↑	-3.1416

Basis State
(|𝜓ₙ…𝜓₁⟩)	Amplitude	Measurement Probability	Phase
|00⟩	0.5879−0.3928𝑖	 50.0000%	↑	-0.5890
|10⟩	−0.6935+0.1379𝑖	 50.0000%	↑	2.9452

fonction dump_machine()

dump_machine est une fonction Python qui retourne le nombre actuel de qubits alloués et un dictionnaire Python d’amplitudes d’état éparses que vous pouvez analyser. L’utilisation de l’une de ces fonctions dans un Jupyter Notebook vous permet d’effectuer vos opérations à la manière d’un débogueur. À l’aide de l’exemple de programme précédent :

import qsharp 
# import qsharp package to acccess the %%qsharp magic command

%%qsharp
// use the %%qsharp magic command to change the cell type from Python to Q#

use qubits = Qubit[2];
X(qubits[0]);
H(qubits[1]);

dump = qsharp.dump_machine()
dump


Basis State
(|𝜓ₙ…𝜓₁⟩)	Amplitude	Measurement Probability	Phase
|11⟩	0.7071+0.0000𝑖	 50.0000%	↑	0.0000
|01⟩	0.7071+0.0000𝑖	 50.0000%	↑	0.0000

%%qsharp
R1Frac(1, 2, qubits[0]);
R1Frac(1, 3, qubits[1]);

dump = qsharp.dump_machine()
dump

Basis State
(|𝜓ₙ…𝜓₁⟩)	Amplitude	Measurement Probability	Phase
|11⟩	0.5879+0.3928𝑖	 50.0000%	↑	0.5890
|01⟩	0.6935+0.1379𝑖	 50.0000%	↑	0.1963

# you can print an abbreviated version of the values
print(dump)

STATE:
|11⟩: 0.5879+0.3928𝑖
|01⟩: 0.6935+0.1379𝑖

# you can access the current qubit count
dump.qubit_count

# you can access individal states by their index
dump[1]

(0.6935199226610738, 0.1379496896414715)

dump[3]

(0.5879378012096794, 0.3928474791935511)