z iVSrSSKrSSKrSSKJrJr SSKJrJrJ r J r SSK r SSK JrJrJrJrJr SSKJr SSK Jr SSKJr SS KJr SS KJr \"S S 5r"S S5rg)zH_DAGDependencyV2 class for representing non-commutativity in a circuit. N) OrderedDict namedtuple)DictList GeneratorAny)QuantumRegisterClassicalRegisterQubitClbitParameterExpression)condition_resources)Bit) DAGOpNode)DAGDependencyError)CommutationChecker BitLocations)index registerscN\rSrSrSrSr\S5r\RS5rSr Sr Sr S r S r S rS rS rSrS\S\4SjrS(SjrSrSrSrSrSrSrSrS)S\\\\44Sjjr S)S\\\\44Sjjr!Sr"Sr#Sr$S r%S!r&S"r'S#r(S$r)S*S%jr*S+S&jr+S'r,g),_DAGDependencyV2(uObject to represent a quantum circuit as a Directed Acyclic Graph (DAG) via operation dependencies (i.e. lack of commutation). .. warning:: This is not part of the public API. 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. **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 `_ c,SUl0Ul0Ul[R"5Ul[ 5Ul[ 5Ul/Ul /Ul 0Ul 0Ul SUl 0UlSUlSUl[#5Ulg)z# Create an empty _DAGDependencyV2. Nrdt)namemetadata _key_cacherxPyDAG _multi_graphrqregscregsqubitsclbits_qubit_indices_clbit_indices _global_phase _op_namesdurationunitr comm_checkerselfs \/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/dagcircuit/dagdependency_v2.py__init___DAGDependencyV2.__init__Ns   HHJ!]  ] $& #% :<9;  .0cUR$)z'Return the global phase of the circuit.)r'r,s r. global_phase_DAGDependencyV2.global_phasexs!!!r1c[U[5(aXlg[U5nU(dSUlgUS[R --Ulg)zSSet the global phase of the circuit. Args: angle (float, ParameterExpression) rN) isinstancer r'floatmathpi)r-angles r.r3r4}sC e0 1 1!& %LE%&"%*a$''k%:"r1c,[UR5$)z*Returns the number of gates in the circuit)lenr r,s r.size_DAGDependencyV2.sizes4$$%%r1cV[R"UR5nUS:aU$S$)z>Return the circuit depth. Returns: int: the circuit depth r)rdag_longest_path_lengthr )r-depths r.rB_DAGDependencyV2.depths+ **4+<+<= u))r1cX[UR5[UR5-$)z?Return the total number of qubits + clbits used by the circuit.)r=r#r$r,s r.width_DAGDependencyV2.widths4;;#dkk"222r1c,[UR5$)z6Return the total number of qubits used by the circuit.)r=r#r,s r. num_qubits_DAGDependencyV2.num_qubits4;;r1c,[UR5$)z>Return the total number of classical bits used by the circuit.)r=r$r,s r. num_clbits_DAGDependencyV2.num_clbitsrJr1c`[SU55(a [S5e[UR5R U5nU(a[SU35eUHMnURR U5 [ [UR5S- /5URU'MO g)zAdd individual qubit wires.c3L# UHn[U[5(+v M g7fN)r7r ).0qubits r. ._DAGDependencyV2.add_qubits..@:eU+++"$znot a Qubit instance.zduplicate qubits N) anyrsetr# intersectionappendrr=r%)r-r#duplicate_qubitsrRs r. add_qubits_DAGDependencyV2.add_qubits @@ @ @$%<= =t{{+88@ $'89I8J%KL LE KK  u %)5c$++6F6JB)OD   &r1c`[SU55(a [S5e[UR5R U5nU(a[SU35eUHMnURR U5 [ [UR5S- /5URU'MO g)zAdd individual clbit wires.c3L# UHn[U[5(+v M g7frP)r7r )rQclbits r.rS._DAGDependencyV2.add_clbits..rUrVznot a Clbit instance.zduplicate clbits rWN) rXrrYr$rZr[rr=r&)r-r$duplicate_clbitsrbs r. add_clbits_DAGDependencyV2.add_clbitsr_r1cd[U[5(d [S5eURUR;a[SUR35eXRUR'[ UR 5n[UR5HnXUR;a+URXRRX45 XU;dMJUR RX5 [[UR 5S- X4/S9URX'M g)z!Add qubits in a quantum register.znot a QuantumRegister instance.duplicate register rWrN)r7r rrr!rYr#ranger>r%rr[rr=)r-qregexisting_qubitsjs r.add_qreg_DAGDependencyV2.add_qregs$00$%FG G 99 "$':499+%FG G $ 499dkk*tyy!Aw$---##DG,66==tiHwo- ""47+/; $q(dYK0##DG, "r1cd[U[5(d [S5eURUR;a[SUR35eXRUR'[ UR 5n[UR5HnXUR;a+URXRRX45 XU;dMJUR RX5 [[UR 5S- X4/S9URX'M g)z#Add clbits in a classical register.z!not a ClassicalRegister instance.rhrWriN)r7r rrr"rYr$rjr>r&rr[rr=)r-cregexisting_clbitsrms r.add_creg_DAGDependencyV2.add_cregs$ 122$%HI I 99 "$':499+%FG G $ 499dkk*tyy!Aw$---##DG,66==tiHwo- ""47+/; $q(dYK0##DG, "r1bitreturnc[U[5(aURU$[U[5(aURU$[ S[ U535e![an[ SUS35UeSnAff=f)a Finds locations in the _DAGDependencyV2, by mapping the Qubit and Clbit to positional index BitLocations is defined as: BitLocations = namedtuple("BitLocations", ("index", "registers")) Args: bit (Bit): The bit to locate. Returns: namedtuple(int, List[Tuple(Register, int)]): A 2-tuple. The first element (``index``) contains the index at which the ``Bit`` can be found (in either :obj:`~_DAGDependencyV2.qubits`, :obj:`~_DAGDependencyV2.clbits`, depending on its type). The second element (``registers``) is a list of ``(register, index)`` pairs with an entry for each :obj:`~Register` in the circuit which contains the :obj:`~Bit` (and the index in the :obj:`~Register` at which it can be found). Raises: DAGDependencyError: If the supplied :obj:`~Bit` was of an unknown type. DAGDependencyError: If the supplied :obj:`~Bit` could not be found on the circuit. z&Could not locate bit of unknown type: zCould not locate provided bit: z). Has it been added to the DAGDependency?N)r7r r%r r&rtypeKeyError)r-ruerrs r.find_bit_DAGDependencyV2.find_bits( #u%%**3//C''**3//(+QRVWZR[Q\)]^^ $1#6_`  s"#A!#A! A!! B+A;;Bc[UUUS9nURRU5UlUR 5 UR UR 5 g)aAdd a DAGOpNode 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 )opqargscargsN)rr add_node_node_id _update_edges _increment_opr~)r- operationrrnew_nodes r.apply_operation_back%_DAGDependencyV2.apply_operation_backsP  !--66x@  8;;'r1c "[UR5S- nURU5nS/U-n[US- SS5GHAnX4(aURU5nURR UR URURUR URUR5(dpURRXASS05 [URURU55Vs/sHofRPM sn5nUHnSX8'M MM[URURU55Vs/sHofRPM sn5nUHnSX8'M GMD gs snfs snf)a@ Updates DagDependencyV2 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 _DAGDependencyV2 from another representation of a circuit, and hence there are no removed nodes (this is why iterating over all nodes is fine). rWTcommuteFN) r=r _get_noderjr+rr~rradd_edgesorted predecessorsr) r- max_node_idmax_node reachable prev_node_id prev_nodenodepredecessor_idspredecessor_ids r.r_DAGDependencyV2._update_edgessf$++,q0 >>+.F[( "+/2r:L& NN<8 ((00LLOOOOKKNNNN %%..|9V[J\]&,373D3DT^^T`Ea3bc3b43bc'O+:49 1+:!*#)/3/@/@P\A]/^_/^t]]/^_#'6N05I-'69;$d`s F F c8URRU5$)zd Args: node_id (int): label of considered node. Returns: node: corresponding to the label. )r get_node_data)r-node_ids r.r_DAGDependencyV2._get_nodeHs  ..w77r1c/nURR5H0nURRU;dMUR U5 M2 U$)z.Get the set of "op" nodes with the given name.)r nodesr~rr[)r-names named_nodesrs r.r_DAGDependencyV2.named_nodesRsF %%++-Dww||u$""4(.r1cURUR;a"URUR==S- ss'gSURUR'gNrW)rr(r-r~s r.r_DAGDependencyV2._increment_opZs< 77dnn $ NN277 #q ( #&'DNN277 #r1cURURS:XaURUR gURUR==S-ss'gr)r(rrs r. _decrement_op_DAGDependencyV2._decrement_op`s? >>"'' "a 'rww' NN277 #q ( #r1cUR$)z)Count the occurrences of operation names.)r(r,s r. count_ops_DAGDependencyV2.count_opsfs ~~r1cH[URR55$)z< Returns: generator(dict): iterator over all the nodes. )iterr rr,s r.op_nodes_DAGDependencyV2.op_nodesjs D%%++-..r1Ncj^U4SjnUcUn[[R"TRUS95$)aU Yield nodes in topological order. Args: key (Callable): A callable which will take a DAGNode object and return a string sort key. If not specified the :attr:`~qiskit.dagcircuit.DAGNode.sort_key` attribute will be used as the sort key for each node. Returns: generator(DAGOpNode): node in topological order c>SRU4Sj[R"URUR555$)N,c3^># UH"nTRU5RSv M$ g7f)04dN)r{r)rQqr-s r.rSC_DAGDependencyV2.topological_nodes.._key..s,9ZA4==#))#./9Zs*-)join itertoolschainrr)xr-s r._key0_DAGDependencyV2.topological_nodes.._keys7889BRSRYRY9Z r1key)rr lexicographical_topological_sortr )r-rrs` r.topological_nodes"_DAGDependencyV2.topological_nodesqs2  ;CB778I8IsSTTr1c$URU5$)a  Yield nodes in topological order. This is a wrapper for topological_nodes since all nodes are op nodes. It's here so that calls to dag.topological_op_nodes can use either DAGCircuit or _DAGDependencyV2. Returns: generator(DAGOpNode): nodes in topological order. )r)r-rs r.topological_op_nodes%_DAGDependencyV2.topological_op_nodess%%c**r1c^[URRUR55$)z;Returns iterator of the successors of a node as DAGOpNodes.)rr successorsrr-rs r.r_DAGDependencyV2.successorss"D%%00?@@r1c^[URRUR55$)z=Returns iterator of the predecessors of a node as DAGOpNodes.)rr rrrs r.r_DAGDependencyV2.predecessorss"D%%224==ABBr1cbURRURUR5$)z5Checks if a second node is in the successors of node.r has_edger)r-r node_succs r. is_successor_DAGDependencyV2.is_successors%  ))$--9K9KLLr1cbURRURUR5$)z7Checks if a second node is in the predecessors of node.r)r-r node_preds r.is_predecessor_DAGDependencyV2.is_predecessors%  )))*<*`, 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)dagscalefilenamestyle)&qiskit.visualization.dag_visualizationr)r-rrrrs r.draw_DAGDependencyV2.draws Fd(PPr1c ^[5n[5nUVs/sHowRPM nnU(d [S5eUHsn U[U R5-nU[U R5-n[ U R SS5n U cMOUR[U 5R5 Mu [U[UU4SjS9[UU4SjS9US9n URRXUS9U lUR!U5 UHn UR#U R 5 M U $s 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 DAGOpNodes 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 _DAGDependencyV2. 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 _DAGDependencyV2. That is, any deduction about commutativity in consolidated _DAGDependencyV2 is correct. On the other hand, suppose that at least one of the nodes, say B, does not commute with E. Then the consolidated _DAGDependencyV2 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[DAGOpNode]): 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 ``_DAGDependencyV2``) 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_block conditionNc>TU$rPr wire_pos_maps r.8_DAGDependencyV2.replace_block_with_op..# LOr1rc>TU$rPrrs r.rr$rr1)rrr) check_cyclez:Replacing the specified node block would introduce a cycle)rYrrrrgetattrr~updaterr$rrr contract_nodesr DAGWouldCyclerr) r- node_blockr~r cycle_check block_qargs block_cargsr block_idsndcondrexs ` r.replace_block_with_op&_DAGDependencyV2.replace_block_with_opsPTe e )34AZZ 4$%HI IB 3rxx= (K 3rxx= (K255+t4D""#6t#<#C#CD  *CD*CD    $ 1 1 @ @!A!H  2B   ruu %G52 $L  sD7!D<<E! EE!)r&r'rr r(r%r$r+r"r)rrr!r#r*)rrrP)gffffff?Ncolor)T)-__name__ __module__ __qualname____firstlineno____doc__r/propertyr3setterr>rBrErHrLr]rernrsrrr{rrrrrrrrrrrrrrrrrrrrrrr__static_attributes__rr1r.rr(s#J(1T"";; &*3   P P""CL@("36j8( ) /UYy#s7J-KU0 + )S#:M0N +ACMM^`I@Q(Or1r)r rr9 collectionsrrtypingrrrr rustworkxrqiskit.circuitr r r r r qiskit.circuit.controlflowrrqiskit.dagcircuit.dagnoderqiskit.dagcircuit.exceptionsr"qiskit.circuit.commutation_checkerrrrrr1r.rsT /--;/;A.*@A NNr1