Présentation du langage de programmation quantique Q#
Q#est un langage de programmation open source de haut niveau pour le développement et l’exécution d’algorithmes 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 de langage, de compilateur et d’exécution suivantes :
- 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 compilateur et le Q# runtime gèrent le mappage entre les qubits de programme et les qubits physiques.
- Intègre l’informatique quantique et classique : la possibilité d’effectuer des calculs classiques et quantiques est essentielle dans un ordinateur quantique universel.
- Respecte les lois de la physique :Q# et les algorithmes quantiques suivent les règles de la physique quantique. Par exemple, vous ne pouvez pas copier ou accéder directement à l’état qubit dans Q#.
Structure d’un Q# programme
Avant de commencer à écrire des programmes quantiques, il est important de comprendre leur structure et leurs composants. Considérez le programme suivant Q# 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 Superposition 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 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. Chaque Q# programme ne peut avoir qu’un namespaceseul . Si aucun espace de noms n’est spécifié, le Q# compilateur utilise le nom de fichier comme espace de noms. Par exemple, le Superposition programme peut être écrit 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;
}
La Q# bibliothèque standard a des espaces de noms prédéfinis qui contiennent des fonctions et des opérations que vous pouvez utiliser dans les programmes quantiques. Pour plus d’informations, consultez espaces de noms intégrés.
Points d’entrée
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.
Dans le Superposition programme, l’opération la plus descriptive MeasureOneQubit() est le point d’entrée du programme.
@EntryPoint()
operation MeasureOneQubit() : Result {
...
Toutefois, le programme peut également être écrit sans l’attribut @EntryPoint() en renommant l’opération MeasureOneQubit() sur Main():
// 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
Q#fournit des types intégrés qui sont communs à la plupart des langages, notamment Int, , DoubleBool, et Stringdes types spécifiques à l’informatique quantique. Par exemple, le Result type représente le résultat d’une mesure qubit et peut avoir l’une des deux valeurs suivantes : Zero ou One.
Dans le Superposition programme, 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);
...
Q# fournit également des types qui définissent des plages, des tableaux et des tuples. Vous pouvez même définir vos propres types personnalisés.
Allocation de qubits
Dans Q#, vous allouez des qubits à l’aide du use mot clé. Les qubits sont toujours alloués dans l’état $\ket{0}$ .
Le Superposition programme définit un qubit unique :
// 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.
Pour plus d’informations, consultez l’instruction Use.
Opérations quantiques
Après avoir alloué un qubit, vous pouvez le transmettre aux opérations et fonctions, également appelées callables. Les opérations sont à la base des programmes en Q#. 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, l’opération Superposition MeasureOneQubit() est essentiellement l’ensemble du programme. Il 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 Unit valeur est équivalente dans NULL 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 retourne un Result type de l’un ou de l’autre Zero One.
Pour implémenter une mesure dans la base $de calcul \lbrace,\ket{1}\rbrace\ket{0}$, vous pouvez également utiliser l’opérationM, qui mesure un qubit dans la base Pauli Z. Cela équivaut M à Measure([PauliZ], [qubit]).
Le Superposition programme 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. Utilisez l’opération Reset pour réinitialiser chaque qubit à l’état avant de la $\ket{0}$ libérer à 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 intégrés
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!");
Le Superposition programme n’a import pas d’instructions 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 Superposition programme. 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);
}
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.
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 à Q# l’aide du Kit de développement Quantum (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. Vous pouvez également intégrer Q# Python dans Jupyter Notebooks. Pour plus d’informations, consultez Différentes façons d’exécuter Q# des programmes.
Commande %%qsharp
Par défaut, Q# les programmes dans Jupyter Notebooks utilisent le ipykernel package Python. Pour ajouter Q# du code à une cellule de bloc-notes, utilisez la %%qsharp commande, qui est activée avec le qsharp package Python, suivie de votre Q# code.
Lorsque vous utilisez %%qsharp, gardez à l’esprit ce qui suit :
- Vous devez d’abord exécuter
import qsharppour activer%%qsharp. %%qsharpétendues à la cellule de notebook dans laquelle elle apparaît et modifie le type de cellule de Python en Q#.- Vous ne pouvez pas placer d’instruction Python avant ou après
%%qsharp. - Q# le code qui suit
%%qsharpdoit respecter la Q# syntaxe. Par exemple, utilisez//plutôt que de#désigner des commentaires et;pour mettre fin aux lignes de code.
Remarque
Les notebooks Azure de l’Portail Azure incluent les dernières versions des qsharp packages Python et azure-quantum vous n’avez donc pas besoin d’installer quoi que ce soit. Pour plus d’informations, consultez Bien démarrer avec Q# les notebooks Azure Quantum.
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
Vous pouvez soumettre vos Q# programmes (également appelés travaux) à Azure Quantum via votre environnement de développement préféré, localement et en ligne. Pour plus d’informations, consultez Comment soumettre des travaux Q#. Vous pouvez également exécuter et envoyer des circuits quantiques écrits dans des langages Qiskit et Cirq.
Azure Quantum offre aujourd’hui quelques-uns des matériels quantiques les plus attrayants et diversifiés disponibles auprès des leaders du secteur. Pour connaître la liste actuelle des fournisseurs de matériel pris en charge, consultez Fournisseurs d’informatique quantique.
Remarque
La cible quantinuum H-Series Emulator basée sur le cloud est disponible sans compte Azure. Pour soumettre un travail au reste des 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.
Le diagramme suivant illustre le workflow de base après l’envoi de votre travail :
