Conception et mise en œuvre d'algorithmes quantiques avec la programmation de niveau fonctionnel

Introduction

La modélisation au niveau fonctionnel est la principale différence entre les méthodes existantes de construction de circuits quantiques à base de portes.

Dans cette note d'application, nous allons apprendre à quel point il est simple de concevoir des algorithmes en utilisant la plateforme Classiq. Commençons par l'un des éléments les plus fondamentaux de la conception d'algorithmes quantiques : la préparation de l'état. L'état que nous voulons générer est la distribution suivante de probabilités sur 8 états possibles :

probabilités = [0,4, 0,05, 0,2, 0,05, 0,3, 0, 0, 0]

Étant donné que le vecteur de probabilité couvre 8 états possibles, nous savons que le registre qui stocke les valeurs contient 3 qubits (²³⁼⁸).

Circuit final

Commençons par la fin, avec le circuit final que nous allons créer, et passons ensuite en revue le processus de construction. Au niveau le plus élevé, c'est-à-dire celui auquel nous le concevrons, le circuit est représenté simplement par ce que nous voulons qu'il fasse : préparer un état en utilisant 3 qubits.

Ce bloc est implémenté par des portes sous-jacentes que la plateforme Classiq synthétisera automatiquement en fonction de la fonctionnalité que nous définissons. Le circuit sous-jacent est présenté ci-dessous, avec des blocs de niveau plus fonctionnel exposés.

Nous pouvons mieux comprendre ce circuit en développant un autre bloc. Le concept de base de la programmation au niveau fonctionnel est de concevoir au niveau le plus abstrait et de laisser la plate-forme Classiq calculer la meilleure implémentation de cette conception dans les niveaux inférieurs, basés sur les portes.

Comment construire un modèle fonctionnel

Avec la plateforme Classiq, nous construisons des modèles fonctionnels de l'algorithme quantique, puis nous laissons la plateforme synthétiser le circuit optimisé pour les modèles donnés.

Pour tout algorithme, qu'il soit le plus simple ou le plus complexe, le modèle est construit dans l'IDE Classiq selon trois étapes simples :

1. Définition des blocs fonctionnels - dans notre exemple, nous n'avons qu'un seul bloc fonctionnel, la préparation de l'état.
2. Définir un modèle fonctionnel de haut niveau qui contiendra les blocs fonctionnels.
3. Câbler les blocs dans le modèle fonctionnel de haut niveau.

Tout d'abord, nous devons nous assurer que nous avons la bonne version de Classiq et que nous sommes dans l'environnement de travail approprié. Bien que les fonctionnalités soient équivalentes avec le SDK Classiq Python, cette note d'application présentera notre environnement de développement intégré (IDE) Classiq.

0. Entrer dans la plateforme Classiq

L'IDE Classiq est disponible sur platform.classiq.io avec un accès limité aux utilisateurs académiques et d'entreprise authentifiés.

Une fois l'accès confirmé, connectez-vous en cliquant sur l'icône dans le coin supérieur droit. Un écran de connexion s'affiche, dans lequel les informations d'identification saisies doivent correspondre aux informations d'identification données pour l'authentification.

Après s'être connecté, l'écran de l'IDE affiche quatre sections principales.

• La barre latérale de gauche (grise) indique la synthèse, la visualisation et l'analyse des circuits, et l'exécution - actuellement, c'est la synthèse, où nous concevons nos algorithmes, qui est affichée.
• La section de téléchargement (jaune) permet aux utilisateurs d'introduire des modèles déjà créés dans la plateforme Classiq.
• La section des modèles (rose) est le lieu de la conception, les modèles étant constitués des contraintes qui limitent la taille, la précision, etc. de nos circuits et du flux logique qui indique les fonctionnalités de nos circuits ou les problèmes qu'ils résolvent.
• Le panneau des suites d'applications et de personnalisation (bleu) contient des exemples et des paramètres permettant aux utilisateurs de personnaliser leurs algorithmes.

1. Définition du bloc fonctionnel - flux logique

Le bloc fonctionnel dont nous disposons est la préparation de l'état. Nous définirons un objet StatePreparation qui encapsule la fonctionnalité que nous voulons dans le flux logique de notre modèle. Cet objet reçoit des paramètres, tels que la distribution de probabilité souhaitée et une limite supérieure pour une erreur d'implémentation (puisqu'il y a généralement un compromis entre la précision de l'implémentation et le nombre de qubits et/ou la profondeur du circuit).

Le circuit final met en œuvre la distribution de probabilité souhaitée avec une erreur, dans ce cas - la divergence de Kullback-Leibler, qui est limitée par la borne supérieure de 0,1 donnée. Il s'agit d'une mesure de la proximité des probabilités obtenues par notre circuit par rapport à celles que nous avons définies.

"logic_flow": [
    {
      "function": "StatePreparation",
      "function_params": {
        "probabilities": [
          0.4,
          0.05,
          0.2,
          0.05,
          0.3,
          0,
          0,
          0
        ],
        "error_metric": {
          "KL": {
            "upper_bound": 0.1
          }
        }
      }
    }
  ]

 2. Définition du modèle fonctionnel de haut niveau - Contraintes matérielles

Le modèle fonctionnel de haut niveau encapsule la fonctionnalité de notre algorithme - en particulier le bloc StatePreparation que nous avons défini. Le modèle est stocké dans le bloc de code .json composé du flux logique que nous avons déjà défini, ainsi que de toutes les contraintes matérielles ; dans ce cas, nous empêchons la synthèse de tout circuit comportant plus de 12 qubits ou plus de 200 portes sur le qubit le plus utilisé.

Nous pouvons ajouter ces contraintes en tapant le code suivant ou en entrant les valeurs dans la section de personnalisation des contraintes sur le panneau de droite, qui ajuste automatiquement le code du modèle.

"constraints": {
    "max_width": 12,
    "max_depth": 200
  },

 3. Câblage des blocs dans le modèle fonctionnel de haut niveau

Dans l'IDE, nous combinons ou câblons nos blocs fonctionnels ensemble dans le flux logique, et comme nous n'avons qu'une seule fonction (notre StatePreparation), notre modèle est entièrement conçu et prêt pour la synthèse. Nous verrons des exemples plus sophistiqués dans les prochaines notes d'application montrant le câblage des fonctions ensemble, avec de nombreux exemples de programmes disponibles dans notre documentation.

Pour synthétiser notre circuit, il suffit de cliquer sur le bouton Synthèse dans le coin inférieur droit.

Voilà, c'est fait ! Nous avons notre circuit et nous pouvons explorer les niveaux fonctionnels en interagissant avec les icônes plus/moins sur le circuit ou en utilisant la barre d'outils à droite.

Exécution d'un modèle fonctionnel

 Nous pouvons maintenant exécuter notre circuit pour obtenir les résultats des mesures. Lorsque nous naviguons vers l'onglet Execution, nous voyons toutes les options matérielles listées avec le fournisseur - IBM Quantum, Azure Quantum, AWS Braket, IonQ, ou NVIDIA - et le type - simulateur ou matériel - des filtres.

Choisissons le simulateur ibm_qasm_simulator, utilisons 1000 clichés et cliquons sur "Exécuter".

Une barre de progression s'affiche au fur et à mesure de l'exécution du circuit, puis les résultats s'affichent.

Le nombre de mesures est indiqué dans l'histogramme, et nous pouvons également télécharger nos résultats d'exécution sous la forme d'un fichier .json contenant plus d'informations.

Félicitations !

Avec peu d'effort ou de compréhension du niveau de notre algorithme basé sur les portes, nous avons pu définir ce que nous voulions exécuter au plus haut niveau et utiliser la plateforme Classiq pour synthétiser le circuit pour nous. Dans cette note d'application, nous avons appris ce qu'est la programmation au niveau fonctionnel et nous avons conçu un algorithme simple de préparation d'état avec l'IDE Classiq. Pour plus d'informations sur la plateforme Classiq, visitez notre site web ou notre documentation ou planifiez une démonstration.

‍