z i+ZSrSSKJr SSKrSSKrSSKrSSKJr SSKJ r SSK r SSK J r SSKJr SSKJrJr SS KJrJr SS KJr SS KJr \R4(aSS KJr "S S5rSrg)zEDAGDependency class for representing non-commutativity in a circuit. ) annotationsN) OrderedDict)Iterator)SessionCommutationChecker)condition_resources)QuantumRegisterQubit)ClassicalRegisterClbit)DAGDependencyError) DAGDepNodeParameterExpressionc"\rSrSrSrSr\S5r\RS$Sj5rSr Sr Sr S r S r S rS rS%S jrS&SjrS'SjrS(SjrSrSrSrSrS)SjrSrS)SjrS)SjrSrSrSrSrSr Sr!Sr"S*S!jr#S+S"jr$S#r%g ), DAGDependency8uObject to represent a quantum circuit as a Directed Acyclic Graph (DAG) via operation dependencies (i.e. lack of commutation). The nodes in the graph are operations represented by quantum gates. The edges correspond to non-commutation between two operations (i.e. a dependency). A directed edge from node A to node B means that operation A does not commute with operation B. The object's methods allow circuits to be constructed. The nodes in the graph have the following attributes: 'operation', 'successors', 'predecessors'. **Example:** Bell circuit with no measurement. .. code-block:: text ┌───┐ qr_0: ┤ H ├──■── └───┘┌─┴─┐ qr_1: ─────┤ X ├ └───┘ The dependency DAG for the above circuit is represented by two nodes. The first one corresponds to Hadamard gate, the second one to the CNOT gate as the gates do not commute there is an edge between the two nodes. **Reference:** [1] Iten, R., Moyard, R., Metger, T., Sutter, D. and Woerner, S., 2020. Exact and practical pattern matching for quantum circuit optimization. `arXiv:1909.05270 `_ cSUl0Ul[R"5Ul[ 5Ul[ 5Ul/Ul/Ul SUl SUl SUl [Ulg)z Create an empty DAGDependency. Ngdt)namemetadatarxPyDAG _multi_graphrqregscregsqubitsclbits _global_phasedurationunitscc comm_checkerselfs Y/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/dagcircuit/dagdependency.py__init__DAGDependency.__init__]sf   HHJ!]  ]   :=  cUR$)z'Return the global phase of the circuit.)rr#s r% global_phaseDAGDependency.global_phasezs!!!r(cSSKJn [X5(aXlg[ U5nU(dSUlgUS[ R --Ulg)zSSet the global phase of the circuit. Args: angle (float, ParameterExpression) rrN)"qiskit.circuit.parameterexpressionr isinstancerfloatmathpi)r$anglers r%r*r+sD K e 1 1!& %LE%&"%*a$''k%:"r(cUR$)z-Returns the DAGDependency in retworkx format.)rr#s r% to_retworkxDAGDependency.to_retworkxs   r(c,[UR5$)z*Returns the number of gates in the circuit)lenrr#s r%sizeDAGDependency.sizes4$$%%r(cV[R"UR5nUS:aU$S$)z>Return the circuit depth. Returns: int: the circuit depth r)rdag_longest_path_lengthr)r$depths r%r=DAGDependency.depths+ **4+<+<= u))r(c[SU55(a [S5e[UR5R U5nU(a[SU35eURR U5 g)zAdd individual qubit wires.c3L# UHn[U[5(+v M g7fN)r/r ).0qubits r% +DAGDependency.add_qubits..@:eU+++"$znot a Qubit instance.zduplicate qubits N)anyr setr intersectionextend)r$rduplicate_qubitss r% add_qubitsDAGDependency.add_qubitsc @@ @ @$%<= =t{{+88@ $'89I8J%KL L 6"r(c[SU55(a [S5e[UR5R U5nU(a[SU35eURR U5 g)zAdd individual clbit wires.c3L# UHn[U[5(+v M g7frA)r/r )rBclbits r%rD+DAGDependency.add_clbits..rFrGznot a Clbit instance.zduplicate clbits N)rHr rIrrJrK)r$rduplicate_clbitss r% add_clbitsDAGDependency.add_clbitsrOr(c[U[5(d [S5eURUR;a[SUR35eXRUR'[ UR 5n[UR5H*nXU;dM UR RX5 M, g)z!Add qubits in a quantum register.znot a QuantumRegister instance.duplicate register N) r/rr rrrIrranger9append)r$qregexisting_qubitsjs r%add_qregDAGDependency.add_qregs$00$%FG G 99 "$':499+%FG G $ 499dkk*tyy!Awo- ""47+"r(c[U[5(d [S5eURUR;a[SUR35eXRUR'[ UR 5n[UR5H*nXU;dM UR RX5 M, g)z#Add clbits in a classical register.z!not a ClassicalRegister instance.rXN) r/r r rrrIrrYr9rZ)r$cregexisting_clbitsr]s r%add_cregDAGDependency.add_cregs$ 122$%HI I 99 "$':499+%FG G $ 499dkk*tyy!Awo- ""47+"r(cHURRU5nX!lU$)zr Args: node (DAGDepNode): considered node. Returns: node_id(int): corresponding label to the added node. )radd_nodenode_id)r$nodergs r%_add_multi_graph_node#DAGDependency._add_multi_graph_nodes$##,,T2 r(cH[URR55$)z< Returns: generator(dict): iterator over all the nodes. )iterrnodesr#s r% get_nodesDAGDependency.get_nodess D%%++-..r(c8URRU5$)zd Args: node_id (int): label of considered node. Returns: node: corresponding to the label. )r get_node_datar$rgs r%get_nodeDAGDependency.get_nodes  ..w77r(c<URRXU5 g)z Function to add an edge from given data (dict) between two nodes. Args: src_id (int): label of the first node. dest_id (int): label of the second node. data (dict): data contained on the edge. N)radd_edge)r$src_iddest_iddatas r%_add_multi_graph_edge#DAGDependency._add_multi_graph_edges ""6D9r(c8URRX5$)z Edge enumeration between two nodes through method get_all_edge_data. Args: src_id (int): label of the first node. dest_id (int): label of the second node. Returns: List: corresponding to all edges between the two nodes. )rget_all_edge_data)r$rwrxs r% get_edgesDAGDependency.get_edgess  226CCr(c URR5VVVVs/sH7nURRUR5H up#nX#U4PM M9 snnnn$s snnnnf)zK Enumeration of all edges. Returns: List: corresponding to the label. )rrm out_edgesrg)r$src_nodesrcdestrys r% get_all_edgesDAGDependency.get_all_edgessf!--335 5%)%6%6%@%@AQAQ%R!D %R 5   s>A$ c8URRU5$)z Enumeration of all incoming edges for a given node. Args: node_id (int): label of considered node. Returns: List: corresponding incoming edges data. )rin_edgesrrs r% get_in_edgesDAGDependency.get_in_edgess  ))'22r(c8URRU5$)z Enumeration of all outgoing edges for a given node. Args: node_id (int): label of considered node. Returns: List: corresponding outgoing edges data. )rrrrs r% get_out_edgesDAGDependency.get_out_edges s  **733r(ch[URRUS5R55$)z Direct successors id of a given node as sorted list. Args: node_id (int): label of considered node. Returns: List: direct successors id as a sorted list Fsortedr adj_directionkeysrrs r%direct_successorsDAGDependency.direct_successors,s+d''55guEJJLMMr(ch[URRUS5R55$)z Direct predecessors id of a given node as sorted list. Args: node_id (int): label of considered node. Returns: List: direct predecessors id as a sorted list Trrrs r%direct_predecessors!DAGDependency.direct_predecessors8s+d''55gtDIIKLLr(cLURRU5R$)z Successors id of a given node as sorted list. Args: node_id (int): label of considered node. Returns: List: all successors id as a sorted list )rrq successorsrrs r%rDAGDependency.successorsDs!  ..w7BBBr(cLURRU5R$)z Predecessors id of a given node as sorted list. Args: node_id (int): label of considered node. Returns: List: all predecessors id as a sorted list )rrq predecessorsrrs r%rDAGDependency.predecessorsPs!  ..w7DDDr(cXSn[[R"URUS95$)z` Yield nodes in topological order. Returns: generator(DAGNode): node in topological order. cUR$rA)sort_key)xs r%_key-DAGDependency.topological_nodes.._keyds :: r(key)rlr lexicographical_topological_sortr)r$rs r%topological_nodesDAGDependency.topological_nodes\s' B778I8ItTUUr(c S/n[USS5(dURU;a/nUH-nURURR U55 M/ [USS5(aJ[ UR 5RnUVs/sHoRR U5PM n nO/n O/n/n [SUURUU//UU S9 n U $s snf)a5Creates a DAGDepNode to the graph and update the edges. Args: operation (qiskit.circuit.Operation): operation qargs (list[~qiskit.circuit.Qubit]): list of qubits on which the operation acts cargs (list[Clbit]): list of classical wires to attach to Returns: DAGDepNode: the newly added node. measure _directiveF _conditionNop) typerrqargscargsrrqindicescindices) getattrrrZrindexrrrr ) r$ operationrr directives qindices_listelem cond_bitsrR cindices_listnew_nodes r%_create_op_nodeDAGDependency._create_op_nodeis [ y,669>>Q[;[M$$T[[%6%6t%<=y,55 0 0D0DELL GP Qye!2!25!9y Q " MM""  %!Rs$CcjURXU5nURU5 UR5 g)aAdd a DAGDepNode to the graph and update the edges. Args: operation (qiskit.circuit.Operation): operation as a quantum gate qargs (list[~qiskit.circuit.Qubit]): list of qubits on which the operation acts cargs (list[Clbit]): list of classical wires to attach to N)rri _update_edges)r$rrrrs r% add_op_nodeDAGDependency.add_op_nodes0'' %@ ""8, r(c j[UR5S- nURU5nS/U-n[US- SS5HnX4(aURU5nURR UR URURUR URUR5(dHURRXASS05 URRU5nUHnSX7'M MMURRU5nUHnSX7'M M g)a; Updates DagDependency by adding edges to the newly added node (max_node) from the previously added nodes. For each previously added node (prev_node), an edge from prev_node to max_node is added if max_node is "reachable" from prev_node (this means that the two nodes can be made adjacent by commuting them with other nodes), but the two nodes themselves do not commute. Currently. this function is only used when creating a new DAGDependency from another representation of a circuit, and hence there are no removed nodes (this is why iterating over all nodes is fine). TcommuteFN) r8rrsrYr"rrrrrvpredecessor_indices)r$ max_node_idmax_node reachable prev_node_id prev_nodepredecessor_idspredecessor_ids r%rDAGDependency._update_edgess$++,q0 ==-F[( "+/2r:L& MM,7 ((00LLOOOOKKNNNN %%..|9V[J\]&*&7&7&K&KL&YO*949 1+:&#'"3"3"G"G "U&5N05I-'61;r(c[[UR5S- SS5HKn[[R "URU55URR U5lMM g)z Create the list of successors. Update DAGDependency 'successors' attribute. It has to be used when the DAGDependency() object is complete (i.e. converters). rrN)rYr8rlistr descendantsrqrrrs r%_add_successorsDAGDependency._add_successorss[ S!2!23a7R@GBFt00':CD   + +G 4 ?Ar(c[S[UR55HKn[[R "URU55URR U5lMM g)z Create the list of predecessors for each node. Update DAGDependency 'predecessors' attribute. It has to be used when the DAGDependency() object is complete (i.e. converters). rN)rYr8rrr ancestorsrqrrrs r%_add_predecessorsDAGDependency._add_predecessorssS QD$5$5 67GDH T..8ED   + +G 4 A8r(c[5nURUlURR5UlURR5UlUR 5H,nUR RUR55 M. UR5H)nUR RUSUSUS5 M+ U$)zh Function to copy a DAGDependency object. Returns: DAGDependency: a copy of a DAGDependency object. rrr-) rrrcopyrrnrrfrrv)r$dagrhedgess r%rDAGDependency.copyso99JJOO% JJOO% NN$D    % %diik 2%'')E    % %eAha%( C* r(NcSSKJn U"XX#S9$)a Draws the DAGDependency graph. This function needs `pydot `, which in turn needs Graphviz ` to be installed. Args: 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: Ipython.display.Image: if in Jupyter notebook and not saving to file, otherwise None. r) dag_drawer)rscalefilenamestyle)&qiskit.visualization.dag_visualizationr)r$rrrrs r%drawDAGDependency.draws Fd(PPr(c f^[5n[5nUVs/sHowRPM nnU(d [S5eUHsn U[U R5-nU[U R5-n[ U R SS5n U cMOUR[U 5R5 Mu URU[UU4SjS9[UU4SjS9S9n URRXUS9U lgs snf![Ran [S 5U eSn A ff=f) aReplace a block of nodes with a single node. This is used to consolidate a block of DAGDepNodes into a single operation. A typical example is a block of CX and SWAP gates consolidated into a LinearFunction. This function is an adaptation of a similar function from DAGCircuit. It is important that such consolidation preserves commutativity assumptions present in DAGDependency. As an example, suppose that every node in a block [A, B, C, D] commutes with another node E. Let F be the consolidated node, F = A o B o C o D. Then F also commutes with E, and thus the result of replacing [A, B, C, D] by F results in a valid DAGDependency. That is, any deduction about commutativity in consolidated DAGDependency is correct. On the other hand, suppose that at least one of the nodes, say B, does not commute with E. Then the consolidated DAGDependency would imply that F does not commute with E. Even though F and E may actually commute, it is still safe to assume that they do not. That is, the current implementation of consolidation may lead to suboptimal but not to incorrect results. Args: node_block (List[DAGDepNode]): A list of dag nodes that represents the node block to be replaced op (qiskit.circuit.Operation): The operation to replace the block with wire_pos_map (Dict[~qiskit.circuit.Qubit, int]): The dictionary mapping the qarg to the position. This is necessary to reconstruct the qarg order over multiple gates in the combined single op node. cycle_check (bool): When set to True this method will check that replacing the provided ``node_block`` with a single node would introduce a cycle (which would invalidate the ``DAGDependency``) and will raise a ``DAGDependencyError`` if a cycle would be introduced. This checking comes with a run time penalty. If you can guarantee that your input ``node_block`` is a contiguous block and won't introduce a cycle when it's contracted to a single node, this can be set to ``False`` to improve the runtime performance of this method. Raises: DAGDependencyError: if ``cycle_check`` is set to ``True`` and replacing the specified block introduces a cycle or if ``node_block`` is empty. z!Can't replace an empty node_blockrNc>TU$rAr wire_pos_maps r%5DAGDependency.replace_block_with_op..I LOr(rc>TU$rArrs r%rrJrr()rr) check_cyclez:Replacing the specified node block would introduce a cycle)rIrgr rrrrupdaterrrrrcontract_nodesr DAGWouldCycle) r$ node_blockrr cycle_check block_qargs block_cargsr block_idsndcondrexs ` r%replace_block_with_op#DAGDependency.replace_block_with_op s$Te e (23 1YY 3$%HI IB 3rxx= (K 3rxx= (K255,5D""#6t#<#C#CD '' *CD*CD(   #00?? @ H +40 $L  sD&D D0 D++D0) rrrr"rrrrrrr )r3zfloat | ParameterExpression)rhr returnint)rzIterator[DAGDepNode])rgrrr )rwrrxr)rgrrz list[int])gffffff?Ncolor)T)&__name__ __module__ __qualname____firstlineno____doc__r&propertyr*setterr5r9r=rMrUr^rcrirnrsrzr~rrrrrrrrrrrrrrrr__static_attributes__rr(r%rr8s"H :"";;$!&* # # , , /8 : D   3 4 N M C E V*X /6b $Q(Gr(rc'n# [5n[R"U6HnX!:wdM UnUv M g7f)zMerge K list without duplicate using python heapq ordered merging Args: *iterables: A list of k sorted lists Yields: Iterator: List from the merging of the k ones (without duplicates N)objectheapqmerge) iterableslastvals r%merge_no_duplicatesrWs0 8D{{I& ;DI's$5 5)r __future__rr1r typing collectionsrcollections.abcr rustworkxr"qiskit.circuit.commutation_libraryrr!qiskit.circuit.controlflowrqiskit.circuitrr r r qiskit.dagcircuit.exceptionsr qiskit.dagcircuit.dagdepnoder TYPE_CHECKINGr.rrrrr(r%rsO" #$O:13;3 F.\\~ r(