DAGDépendance

class qiskit.dagcircuit.DAGDependency

Bases : object

Objet permettant de représenter un circuit quantique sous la forme d'un graphe acyclique orienté (DAG) par le biais de dépendances d'opérations (c'est-à-dire l'absence de commutation).

Les nœuds du graphe sont des opérations représentées par des portes quantiques. Les arêtes correspondent à la non-commutation entre deux opérations (c'est-à-dire à une dépendance). Une arête dirigée du nœud A vers le nœud B signifie que l'opération A ne commute pas avec l'opération B. Les méthodes de l'objet permettent de construire des circuits.

Les nœuds du graphe ont les attributs suivants : "opération", "successeurs", "prédécesseurs".

Exemple :

Circuit de cloche sans mesure.

      ┌───┐
qr_0: ┤ H ├──■──
      └───┘┌─┴─┐
qr_1: ─────┤ X ├
           └───┘

Le DAG de dépendance du circuit ci-dessus est représenté par deux nœuds. La première correspond à la porte de Hadamard, la seconde à la porte CNOT, car les portes ne s'annulent pas lorsqu'il y a une arête entre les deux nœuds.

Référence :

[1] Iten, R., Moyard, R., Metger, T., Sutter, D. et Woerner, S., 2020. Correspondance exacte et pratique pour l'optimisation des circuits quantiques. arXiv:1909.05270

Créer un DAGDependency vide.

Attributs

global_phase

Renvoie la phase globale du circuit.

Méthodes

add_clbits

add_clbits(clbits)

Ajouter des fils de connexion individuels.

add_creg

add_creg(creg)

Ajouter des clbits dans un registre classique.

add_op_node

add_op_node(operation, qargs, cargs)

Ajouter une adresse DAGDepNode au graphe et mettre à jour les arêtes.

Paramètres

add_qreg

add_qreg(qreg)

Ajouter des qubits dans un registre quantique.

add_qubits

add_qubits(qubits)

Ajouter des fils de qubit individuels.

copy

copy()

Fonction permettant de copier un objet DAGDependency. :returns : une copie d'un objet DAGDependency. :rtype : DAGDépendance

depth

depth()

Renvoie la profondeur du circuit. :returns : la profondeur du circuit :rtype : int

direct_predecessors

direct_predecessors(node_id)

Identifiant des prédécesseurs directs d'un nœud donné sous forme de liste triée.

Paramètres

node_id (int) – étiquette du nœud considéré.

Retours

l'identifiant des prédécesseurs directs sous forme de liste triée

Type de retour

Liste

direct_successors

direct_successors(node_id)

Identité des successeurs directs d'un nœud donné sous forme de liste triée.

Paramètres

node_id (int) – étiquette du nœud considéré.

Retours

id des successeurs directs sous forme de liste triée

Type de retour

Liste

draw

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

Dessine le graphe de dépendance DAGD.

Cette fonction nécessite pydot, qui nécessite à son tour l'installation de Graphviz.

Avertissement

Cette fonction lancera l'outil Graphviz du système sur un fichier contenant des chaînes de caractères définies par l'utilisateur (telles que les étiquettes de portes ou les noms de registres). Il est recommandé de n'appeler cette fonction qu'avec des données fiables.

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

get_all_edges

get_all_edges()

Enumération de toutes les arêtes.

Retours

correspondant à l'étiquette.

Type de retour

Liste

get_edges

get_edges(src_id, dest_id)

Enumération des arêtes entre deux nœuds par la méthode get_all_edge_data.

Paramètres

src_id (int) – l'étiquette du premier nœud.
dest_id (int) – l'étiquette du deuxième nœud.

Retours

correspondant à toutes les arêtes entre les deux nœuds.

Type de retour

Liste

get_in_edges

get_in_edges(node_id)

Enumération de toutes les arêtes entrantes pour un nœud donné.

Paramètres

node_id (int) – étiquette du nœud considéré.

Retours

les données des bords entrants correspondants.

Type de retour

Liste

get_node

get_node(node_id)

Paramètres

node_id (int) – étiquette du nœud considéré.

Retours

correspondant à l'étiquette.

Type de retour

noeud

get_nodes

get_nodes()

Retours

itérateur sur tous les nœuds.

Type de retour

générateur (dict )

get_out_edges

get_out_edges(node_id)

Enumération de toutes les arêtes sortantes pour un nœud donné.

Paramètres

node_id (int) – étiquette du nœud considéré.

Retours

les données des bords sortants correspondants.

Type de retour

Liste

predecessors

predecessors(node_id)

Identifiant des prédécesseurs d'un nœud donné sous forme de liste triée.

Paramètres

node_id (int) – étiquette du nœud considéré.

Retours

tous les id prédécesseurs sous forme de liste triée

Type de retour

Liste

replace_block_with_op

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 DAGDepNodes en une seule opération. Un exemple typique est celui d'un bloc de portes CX et SWAP regroupées sur un site LinearFunction. Cette fonction est une adaptation d'une fonction similaire de DAGCircuit.

Il est important que cette consolidation préserve les hypothèses de commutativité présentes dans DAGDependency. Supposons par exemple que chaque nœud d'un bloc [A, B, C, D] commute avec un autre nœud E. Soit F le nœud consolidé, F = A o B o C o D. Alors F commute également avec E, et donc le résultat du remplacement de [A, B, C, D] par F donne une DAGDépendance valide. En d'autres termes, toute déduction sur la commutativité dans un DAGDépendance consolidé est correcte. D'autre part, supposons qu'au moins un des nœuds, disons B, ne commute pas avec E. Dans ce cas, la DAGDependency consolidée impliquerait que F ne commute pas avec E. Même si F et E peuvent effectivement faire la navette, on peut supposer qu'ils ne le font pas. En d'autres termes, la mise en œuvre actuelle de la consolidation peut conduire à des résultats sous-optimaux, mais pas à des résultats erronés.

Paramètres

node_block (List[DAGDepNode]) – 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[Qubit, int]) – Le dictionnaire qui associe le qarg à la position. Cela est nécessaire pour reconstituer l'ordre des qargs sur plusieurs portes au sein du nœud combiné à opération unique.
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 DAGDependency) et déclenche une alerte DAGDependencyError 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

DAGDependencyError – 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.

size

size()

Renvoie le nombre de portes dans le circuit

successors

successors(node_id)

Identité des successeurs d'un nœud donné sous forme de liste triée.

Paramètres

node_id (int) – étiquette du nœud considéré.

Retours

tous les identifiants des successeurs sous forme de liste triée

Type de retour

Liste

to_retworkx

to_retworkx()

Renvoie le DAGDependency au format retworkx.

topological_nodes

topological_nodes()

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

Retours

dans l'ordre topologique.

Type de retour

generator (DAGNode )

Cette page a-t-elle été utile ?

Signaler un bogue, une coquille ou proposer du contenu sur GitHub.