Dans cette note d'application, nous discuterons des différents types de contraintes quantiques, de leur importance et de la manière dont la plateforme logicielle de conception d'algorithmes quantiques Classiq permet aux utilisateurs de satisfaire ces contraintes et d'étudier les compromis entre elles.

À propos des contraintes

Nous vivons dans un monde de contraintes. En informatique classique, l'abondance des algorithmes de tri montre qu'à chaque contrainte correspond un compromis, et qu'il n'existe pas de solution unique qui soit la meilleure dans tous les cas. Le tri rapide est très rapide mais est limité par son implémentation correcte, le tri en tas nécessite peu de mémoire mais peut être limité par la vitesse, et ainsi de suite. Les contraintes sont les barrières entre le possible et l'impossible.

En informatique quantique, cela se traduit par diverses propriétés mesurables : nombre de qubits, temps de décohérence, profondeur des circuits, ensembles de portes de base, etc. 

Ces contraintes quantiques dictent le potentiel, avec de nombreux compromis qui méritent d'être étudiés. Peut-être qu'une institution financière intéressée par l'optimisation de portefeuilles à l'aide d'algorithmes hybrides quantiques/classiques se soucie davantage du nombre de qubits que de la précision pure de la solution. Ou encore, une entreprise de logistique intéressée par la résolution de problèmes de satisfiabilité à l'aide d'algorithmes purement quantiques se préoccupe davantage de la profondeur du circuit, car les erreurs s'ajoutent à chaque porte. Les contraintes quantiques ne sont pas universelles. Chaque cas d'utilisation quantique s'accompagne de priorités différentes, et si chaque fournisseur de matériel a des contraintes différentes, cela vaut la peine de rester ouvert et portable car le leader de la course aux armements quantiques se déplace souvent.

Les ordinateurs quantiques d'aujourd'hui seront remplacés en temps voulu, leur potentiel étant de plus en plus limité. Nous avons déjà vu du matériel avec un nombre de qubits à un chiffre dépassé par ceux qui se comptent maintenant par centaines, IBM prévoyant une machine à 1000 qubits d'ici 2023. Les entreprises souhaitent tirer le maximum de performances des ordinateurs existants avec leurs contraintes actuelles, tout en étant suffisamment flexibles pour s'adapter à un nouvel ensemble de contraintes avec les futures générations d'ordinateurs quantiques.

Classiq offre une plateforme logicielle unique pour aider les entreprises à créer des logiciels quantiques optimisés, en tirant parti des machines d'aujourd'hui tout en se préparant à celles de demain. Grâce à la plateforme Classiq, les utilisateurs peuvent passer facilement d'un fournisseur de matériel à l'autre en tenant compte de leurs contraintes spécifiques. Le puissant moteur de synthèse de Classiq prend en compte des modèles fonctionnels de haut niveau (par exemple, une définition de ce que le logiciel doit faire) et un ensemble de contraintes définies par l'utilisateur. La plateforme transforme ensuite ces modèles en un logiciel implémentable qui fournit la fonctionnalité tout en respectant les contraintes, prêt à être exécuté sur le fournisseur de matériel quantique de son choix.

Sans avoir à spécifier quelles portes se connectent à quels qubits, les utilisateurs peuvent se concentrer sur ce qui peut être réalisé avec quelles contraintes, tandis que la plateforme Classiq s'occupe du comment. Pour ce faire, elle explore un vaste espace de conception des implémentations possibles, cherchant à trouver une méthode pour respecter la fonctionnalité ainsi que les contraintes. Ainsi, lorsque les contraintes changent, il suffit de générer un nouveau circuit en utilisant le modèle fonctionnel existant.

Examinons quelques contraintes quantiques et leurs compromis qui peuvent être mis en œuvre avec Classiq.

Précision du circuit

La précision d'un circuit peut être représentée de plusieurs façons et est une mesure de la proximité de notre résultat par rapport à nos attentes. Par exemple, dans un circuit qui prépare des qubits dans un certain état, que ce soit en spécifiant la fonction de masse de probabilité ou le mélange gaussien, Classiq offre plusieurs métriques d'erreur à utiliser - la divergence de Kullback-Leibler (KL), les normes Lp , et plus encore. Aujourd'hui, nous allons montrer comment nous travaillons avec la métrique KL. 

Supposons que nous devions initialiser 3 qubits dans l'état suivant :

Nous pouvons y parvenir en appelant la fonction Classiq State Preparation et en spécifiant les probabilités. Commençons par définir notre contrainte comme une erreur KL maximale de 1% ou une précision de 99% pour chaque état.

Classiq propose deux méthodes équivalentes pour concevoir des circuits quantiques : un modèle textuel accessible sous forme de plugin VSCode ou un SDK Python.

Voici à quoi ressemble cette préparation d'état dans le modèle textuel :

{
   "logic_flow": [{
       "function": "StatePreparation",
       "function_params": {
         "probabilities": {"pmf": [0.05, 0.11, 0.13, 0.23, 0.27, 0.12, 0.03, 0.06]},
         "error_metric": {"KL": {"upper_bound": 0.01}}
       }
     }
   ]
 }

Et avec le SDK Python :

from classiq import ModelDesigner
from classiq.builtin_functions import StatePreparation
from classiq.interface.generator.state_preparation import PMF

model_designer = ModelDesigner()
probabilities = (0.05, 0.11, 0.13, 0.23, 0.27, 0.12, 0.03, 0.06)

params = StatePreparation(probabilities=PMF(pmf=probabilities),
                         error_metric={"KL": {"upper_bound": 0.01}})

model_designer.StatePreparation(params=params)

circuit = model_designer.synthesize()
circuit.show()
print(circuit.qasm)

Lorsque nous générons ce circuit, le code de l'utilisateur est envoyé à Classiq via le cloud, le moteur de synthèse trouve le circuit optimal, le résultat est renvoyé à l'utilisateur, et le code envoyé au cloud est automatiquement supprimé, Classiq ne conservant que les métriques relatives à la réussite de la synthèse. Voici notre résultat dans VS Code :

Nous avons simplement spécifié les probabilités et la précision, et nous obtenons ce circuit avec 4 qubits actionnés par une variété de portes. Comme nous voulions trois qubits dans cet état spécifique (marqués de _q0 à _q2), nous voyons qu'un qubit auxiliaire, _q3, a été automatiquement généré pour faciliter les calculs lors de la préparation de nos trois qubits.

À côté de l'image du circuit généré, nous pouvons voir sur le côté droit le code Open QASM 2.0 qui le met en œuvre.

Mais que se passe-t-il si nous ne disposons pas des ressources nécessaires pour avoir un circuit aussi précis, ou si nous préférons préserver les ressources quantiques pour les étapes ultérieures de notre algorithme ? Voyons à quoi ressemble un circuit avec une erreur KL de 5 %.

Il suffit d'un petit changement pour obtenir des résultats très différents. Nous pouvons voir à quel point ces précisions sont différentes en collant notre code Open QASM 2.0 dans le Quantum Composer d'IBM.

Comme il est très facile de modifier les circuits quantiques avec du code fonctionnel, les utilisateurs peuvent consacrer beaucoup plus de temps à l'étude des compromis ou à la création de nouvelles idées de circuits. Voyons un autre exemple de contrainte quantique.

Largeur du circuit

La largeur d'un circuit quantique est le nombre de qubits dans le circuit. Contrairement aux circuits classiques, les circuits quantiques ne peuvent circuler que dans un seul sens, la largeur ou le nombre de qubits déterminant la forme du circuit en même temps que la profondeur, dont nous parlerons plus loin. Si certains déclarent que le nombre de qubits d'un ordinateur quantique est le principal facteur contribuant à sa puissance, de nombreux facteurs entrent en ligne de compte pour déterminer quel ordinateur est le mieux adapté à chaque cas.

Supposons que nous ayons besoin de 3 instances de notre préparation d'état à 3 qubits ci-dessus avec une erreur KL de 5%.

Nous nous concentrerons sur le modèle textuel dans la suite de cette note d'application, bien que la fonctionnalité puisse toujours être réalisée avec le SDK Python. Nous appelons notre fonction de préparation de l'état trois fois :

{
	"logic_flow": [
    	{
    	"function": "StatePreparation",
    	"function_params": {
        	"probabilities": {"pmf":[0.05, 0.11, 0.13, 0.23, 0.27, 0.12, 0.03, 0.06]},
        	"error_metric": {"KL": {"upper_bound": 0.05}}
            },
    	"name": "state_preparation_1"
    	},
    	{
    	"function": "StatePreparation",
    	"function_params": {
        	"probabilities": {"pmf":[0.05, 0.11, 0.13, 0.23, 0.27, 0.12, 0.03, 0.06]},
        	"error_metric": {"KL": {"upper_bound": 0.05}}
        	},
    	"name": "state_preparation_2"
    	},
    	{
    	"function": "StatePreparation",
    	"function_params": {
        	"probabilities": {"pmf":[0.05, 0.11, 0.13, 0.23, 0.27, 0.12, 0.03, 0.06]},
        	"error_metric": {"KL": {"upper_bound": 0.05}}
        	},
    	"name": "state_preparation_3"
    	}
	]
}

Et le circuit qui en résulte :

‍

Mais qu'en est-il si nous sommes limités à 10 qubits pour créer ce circuit ? Pouvons-nous créer la même fonctionnalité que celle obtenue avec ce circuit tout en étant limités en largeur ? Essayons d'ajouter une contrainte de nombre de qubits.

Dans notre modèle textuel, nous ajoutons cette ligne juste avant notre flux logique.

"constraints": {"max_width": 10},

Le résultat ?

La synthèse du circuit est réussie. Ce circuit interactif peut être réduit/élargi en cliquant sur l'icône -/+ dans le coin supérieur gauche de chaque bloc. Nous avons économisé 2 qubits, tout en créant un circuit plus profond, grâce à la plateforme Classiq qui explore automatiquement la réutilisation des qubits auxiliaires, comme on peut le voir ici sur q3 _{et q7}. Non seulement cela permet aux experts quantiques d'économiser du temps et de l'énergie dans la conception au niveau des composants, mais ce processus de recherche de solutions sous des contraintes données peut être réalisé sans effort par des experts dans d'autres domaines.

Profondeur du circuit

La profondeur, comme indiqué ci-dessus, détermine la forme du circuit, les circuits plus profonds ayant souvent plus de portes que les circuits moins profonds. Dans l'ère actuelle du matériel quantique, les erreurs de porte peuvent s'accumuler rapidement. Avec un circuit trop profond, les utilisateurs peuvent se retrouver avec un bruit absurde, c'est pourquoi il est essentiel de minimiser la profondeur.

Supposons que nous ayons 16 qubits pour mettre en œuvre 5 préparations d'état différentes avec des erreurs KL variables, comme le montre le code ci-dessous :

{
   "constraints": {
       "max_width": 16
   },
   "logic_flow": [{
       "function": "StatePreparation",
       "function_params": {
           "num_qubits": 4,
           "probabilities": {
               "pmf": [0.4, 0.05, 0.2, 0.05, 0.3, 0.0, 0.0, 0.0]
           },
           "error_metric": {"KL": {"upper_bound": 0.3}}
       },
       "name": "sp1"
   },
   {
       "function": "StatePreparation",
       "function_params": {
           "num_qubits": 4,
           "probabilities": {
               "pmf": [0.4, 0.05, 0.2, 0.05, 0.0, 0.3, 0.0, 0.0]
           },
           "error_metric": {"KL": {"upper_bound": 0.32}}
       },
       "name": "sp2"
   },
   {
       "function": "StatePreparation",
       "function_params": {
           "num_qubits": 4,
           "probabilities": {
               "pmf": [0.4, 0.05, 0.0, 0.05, 0.3, 0.0, 0.2, 0.0]
           },
           "error_metric": {"KL": {"upper_bound": 0.32}}
       },
       "name": "sp3"
   },
   {
       "function": "StatePreparation",
       "function_params": {
           "num_qubits": 4,
           "probabilities": {
               "pmf": [0.4, 0.0, 0.2, 0.05, 0.3, 0.0, 0.0, 0.05]
           },
           "error_metric": {"KL": {"upper_bound": 0.34}}
       },
       "name": "sp4"
   },
   {
       "function": "StatePreparation",
       "function_params": {
           "num_qubits": 4,
           "probabilities": {
               "pmf": [0.4, 0.05, 0.2, 0.0, 0.35, 0.0, 0.0, 0.0]
           },
           "error_metric": {"KL": {"upper_bound": 0.3}}
       },
       "name": "sp5"
   }
]
}

Nous pouvons voir la réutilisation des qubits auxiliaires sur _q3, _q7 et _q14, et nous pouvons utiliser l'outil Classiq Analyzer pour voir à quel point ce circuit est profond - dans ce cas 126.

Supposons que nous soyons limités à une profondeur de 85. Ajoutons une contrainte de profondeur pour voir si cette fonctionnalité peut être créée d'une autre manière. Nous la spécifions dans notre dictionnaire de contraintes.

   "constraints": {
       "max_width": 16,
       "max_depth": 85
   },

Et notre circuit :

Nous voyons maintenant la réutilisation des qubits auxiliaires sur _q3, _q7, _q11, et _q15, et la profondeur de notre circuit est de 82. Non seulement vous pouvez facilement synthétiser et éditer des circuits quantiques avec Classiq, mais vous pouvez également les analyser de manière transparente pour mieux étudier les compromis qui vous sont propres.

Jeu de portes

Tout comme la modalité spécifique permettant d'obtenir des qubits manipulables varie d'un fournisseur de matériel à l'autre, il en va de même pour les jeux de portes natifs. Ces ensembles de base déterminent les manipulations possibles, toutes les opérations étant composées de combinaisons de ces portes. Par exemple, l'IBMQX5 possède un jeu de portes natives _u1(λ), _u2(λ,θ), _u3(λ,θ,Φ) et CNOT, tandis que le processeur Rigetti Agave possède des portes _Rx, _Rz et CZ. Bien que nous ne sachions pas qui sera le vainqueur de la course à l'armement quantique, il est essentiel de pouvoir choisir les portes natives utilisées par votre circuit pour ne pas être prisonnier d'un fournisseur dont les performances sont supérieures aux siennes.

Supposons que nous voulions l'état suivant :

Nous pouvons atteindre cet état avec une erreur KL de 1% avec le circuit produit à partir du code de modèle textuel suivant :

{
	"logic_flow":[
  	{
     	"function": "StatePreparation",
     	"function_params": {
        	"probabilities": {"pmf":[0.45, 0.11, 0.23, 0.21]},
        	"error_metric": {"KL": {"upper_bound": 0.01}}
     	}
  	}
   ]
}

Nous voyons notre code Open QASM 2.0, et ce circuit a 2 qubits avec une profondeur de 7 grâce à l'utilisation des portes Hadamard, RY, X, et CNOT.

Mais que se passe-t-il si notre fournisseur de matériel propose un jeu de portes spécifique dépourvu de ces options ? Pouvons-nous obtenir les mêmes résultats avec un jeu de portes de base composé des portes CNOT, SQRT(X), RZ et X ? Spécifions ces portes dans notre code au-dessus de notre flux logique.

	"hardware_settings": {
  	"basis_gates": ["cx", "sx", "rz", "x"]
   },

Nous constatons que cet état peut encore être créé lorsque l'on se limite à ces portes, avec un circuit légèrement plus profond. 

Les transpileurs se chargent de convertir les portes de base en portes universelles, mais l'application de cette contrainte au niveau fonctionnel permet d'obtenir de meilleurs résultats grâce à l'optimisation lorsque les circuits deviennent beaucoup plus grands. Si un transpileur peut annuler des portes de Hadamard consécutives, il n'est pas en mesure d'annuler des blocs fonctionnels consécutifs, tels que QFT suivi de ^QFT†.

Enfin, confirmons que ces circuits ont la même fonctionnalité en copiant notre code Open QASM 2.0 de chaque circuit dans l'IBM Quantum Composer.

Et nous voyons la même distribution de probabilité. La possibilité de changer les portes de base est un élément essentiel pour rester flexible et ouvert à plusieurs fournisseurs de matériel, alors qu'ils sont souvent plus performants les uns que les autres et qu'ils offrent une variété de compromis.

Conclusion

Dans cette note d'application, nous avons appris comment les contraintes quantiques sont créées à partir des limitations matérielles et comment un logiciel qui peut facilement ajuster ces contraintes permet aux utilisateurs d'explorer les compromis entre eux. Que vous soyez limité par la profondeur, la largeur ou la précision du circuit, Classiq peut s'adapter à vos besoins.

Pour en savoir plus sur la façon dont Classiq peut vous aider à vous adapter à diverses contraintes quantiques, planifiez une démonstration sans engagement ici ou consultez nos prochains événements ici.