Skip to main content
IBM Quantum Platform

cible

class qiskit.transpiler.Target(description=None, num_qubits=0, dt=None, granularity=1, min_length=1, pulse_alignment=1, acquire_alignment=1, qubit_properties=None, concurrent_measurements=None, **_subclass_kwargs)

GitHub

Bases : BaseTarget

L'objet Target a pour but d'informer le compilateur de Qiskit des contraintes d'un backend particulier afin que le compilateur puisse compiler un circuit d'entrée en quelque chose qui fonctionne et qui est optimisé pour un appareil. Il contient actuellement une description des instructions sur un backend et de leurs propriétés, ainsi que des informations sur le calendrier. Toutefois, cette interface exacte peut évoluer au fil du temps en fonction des besoins du compilateur. Ces changements seront effectués de manière rétrocompatible et contrôlée lorsqu'ils seront apportés (par le biais de versions, de sous-classes ou de mixins) pour compléter l'ensemble des informations exposées par une cible.

À titre d'exemple simple, supposons qu'un backend dispose de deux qubits, qu'il prenne en charge UGate sur les deux qubits et CXGate dans les deux sens. Pour modéliser cela, vous devriez créer la cible comme suit :

from qiskit.transpiler import Target, InstructionProperties
from qiskit.circuit.library import UGate, CXGate
from qiskit.circuit import Parameter

gmap = Target()
theta = Parameter('theta')
phi = Parameter('phi')
lam = Parameter('lambda')
u_props = {
    (0,): InstructionProperties(duration=5.23e-8, error=0.00038115),
    (1,): InstructionProperties(duration=4.52e-8, error=0.00032115),
}
gmap.add_instruction(UGate(theta, phi, lam), u_props)
cx_props = {
    (0,1): InstructionProperties(duration=5.23e-7, error=0.00098115),
    (1,0): InstructionProperties(duration=4.52e-7, error=0.00132115),
}
gmap.add_instruction(CXGate(), cx_props)

Chaque instruction du site Target est indexée par un nom de chaîne unique qui identifie de manière unique cette instance d'un objet de la cible Instruction dans la cible. Il existe une correspondance 1:1 entre un nom et une instance dans la cible et chaque nom doit être unique Instruction dans la cible et chaque nom doit être unique. Par défaut, le nom est l'attribut name de l'instruction, mais il peut être défini comme n'importe quel nom. Cela permet à une même cible d'avoir plusieurs instances de la même classe d'instruction avec des paramètres différents. Par exemple, si une cible de backend a deux instances d'un RXGate l'une est paramétrée sur n'importe quel thêta tandis que l'autre est réglée pour un thêta de pi/6, vous pouvez les ajouter en faisant quelque chose comme :

import math

from qiskit.transpiler import Target, InstructionProperties
from qiskit.circuit.library import RXGate
from qiskit.circuit import Parameter

target = Target()
theta = Parameter('theta')
rx_props = {
    (0,): InstructionProperties(duration=5.23e-8, error=0.00038115),
}
target.add_instruction(RXGate(theta), rx_props)
rx_30_props = {
    (0,): InstructionProperties(duration=1.74e-6, error=.00012)
}
target.add_instruction(RXGate(math.pi / 6), rx_30_props, name='rx_30')

Ensuite, dans l'objet target accédant à rx_30 , on obtiendra l'angle fixe RXGate tandis que rx obtiendra l'angle paramétré RXGate.

Vous pouvez éventuellement spécifier une limite pour les valeurs valides sur une porte dans la cible en utilisant l'argument angle_bounds clé lors de l'appel de add_instruction() la méthode. Les limites sont définies sur les opérations et non sur les instructions individuelles. Ainsi, lorsque vous appelez add_instruction() les limites s'appliquent à tous les qargs pour lesquels elles sont définies. Les limites sont spécifiées sous la forme d'une liste de couples de nombres flottants, le premier nombre flottant représentant la limite inférieure et le second la limite supérieure. Par exemple, si vous avez spécifié une limite d'angle :

[(0.0, 3.14), (-3.14, 3.14), (0.0, 1.0)]

indique les limites angulaires d'une porte à 3 paramètres où le premier paramètre accepte les angles entre 0 et 3.14, le deuxième entre -3.14 et 3.14, et le troisième entre 0 et 1. Toutes les limites sont également fixées de manière inclusive. Une borne peut également être spécifiée avec None au lieu d'un 2-tuple, ce qui indique que le paramètre n'a pas de contraintes. Par exemple :

[(0.0, 3.14), None, None]

indique une limite d'angle pour une porte à 3 paramètres où seul le premier paramètre est limité aux angles compris entre 0.0 et 3.14 et où les autres paramètres acceptent n'importe quelle valeur.

gate_has_angle_bounds()Vous pouvez vérifier si certaines opérations de la cible ont des limites d'angle définies à l'aide de, has_angle_bounds() ainsi que si un nom spécifique de la cible a des limites d'angle définies à l'aide de. Pour vérifier si un ensemble donné de valeurs de paramètres respecte les limites d'angle, on peut utiliser supported_angle_bound(). Dans les gestionnaires de passes prédéfinis, WrapAngles la passe sert à imposer les limites d'angle; pour que cela fonctionne, vous devez fournir une fonction au gestionnaire WrapAngleRegistry de passe utilisé. Pour plus de détails à ce sujet, consultez : « Angle bounds on Gates ».

Cette classe peut être interrogée via le protocole de mappage, en utilisant le nom de l'instruction comme clé. Vous pouvez modifier n'importe quelle propriété d'une instruction via la méthode update_instruction_properties() méthode. La modification via le protocole de mappage ou la modification des attributs d'un objet n'est pas prise en charge et invalide l'état interne de l'objet InstructionProperties n'est pas prise en charge et cela invalidera l'état interne de l'objet.

Remarque

Cette classe suppose que les indices des qubits commencent à 0 et constituent un ensemble contigu. Si vous souhaitez une sous-cartographie, les bits devront être réindexés dans un nouvel objet Target objet.

Remarque

Cette classe ne prend en charge que les ajouts de portes, de qargs et de propriétés. Si vous devez supprimer l'un d'entre eux, la meilleure solution consiste à itérer sur un objet existant et à créer un nouveau sous-ensemble (ou à utiliser l'une des méthodes prévues à cet effet). L'objet met en cache en interne différentes vues et celles-ci pourraient être invalidées par les suppressions.


Sous-classification

Bien qu'il soit techniquement possible de sous-classer Targetmais il faut savoir que la majorité des informations intégrées sont en Rust et sont interrogées à partir de Rust dans les passes du transpilateur intégré. Python -ne sont pas visibles par Rust, et vous ne devriez pas vous appuyer sur elles pour modifier le comportement des passes de transpilation intégrées de Qiskit. Target est largement supposé être une représentation d'une QPU qui a des constructeurs spécialisés, et non des sous-classes spécialisées; l'API habituelle pour construire une QPU devrait être une fonction qui renvoie la base de la QPU Target devrait être une fonction qui renvoie une base Targetet non une sous-classe avec un initialisateur personnalisé.

Vous pouvez utiliser la sous-classification pour ajouter des propriétés supplémentaires de l'espace d' Python, par Targetexemple pour les interpréter ensuite dans des étapes de transcompilation spécifiques à un backend personnalisé; l'objet Target est transmis aux constructeurs des plugins d'étape.

Vous ne devriez pas sous-classer Target pour tenter de modifier le comportement des passes intégrées de Qiskit; la sous-classe Python -space ne sera pas vue par les passes écrites en Rust.

De plus, comme le cœur de Target est écrit en Rust, il utilise __new__() comme initialisateur, et vous devez vous assurer que les bons arguments sont transmis à l'implémentation sous-jacente. Si vous remplacez la signature de la méthode __init__() vous devez également inclure une surcharge de la méthode __new__() avec la même signature, qui appelle super().__new__() de manière correcte.

Créer un nouvel Target objet.

param description

Chaîne facultative décrivant la cible.

description du type

str

param num_qubits

Un int optionnel pour spécifier le nombre de qubits de la cible backend. Il ne s'agit pas d'une limite stricte à la construction; tout appel à add_instruction() entraînera la mise à jour de l'ensemble num_qubits pour tenir compte de toute qargs concrète dans les propriétés données.

Cette valeur peut être explicitement fixée à None pour indiquer un simulateur ou une autre machine abstraite qui n'impose aucune limite au nombre de qubits Target représentant un simulateur ou une autre machine abstraite qui n'impose aucune limite au nombre de qubits. Dans ce cas, toutes les instructions ajoutées à la cible doivent être globales (avec properties=None ou properties={None: None}).

type num_qubits

int

param dt

Résolution temporelle des signaux d'entrée en secondes

type dt

séparer

param granularité

Valeur entière représentant la résolution minimale de la porte d'impulsion en unités de dt. Une porte d'impulsion définie par l'utilisateur doit avoir une durée égale à un multiple de cette valeur de granularité.

granularité du type

int

param min_length

Valeur entière représentant la longueur minimale de la porte d'impulsion en unités de dt. Une porte d'impulsion définie par l'utilisateur doit être plus longue que cette longueur.

type min_length

int

param pulse_alignment

Valeur entière représentant une résolution temporelle de l'heure de début de l'instruction de porte. L'instruction de porte doit commencer à un moment qui est un multiple de la valeur d'alignement.

type pulse_alignment

int

param acquire_alignment

Valeur entière représentant une résolution temporelle de l'heure de début de l'instruction de mesure. L'instruction de mesure doit commencer à un moment qui est un multiple de la valeur d'alignement.

type acquire_alignment

int

param qubit_properties

Une liste d'objets QubitProperties définissant les caractéristiques de chaque qubit sur le dispositif cible. Si elle est spécifiée, la longueur de cette liste doit correspondre au nombre de qubits de la cible, où l'index de la liste correspond au numéro du qubit pour lequel les propriétés sont définies. Si certains qubits n'ont pas de propriétés disponibles, vous pouvez définir cette entrée à None

type qubit_properties

liste

param mesures_concurrentes

Une liste d'ensembles de qubits qui doivent être mesurés ensemble. Il doit être fourni sous la forme d'une liste imbriquée comme [[0, 1], [2, 3, 4]].

type mesures concurrentes

liste

soulève ValueError

Si num_qubits et qubit_properties sont tous deux définis et que la valeur de num_qubits diffère de la longueur de qubit_properties.


Attributs

acquire_alignment

concurrent_measurements

description

dt

Retour dt.

granularity

instructions

Obtenir la liste des tuples (Instruction, (qargs)) pour la cible

Pour les opérations à largeur variable définies globalement, le n-uplet sera de la forme (class, None) où la classe est la classe d'opération réelle définie globalement.

min_length

num_qubits

operation_names

Obtenir les noms des opérations dans la cible.

operations

Obtenir les objets de l'opération dans la cible.

physical_qubits

Renvoie une liste triée de qubits physiques.

pulse_alignment

qargs

L'ensemble des qargs de la cible.

qubit_properties


Méthodes

add_instruction

add_instruction(instruction, properties=None, name=None, *, angle_bounds=None)

GitHub

Ajouter une nouvelle instruction au Target

Les objets Target étant strictement additifs, il s'agit de la principale méthode de modification d'un site Target. En règle générale, vous utiliserez cette fonction pour remplir entièrement un site Target avant de l'utiliser dans le fichier BackendV2. Par exemple :

from qiskit.circuit.library import CXGate
from qiskit.transpiler import Target, InstructionProperties

target = Target()
cx_properties = {
    (0, 1): None,
    (1, 0): None,
    (0, 2): None,
    (2, 0): None,
    (0, 3): None,
    (2, 3): None,
    (3, 0): None,
    (3, 2): None
}
target.add_instruction(CXGate(), cx_properties)

Ajoutera un CXGate à la cible sans propriétés (durée, erreur, etc.) avec la liste des bords de couplage : (0, 1), (1, 0), (0, 2), (2, 0), (0, 3), (2, 3), (3, 0), (3, 2). Si des propriétés sont disponibles pour l'instruction, vous pouvez remplacer la valeur None dans le dictionnaire des propriétés par un objet InstructionProperties objet. Ce schéma est répété pour chaque Instruction que la cible prend en charge.

Paramètres

  • instruction (Union[qiskit.circuit.Instruction, Type[qiskit.circuit.Instruction]]) – L'objet d'opération à ajouter à la carte. S'il s'agit d'un paramètre, n'importe quelle valeur peut être définie pour celui-ci. En option, pour les instructions à largeur variable (telles que les opérations de contrôle de flux comme ForLoop ou MCXGate), vous pouvez spécifier la classe. Si la classe est spécifiée, l'argument name doit alors être spécifié. Lorsqu'une classe est utilisée, la porte est considérée comme globale et ne dispose d'aucune propriété définie.
  • properties (dict) – Un dictionnaire d'entrées qarg vers un objet InstructionProperties pour l'implémentation de cette instruction dans le backend. Les propriétés sont facultatives pour toute implémentation d'instruction, si aucune n'est disponible pour le backend, la valeur peut être None InstructionProperties n'est disponible pour le backend, la valeur peut être None. Si l'instruction n'est soumise à aucune contrainte (comme dans le cas d'une simulation idéale sans bruit), la valeur peut être fixée à {None, None} , ce qui indique que l'instruction s'exécute sur tous les qubits (ou sur toutes les permutations de qubits disponibles pour les portes à qubits multiples). Le premier None indique qu'elle s'applique à tous les qubits et le second None indique qu'il n'y a pas de qubits pour l'instruction InstructionProperties pour l'instruction. Par défaut, si properties n'est pas défini, cela équivaut à passer {None: None}.
  • name (str) – Un nom facultatif à utiliser pour identifier l'instruction. S'il n'est pas spécifié, l'attribut name de gate sera utilisé. Toutes les portes du site Target doivent porter un nom unique. Les backends peuvent différencier les différents paramétrages d'une même porte en fournissant un nom unique pour chacun d'entre eux (par exemple “rx30”, “rx60”, `”rx90”``, comme dans l'exemple de la documentation de la classe Target ).
  • angle_bounds (list) – Les limites des paramètres pour une porte donnée. Elle est spécifiée par une liste de tuples (low, high) qui représentent les limites inférieure et supérieure (inclusivement) des valeurs flottantes autorisées pour le paramètre à cette position. Si un paramètre n'a pas de limite d'angle, vous pouvez utiliser None pour le représenter. Par exemple, si une porte à trois paramètres n'a de limite que pour le deuxième paramètre, vous la représenterez par : [None, [0, 3.14], None] , ce qui signifie que les premier et troisième paramètres autorisent n'importe quelle valeur, mais que le deuxième paramètre n'accepte que des valeurs comprises entre 0 et 3.14.

Augmentations

  • AttributeError - Si la porte est déjà dans la carte
  • TranspilerError – Si une classe d'opération est transmise à instruction et qu'aucun nom n'est spécifié ou properties que est défini.

build_coupling_map

build_coupling_map(two_q_gate=None, filter_idle_qubits=False)

GitHub

Obtenir un CouplingMap de cette cible.

Si l'on mélange des opérations sur deux qubits soumises à une contrainte de connectivité et d'autres définies de manière globale, cela renverra également un None résultat, car la connectivité globale implique qu'il n'y a aucune contrainte sur la cible. Si vous souhaitez voir les contraintes des opérations à deux qubits qui en comportent, vous devez utiliser two_q_gate l'argument pour limiter l'affichage aux portes qui comportent une contrainte.

Paramètres

  • two_q_gate (str) – Nom facultatif d'une porte à deux qubits dans le site Target pour laquelle la carte de couplage doit être générée. Si elle est spécifiée, la carte de couplage de sortie ne comportera que les arêtes entre les qubits où cette porte est présente.
  • filter_idle_qubits (bool) – Si elle est définie à True , la sortie CouplingMap supprimera tous les qubits qui n'ont pas d'opérations définies dans la cible. Notez qu'en utilisant cet argument, vous obtiendrez un objet de sortie CouplingMap qui comporte des trous dans ses indices qui peuvent différer des hypothèses de la classe. Le cas typique d'utilisation de cet argument est d'être associé à CouplingMap.connected_components() qui traitera les trous comme prévu.

Retours

**L'objet CouplingMap **

pour cet objectif. S'il n'y a pas de contraintes de connectivité dans la cible, le résultat sera None.

Type de retour

CouplingMap

Augmentations

  • ValueError - Si une porte ne comportant pas deux qubits est transmise à two_q_gate.
  • IndexError - Si une instruction ne figurant pas sur le site Target est transmise au site two_q_gate.

durations

durations()

GitHub

Obtenir un objet InstructionDurations de la cible

Retours

La durée de l'instruction représentée dans le

cible

Type de retour

InstructionDurations

from_configuration

classmethod from_configuration(basis_gates, num_qubits=None, coupling_map=None, instruction_durations=None, concurrent_measurements=None, dt=None, timing_constraints=None, custom_name_mapping=None)

GitHub

Créer un objet cible à partir de la configuration globale individuelle

Avant la création de la classe Target les contraintes d'un backend étaient représentées par une collection d'objets différents qui, ensemble, représentaient un sous-ensemble des informations contenues dans la classe Target. Cette fonction fournit une interface simple pour convertir ces objets distincts en un fichier Target.

Ce constructeur utilisera les données de basis_gates, num_qubits et coupling_map pour construire un modèle de base du backend et les données de instruction_durations, backend_properties et inst_map sont ensuite interrogées (dans cet ordre) sur la base de ce modèle pour rechercher les propriétés de chaque instruction et de chaque qubit. En cas d'incohérence entre les entrées, toute information supplémentaire ou contradictoire figurant dans instruction_durations, backend_properties ou inst_map sera ignorée.

Paramètres

  • basis_gates (list[str]) – Liste des noms des portes de base pour le backend. Pour que la cible soit créée, ces noms doivent soit figurer dans la sortie de get_standard_gate_name_mapping() soit être présents dans l'argument spécifié custom_name_mapping .
  • num_qubits (int | None) – Le nombre de qubits pris en charge par le backend.
  • coupling_map (CouplingMap | None) – La carte de couplage représentant les contraintes de connectivité sur le backend. Si elle est spécifiée, toutes les portes de basis_gates seront prises en charge sur tous les qubits (ou paires de qubits).
  • instruction_durations (InstructionDurations | None) – Durées d'instruction optionnelles pour les instructions. Si elle est spécifiée, elle aura la priorité pour définir le champ duration dans les objets pour les instructions dans la cible InstructionProperties pour les instructions de la cible.
  • concurrent_measurements (list) – Une liste d'ensembles de qubits qui doivent être mesurés ensemble. Il doit être fourni sous la forme d'une liste imbriquée comme [[0, 1], [2, 3, 4]].
  • dt (float | None) – Résolution temporelle des signaux d'entrée en secondes
  • timing_constraints (TimingConstraints | None) – Contraintes de synchronisation facultatives à inclure dans le Target
  • custom_name_mapping (dict[str, Any] | None) – Dictionnaire facultatif qui associe des noms personnalisés de portes/opérations à basis_gates un Operation objet représentant cette porte/opération. Par défaut, la plupart des noms de portes standard sont associés à l'objet « porte standard » qiskit.circuit.library ; il n'est donc nécessaire de le préciser que si l'entrée basis_gates définit des portes dont les noms ne font pas partie de cet ensemble.

Retours

la cible construite à partir de la configuration d'entrée

Type de retour

Cible

Augmentations

  • TranspilerError – Si les portes de base d'entrée contiennent plus de 2 qubits et coupling_map que est
  • spécifié. -
  • KeyError - Si aucune correspondance n'est disponible pour une adresse basis_gate.

gate_has_angle_bounds

gate_has_angle_bounds(name)

Vérifier si un portail spécifique a une limite d'angle définie

Paramètres

name (str) – Le nom de l'instruction pour vérifier si elle a une borne d'angle définie

Retours

Cette fonction renvoie True si la porte se trouve dans la cible et si les limites de l'angle sont définies. Elle renvoie False si la porte n'a pas de limites d'angle définies ou si elle n'est pas dans la cible.

Type de retour

booléen

get

get(key, default=None)

GitHub

Obtient un élément de la cible. Si elle n'est pas trouvée, elle renvoie une valeur par défaut fournie ou None.

get_non_global_operation_names

get_non_global_operation_names(strict_direction=False)

GitHub

Retourne les noms d'opérations non globales pour la cible

Les opérations non globales sont celles de la cible qui ne s'appliquent pas à tous les qubits (pour les opérations sur un seul qubit) ou à tous les qargs multi-qubits (pour les opérations multi-qubits).

Paramètres

strict_direction (bool) – Si la valeur est fixée à True , les opérations multi-qubits considérées comme non globales respectent la direction stricte (ou l'ordre des qubits dans les qargs est important). Par exemple, si cx est défini sur (0, 1) et ecr sur (1, 0) , par défaut, aucun des deux ne sera considéré comme non global, mais si strict_direction est défini sur True , cx et ecr seront renvoyés.

Retours

Une liste de noms d'opérations pour les opérations qui ne sont pas globales dans cette cible

Type de retour

Liste [str ]

has_angle_bounds

has_angle_bounds()

Vérifier s'il existe des limites d'angle dans la cible

Retours

Cette méthode renvoie True si des limites d'angle ont été définies pour l'une ou l'autre des instructions du circuit

Type de retour

booléen

instruction_properties

instruction_properties(index)

GitHub

Obtenir les propriétés d'une instruction pour un tuple d'instructions spécifique

Cette méthode doit être utilisée conjointement avec l'attribut instructions d'un objet Target d'un objet. Vous pouvez utiliser cette méthode pour obtenir rapidement les propriétés d'instruction d'un élément de instructions en utilisant l'index de cette liste. Cependant, si vous ne travaillez pas directement avec instructions il est probablement plus efficace d'accéder directement à la cible via le nom et les qubits pour obtenir les propriétés de l'instruction. Par exemple, si instructions retourné :

[(XGate(), (0,)), (XGate(), (1,))]

vous pourriez obtenir les propriétés du XGate sur le qubit 1 avec :

props = target.instruction_properties(1)

mais il serait plus efficace d'y accéder directement par le nom :

props = target['x'][(1,)]

(en supposant que le nom canonique de XGatedans la cible est 'x'). Ceci est particulièrement vrai pour les cibles plus grandes, car l'échelle sera plus mauvaise avec le nombre de tuples d'instructions dans une cible.

Paramètres

index (int) – L'index du tuple d'instruction de l'attribut instructions attribut. Par exemple, si vous voulez les propriétés du troisième élément de instructions vous devez lui attribuer la valeur 2.

Retours

Propriétés de l'instruction pour l'ensemble d'instructions spécifié

Type de retour

InstructionProperties

instruction_supported

instruction_supported(operation_name=None, qargs=Ellipsis, operation_class=None, parameters=None, check_angle_bounds=True)

Indique si l'instruction (opération + qubits) est prise en charge par la cible

Paramètres

  • operation_name (str) – Le nom de l'opération pour l'instruction. Cet argument ou operation_class doit être spécifié. Si les deux sont spécifiés, operation_class aura la priorité et cet argument sera ignoré.

  • qargs (tuple) – Le tuple d'indices de qubits pour l'instruction. Si cela n'est pas spécifié, cette méthode renverra True si l'opération spécifiée est prise en charge sur n'importe quel qubit. L'application type aura toujours ce paramètre défini (sinon, cela revient à vérifier si la cible contient l'opération). Normalement, vous ne devriez pas définir cet argument si vous souhaitez vérifier de manière plus générale que la cible supporte une opération avec parameters sur n'importe quel qubit.

  • operation_class (Type[qiskit.circuit.Instruction]) – Classe d'opération permettant de vérifier si la cible prend en charge une opération donnée en fonction de sa classe plutôt que de son nom. Cette recherche est plus coûteuse, car elle nécessite de parcourir toutes les opérations de la cible, au lieu de se limiter à une simple consultation. Si cette option est spécifiée, elle prévaudra sur l'argument operation_name . Cette opération sert généralement à vérifier si une variante spécifique d'une opération est prise en charge par le backend. Par exemple, si vous vouliez vérifier si une opération RXGate était prise en charge sur un qubit spécifique avec un angle fixe. Cette variante à angle fixe portera généralement un nom différent de celui de name l'attribut ("rx") de l'objet dans la cible. Cela permet de vérifier si des instances de la classe sont disponibles dans ce cas précis.

  • parameters (list) –

    Une liste de paramètres pour vérifier si la cible les prend en charge sur les qubits spécifiés. Si l'instruction prend en charge les valeurs des paramètres spécifiés dans la liste pour l'opération et les qargs spécifiés, elle renvoie True , mais si les paramètres ne sont pas pris en charge par l'instruction spécifiée, elle renvoie False. Si cet argument n'est pas spécifié, cette méthode renvoie True si l'instruction est prise en charge indépendamment des paramètres de l'instruction. Si elle est spécifiée avec un objet Parameter dans la liste, cette entrée sera traitée comme supportant n'importe quelle valeur, mais les noms des paramètres ne seront pas vérifiés (par exemple, si une opération dans la cible est répertoriée comme étant paramétrée avec "theta" et que "phi" est passé dans cette fonction qui renverra True). Par exemple, s'il est appelé avec :

    parameters = [Parameter("theta")]
    target.instruction_supported("rx", (0,), parameters=parameters)

    renverra True si un RXGate est supporté sur le qubit 0 et qu'il accepte n'importe quel paramètre. Si vous devez vérifier un paramètre de valeur numérique fixe, cet argument est généralement associé à l'argument operation_class . Par exemple :

    target.instruction_supported("rx", (0,), RXGate, parameters=[pi / 4])

    renvoie True si un RXGate( pi/4 ) existe sur le qubit 0.

  • check_angle_bounds (bool) – Si elle est définie sur True (valeur par défaut), la valeur de parameters sera validée par rapport à toutes les limites d'angle définies dans la cible. Si l'une des valeurs de parameters est définie comme étant une instance de ParameterExpression cet indicateur n'aura aucun effet car les limites d'angle n'ont d'impact que sur les opérations non paramétrées dans le circuit.

Retours

Renvoie True si l'instruction est prise en charge et False si elle ne l'est pas.

Type de retour

booléen

items

items()

GitHub

Renvoie des paires de noms de porte et sa carte des propriétés (str, dicttuple[, InstructionProperties] )

keys

keys()

GitHub

Retourner les clés (noms d'opérations) de la cible

operation_from_name

operation_from_name(instruction)

Obtenir l'objet de la classe d'opération pour un nom donné

Paramètres

instruction (str) – Le nom de l'instruction pour obtenir l'instance Instruction pour

Retours

L'instance d'instruction correspondant au nom. Cette classe peut également servir de classe pour les variables définies globalement avec des opérations.

Type de retour

qiskit.circuit.Instruction

operation_names_for_qargs

operation_names_for_qargs(qargs, /)

Obtenir les noms des opérations pour un tuple qargs spécifié

Paramètres

qargs (tuple) – Un tuple qargs des qubits pour obtenir les portes qui s'y appliquent. Par exemple, (0,) renvoie l'ensemble des instructions qui s'appliquent au qubit 0. S'il est défini à None , il renvoie les noms de toutes les opérations définies globalement dans la cible.

Retours

L'ensemble des noms d'opérations qui s'appliquent à l'adresse qargs spécifiée.

Type de retour

set

Augmentations

KeyError - Si qargs n'est pas dans la cible

operations_for_qargs

operations_for_qargs(qargs, /)

Obtenir l'objet de la classe d'opération pour un tuple qargs spécifié

Paramètres

qargs (tuple) – Un tuple qargs des qubits pour obtenir les portes qui s'y appliquent. Par exemple, (0,) renvoie l'ensemble des instructions qui s'appliquent au qubit 0. Si elle est définie à None , elle renverra toutes les opérations définies globalement dans la cible.

Retours

La liste des instances Instruction qui s'appliquent au qarg spécifié. Il peut également s'agir d'une classe si une opération de largeur variable est définie globalement.

Type de retour

liste

Augmentations

KeyError - Si qargs n'est pas dans la cible

qargs_for_operation_name

qargs_for_operation_name(operation)

GitHub

Obtenir les qargs pour un nom d'opération donné

Paramètres

operation (str) – Le nom de l'opération pour laquelle les qargs doivent être obtenus

Retours

L'ensemble des qargs auxquels s'applique l'instance de portail.

Type de retour

set

seconds_to_dt

seconds_to_dt(duration)

GitHub

Convertir une durée donnée en secondes en unités de dt

Paramètres

duration (float) – La durée en secondes, par exemple dans un champ InstructionProperties pour une instruction dans la cible.

Type de retour

int

Retours

durée : La durée en unités de dt

supported_angle_bound

supported_angle_bound(name, angles)

Vérifier que les paramètres d'un portail spécifique sont conformes aux limites de l'angle

Paramètres

  • name (str) – Le nom de l'instruction pour vérifier les limites de l'angle de
  • angles (list) – Une liste de valeurs de paramètres flottants pour name afin de vérifier si elles sont conformes aux limites d'angle définies.

Retours

Renvoie True si les valeurs des paramètres spécifiés sont compatibles avec les limites de l'angle. False est renvoyée si l'un des paramètres est en dehors des limites définies.

Type de retour

booléen

Augmentations

  • TranspilerError – Si name ne figure pas dans la cible ou si
  • ont des limites angulaires définies. -

timing_constraints

timing_constraints()

GitHub

Obtenir un objet TimingConstraints de la cible

Retours

Les contraintes de temps représentées dans le Target

Type de retour

TimingConstraints

update_instruction_properties

update_instruction_properties(instruction, qargs, properties)

GitHub

Mise à jour de l'objet de propriété pour une paire d'instructions qarg déjà présente dans la cible.

Pour faciliter l'accès, un utilisateur peut obtenir la correspondance entre les qargs applicables à une instruction et les propriétés de cette instruction via le protocole de correspondance (en utilisant __getitem__), avec le nom de l'instruction comme clé. Cette méthode est le seul moyen de modifier/mettre à jour les propriétés d'une instruction dans le site Target. L'utilisation du protocole de mappage pour les modifications n'est pas prise en charge.

Paramètres

  • instruction (str) – Nom de l'instruction à mettre à jour
  • qargs (tuple) – Les qargs pour mettre à jour les propriétés de
  • properties (InstructionProperties) – Propriétés à définir pour cette instruction

Augmentations

KeyError - Si instruction ou qarg ne se trouvent pas dans la cible

values

values()

GitHub

Renvoie la carte des propriétés (qargs -> InstructionProperties ) de chaque instruction de la cible

Paramètres

  • description (str | None)
  • num_qubits (int | None)
  • dt (float | None)
  • granularity (int)
  • min_length (int)
  • pulse_alignment (int)
  • acquire_alignment (int)
  • qubit_properties (list | None)
  • concurrent_measurements (list | None)
Cette page a-t-elle été utile ?
Signaler un bogue, une coquille ou proposer du contenu sur GitHub.