qiskit.dagcircuit.DAGCircuit¶

class
DAGCircuit
[source]¶ Quantum circuit as a directed acyclic graph.
There are 3 types of nodes in the graph: inputs, outputs, and operations. The nodes are connected by directed edges that correspond to qubits and bits.
Create an empty circuit.
Methods
__init__
()Create an empty circuit.
add_creg
(creg)Add all wires in a classical register.
add_qreg
(qreg)Add all wires in a quantum register.
ancestors
(node)Returns set of the ancestors of a node as DAGNodes.
apply_operation_back
(op[, qargs, cargs, …])Apply an operation to the output of the circuit.
apply_operation_front
(op, qargs, cargs[, …])Apply an operation to the input of the circuit.
bfs_successors
(node)Returns an iterator of tuples of (DAGNode, [DAGNodes]) where the DAGNode is the current node and [DAGNode] is its successors in BFS order.
collect_runs
(namelist)Return a set of nonconditional runs of “op” nodes with the given names.
compose
(other[, edge_map, qubits, clbits, …])Compose the
other
circuit onto the output of this circuit.compose_back
(input_circuit[, edge_map])DEPRECATED: use DAGCircuit.compose() instead.
Count the occurrences of operation names.
Count the occurrences of operation names on the longest path.
depth
()Return the circuit depth.
descendants
(node)Returns set of the descendants of a node as DAGNodes.
draw
([scale, filename, style])Draws the dag circuit.
edges
([nodes])Iterator for edge values and source and dest node
extend_back
(dag[, edge_map])DEPRECATED: Add dag at the end of self, using edge_map.
from_networkx
(graph)Take a networkx MultiDigraph and create a new DAGCircuit.
Return a list of op nodes in the first layer of this dag.
Get the list of gate nodes in the dag.
has_calibration_for
(node)Return True if the dag has a calibration defined for the node operation.
idle_wires
([ignore])Return idle wires.
layers
()Yield a shallow view on a layer of this DAGCircuit for all d layers of this circuit.
Returns the longest path in the dag as a list of DAGNodes.
Get list of 3+ qubit operations.
Yield layers of the multigraph.
named_nodes
(*names)Get the set of “op” nodes with the given name.
node
(node_id)Get the node in the dag.
nodes
()Iterator for node values.
nodes_on_wire
(wire[, only_ops])Iterator for nodes that affect a given wire.
Return the total number of classical bits used by the circuit.
Return the total number of qubits used by the circuit.
Compute how many components the circuit can decompose into.
op_nodes
([op, include_directives])Get the list of “op” nodes in the dag.
predecessors
(node)Returns iterator of the predecessors of a node as DAGNodes.
Return a dictionary of circuit properties.
quantum_predecessors
(node)Returns iterator of the predecessors of a node that are connected by a quantum edge as DAGNodes.
quantum_successors
(node)Returns iterator of the successors of a node that are connected by a quantum edge as DAGNodes.
remove_all_ops_named
(opname)Remove all operation nodes with the given name.
remove_ancestors_of
(node)Remove all of the ancestor operation nodes of node.
remove_descendants_of
(node)Remove all of the descendant operation nodes of node.
remove_nonancestors_of
(node)Remove all of the nonancestors operation nodes of node.
remove_nondescendants_of
(node)Remove all of the nondescendants operation nodes of node.
remove_op_node
(node)Remove an operation node n.
Reverse the operations in the
self
circuit.Yield a layer for all gates of this circuit.
size
()Return the number of operations.
substitute_node
(node, op[, inplace])Replace a DAGNode with a single instruction.
substitute_node_with_dag
(node, input_dag[, …])Replace one node with dag.
successors
(node)Returns iterator of the successors of a node as DAGNodes.
Get list of 3ormorequbit gates: (id, data).
Returns a copy of the DAGCircuit in networkx format.
Yield nodes in topological order.
Yield op nodes in topological order.
Get list of 2qubit gates.
Get list of 2 qubit operations.
width
()Return the total number of qubits + clbits used by the circuit.
Attributes
Return calibration dictionary.
Return a list of classical bits (as a list of Clbit instances).
Return the global phase of the circuit.
Returns the number of nodes in the dag.
Return a list of qubits (as a list of Qubit instances).
Return a list of the wires in order.

apply_operation_back
(op, qargs=None, cargs=None, condition=None)[source]¶ Apply an operation to the output of the circuit.
 Parameters
op (qiskit.circuit.Instruction) – the operation associated with the DAG node
qargs (list[Qubit]) – qubits that op will be applied to
cargs (list[Clbit]) – cbits that op will be applied to
condition (tuple or None) – DEPRACTED optional condition (ClassicalRegister, int)
 Returns
the current max node
 Return type
 Raises
DAGCircuitError – if a leaf node is connected to multiple outputs

apply_operation_front
(op, qargs, cargs, condition=None)[source]¶ Apply an operation to the input of the circuit.
 Parameters
op (qiskit.circuit.Instruction) – the operation associated with the DAG node
qargs (list[Qubit]) – qubits that op will be applied to
cargs (list[Clbit]) – cbits that op will be applied to
condition (tuple or None) – DEPRACTED optional condition (ClassicalRegister, int)
 Returns
the current max node
 Return type
 Raises
DAGCircuitError – if initial nodes connected to multiple out edges

bfs_successors
(node)[source]¶ Returns an iterator of tuples of (DAGNode, [DAGNodes]) where the DAGNode is the current node and [DAGNode] is its successors in BFS order.

property
calibrations
¶ Return calibration dictionary.
 The custom pulse definition of a given gate is of the form
{‘gate_name’: {(qubits, params): schedule}}

property
clbits
¶ Return a list of classical bits (as a list of Clbit instances).

collect_runs
(namelist)[source]¶ Return a set of nonconditional runs of “op” nodes with the given names.
For example, “… h q[0]; cx q[0],q[1]; cx q[0],q[1]; h q[1]; ..” would produce the tuple of cx nodes as an element of the set returned from a call to collect_runs([“cx”]). If instead the cx nodes were “cx q[0],q[1]; cx q[1],q[0];”, the method would still return the pair in a tuple. The namelist can contain names that are not in the circuit’s basis.
Nodes must have only one successor to continue the run.

compose
(other, edge_map=None, qubits=None, clbits=None, front=False, inplace=True)[source]¶ Compose the
other
circuit onto the output of this circuit.A subset of input wires of
other
are mapped to a subset of output wires of this circuit.other
can be narrower or of equal width toself
. Parameters
other (DAGCircuit) – circuit to compose with self
edge_map (dict) – DEPRECATED  a {Bit: Bit} map from input wires of other to output wires of self (i.e. rhs>lhs). The key, value pairs can be either Qubit or Clbit mappings.
qubits (list[Qubitint]) – qubits of self to compose onto.
clbits (list[Clbitint]) – clbits of self to compose onto.
front (bool) – If True, front composition will be performed (not implemented yet)
inplace (bool) – If True, modify the object. Otherwise return composed circuit.
 Returns
the composed dag (returns None if inplace==True).
 Return type
 Raises
DAGCircuitError – if
other
is wider or there are duplicate edge mappings.

count_ops
()[source]¶ Count the occurrences of operation names.
Returns a dictionary of counts keyed on the operation name.

count_ops_longest_path
()[source]¶ Count the occurrences of operation names on the longest path.
Returns a dictionary of counts keyed on the operation name.

depth
()[source]¶ Return the circuit depth. :returns: the circuit depth :rtype: int
 Raises
DAGCircuitError – if not a directed acyclic graph

draw
(scale=0.7, filename=None, style='color')[source]¶ Draws the dag circuit.
This function needs pydot, which in turn needs Graphviz to be installed.
 Parameters
scale (float) – scaling factor
filename (str) – file path to save image to (format inferred from name)
style (str) – ‘plain’: B&W graph; ‘color’ (default): color input/output/op nodes
 Returns
if in Jupyter notebook and not saving to file, otherwise None.
 Return type
Ipython.display.Image

edges
(nodes=None)[source]¶ Iterator for edge values and source and dest node
This works by returning the output edges from the specified nodes. If no nodes are specified all edges from the graph are returned.
 Parameters
nodes (DAGNodelist(DAGNode) – Either a list of nodes or a single input node. If none is specified all edges are returned from the graph.
 Yields
edge –
 the edge in the same format as out_edges the tuple
(source node, destination node, edge data)

classmethod
from_networkx
(graph)[source]¶ Take a networkx MultiDigraph and create a new DAGCircuit.
 Parameters
graph (networkx.MultiDiGraph) – The graph to create a DAGCircuit object from. The format of this MultiDiGraph format must be in the same format as returned by to_networkx.
 Returns
 The dagcircuit object created from the networkx
MultiDiGraph.
 Return type

gate_nodes
()[source]¶ Get the list of gate nodes in the dag.
 Returns
the list of DAGNodes that represent gates.
 Return type
list[DAGNode]

property
global_phase
¶ Return the global phase of the circuit.

has_calibration_for
(node)[source]¶ Return True if the dag has a calibration defined for the node operation. In this case, the operation does not need to be translated to the device basis.

idle_wires
(ignore=None)[source]¶ Return idle wires.
 Parameters
ignore (list(str)) – List of node names to ignore. Default: []
 Yields
Bit – Bit in idle wire.

layers
()[source]¶ Yield a shallow view on a layer of this DAGCircuit for all d layers of this circuit.
A layer is a circuit whose gates act on disjoint qubits, i.e., a layer has depth 1. The total number of layers equals the circuit depth d. The layers are indexed from 0 to d1 with the earliest layer at index 0. The layers are constructed using a greedy algorithm. Each returned layer is a dict containing {“graph”: circuit graph, “partition”: list of qubit lists}.
The returned layer contains new (but semantically equivalent) DAGNodes. These are not the same as nodes of the original dag, but are equivalent via DAGNode.semantic_eq(node1, node2).
TODO: Gates that use the same cbits will end up in different layers as this is currently implemented. This may not be the desired behavior.

multi_qubit_ops
()[source]¶ Get list of 3+ qubit operations. Ignore directives like snapshot and barrier.

node
(node_id)[source]¶ Get the node in the dag.
 Parameters
node_id (int) – Node identifier.
 Returns
the node.
 Return type
node

property
node_counter
¶ Returns the number of nodes in the dag.

nodes_on_wire
(wire, only_ops=False)[source]¶ Iterator for nodes that affect a given wire.
 Parameters
wire (Bit) – the wire to be looked at.
only_ops (bool) – True if only the ops nodes are wanted; otherwise, all nodes are returned.
 Yields
DAGNode – the successive ops on the given wire
 Raises
DAGCircuitError – if the given wire doesn’t exist in the DAG

num_qubits
()[source]¶ Return the total number of qubits used by the circuit. num_qubits() replaces former use of width(). DAGCircuit.width() now returns qubits + clbits for consistency with Circuit.width() [qiskitterra #2564].

op_nodes
(op=None, include_directives=True)[source]¶ Get the list of “op” nodes in the dag.
 Parameters
op (Type) –
qiskit.circuit.Instruction
subclass op nodes to return. If None, return all op nodes.include_directives (bool) – include barrier, snapshot etc.
 Returns
the list of node ids containing the given op.
 Return type
list[DAGNode]

quantum_predecessors
(node)[source]¶ Returns iterator of the predecessors of a node that are connected by a quantum edge as DAGNodes.

quantum_successors
(node)[source]¶ Returns iterator of the successors of a node that are connected by a quantum edge as DAGNodes.

property
qubits
¶ Return a list of qubits (as a list of Qubit instances).

remove_op_node
(node)[source]¶ Remove an operation node n.
Add edges from predecessors to successors.

reverse_ops
()[source]¶ Reverse the operations in the
self
circuit. Returns
the reversed dag.
 Return type

serial_layers
()[source]¶ Yield a layer for all gates of this circuit.
A serial layer is a circuit with one gate. The layers have the same structure as in layers().

substitute_node
(node, op, inplace=False)[source]¶ Replace a DAGNode with a single instruction. qargs, cargs and conditions for the new instruction will be inferred from the node to be replaced. The new instruction will be checked to match the shape of the replaced instruction.
 Parameters
node (DAGNode) – Node to be replaced
op (qiskit.circuit.Instruction) – The
qiskit.circuit.Instruction
instance to be added to the DAGinplace (bool) – Optional, default False. If True, existing DAG node will be modified to include op. Otherwise, a new DAG node will be used.
 Returns
the new node containing the added instruction.
 Return type
 Raises
DAGCircuitError – If replacement instruction was incompatible with
location of target node. –

substitute_node_with_dag
(node, input_dag, wires=None)[source]¶ Replace one node with dag.
 Parameters
node (DAGNode) – node to substitute
input_dag (DAGCircuit) – circuit that will substitute the node
wires (list[Bit]) – gives an order for (qu)bits in the input circuit. This order gets matched to the node wires by qargs first, then cargs, then conditions.
 Raises
DAGCircuitError – if met with unexpected predecessor/successors

topological_nodes
()[source]¶ Yield nodes in topological order.
 Returns
node in topological order
 Return type
generator(DAGNode)

topological_op_nodes
()[source]¶ Yield op nodes in topological order.
 Returns
op node in topological order
 Return type
generator(DAGNode)

two_qubit_ops
()[source]¶ Get list of 2 qubit operations. Ignore directives like snapshot and barrier.

width
()[source]¶ Return the total number of qubits + clbits used by the circuit. This function formerly returned the number of qubits by the calculation return len(self._wires)  self.num_clbits() but was changed by issue #2564 to return number of qubits + clbits with the new function DAGCircuit.num_qubits replacing the former semantic of DAGCircuit.width().

property
wires
¶ Return a list of the wires in order.
