Que sont Q# et les Quantum Development Kit?

  • Article

Le Quantum Development Kit (QDK) est le Kit de développement logiciel (SDK) requis pour l’interface avec le service Azure Quantum. Il est intégré au portail Azure Quantum, où vous pouvez développer des programmes à l’aide des notebooks Jupyter hébergés gratuitement. Vous pouvez également installer le QDK localement sur votre ordinateur pour utiliser votre propre environnement de développement local et travailler en ligne et hors connexion avec le service Azure Quantum. Avec , Quantum Development Kitvous pouvez créer des programmes qui s’exécutent sur du matériel quantique ou formuler des problèmes qui s’exécutent sur des résolveurs d’optimisation d’inspiration quantique dans Azure Quantum.

Le QDK inclut le langage de programmation quantique , un langage Q#de programmation open source de haut niveau qui vous permet de concentrer votre travail au niveau de l’algorithme et de l’application pour créer des programmes quantiques.

Le QDK offre une prise en charge pour Q#, mais également pour Qiskit et Cirq pour l’informatique quantique. Par conséquent, si vous travaillez déjà dans d’autres langages de développement, vous pouvez également exécuter vos circuits sur Azure Quantum.

Le QDK contient des composants qui peuvent être utilisés de manière autonome, indépendamment du service Azure Quantum :

Prise en main de Q# et Quantum Development Kit

Pour rentrer directement dans le vif du sujet, vous pouvez explorer Q# sur le portail Azure Quantum sans installation requise. Pour plus d’informations, consultez Prise en main avec Q# et un notebook Azure Quantum.

Pour obtenir d’autres options d’environnement de développement, consultez Configurer .Quantum Development Kit

Le 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. Il fait partie du Quantum Development Kit QDK et est conçu pour être indépendant du matériel, mettre à l’échelle la gamme complète d’applications quantiques et optimiser l’exécution. Pour plus d’informations sur le projet de développement du langage Q#, consultez le Référentiel de conception de Q# et des bibliothèques principales sur GitHub.

Le langage de programmation Q# utilise des éléments connus des langages Python, C# et F#. Il prend en charge un modèle de procédure de base permettant l’écriture de programmes avec des boucles, des instructions if/then ainsi que des types de données courants. Il introduit également de nouvelles structures de données et opérations quantiques spécifiques (par exemple la répétition jusqu’à la réussite et l’estimation de phase adaptative), ce qui permet l’intégration entre calculs quantiques et calculs classiques. Par exemple, le contrôle de flux d’un programme classique peut s’appuyer sur le résultat d’une mesure quantique.

Intégration au calcul quantique et classique

Q# est un langage autonome qui offre un niveau élevé d’abstraction. Il n’existe aucune notion d’état quantique ou de circuit. À la place, Q# implémente des programmes en termes d’instructions et d’expressions, tout comme les langages de programmation classiques. Des fonctionnalités quantiques distinctes (par exemple la prise en charge des foncteurs et des constructions de flux de contrôle) facilitent l’expression, notamment l’estimation de phases et les algorithmes de chimie quantique.

Le langage Q# prend en charge l’intégration à l’informatique classique et quantique. Cela permet de nettoyer l’expression des algorithmes adaptatifs, comme l’estimation de la phase de marche aléatoire, qui sont difficiles à exprimer directement dans le modèle de circuit d’une séquence fixe de portes quantiques.

Q# prend en charge un flux de contrôle classique général lors de l’exécution d’un algorithme. En particulier, le contrôle de flux classique est basé sur les résultats des mesures quantiques, ce qui facilite l’écriture d’objets qui dépendent de mesures intermédiaires. Par exemple, la boucle requise pour les algorithmes probabilistes tels que la recherche Grover peut facilement être exprimée en Q#, plutôt que de devoir revenir au pilote classique pour vérifier si le résultat satisfait à l’oracle, et réexécutée si ce n’est pas le cas.

Les qubits comme références opaques

En Q#, les qubits représentent des ressources demandées au runtime en cas de besoin et retournées lorsqu’elles ne sont plus utilisées. Ce processus est similaire à la façon dont les langages classiques gèrent la mémoire du tas.

En Q#, les qubits sont modélisés comme des types de données opaques qui représentent une référence à un système quantique spécifique à deux états, physique ou logique (corrigé des erreurs), sur lequel des opérations quantiques peuvent être effectuées. Il s’agit d’une vision opérationnelle des qubits : c’est-à-dire ceux-ci sont définis par ce que l’on peut leur faire.

Le mappage d’une variable qubit dans un programme à un qubit logique ou physique réel est décidé par le runtime, et ce mappage peut être différé jusqu’à ce que la topologie et d’autres détails de l’appareil target soient connus. L’exécution est chargée de déterminer une association permettant à l’algorithme de s’exécuter, notamment tout transfert d’état de qubit et toute réassociation nécessaire pendant l’exécution.

La représentation utilisée en Q# revêt une implication intéressante : tout le calcul informatique quantique est effectué par effet secondaire. Il n’y a aucun moyen d’interagir directement avec l’état quantique de l’ordinateur ; aucune représentation logicielle n’est possible. En fait, vous exécutez ces opérations sur les entités qubit, et ces opérations ont pour effet secondaire de modifier l’état quantique. En effet, l’état quantique de l’ordinateur est une variable globale opaque qui est inaccessible, sauf par le biais d’un petit ensemble de primitives d’accesseur (mesures), et ces accesseurs ont eux-mêmes des effets secondaires sur l’état quantique, et sont donc en réalité des « mutateurs avec résultats » plutôt que de véritables accesseurs.

Respecter les lois de la physique

Les programmes quantiques doivent être tenus de respecter les lois de la physique. Par exemple, la copie de l’état d’un qubit ou l’accès direct à l’état qubit ne sont pas possibles en Q#.

Par conséquent, Q# n’a pas la capacité d’aller voir directement dans l’état d’un qubit ou d’autres propriétés de la mécanique quantique, capacité qui garantit qu’un programme en Q# peut être exécuté physiquement sur un ordinateur quantique. Un programme Q# peut appeler des opérations et des fonctions, par exemple DumpOperation operation, pour extraire des informations classiques d’un qubit. Ces informations permettent la validation et l’examen de l’état pour faciliter le débogage avec un simulateur. Pour plus d’informations, consultez Test et débogage.

Indépendant du matériel

Q# est indépendant du matériel, ce qui signifie qu’il fournit les moyens d’exprimer et de tirer parti de puissants concepts d’informatique quantique indépendamment de l’évolution future du matériel. Pour être utilisable dans un large éventail d’applications, Q# vous permet de créer des couches d’abstractions et des composants réutilisables. Pour que le matériel quantique reste performant au fil de son évolution, le langage de programmation quantique Q# garantit la scalabilité des applications et des efforts de développement. Même si la complexité complète de ces calculs nécessite un développement matériel supplémentaire, Q# les programmes peuvent être targetexécutés sur différents back-ends matériels quantiques dans Azure Quantum.

Exécution efficace

Le langage Q# se concentre sur l’expression d’informations pour optimiser l’exécution des composants quantiques, indépendamment du contexte dans lequel ils sont appelés. Q# permet au développeur de communiquer ses connaissances sur un calcul afin que le compilateur puisse prendre une décision éclairée sur la manière de les traduire en instructions, en tirant parti des informations relatives à l’application de bout en bout qui ne sont pas accessibles au développeur.

Pour en savoir plus sur les fonctionnalités QDK et les éléments généraux qui s’intègrent dans un programme Q#, consultez le guide de l’utilisateur du langage Q# de programmation quantique.

Workflow de développement quantique avec le kit de développement Quantum

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.

Tout ce dont vous avez besoin pour écrire et exécuter des programmes Q#, notamment le compilateur Q#, les bibliothèques Q# et les simulateurs quantiques, est prédéployé dans les notebooks Jupyter hébergés dans le portail Azure. Le kit de développement Quantum peut également être installé et exécuté sur un ordinateur local. Vous pouvez donc utiliser votre environnement IDE et votre langage favoris localement pour envoyer des travaux à du matériel quantique ou à des simulateurs cloud dans Azure Quantum, ou travailler avec des simulateurs locaux. Pour plus d’informations, consultez Configuration d’un environnement de développement quantique.

Le diagramme suivant montre les différentes étapes d’un programme quantique, de l’idée à la fin de l’implémentation sur Azure Quantum, et les outils proposés par le QDK pour chaque étape.

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

Notes

Vous utilisez le même code Q# pour toutes les étapes du workflow. À court terme, vous devrez peut-être ajuster certaines parties du code pour prendre en compte les limitations actuelles du matériel. Mais à long terme, vous pourrez basculer entre plusieurs simulateurs et fournisseurs de matériel sans aucune modification de code.

Écrire votre programme quantique

Un programme Q# peut se compiler dans une application autonome, s’exécuter dans un Notebook Jupyter, ou être appelé par un programme hôte écrit en Python ou dans un langage .NET.

Si vous souhaitez commencer à pratiquer et à écrire vos programmes Q# sans installer de logiciels supplémentaires, vous pouvez utiliser les notebooks Jupyter hébergés disponibles dans votre espace de travail Azure Quantum dans le portail Azure. L’exemple de galerie contient une collection d’exemples de notebooks annotés : sélectionnez l’exemple que vous souhaitez explorer et exécutez-le sur des simulateurs basés sur le cloud ou sur des ordinateurs quantiques réels.

Si vous préférez un environnement de développement local, vous pouvez créer votre programme Q# à l’aide de Notebooks Jupyter avec le noyau IQ# ou les extensions du kit de développement Quantum pour Visual Studio Code et Visual Studio 2022, puis les exécuter sur du matériel quantique ou des simulateurs cloud ou locaux.

Quel que soit votre environnement préféré, vous pouvez suivre les didacticiels Q# et commencer à écrire des programmes quantiques pour explorer des concepts quantiques comme la superposition, l’intrication, l’algorithme quantique de Grover et d’autres phénomènes quantiques.

Si vous n’avez pas de compte Azure et que vous souhaitez tester Q# sans installer le QDK localement, vous pouvez utiliser Binder pour exécuter les Q# exemples dans Jupyter Notebooks en ligne.

Explorer des bibliothèques spécifiques à un domaine

Les bibliothèques Q# vous aideront à maintenir votre code à un niveau élevé, ce qui vous permettra d’exécuter des opérations quantiques complexes sans avoir à concevoir des séquences d’opérations de bas niveau. Les nouveaux projets Q# incluent automatiquement la bibliothèque standardQ#, qui fournit un ensemble de fonctions et d’opérations essentielles et très utiles pour écrire des programmes quantiques en Q#.

En plus de la bibliothèque standard, le QDK comprend une bibliothèque de chimie quantique permettant de simuler des problèmes de dynamique quantique et de structure électronique sur des ordinateurs quantiques, une bibliothèque d’apprentissage automatique quantique fournissant une implémentation des classificateurs séquentiels qui tirent parti de l’informatique quantique pour exécuter des expériences d’apprentissage automatique hybride quantique/classique, et une bibliothèque numérique quantique prenant en charge un large éventail de fonctionnalités numériques.

Exécuter des programmes dans des simulateurs

Une fois que vous avez écrit votre programme, le kit de développement Quantum vous offre un ensemble de simulateurs quantiques : il s’agit de programmes classiques qui simulent le comportement d’un système quantique. Vous pouvez ainsi exécuter une petite instance de votre programme et voir ce qu’il fait sans avoir accès au matériel réel. Vous pouvez exécuter vos programmes quantiques sur un simulateur quantique d’état complet, un simulateur de Toffoli à portée limitée, un simulateur de parcimonie pour les systèmes avec un grand nombre de qubits, ou même utiliser le simulateur de bruit pour simuler le comportement des programmes en Q# sous l’influence d’environnements bruyants.

Consultez la liste complète des simulateurs quantiques.

Estimer les ressources

Avant de procéder à l’exécution sur du matériel quantique, vous devez déterminer si votre programme peut s’exécuter sur du matériel existant et évaluer le nombre de ressources qui seront consommées. Vous pouvez utiliser le simulateur de trace pour estimer le nombre de qubits et de portes quantiques dont vous avez besoin et déboguer du code classique qui fait partie de votre programme quantique.

Vous pouvez également soumettre votre programme quantique à l’estimateur targetde ressources Azure Quantum dans Portail Azure. L’estimateur de ressources Azure Quantum calcule l’estimation des ressources physiques après la disposition en tenant compte des hypothèses relatives aux paramètres de qubit, aux codes de correction d’erreur quantique et à un budget d’erreur. Il est gratuit et nécessite un compte Azure.

Envoyer des travaux au service Azure Quantum

Azure Quantum, le service d’informatique quantique cloud d’Azure, contient un ensemble diversifié de solutions et de technologies quantiques. Azure Quantum offre une voie ouverte, flexible et évolutive vers l'informatique quantique qui vous permet d'exécuter votre programme sur du matériel quantique. Vous pouvez exécuter vos programmes Q# Qiskit, Cirq et Qiskit sur plusieurs systèmes quantiques. Pour connaître la liste actuelle des fournisseurs de matériel pris en charge, consultez Fournisseurs d’informatique quantique.

Conseil

Les utilisateurs pour la première fois obtiennent automatiquement des crédits Azure Quantumgratuits de 500 $ (USD) à utiliser avec chaque fournisseur de matériel quantique participant. Si vous avez consommé tous les crédits et voulez en obtenir davantage, vous pouvez vous inscrire au programme de crédits Azure Quantum.

Une fois que vous avez créé un espace de travail Azure Quantum, vous pouvez soumettre vos programmes Q# (également appelés travaux) à Azure Quantum par le biais de votre environnement de développement favori, à la fois 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 Qiskit ou Cirq.

Le diagramme suivant illustre le workflow de base après l’envoi de votre travail :

Diagramme montrant l’autorisation de travail après une soumission de travail à Azure Quantum.

Azure Quantum propose certaines des ressources quantiques les plus fascinantes et diverses disponibles aujourd’hui auprès des leaders du secteur. Avec Azure Quantum et le QDK, pouvez écrire des programmes d’informatique quantique et d’optimisation d’inspiration quantique, et les envoyer à Azure Quantum pour qu’ils soient exécutés sur du matériel quantique et des résolveurs d’optimisation.

Étapes suivantes

Si vous souhaitez en savoir plus, les katas quantiques offrent une bonne introduction aux concepts de l’informatique quantique, comme les opérations quantiques courantes et la manipulation des qubits.