Quels sont les principaux composants d’un programme Q# ?

Avant d’écrire vos propres programmes quantiques, il est important de comprendre la structure et les composants du langage de programmation Q#.

Dans cette unité, vous allez découvrir les composants de base d’un programme Q#.

Opération Main

Chaque programme Q# doit contenir au moins une opération. Le compilateur Q# commence à exécuter un programme à partir de l’opération de point d’entrée, qui est l’opération Main par défaut. Par exemple, le programme Q# suivant contient une opération appelée Main qui crée un qubit et retourne une mesure de l’état du qubit :

// This operation is the entry point to your program because it's name is Main
operation Main() : Result {
    use q = Qubit();
    return M(q);
}

Votre code Q# ne peut pas s’exécuter sans opération de point d’entrée. Si vous souhaitez utiliser une opération autre que Main votre point d’entrée, utilisez l’attribut @EntryPoint() . Par exemple, le code suivant donne à l’opération précédente un nom plus descriptif, MeasureOneQubitet définit cette opération comme point d’entrée de votre programme Q# :

// The @EntryPoint() attribute tells the compiler to start running your code from this operation
@EntryPoint()
operation MeasureOneQubit() : Result {
    use q = Qubit();
    return M(q);
}

Les types

Q# fournit de nombreux types de données intégrés que vous connaissez peut-être déjà, tels que Int, Double, Boolet String. Q# fournit également des types spécifiques à l’informatique quantique, tels que Qubit et Result.

Par exemple, l’opération MeasureOneQubit retourne une Result valeur de type. Le Result type représente l’état d’un qubit lorsque le qubit est mesuré et peut avoir une valeur de l’un ou l’autre ZeroOne.

Bibliothèques quantiques

Q# est fourni avec plusieurs bibliothèques qui contiennent des fonctions et des opérations pour vous aider à écrire des programmes quantiques. Pour appeler une fonction ou une opération à partir d’une bibliothèque, utilisez le import mot clé et spécifiez l’espace de noms de la bibliothèque. Par exemple, pour utiliser la Message fonction à partir de l’espace Microsoft.Quantum.Intrinsic de noms dans la bibliothèque quantique standard, utilisez le code suivant :

// import all functions and operations from Microsoft.Quantum.Intrinsic 
import Microsoft.Quantum.Intrinsic.*;

operation Main() : Unit {
    // call the Message function from Microsoft.Quantum.Intrinsic
    Message("Hello quantum world!");
}

L’astérisque signifie que vous importez toutes les fonctions de l’espace de noms Microsoft.Quantum.Intrinsic. Vous pouvez également importer uniquement la Message fonction :

// import only the Message function from Microsoft.Quantum.Intrinsic 
import Microsoft.Quantum.Intrinsic.Message;

operation Main() : Unit {
    // call the Message function from Microsoft.Quantum.Intrinsic
    Message("Hello quantum world!");
}

Vous pouvez importer des espaces de noms dans la bibliothèque standard avec Std au lieu de Microsoft.Quantum. Par exemple, le code suivant importe toutes les fonctions et opérations depuis l’espace de noms Microsoft.Quantum.Intrinsic :

// import everything from Std.Intrinsic (Microsoft.Quantum.Intrinsic)
import Std.Intrinsic.*;

operation Main() : Unit {
    // call the Message function from Std.Intrinsic
    Message("Hello quantum world!");
}

Pour explorer la bibliothèque standard Q#, consultez la référence de l’API.

Allocation de qubits

Pour allouer un qubit en Q#, utilisez le use mot clé et le Qubit type. Qubits que vous allouez avec le use mot clé commencent toujours dans l’état $\ket{0} $.

Vous pouvez allouer un qubit unique ou plusieurs qubits dans un tableau de qubits. Voici un exemple qui alloue un qubit unique dans la variable q1 et un tableau de cinq qubits dans q5:

use q1 = Qubit();  // Allocate one qubit
use q5 = Qubit[5]; // Allocate five qubits

Mesure de qubit

En Q#, l’opération Measure effectue une mesure conjointe d’un ou de plusieurs qubits dans les bases de Pauli spécifiées, qui peuvent être PauliX, PauliY ou PauliZ. L’opération retourne un Measure type Result dont la valeur est soit Zero ou One.

Pour effectuer une mesure dans la base de calcul $\lbrace\ket{c0},\ket{c1}\rbrace$, vous pouvez également utiliser l’opération M. L’opération M équivaut à l’opération Measure dans la base Pauli-Z. M([qubit]) Elle se comporte donc exactement de la même façon que Measure([PauliZ], [qubit]). Toutefois, l’opération M accepte uniquement les qubits uniques comme entrée, et non les tableaux qubits.

Réinitialiser les qubits

Dans Q#, les qubits doivent être dans l’état $\ket{0}$ pour les libérer. Lorsque vous avez terminé d’utiliser un qubit, appelez l’opération Reset pour réinitialiser le qubit à l’état $\ket{0}$. Par exemple, le code suivant alloue un qubit, mesure l’état du qubit, puis réinitialise le qubit :

operation Main() : Result {
    use q = Qubit();
    let result = M(q);

    // Reset the qubit so that you can release it
    Reset(q);

    return result;
    }