Plugins de synthèse

qiskit.transpiler.passes.synthesis.plugin

Ce module définit les interfaces des plugins pour les passes du transpilateur de synthèse dans Qiskit. Ceux-ci fournissent un point d'accroche pour les paquets python externes afin d'implémenter leurs propres techniques de synthèse et de les exposer de manière transparente en tant qu'options opt-in pour les utilisateurs lorsqu'ils lancent le programme transpile().

Les interfaces des plugins sont construites à l'aide de points d'entrée setuptools qui permettent aux paquets externes à qiskit d'annoncer qu'ils incluent un plugin de synthèse.

Voir qiskit.transpiler.preset_passmanagers.plugin pour plus de détails sur la façon d'écrire des plugins pour les étapes du transpilateur.

API du plugin Synthesis

API du plugin de synthèse unitaire

API du plugin de synthèse de haut niveau

Écriture de plugins

Plugins de synthèse unitaire

Pour écrire un plugin de synthèse unitaire, il y a deux étapes principales. La première étape consiste à créer une sous-classe de la classe abstraite du plugin : UnitarySynthesisPlugin. La classe de plugin définit l'interface et le contrat des plugins de synthèse unitaire. La méthode principale est run() qui prend un seul argument de position, une matrice unitaire sous forme de tableau NumPy, et qui doit renvoyer un DAGCircuit objet représentant le circuit synthétisé à partir de cette matrice unitaire. Ensuite, pour indiquer au transpileur Qiskit quelles informations sont nécessaires pour cette passe, il faut implémenter plusieurs méthodes de propriété obligatoires, telles que supports_basis_gates et supports_coupling_map , selon que le plugin prend en charge et/ou nécessite cette entrée pour effectuer la synthèse. Pour plus de détails, consultez la UnitarySynthesisPlugin documentation concernant tous les champs obligatoires. Voici à quoi pourrait ressembler une classe de plugin :

from qiskit.transpiler.passes.synthesis import plugin
from qiskit_plugin_pkg.synthesis import generate_dag_circuit_from_matrix


class SpecialUnitarySynthesis(plugin.UnitarySynthesisPlugin):
    @property
    def supports_basis_gates(self):
        return True

    @property
    def supports_coupling_map(self):
        return False

    @property
    def supports_natural_direction(self):
        return False

    @property
    def supports_pulse_optimize(self):
        return False

    @property
    def supports_gate_lengths(self):
        return False

    @property
    def supports_gate_errors(self):
        return False

    @property
    def supports_gate_lengths_by_qubit(self):
        return False

    @property
    def supports_gate_errors_by_qubit(self):
        return False

    @property
    def min_qubits(self):
        return None

    @property
    def max_qubits(self):
        return None

    @property
    def supported_bases(self):
        return None

    def run(self, unitary, **options):
        basis_gates = options['basis_gates']
        dag_circuit = generate_dag_circuit_from_matrix(unitary, basis_gates)
        return dag_circuit

Si, pour une raison quelconque, les paramètres disponibles pour cette run() méthode s'avéraient insuffisants, merci de créer un ticket afin que nous puissions discuter de l'extension de l'interface du plugin avec de nouveaux paramètres optionnels, qui pourraient être ajoutés de manière rétrocompatible pour les prochaines versions. Notez toutefois que l'interface de ce plugin est considérée comme stable et qu'il est garanti qu'elle ne subira aucune modification susceptible de causer des incompatibilités. Si des modifications s'avèrent nécessaires (par exemple pour élargir la gamme d'options de saisie disponibles), celles-ci seront apportées de manière à ne pas nécessiter de modifications des plugins existants.

La deuxième étape consiste à définir le UnitarySynthesisPlugin comme point d'entrée setuptools dans les métadonnées du paquet. Pour ce faire, il suffit d'ajouter une entry-points table dans pyproject.toml le paquet du plugin, contenant les points d'entrée nécessaires sous l'espace qiskit.unitary_synthesis de noms. Par exemple :

[project.entry-points."qiskit.unitary_synthesis"]
"special" = "qiskit_plugin_pkg.module.plugin:SpecialUnitarySynthesis"

Il n'y a pas de limite au nombre de plugins qu'un seul paquet peut inclure, tant que chaque plugin a un nom unique. Ainsi, un seul paquet peut exposer plusieurs plugins si nécessaire. Le nom default est utilisé par Qiskit lui-même et ne peut pas être utilisé dans un plugin.

Configuration du plugin de synthèse unitaire

Pour certains plugins de synthèse unitaire qui exposent plusieurs options et paramètres, l'interface du plugin comporte une option permettant aux utilisateurs de fournir un dictionnaire de configuration de forme libre. Il sera transmis à la méthode run() en tant que kwarg options . Si votre plugin dispose de ces options de configuration, vous devez clairement documenter la manière dont l'utilisateur doit spécifier ces options de configuration et la manière dont elles sont utilisées, puisqu'il s'agit d'un champ de type "free form".

Plugins de synthèse de haut niveau

La création d'un plugin de synthèse de haut niveau est, d'un point de vue conceptuel, similaire à celle d'un plugin de synthèse unitaire. La première étape consiste à créer une sous-classe de la classe abstraite de plugin : HighLevelSynthesisPlugin, qui définit l'interface et le contrat des plugins de synthèse de haut niveau. La méthode principale est run(). L'argument high_level_object de position spécifie l'« objet de niveau supérieur » à synthétiser, qui peut être n'importe quel objet de type Operation (y compris, par exemple, LinearFunction ou Clifford). L'argument target « keyword » spécifie le backend cible, ce qui permet au plugin d'accéder à toutes les informations spécifiques à cette cible, telles que la carte de couplage, l'ensemble de portes prises en charge, etc. L'argument coupling_map « keyword » ne sert qu'à définir la carte de couplage et n'est utilisé que lorsque target n'est pas spécifié. L'argument qubits « keyword » spécifie la liste des qubits sur lesquels l'objet de niveau supérieur est défini, dans le cas où la synthèse est effectuée sur le circuit physique. La valeur de None indique que la configuration n'a pas encore été choisie et que les qubits physiques de la carte cible ou de la carte de couplage sur laquelle porte cette opération n'ont pas encore été déterminés. De plus, les options et paramètres spécifiques aux plugins peuvent être définis via options, qui est un dictionnaire de configuration au format libre. Si votre plugin dispose de ces options de configuration, vous devriez indiquer clairement comment l'utilisateur doit les définir et comment elles sont utilisées, car il s'agit d'un champ libre. La méthode run() est censée renvoyer un QuantumCircuit objet représentant le circuit synthétisé à partir de cet objet de niveau supérieur. Il est également possible de renvoyer None une valeur indiquant que la méthode de synthèse n'est pas en mesure de synthétiser l'objet de niveau supérieur donné. La synthèse proprement dite des objets de niveau supérieur est effectuée par HighLevelSynthesis le passage du transpileur. Pour plus de détails, consultez la HighLevelSynthesisPlugin documentation concernant tous les champs obligatoires. Voici à quoi pourrait ressembler une classe de plugin :

from qiskit.transpiler.passes.synthesis.plugin import HighLevelSynthesisPlugin
from qiskit.synthesis.clifford import synth_clifford_bm


class SpecialSynthesisClifford(HighLevelSynthesisPlugin):

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
    if higher_level_object.num_qubits <= 3:
        return synth_clifford_bm(high_level_object)
    else:
        return None

L'exemple ci-dessus crée un plugin permettant de synthétiser des objets de type Clifford comportant au plus 3 qubits, à l'aide de la méthode synth_clifford_bm.

La deuxième étape consiste à définir le HighLevelSynthesisPlugin comme point d'entrée setuptools dans les métadonnées du paquet. Pour ce faire, il suffit d'ajouter une entry-points table dans pyproject.toml pour le paquet du plugin, contenant les points d'entrée nécessaires sous l'espace qiskit.synthesis de noms. Par exemple :

[project.entry-points."qiskit.synthesis"]
"clifford.special" = "qiskit_plugin_pkg.module.plugin:SpecialSynthesisClifford"

Le name se compose de deux parties séparées par un point «. » : le nom du type auquel s'applique le plugin de Operation synthèse (clifford), et le nom du plugin (special). Il n'y a pas de limite au nombre de plugins qu'un même paquet peut inclure, à condition que chaque plugin porte un nom unique.

Utilisation des plugins

Plugins de synthèse unitaire

Pour utiliser un plugin, il suffit d'installer le paquet qui inclut un plugin de synthèse. Qiskit découvrira alors automatiquement les plugins installés et les exposera en tant qu'options valides pour les constructeurs transpile() kwargs et constructeurs de passe appropriés. S'il y a des plugins installés qui ne peuvent pas être chargés/importés, cela sera consigné dans Python logging.

Pour obtenir la liste des plugins de synthèse unitaire installés, vous pouvez utiliser la qiskit.transpiler.passes.synthesis.plugin.unitary_synthesis_plugin_names() fonction.

Plugins de synthèse de haut niveau

Pour utiliser un plugin de synthèse de haut niveau, vous devez d'abord instancier un HLSConfig afin d'y stocker les noms des plugins à utiliser pour divers objets de haut niveau. Par exemple :

HLSConfig(permutation=["acg"], clifford=["layers"], linear_function=["pmh"])

crée une configuration de synthèse de haut niveau qui utilise le acg plug-in pour la synthèse PermutationGate des objets, le layers plug-in pour la synthèse Clifford des objets et le pmh plug-in pour la synthèse LinearFunction des objets. Les arguments par mot-clé correspondent aux Operation.name champs des objets concernés. Par exemple, toutes Clifford les opérations possèdent le nameclifford , qui est donc utilisé comme argument-clé. Vous pouvez spécifier ici n'importe quel argument-clé pris en charge par les plugins que vous avez installés, y compris les objets utilisateur personnalisés si vous avez installé des plugins les prenant en charge. Consultez HLSConfig cette page pour plus de détails sur les autres formats permettant de configurer les plugins au sein de chaque argument.

Pour chaque objet de haut niveau, la liste des plugins donnés est essayée en séquence jusqu'à ce que l'un d'entre eux réussisse (dans l'exemple ci-dessus, chaque liste ne contient qu'un seul plugin). En plus de spécifier un plugin par son nom, vous pouvez transmettre un tuple (name, options) , où le deuxième élément du tuple est un dictionnaire contenant des options pour le plugin.

Une fois créé, vous transmettez cet HLSConfig objet à l'argument hls_config de transpile() ou generate_preset_pass_manager() , qui utilisera les plugins spécifiés dans le cadre du processus de compilation global.

Operation.namePour obtenir la liste des plugins de synthèse de haut niveau installés pour un système donné, vous pouvez utiliser la high_level_synthesis_plugin_names() fonction, en lui passant le système souhaité name en argument :

high_level_synthesis_plugin_names("clifford")

renvoie une liste de tous les plugins de synthèse Clifford installés.

Plug-in disponibles

Vous trouverez ci-dessous les classes de plugins de synthèse disponibles dans Qiskit. Ces classes ne doivent pas être utilisées directement, mais plutôt par l'intermédiaire de l'interface du plugin décrite ci-dessus. Les classes sont listées ici pour faciliter la recherche de la documentation pour chacun des plugins inclus et pour faciliter la comparaison entre les différentes méthodes de synthèse pour un objet donné.

Plugins de synthèse unitaire

Plugin de synthèse AQC

Plugin de synthèse Solovay-Kitaev

Plugin de synthèse Ross-Selinger

Plugin Clifford Unitary Synthesis

Plugin de synthèse unitaire par défaut

Le plugin de synthèse unitaire par défaut définit l'algorithme par défaut utilisé par UnitarySynthesis le passage du transpileur pour synthétiser les portes unitaires du circuit. Son comportement dépend du nombre de qubits dans l'opérateur unitaire cible et de la base cible.

Ensembles de bases continus

Lorsque la base cible est continue (c'est-à-dire autre que Clifford+T), le plugin utilise les décompositions suivantes :

• Portes à 1 qubit : décompositions en angles d'Euler (voir OneQubitEulerDecomposer).
• Portes à 2 qubits : décompositions de KAK/Cartan (voir TwoQubitBasisDecomposer, TwoQubitControlledUDecomposer, XXDecomposer).
• Portes à 3 qubits ou plus : décomposition quantique de Shannon, voir qs_decomposition().

Pour les portes à 1 et 2 qubits, le plugin utilise les informations d'erreur de base provenant de la cible pour sélectionner la décomposition qui maximise la fidélité attendue.

Ensembles de bases Clifford+T

Lorsque la base cible est Clifford+T, le plugin utilise l'algorithme de Solovay-Kitaev (voir SolovayKitaevDecomposition) pour approximer les opérateurs unitaires à 1 qubit. Les paramètres utilisés pour créer des approximations de base sont basis_gates=["h", "t", "tdg"], depth=12 et recursion_degree=5, et ont été choisis de manière empirique afin de trouver un juste équilibre entre la qualité de l'approximation et le coût de calcul. Pour utiliser Solovay-Kitaev avec des paramètres personnalisés, ou pour éviter de recalculer les approximations pour plusieurs circuits, vous pouvez utiliser SolovayKitaevSynthesis le plugin de synthèse unitaire à la place de ce plugin par défaut.

À l'heure actuelle, Qiskit ne comprend pas d'algorithmes permettant d'approximer directement les unitaires à 2 qubits ou plus dans le jeu de bases Clifford+T. Par conséquent, le gestionnaire de passes prédéfinies décompose d'abord ces portes en ["cx", "u"] base, puis applique Solovay-Kitaev aux portes unitaires à 1 qubit qui en résultent.

Synthèse de haut niveau

Parmi les plugins de synthèse de haut niveau directement disponibles dans Qiskit, on trouve des plugins permettant de synthétiser Clifford des objets, LinearFunction des objets et PermutationGate des objets. Certains de ces plugins visent implicitement une connectivité « tous-à-tous ». Il ne s'agit pas d'une contrainte pratique, car HighLevelSynthesis cette étape s'exécute généralement avant la mise en page et le routage, ce qui garantit que le circuit final respecte la connectivité du dispositif grâce à l'insertion de portes SWAP supplémentaires. Un bon exemple est le plug-in ACGSynthesisPermutation de synthèse par permutation, qui permet de synthétiser n'importe quelle permutation à l'aide de deux couches de portes SWAP au maximum. En revanche, certains plugins visent implicitement une connectivité linéaire. En règle générale, les circuits de synthèse présentent une profondeur et un nombre de portes plus importants; toutefois, aucune porte SWAP supplémentaire ne serait insérée si, lors de la passe de disposition suivante, une ligne consécutive de qubits était choisie au sein de la topologie du dispositif. nUn bon exemple en est le plugin KMSSynthesisPermutation de synthèse par permutation, qui permet de synthétiser n'importe quelle permutation de n qubits en profondeur. En règle générale, il est difficile de savoir à l'avance laquelle des deux approches — synthétiser des circuits pour une connectivité « tous-à-tous » et insérer des portes SWAP, ou bien synthétiser des circuits pour une connectivité linéaire et insérer moins de portes SWAP, voire aucune — permet d'obtenir un meilleur circuit final; il est donc probablement judicieux d'essayer les deux et de voir laquelle donne de meilleurs résultats. Enfin, certains plugins peuvent cibler un type de connexion spécifique et doivent donc être exécutés une fois la mise en page définie. Dans ce cas, le circuit synthétisé s'adapte automatiquement à la topologie du dispositif. Un bon exemple en est le plugin TokenSwapperSynthesisPermutation de synthèse par permutation, qui permet de synthétiser des permutations arbitraires par rapport à des applications de couplage arbitraires. Pour plus de détails, veuillez consulter la description de chaque plugin.

Pour chaque objet de haut niveau, nous fournissons un tableau répertoriant tous ses plugins disponibles directement dans Qiskit. Nous indiquons le nom du plugin, sa classe, la carte de connectivité ciblée et, éventuellement, des informations supplémentaires. HLSConfigRappelons que les plugins doivent être utilisés via la méthode décrite précédemment, par exemple :

HLSConfig(permutation=["kms"])

crée une configuration de synthèse de haut niveau qui utilise le kms plugin pour synthétiser PermutationGate les objets – c'est-à-dire ceux dont le nom se termine par name = "permutation". Dans ce cas, le nom du plugin est « kms », et la classe du plugin est KMSSynthesisPermutation. Cet algorithme de synthèse particulier a permis de créer un circuit respectant la connectivité linéaire « plus proche voisin ».

Plugins de synthèse de haut niveau

Synthèse de Clifford

Synthèse de fonctions linéaires

Synthèse par permutation

Synthèse QFT

Synthèse MCX

Le tableau suivant répertorie les plugins de synthèse disponibles pour une MCXGate porte comportant k qubits de contrôle. Si le nombre disponible de qubits auxiliaires « propres » ou « sales » n'est pas suffisant, la méthode de synthèse correspondante renverra « None ».

Synthèse MCMT

Comparateurs d'entiers

Sommes

Synthèse de l'évolution de Pauli

Synthèse modulaire d'additionneurs

Synthèse d'un demi-additionneur

Synthèse d'additionneur complet

Synthèse multiplicatrice