Circuit DAG

Renvoie la séquence actuelle des instances enregistrées Clbit sous forme de liste.

Retours

Séquence actuelle de clbits enregistrés.

Type de retour

list(Clbit)

Retourne le dict contenant les ClassicalRegisters dans le circuit

Renvoie la durée totale du circuit, fixée par une passe du transpondeur d'ordonnancement. Son unité est spécifiée par unit

DÉCRYPTÉ depuis Qiskit 1.3.0 et sera supprimé dans Qiskit 3.0.0

Renvoie la phase globale du circuit.

Métadonnées du circuit

Nom du circuit. En général, cela correspond au nom du site QuantumCircuit à partir duquel le DAG a été généré.

Renvoie le nombre de nœuds dans le dag.

Nombre d'étirements capturés suivis par le circuit.

Nombre de variables classiques capturées et suivies par le circuit.

Nombre d'étirements locaux déclarés suivis par le circuit.

Nombre de variables classiques locales déclarées suivies par le circuit.

Nombre de variables classiques d'entrée suivies par le circuit.

Nombre total de tronçons suivis par le circuit.

Nombre total de variables classiques suivies par le circuit.

Retourne le dict contenant les QuantumRegisters dans le circuit

Renvoie la séquence actuelle des instances enregistrées Qubit sous forme de liste.

Retours

La séquence actuelle de qubits enregistrés.

Type de retour

list(Qubit)

Renvoie l'unité dans laquelle la durée est spécifiée.

DÉCRYPTÉ depuis Qiskit 1.3.0 et sera supprimé dans Qiskit 3.0.0

Renvoie une liste des fils dans l'ordre.

add_captured_stretch(stretch)

Ajouter un étirement capturé au circuit.

Paramètres

stretch - l'étirement à ajouter.

add_captured_var(var)

Ajouter une variable capturée au circuit.

Paramètres

var - la variable à ajouter.

add_clbits(clbits)

Ajouter des fils de connexion individuels.

add_creg(creg)

Additionner tous les fils dans un registre classique.

add_declared_stretch(stretch)

Ajouter un étirement déclaré au circuit.

Paramètres

stretch - l'étirement à ajouter.

add_declared_var(var)

Ajouter une variable locale déclarée au circuit.

Paramètres

var - la variable à ajouter.

add_input_var(var)

Ajoutez une variable d'entrée au circuit.

Paramètres

var - la variable à ajouter.

add_qreg(qreg)

Additionner tous les fils dans un registre quantique.

add_qubits(qubits)

Ajouter des fils de qubit individuels.

ancestors(node)

Renvoie l'ensemble des ancêtres d'un nœud sous forme de DAGOpNodeet DAGInNodes.

Les ancêtres sont l'ensemble des nœuds qui peuvent atteindre le nœud cible. Alors que les DAGCircuit.predecessors() ne contient que les prédécesseurs immédiats, les ancêtres contiennent récursivement les prédécesseurs de chaque prédécesseur.

apply_operation_back(op, qargs=None, cargs=None, *, check=True)

Appliquer une opération à la sortie du circuit.

Paramètres

• op (qiskit.circuit.Operation) – l'opération associée au nœud du DAG
• qargs (tuple[Qubit]) – les qubits auxquels cette opération sera appliquée
• cargs (tuple[Clbit]) – les bits auxquels cette opération sera appliquée
• check (bool) – Si True (par défaut), cette fonction garantira le respect des DAGCircuit invariants de la structure de données (toutes qargs les entrées sont Qubitdes \ s, toutes font partie du DAG, etc.). FalseDans ce cas, l'appelant doit lui-même garantir le respect de ces invariants, mais le coût de plusieurs vérifications sera ainsi évité. Cela s'avère particulièrement utile lorsqu'on crée un nouveau DAG à partir d'un ensemble de nœuds dont on sait qu'ils sont corrects.

Retours

le nœud de l'opération qui a été ajoutée au dag

Type de retour

DAGOpNode

Augmentations

DAGCircuitError – si un nœud feuille est connecté à plusieurs sorties

apply_operation_front(op, qargs=None, cargs=None, *, check=True)

Appliquer une opération à l'entrée du circuit.

Paramètres

• op (qiskit.circuit.Operation) – l'opération associée au nœud du DAG
• qargs (tuple[Qubit]) – les qubits auxquels cette opération sera appliquée
• cargs (tuple[Clbit]) – les bits auxquels cette opération sera appliquée
• check (bool) – Si True (par défaut), cette fonction garantira le respect des DAGCircuit invariants de la structure de données (toutes qargs les entrées sont Qubitdes \ s, toutes font partie du DAG, etc.). FalseDans ce cas, l'appelant doit lui-même garantir le respect de ces invariants, mais le coût de plusieurs vérifications sera ainsi évité. Cela s'avère particulièrement utile lorsqu'on crée un nouveau DAG à partir d'un ensemble de nœuds dont on sait qu'ils sont corrects.

Retours

le nœud de l'opération qui a été ajoutée au dag

Type de retour

DAGOpNode

Augmentations

DAGCircuitError – si les nœuds initiaux sont connectés à plusieurs arêtes sortantes

bfs_successors(node)

Renvoie un itérateur de tuples de (DAGNode, [DAGNodes]) où DAGNode est le nœud actuel et [DAGNodes] est une liste des successeurs dans l'ordre BFS.

classical_predecessors(node)

Renvoie un itérateur des prédécesseurs d'un nœud qui sont connectés par une arête classique comme DAGOpNodes et DAGInNodes.

classical_successors(node)

Renvoie un itérateur des successeurs d'un nœud qui sont connectés par une arête classique comme DAGOpNodes et DAGOutNodes.

collect_1q_runs()

Retourne un ensemble de parcours non conditionnels de 1q nœuds "op".

collect_2q_runs()

Retourne un ensemble de parcours non conditionnels de 2q nœuds "op".

collect_runs(namelist)

Renvoie un ensemble de parcours non conditionnels de nœuds "op" avec les noms donnés.

Par exemple, "... h [q0]; cx [q0], [q1]; cx [q0], [q1]; h [q1];..." produirait le tuple de nœuds cx en tant qu'élément de l'ensemble renvoyé par un appel à collect_runs( ["cx"]). Si les nœuds cx étaient "cx [q0], [q1]; cx [q1], [q0];", la méthode renverrait toujours la paire dans un tuple. La liste de noms peut contenir des noms qui ne figurent pas dans la base du circuit.

Les nœuds ne doivent avoir qu'un seul successeur pour continuer la course.

compose(other, qubits=None, clbits=None, front=False, inplace=True, *, inline_captures=False)

Composez le circuit other sur la sortie de ce circuit.

Un sous-ensemble de fils d'entrée de other est mis en correspondance avec un sous-ensemble de fils de sortie de ce circuit.

other peut être plus étroite ou de même largeur que self.

Paramètres

• other (DAGCircuit) – circuit pour composer avec soi-même
• qubits (list[Qubit|int]) – qubits de soi sur lesquels composer.
• clbits (list[Clbit|int]) – clbits de soi sur lesquels composer.
• front (bool) – Si la valeur est « True », la composition frontale sera effectuée (fonctionnalité non encore implémentée)
• inplace (bool) – Si True, modifier l'objet. Dans le cas contraire, le circuit composé est renvoyé.
• inline_captures (bool) – Si True, les variables marquées comme "captures" dans le DAG other seront intégrées aux utilisations existantes de ces mêmes variables dans self. Si False, toutes les variables de other doivent être distinctes de self, et elles seront ajoutées à self.

Retours

le dag composé (renvoie None si inplace==True).

Type de retour

DAGCircuit

Augmentations

DAGCircuitError – si other est plus large ou s’il existe des correspondances de bords en double.

control_flow_op_nodes()

Obtenir une liste des nœuds "op" du dag qui contiennent des instructions de flux de contrôle.

Retours

La liste des nœuds dag contenant des opérations de flux de contrôle.

Type de retour

liste [ DAGOpNode ]

copy_empty_like(*, vars_mode=Ellipsis)

Renvoie une copie de self avec la même structure mais vide.

Cette structure comprend

• nom et autres métadonnées
• phase globale
• durée
• tous les qubits et clbits, y compris les registres.

Retours

Une copie vide de soi.

Type de retour

DAGCircuit

count_ops(*, recurse=True)

Compter les occurrences des noms d'opérations.

Paramètres

recurse - si True (par défaut), recurse dans les opérations de flux de contrôle. Dans tous les cas, on ne compte que le nombre de fois où l'opération apparaît dans un bloc possible; les deux branches des boucles "if" sont comptées, et les blocs des boucles "for" et "while" ne sont comptés qu'une seule fois.

Retours

une correspondance entre les noms des opérations et le nombre de fois qu'ils apparaissent.

Type de retour

Mapping [str, int ]

count_ops_longest_path()

Compter les occurrences des noms d'opérations sur le chemin le plus long.

Renvoie un dictionnaire de comptages dont la clé est le nom de l'opération.

depth(*, recurse=False)

Renvoyer la profondeur du circuit. Si un flux de contrôle est présent, ce décompte ne peut être qu'une estimation, car le chemin complet du flux de contrôle ne peut être connu de manière statique.

Paramètres

récursivité – si True, alors passer à des opérations de flux de contrôle par récursivité. Les boucles « for » avec des itérateurs de longueur connue sont comptabilisées comme si la boucle avait été « déroulée » manuellement ( c'est-à-dire avec chaque itération du corps de la boucle écrite explicitement). Les blocs « if-else » prennent en compte la branche la plus longue des deux. Les boucles « while » sont comptabilisées comme si le corps de la boucle n'était exécuté qu'une seule fois. La valeur par défaut est False et une exception est levée DAGCircuitError si un flux de contrôle est présent, afin d'éviter de renvoyer silencieusement un nombre absurde.

Retours

la profondeur du circuit

Type de retour

int

Augmentations

• DAGCircuitError – s'il ne s'agit pas d'un graphe acyclique orienté
• DAGCircuitError – si un flux de contrôle inconnu est présent dans un appel récursif, ou si un flux de contrôle quelconque est présent dans un appel non récursif.

descendants(node)

Renvoie l'ensemble des descendants d'un nœud sous forme de DAGOpNodes et DAGOutNodes.

Les descendants constituent l'ensemble de tous les nœuds accessibles à partir du nœud cible. En comparaison, DAGCircuit.successors() est un itérateur sur les successeurs immédiats, tandis que cette méthode contient tous les successeurs des successeurs.

draw(scale=0.7, filename=None, style='color')

Dessine le circuit dag.

Cette fonction nécessite l'installation de Graphviz. Graphviz n'est pas un paquet python et ne peut pas être installé par pip (le paquet graphviz sur PyPI est une bibliothèque d'interface Python pour Graphviz et n'installe pas réellement Graphviz). Vous pouvez vous référer à la documentation de Graphviz pour savoir comment l'installer.

Paramètres

• scale (float) – facteur d'échelle
• filename (str) – chemin d'accès du fichier dans lequel enregistrer l'image (format déduit du nom)
• style (str) – 'plain' : Graphique B&W; 'color' (par défaut) : nœuds d'entrée/sortie/op en couleur

Retours

s'il s'agit d'un notebook Jupyter qui n'enregistre pas dans un fichier, sinon None.

Type de retour

Ipython.display.Image

edges(nodes=None)

Itérateur pour les valeurs d'arêtes avec nœud source et nœud de destination.

Elle renvoie les arêtes sortantes à partir des nœuds spécifiés. Si aucun nœud n'est spécifié, toutes les arêtes du graphe sont renvoyées.

Paramètres

nodes (DAGOpNode, DAGInNode, or DAGOutNode|list(DAGOpNode, DAGInNode, or DAGOutNode) – Soit une liste de nœuds, soit un seul nœud d'entrée. Si aucune n'est spécifiée, toutes les arêtes sont renvoyées du graphe.

Rendements

bord -

l'arête sous forme de tuple au format

(nœud source, nœud de destination, fil d'arête)

find_bit(bit)

Trouve des emplacements dans le circuit, en faisant correspondre le Qubit et le Clbit à l'index positionnel BitLocations est défini comme suit : = namedtuple( ("index", "registers")) : BitLocations = namedtuple( “BitLocations”, ("index", "registers"))

Paramètres

bit (Bit) – L'élément à localiser.

Retours

Un 2-tuple. Le premier élément (index)

contient l'index auquel le site Bit peut être trouvé (dans l'une ou l'autre des langues suivantes qubits, clbitsselon son type). Le deuxième élément (registers) est une liste de paires (register, index) avec une entrée pour chaque Register dans le circuit qui contient le Bit (et l'index dans le Register auquel il peut être trouvé).

Type de retour

namedtuple(int, ListTuple [(Register, int)] )

Augmentations :

DAGCircuitError: Si l'adresse Bit fournie est d'un type inconnu. DAGCircuitError: Si l'adresse Bit fournie n'a pas été trouvée sur le circuit.

front_layer()

Retourne une liste des nœuds op de la première couche de ce dag.

gate_nodes()

Obtenir la liste des nœuds de la porte dans le dag.

Retours

la liste des DAGOpNodes qui représentent les portes.

Type de retour

liste [ DAGOpNode ]

has_identifier(var)

Cet identifiant figure-t-il dans le DAG?

Paramètres

var - l'identifiant ou le nom à vérifier.

has_stretch(stretch)

Ce tronçon se trouve-t-il dans le DAG?

Paramètres

var - le tronçon ou le nom à vérifier.

has_var(var)

Cette variable en temps réel se trouve-t-elle dans le DAG?

Paramètres

var - la variable ou le nom à vérifier.

idle_wires(ignore=None)

Retourner les fils de ralenti.

Paramètres

ignore (list(str)) – Liste des noms de nœuds à ignorer. Par défaut : []

Rendements

Bit - Bit dans le fil de ralenti.

Augmentations

DAGCircuitError – Si le DAG n'est pas valide

is_empty()

Renvoie true s'il n'y a aucun nœud d'opération dans le graphe.

is_predecessor(node, node_pred)

Vérifie si un deuxième nœud se trouve dans les prédécesseurs du nœud.

is_successor(node, node_succ)

Vérifie si un deuxième nœud se trouve dans les successeurs du nœud.

iter_captured_stretches()

Itérable sur les étirements capturés suivis par le circuit.

iter_captured_vars()

Itérable sur les variables classiques capturées suivies par le circuit.

iter_captures()

Itérable sur tous les identificateurs capturés suivis par le circuit.

iter_declared_stretches()

Itérable sur les étirements déclarés suivis par le circuit.

iter_declared_vars()

Itérable sur les variables classiques déclarées suivies par le circuit.

iter_input_vars()

Itérable sur les variables classiques d'entrée suivies par le circuit.

iter_stretches()

Itérable sur tous les tronçons suivis par le circuit.

iter_vars()

Itérable sur toutes les variables classiques suivies par le circuit.

layers(*, vars_mode=Ellipsis)

Donne une vue superficielle d'une couche de ce DAGCircuit pour toutes les d couches de ce circuit.

Une couche est un circuit dont les portes agissent sur des qubits disjoints, c'est-à-dire qu'une couche a une profondeur de 1. Le nombre total de couches est égal à la profondeur du circuit d. Les couches sont indexées de 0 à d-1, la couche la plus ancienne étant indexée à 0. Les couches sont construites à l'aide d'un algorithme gourmand. Chaque couche renvoyée est un dict contenant {“graph”: circuit graph, “partition”: list of qubit lists}.

La couche renvoyée contient de nouvelles informations (mais sémantiquement équivalentes) DAGOpNodes, DAGInNodes, et DAGOutNodes. Ces nœuds ne sont pas les mêmes que ceux du dag original, mais sont équivalents via DAGNode.semantic_eq ( node1, node2 ).

TODO : Les portes qui utilisent les mêmes cbits se retrouveront dans des couches différentes, comme c'est actuellement le cas. Ce n'est peut-être pas le comportement souhaité.

longest_path()

Renvoie le chemin le plus long dans le dag sous la forme d'une liste de DAGOpNodes, DAGInNodes, et DAGOutNodes.

make_physical(num_qubits=None)

Mettre self dans la forme physique canonique, avec le nombre donné de qubits.

Elle agit sur place et n'a pas besoin de traverser le DAG. Il est destiné à être utilisé lorsque l'on sait que le DAG représente déjà un circuit physique et qu'il suffit d'affirmer qu'il s'agit d'une forme physique canonique.

Cela efface toute information sur les qubits virtuels dans la base de données DAGCircuit; si vous l'utilisez vous-même, vous devrez peut-être vous assurer d'avoir créé et stocké un qubits virtuel approprié Layout. Il s'agit en fait d'appliquer la disposition "triviale" qui consiste à faire correspondre le qubit virtuel 0 au qubit physique 0, et ainsi de suite.

Paramètres

num_qubits - s'il est donné, le nombre total de qubits physiques dans la sortie; il doit être au moins aussi grand que le nombre de qubits dans le DAG. S'il n'est pas indiqué, le nombre de qubits reste inchangé.

multi_qubit_ops()

Obtenir la liste des opérations sur 3+ qubits. Ignorer les directives telles que snapshot et barrier.

multigraph_layers()

Couches de rendement de la multigraphie.

named_nodes(*names)

Obtenir l'ensemble des nœuds "op" portant le nom donné.

node(node_id)

Obtenir le nœud dans le dag.

Paramètres

node_id (int) – Identifiant du nœud.

Retours

le nœud.

Type de retour

noeud

nodes()

Itérateur pour les valeurs des nœuds.

Rendements

node - le nœud.

nodes_on_wire(wire, only_ops=False)

Itérateur pour les nœuds qui affectent un fil donné.

Paramètres

• wire (Bit) – le câble à examiner.
• only_ops (bool) – True si seuls les nœuds ops sont souhaités; sinon, tous les nœuds sont renvoyés.

Rendements

Iterator - les nœuds successifs sur le fil donné

Augmentations

DAGCircuitError – si la liaison indiquée n'existe pas dans le DAG

num_blocks()

Renvoie le nombre de blocs de base dans ce circuit.

num_clbits()

Renvoie le nombre total de bits classiques utilisés par le circuit.

num_ops()

Obtenir le nombre de nœuds op dans le DAG.

num_qubits()

Retourne le nombre total de qubits utilisés par le circuit. num_qubits() remplace l'ancienne utilisation de width(). DAGCircuit.width () renvoie maintenant qubits + clbits par cohérence avec Circuit.width () [qiskit-terra #2564].

num_tensor_factors()

Calculez le nombre de composants en lesquels le circuit peut se décomposer.

op_nodes(op=None, include_directives=True)

Obtenir la liste des nœuds "op" dans le dag.

Paramètres

• op (Type) –qiskit.circuit.Operation sous-classe des nœuds op à renvoyer. Si None, renvoie tous les nœuds d'opération.
• include_directives (bool) – comprennent la barrière, l'instantané, etc.

Retours

la liste des nœuds dag contenant l'op donné.

Type de retour

liste [ DAGOpNode ]

op_predecessors(node)

Renvoie l'itérateur des prédécesseurs "op" d'un nœud dans le dag.

op_successors(node)

Renvoie un itérateur des successeurs "op" d'un nœud dans le dag.

predecessors(node)

Renvoie un itérateur des prédécesseurs d'un nœud sous forme de DAGOpNodes et DAGInNodes.

properties()

Renvoie un dictionnaire des propriétés du circuit.

quantum_causal_cone(qubit)

Renvoie le cône causal d'un qubit.

Le cône causal d'un qubit est l'ensemble des qubits qui peuvent influencer la sortie de ce qubit par des interactions, que ce soit par des portes ou des opérations multi-qubits. Connaître le cône de causalité d'un qubit peut s'avérer utile lors du débogage de circuits défectueux, car cela permet d'identifier le(s) fil(s) à l'origine du problème.

Cette méthode ne prend en compte aucune dépendance classique des données dans le site DAGCircuit, les fils de bits classiques sont ignorés aux fins de la construction du cône de causalité.

Paramètres

qubit (Qubit) – Le qubit de sortie pour lequel nous souhaitons déterminer le cône causal.

Retours

L'ensemble des qubits dont les interactions affectent qubit.

Type de retour

Ensemble [ qubit ]

quantum_predecessors(node)

Renvoie un itérateur des prédécesseurs d'un nœud qui sont connectés par une arête quantique comme DAGOpNodes et DAGInNodes.

quantum_successors(node)

Renvoie un itérateur des successeurs d'un nœud qui sont connectés par une arête quantique comme DAGOpNodes et DAGOutNodes.

remove_all_ops_named(opname)

Supprime tous les nœuds d'opération portant le nom donné.

remove_ancestors_of(node)

Supprime tous les nœuds d'opération ancêtres du nœud.

remove_clbits(*clbits)

Retirer les bits classiques du circuit. Tous les bits DOIVENT être inactifs. Tous les registres contenant des références à au moins un des bits spécifiés seront également supprimés.

Paramètres

clbits (List[Clbit]) – Les éléments à supprimer.

Augmentations

DAGCircuitError – un bit n'est pas à l'état Clbit« »; il n'est pas inclus dans le circuit ou n'est pas inactif.

remove_cregs(*cregs)

Retirer les registres classiques du circuit, en laissant les bits sous-jacents en place.

Augmentations

• DAGCircuitError – un « creg » n'est pas un « ClassicalRegister, » ou ne figure pas dans
• le circuit. -

remove_descendants_of(node)

Supprime tous les nœuds d'opération descendants du nœud.

remove_nonancestors_of(node)

Supprimer tous les nœuds d'opération non ancestraux du nœud.

remove_nondescendants_of(node)

Supprimer tous les nœuds d'opération non descendants du nœud.

remove_op_node(node)

Supprimer un nœud d'opération n.

Ajouter des arêtes entre les prédécesseurs et les successeurs.

remove_qregs(*qregs)

Retirer les registres quantiques du circuit, en laissant les bits sous-jacents en place.

Augmentations

• DAGCircuitError – un qreg n'est pas un « QuantumRegister, » ou ne figure pas dans
• le circuit. -

remove_qubits(*qubits)

Retirer les bits quantiques du circuit. Tous les bits DOIVENT être inactifs. Tous les registres contenant des références à au moins un des bits spécifiés seront également supprimés.

Paramètres

qubits (List[Qubit]) – Les éléments à supprimer.

Augmentations

DAGCircuitError – un qubit n'est pas un Qubit, ne fait pas partie du circuit ou n'est pas inactif.

replace_block_with_op(node_block, op, wire_pos_map, cycle_check=True)

Remplacer un bloc de nœuds par un seul nœud.

Elle est utilisée pour consolider un bloc de DAGOpNodes en une seule opération. Un exemple typique est celui d'un bloc de portes consolidé en un seul site UnitaryGate représentant la matrice unitaire du bloc.

Paramètres

• node_block (List[DAGNode]) – Une liste de nœuds dag représentant le bloc de nœuds à remplacer
• op (qiskit.circuit.Operation) – L'opération de remplacement du bloc par
• wire_pos_map (Dict[Bit, int]) – Le dictionnaire qui associe les bits à leurs positions dans la sortie qargs ou cargs. Cela est nécessaire pour reconstituer l'ordre des arguments sur plusieurs portes au sein du nœud d'opération unique combiné. Si un Bit élément ne figure pas dans le dictionnaire, il ne sera pas ajouté aux arguments; cela peut s'avérer utile lors de la gestion d'opérations de contrôle de flux dont les condition champs ou target contiennent des bits inhérents.
• cycle_check (bool) – Lorsqu'elle vaut True, cette méthode vérifie que le remplacement du site node_block par un seul nœud n'introduit pas un cycle (ce qui invaliderait le site DAGCircuit) et déclenche une alerte DAGCircuitError si un cycle est introduit. Ce contrôle est assorti d'une pénalité de durée d'exécution. Si vous pouvez garantir que votre entrée node_block est un bloc contigu et qu'elle n'introduira pas de cycle lorsqu'elle sera réduite à un seul nœud, cette valeur peut être fixée à False afin d'améliorer les performances d'exécution de cette méthode.

Augmentations

DAGCircuitError – si cycle_check est défini sur True et que le remplacement du bloc spécifié entraîne l'apparition d'un cycle, ou si node_block est vide.

Retours

Le nœud op qui remplace le bloc.

Type de retour

DAGOpNode

reverse_ops()

Inverser les opérations dans le circuit self .

Retours

le dag inversé.

Type de retour

DAGCircuit

separable_circuits(remove_idle_qubits=False, *, vars_mode=Ellipsis)

Décomposer le circuit en ensembles de qubits sans portes les reliant.

Paramètres

remove_idle_qubits (bool) – Drapeau indiquant s'il faut supprimer les qubits inactifs des circuits séparés. Si False, chaque circuit de sortie contiendra le même nombre de qubits que self.

Retours

Les circuits résultant de la séparation de self en ensembles

de qubits déconnectés

Type de retour

Liste [DAGCircuit ]

Chaque instance DAGCircuit renvoyée par cette méthode contiendra le même nombre de clbits que self. Les informations globales sur la phase contenues dans le site self ne seront pas conservées dans les sous-circuits renvoyés par cette méthode.

serial_layers(*, vars_mode=Ellipsis)

Produire un calque pour toutes les portes de ce circuit.

Une couche sérielle est un circuit avec une seule porte. Les couches ont la même structure que dans layers().

size(*, recurse=False)

Renvoie le nombre d'opérations. Si un flux de contrôle est présent, ce décompte ne peut être qu'une estimation, car le chemin complet du flux de contrôle ne peut être connu de manière statique.

Paramètres

récursivité – si True, alors passer à des opérations de flux de contrôle par récursivité. Les boucles « for » avec des itérateurs de longueur connue sont comptabilisées comme « déroulées ». Les blocs « if-else » additionnent les deux branches. Les boucles « while » sont comptabilisées comme si le corps de la boucle n'était exécuté qu'une seule fois. La valeur par défaut est False et une exception est levée DAGCircuitError si un flux de contrôle est présent, afin d'éviter de renvoyer silencieusement un nombre pratiquement dénué de sens.

Retours

la taille du circuit

Type de retour

int

Augmentations

DAGCircuitError – si une variable inconnue ControlFlowOp est présente dans un appel avec recurse=True, ou si un flux de contrôle quelconque est présent dans un appel non récursif.

structurally_equal(other)

Ces deux DAG sont-ils structurellement égaux?

Cette fonction renvoie la réponse "vrai" si les structures du graphique sont exactement les mêmes l'une que l'autre, y compris les indices de nœuds valides, les ordres des arêtes, etc. Il s'agit d'une vérification beaucoup plus stricte que l'équivalence des graphes, et elle est surtout utile pour vérifier si deux instances ont été construites et manipulées exactement de la même manière DAGCircuit ont été construites et manipulées exactement de la même manière. Par exemple, cette méthode peut être utilisée pour tester si une séquence de manipulations d'un DAG est déterministe.

Cette méthode ne prend pas en compte les métadonnées de suivi telles que metadata ou namemais prend en compte de nombreux détails d'implémentation de bas niveau de la représentation interne, dont la plupart ne modifient pas la sémantique du circuit.

Cette méthode devrait, en général, être beaucoup plus rapide que les contrôles d'équivalence de graphes, mais elle renverra False dans beaucoup plus de situations. Cette méthode ne devrait jamais renvoyer True lorsqu'une vérification de l'équivalence des graphes renverrait False.

substitute_node(node, op, inplace=False, propagate_condition=None)

Remplacer un site DAGOpNode en une seule opération. les qargs, cargs et conditions de la nouvelle opération seront déduits du nœud à remplacer. La nouvelle opération sera vérifiée pour correspondre à la forme de l'opération remplacée.

Paramètres

• node (DAGOpNode) – Nœud à remplacer
• op (qiskit.circuit.Operation) – L'instance qiskit.circuit.Operation instance à ajouter au DAG
• inplace (bool) – Facultatif, par défaut False. Si True, le nœud DAG existant sera modifié pour inclure op. Dans le cas contraire, un nouveau nœud DAG sera utilisé.
• propagate_condition (bool) – DÉCRYPTAGE d'une option ancienne qui permettait de contrôler le comportement du flux de contrôle. Elle n'a plus d'effet, elle a été conservée pour des raisons de compatibilité ascendante. Sera supprimée à Qiskit 3.0.

Retours

le nouveau nœud contenant l'opération ajoutée.

Type de retour

DAGOpNode

Augmentations

• DAGCircuitError – Si l'opération de remplacement était incompatible avec
• localisation du nœud cible. -

substitute_node_with_dag(node, input_dag, wires=None, propagate_condition=None)

Remplacer un nœud par dag.

Paramètres

• node (DAGOpNode) – nœud de substitution
• input_dag (DAGCircuit) – circuit qui remplacera le nœud
• wires (list[Bit] | Dict[Bit, Bit]) – détermine l'ordre des (qu)bits dans le circuit d'entrée. input_dagS'il s'agit d'une liste, les éléments font référence à ceux de la liste, et l'ordre est d'abord mis en correspondance avec les fils du nœud via qargs, puis via cargs, puis via conditions. S'il s'agit d'un dictionnaire, alors il s'agit d'une correspondance entre les bits du input_dag et ceux sur lesquels le node agit.
• propagate_condition (bool) – DÉCRYPTAGE d'une option ancienne qui permettait de contrôler le comportement du flux de contrôle. Elle n'a plus d'effet, elle a été conservée pour des raisons de compatibilité ascendante. Sera supprimée à Qiskit 3.0.

Retours

fait correspondre les ID des nœuds de l'entrée à leurs nouvelles incarnations dans l'utilisateur.

Type de retour

dict

Augmentations

DAGCircuitError – en cas de prédécesseur(s) ou de successeur(s) inattendu(s)

successors(node)

Renvoie un itérateur des successeurs d'un nœud en tant que DAGOpNodeet DAGOutNodes.

swap_nodes(node1, node2)

Échanger des nœuds connectés, par exemple en raison d'une commutation.

Paramètres

• node1 (OpNode) – nœud prédécesseur
• node2 (OpNode) – nœud successeur

Augmentations

DAGCircuitError – si l'un des nœuds n'est pas un « OpNode » ou si les nœuds ne sont pas connectés

to_circuit(*, copy_operations=True)

Convertir ce DAG en un fichier QuantumCircuit.

Il s'agit d'une simple enveloppe autour de dag_to_circuit().

Paramètres

copy_operations – indique s'il faut effectuer une copie profonde des instructions individuelles. Si cette option est False activée, l'opération est moins coûteuse, mais les modifications apportées aux instructions du circuit auront une incidence sur le circuit d'origine.

Retours

a QuantumCircuit représentant ce même DAG.

topological_nodes(key=None, reverse=False)

Les nœuds de rendement sont classés par ordre topologique.

Paramètres

• key (Callable) – Un appel qui prend un objet DAGNode et renvoie une clé de tri sous forme de chaîne. Si elle n'est pas spécifiée, les bit qargs et cargs d'un noeud seront utilisés pour le tri.
• reverse (bool) – Si vrai, renvoie les nœuds dans l'ordre topologique inverse.

Retours

nœud dans l'ordre topologique

Type de retour

générateur (DAGOpNode, DAGInNode, ou DAGOutNode )

topological_op_nodes(key=None, reverse=False)

Rendement des nœuds op dans l'ordre topologique.

Autorisé à passer dans une clé spécifique pour briser les égalités dans l'ordre supérieur

Paramètres

• key (Callable) – Un appel qui prend un objet DAGNode et renvoie une clé de tri sous forme de chaîne. Si elle n'est pas spécifiée, les qargs et cargs d'un noeud seront utilisés pour le tri.
• reverse (bool) – Si vrai, renvoie les nœuds op dans l'ordre topologique inverse.

Retours

nœud op dans l'ordre topologique

Type de retour

générateur( DAGOpNode )

two_qubit_ops()

Obtenir la liste des opérations sur 2 qubits. Ignorer les directives telles que snapshot et barrier.

width()

Retourne le nombre total de qubits + clbits utilisés par le circuit. Cette fonction renvoyait auparavant le nombre de qubits par le calcul return len( self._wires ) - self.num_clbits () mais a été modifiée par le numéro 2564 pour renvoyer le nombre de qubits + clbits avec la nouvelle fonction DAGCircuit.num_qubits remplaçant l'ancienne sémantique de DAGCircuit.width ().