Partager via

Présentation du langage de programmation quantique Q#

Q# est un langage de programmation open source de haut niveau développé par Microsoft pour écrire des programmes quantiques. Q# est inclus dans le Kit de développement Quantum (QDK). Pour plus d’informations, consultez Configurer le Kit de développement Quantum.

En tant que langage de programmation quantique, Q# répond aux exigences suivantes pour le langage, le compilateur et le runtime :

  • Indépendant du matériel : Les qubits dans les algorithmes quantiques ne sont pas liés à un matériel ou une disposition quantique spécifique. Le Q# compilateur et le runtime gèrent le mappage entre les qubits de programme et les qubits physiques, ce qui permet au même code de s’exécuter sur différents processeurs quantiques.
  • Intégration de l’informatique quantique et classique :Q# permet l’intégration de calculs quantiques et classiques, qui est essentiel pour l’informatique quantique universelle.
  • Gestion des qubits :Q# fournit des opérations et des fonctions intégrées pour la gestion des qubits, notamment la création d’états de superposition, des qubits d’enchevêtrement et l’exécution de mesures quantiques.
  • Respectez les lois de la physique :Q# et les algorithmes quantiques doivent suivre les règles de la physique quantique. Par exemple, vous ne pouvez pas copier ou accéder directement à l’état qubit dans Q#.

Pour plus d'informations sur les origines de Q#, consultez le billet de blog Pourquoi avons-nous besoin de Q#?.

Structure d’un Q# programme

Avant de commencer à écrire Q# des programmes, il est important de comprendre leur structure et leurs composants. Considérez le programme suivant Q# , nommé Superposition, qui crée un état de superposition :

namespace Superposition {
    @EntryPoint()
    operation MeasureOneQubit() : Result {
        // Allocate a qubit. By default, it's in the 0 state.  
        use q = Qubit();  
        // Apply the Hadamard operation, H, to the state.
        // It now has a 50% chance of being measured as 0 or 1.
        H(q);      
        // Measure the qubit in the Z-basis.
        let result = M(q);
        // Reset the qubit before releasing it.
        Reset(q);
        // Return the result of the measurement.
        return result;
    }
}

En fonction des commentaires (//), le Q# programme alloue d’abord un qubit, applique une opération pour placer le qubit en superposition, mesure l’état du qubit, réinitialise le qubit et retourne enfin le résultat.

Nous allons décomposer ce Q# programme en ses composants.

Espaces de noms utilisateur

Q# les programmes peuvent éventuellement commencer par un espace de noms défini par l’utilisateur, par exemple :

namespace Superposition {
    // Your code goes here.
}

Les espaces de noms peuvent vous aider à organiser les fonctionnalités associées. Les espaces de noms sont facultatifs dans Q# les programmes, ce qui signifie que vous pouvez écrire un programme sans définir d’espace de noms.

Par exemple, le programme superposition de l’exemple peut également être écrit sans espace de noms comme suit :

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Remarque

Chaque Q# programme ne peut avoir qu’un namespaceseul . Si vous ne spécifiez pas d’espace de noms, le Q# compilateur utilise le nom de fichier comme espace de noms.

Points d’entrée

Chaque Q# programme doit avoir un point d’entrée, qui est le point de départ du programme. Par défaut, le Q# compilateur démarre l’exécution d’un programme à partir de l’opération Main() , le cas échéant, qui peut se trouver n’importe où dans le programme. Si vous le souhaitez, vous pouvez utiliser l’attribut @EntryPoint() pour spécifier n’importe quelle opération dans le programme comme point d’exécution.

Par exemple, dans le programme superposition , l’opération MeasureOneQubit() est le point d’entrée du programme, car elle a l’attribut @EntryPoint() avant la définition de l’opération :

@EntryPoint()
operation MeasureOneQubit() : Result {
    ...
}

Toutefois, le programme peut également être écrit sans l’attribut @EntryPoint() en renommant l’opération MeasureOneQubit()Main(), par exemple :

// The Q# compiler automatically detects the Main() operation as the entry point. 

operation Main() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Types

Les types sont essentiels dans n’importe quel langage de programmation, car ils définissent les données qu’un programme peut utiliser. Q#fournit des types intégrés qui sont communs à la plupart des langages, notamment Int, , DoubleBool, et Stringdes types qui définissent des plages, des tableaux et des tuples.

Q# fournit également des types spécifiques à l’informatique quantique. Par exemple, le Result type représente le résultat d’une mesure qubit et peut avoir deux valeurs : Zero ou One.

Dans le programme Superposition , l’opération MeasureOneQubit() retourne un Result type, qui correspond au type de retour de l’opération M . Le résultat de la mesure est stocké dans une nouvelle variable définie à l’aide de l’instruction let :

// The operation definition returns a Result type.
operation MeasureOneQubit() : Result {
    ...
    // Measure the qubit in the Z-basis, returning a Result type.
    let result = M(q);
    ...
}

Un autre exemple de type spécifique au quantum est le Qubit type, qui représente un bit quantique.

Q# vous permet également de définir vos propres types personnalisés. Pour plus d’informations, consultez Déclarations de type.

Allocation de qubits

Dans Q#, vous allouez des qubits à l’aide du use mot clé et du Qubit type. Les qubits sont toujours alloués dans l’état $\ket{0}$ .

Par exemple, le programme superposition définit un qubit unique et le stocke dans la variable q:

// Allocate a qubit.
use q = Qubit();

Vous pouvez également allouer plusieurs qubits et accéder à chacun par le biais de son index :

use qubits = Qubit[2]; // Allocate two qubits.
H(qubits[0]); // Apply H to the first qubit.
X(qubits[1]); // Apply X to the second qubit.

Opérations quantiques

Après avoir alloué un qubit, vous pouvez le transmettre aux opérations et aux fonctions. Les opérations sont les blocs de construction de base d’un Q# programme. Une Q# opération est une sous-routine quantique ou une routine appelante qui contient des opérations quantiques qui modifient l’état du registre qubit.

Pour définir une Q# opération, vous spécifiez un nom pour l’opération, ses entrées et sa sortie. Dans le programme Superposition , l’opération MeasureOneQubit() ne prend aucun paramètre et retourne un Result type :

operation MeasureOneQubit() : Result {
    ...
}

Voici un exemple de base qui ne prend aucun paramètre et attend aucune valeur de retour. La valeur Unit est équivalente à NULL dans d’autres langues.

operation SayHelloQ() : Unit {
    Message("Hello quantum world!");
}

La Q# bibliothèque standard fournit également des opérations que vous pouvez utiliser dans des programmes quantiques, tels que l’opération Hadamard, Hdans le Superposition programme. Étant donné un qubit sur la base Z, H place le qubit dans une superposition même, où il a une probabilité de 50 % d’être mesurée en tant que Zero ou One.

Mesure des qubits

Bien qu’il existe de nombreux types de mesures quantiques, Q# se concentre sur les mesures projectives sur des qubits uniques, également appelées mesures Pauli.

Dans Q#, l’opération Measure mesure un ou plusieurs qubits dans la base Pauli spécifiée, qui peut être PauliX, PauliYou PauliZ. Measure renvoie un type Result soit Zero soit One.

Pour implémenter une mesure dans la base computationnelle $\lbrace\ket{0},\ket{1}\rbrace$, vous pouvez également utiliser l’opération M, qui mesure un qubit dans la base de Pauli Z. Cela équivaut M à Measure([PauliZ], [qubit]).

Par exemple, le programme Superposition utilise l’opération M :

// Measure the qubit in the Z-basis.
let result = M(q);

Réinitialisation de qubits

Dans Q#, les qubits doivent être dans l’état $\ket{0}$ lorsqu’ils sont libérés pour éviter les erreurs dans le matériel quantique. Vous pouvez réinitialiser un qubit à l’état $\ket{0}$ à l’aide de l’opération Reset à la fin du programme. L’échec de la réinitialisation d’un qubit entraîne une erreur d’exécution.

// Reset a qubit.
Reset(q);

Espaces de noms de bibliothèque standard

La Q# bibliothèque standard a des espaces de noms intégrés qui contiennent des fonctions et des opérations que vous pouvez utiliser dans les programmes quantiques. Par exemple, l’espace Microsoft.Quantum.Intrinsic de noms contient des opérations et des fonctions couramment utilisées, telles que M la mesure des résultats et Message l’affichage des messages utilisateur n’importe où dans le programme.

Pour appeler une fonction ou une opération, vous pouvez spécifier l’espace de noms complet ou utiliser une import instruction, ce qui rend toutes les fonctions et opérations de cet espace de noms disponibles et rend votre code plus lisible. Les exemples suivants appellent la même opération :

Microsoft.Quantum.Intrinsic.Message("Hello quantum world!");

// imports all functions and operations from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.*;
Message("Hello quantum world!");

// imports just the `Message` function from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.Message;
Message("Hello quantum world!");

// namespaces in the standard library may be imported using `Std` instead of `Microsoft.Quantum`. 
import Std.Intrinsic.*;
Message("Hello quantum world!");

Remarque

Le programme Superposition n’a pas d’instructions import ni d’appels avec des espaces de noms complets. Cela est dû au fait que l’environnement Q# de développement charge automatiquement deux espaces de noms : Microsoft.Quantum.Core et Microsoft.Quantum.Intrinsic, qui contiennent des fonctions et des opérations couramment utilisées.

Vous pouvez tirer parti de l’espace Microsoft.Quantum.Measurement de noms à l’aide de l’opération MResetZ pour optimiser le programme Superposition . MResetZ combine les opérations de mesure et de réinitialisation en une seule étape, comme dans l’exemple suivant :

// Import the namespace for the MResetZ operation.
import Microsoft.Quantum.Measurement.*;

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.      
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1. 
    H(q);   
    // Measure and reset the qubit, and then return the result value.
    return MResetZ(q);
}

Apprendre à développer des programmes quantiques avec Q# et Azure Quantum

Q# et Azure Quantum sont une combinaison puissante pour le développement et l’exécution de programmes quantiques. Avec Q# et Azure Quantum, vous pouvez écrire des programmes quantiques, simuler leur comportement, estimer les besoins en ressources et les exécuter sur du matériel quantique réel. Cette intégration vous permet d’explorer le potentiel de l’informatique quantique et de développer des solutions innovantes pour des problèmes complexes. Qu’il s’agisse d’un débutant ou d’un développeur quantique expérimenté, Q# azure Quantum fournit les outils et les ressources dont vous avez besoin pour déverrouiller la puissance du calcul quantique.

Le diagramme suivant montre les étapes à travers lesquelles un programme quantique passe lorsque vous le développez avec Q# et Azure Quantum. Votre programme commence par l’environnement de développement et se termine par la soumission du travail à du matériel quantique réel.

Diagramme montrant le flux de travail du développement de programmation quantique.

Nous allons décomposer les étapes du diagramme.

Choisir votre environnement de développement

Exécutez vos programmes quantiques dans votre environnement de développement préféré. Vous pouvez utiliser l’éditeur de code en ligne sur le site web Azure Quantum, les notebooks Jupyter hébergés dans votre espace de travail Azure Quantum dans le Portail Azure ou dans un environnement de développement local avec Visual Studio Code. Pour plus d’informations, consultez Différentes façons d’exécuter Q# des programmes.

Écrire votre programme quantique

Vous pouvez écrire des programmes quantiques dans Q# en utilisant le Kit de développement quantique (QDK). Pour commencer, consultez Démarrage rapide : Créer votre premier Q# programme.

En outre, le QDK offre une prise en charge d’autres langages Q#pour l’informatique quantique, comme Qiskit et Cirq.

Intégrer à Python

Vous pouvez utiliser Q# lui-même ou avec Python dans différents IDE. Par exemple, vous pouvez utiliser un Q# projet avec un programme hôte Python pour appeler Q# des opérations ou l’intégrer Q# à Python dans Jupyter Notebooks. Pour plus d’informations, consultez Intégration de Q# et Python.

La commande %%qsharp

Par défaut, Q# les programmes dans Jupyter Notebooks utilisent le ipykernel package Python. Pour ajouter du code Q# à une cellule de bloc-notes, utilisez la commande %%qsharp, qui est activée avec le paquet Python qsharp, suivie de votre code Q#.

Lorsque vous utilisez %%qsharp, gardez à l’esprit ce qui suit :

  • Vous devez d’abord exécuter import qsharp pour activer %%qsharp.
  • %%qsharp se limite à la cellule de notebook dans laquelle il apparaît et change le type de cellule de Python à Q#.
  • Vous ne pouvez pas placer d’instruction Python avant ou après %%qsharp.
  • Q# le code qui suit %%qsharp doit respecter la Q# syntaxe. Par exemple, utilisez // plutôt que de # désigner des commentaires et ; pour mettre fin aux lignes de code.

Estimer les ressources

Avant d’exécuter sur du matériel quantique réel, vous devez déterminer si votre programme peut s’exécuter sur du matériel existant et le nombre de ressources qu’il consommera.

L’estimateur de ressources Azure Quantum vous permet d’évaluer les décisions architecturales, de comparer les technologies qubit et de déterminer les ressources nécessaires pour exécuter un algorithme quantique donné. Vous pouvez choisir parmi les protocoles prédéfinis à tolérance de panne et spécifier des hypothèses du modèle qubit physique sous-jacent.

Pour plus d’informations, consultez Exécuter votre première estimation de ressource.

Remarque

L’estimateur de ressources Azure Quantum est gratuit et ne nécessite pas de compte Azure.

Exécuter votre programme dans la simulation

Lorsque vous compilez et exécutez un programme quantique, le QDK crée une instance du simulateur quantique et lui transmet le Q# code. Le simulateur utilise le code Q# pour créer des qubits (simulations de particules quantiques) et appliquer des transformations afin de changer leur état. Les résultats des opérations quantiques dans le simulateur sont ensuite retournés au programme. L’isolation du code Q# dans le simulateur garantit que les algorithmes suivent les lois de la physique quantique et s’exécutent correctement sur les ordinateurs quantiques.

Soumettre votre programme à du matériel quantique réel

Une fois que vous avez testé votre programme en simulation, vous pouvez l’exécuter sur du matériel quantique réel. Lorsque vous exécutez un programme quantique dans Azure Quantum, vous créez et exécutez un travail. Pour envoyer un travail aux fournisseurs Azure Quantum, vous avez besoin d’un compte Azure et d’un espace de travail quantique. Si vous n’avez pas d’espace de travail quantique, consultez Créer un espace de travail Azure Quantum.

Azure Quantum offre certains des matériels quantiques les plus attrayants et diversifiés. Pour connaître la liste actuelle des fournisseurs de matériel pris en charge, consultez Fournisseurs d’informatique quantique.

Une fois que vous avez envoyé votre travail, Azure Quantum gère le cycle de vie des travaux, notamment la planification, l’exécution et la supervision des travaux. Vous pouvez suivre l’état de votre travail et afficher les résultats dans le portail Azure Quantum.

Contenu connexe