g`@dZddlmZddlmZmZddlmZddlm Z m Z m Z m Z ddl mZddlmZmZmZdd lmZGd d ZGd d ZddZGddZdS)zVarious ways to divide a DAG into blocks of nodes, to split blocks of nodes into smaller sub-blocks, and to consolidate blocks.) annotations)IterableCallable) DAGDepNode)QuantumCircuitCircuitInstructionClassicalRegisterBit)condition_resources) DAGOpNode DAGCircuit DAGDependency)DAGCircuitErrorcReZdZdZddZdZddZd Zd Zd Z ddZ ddZ dS)BlockCollectoraThis class implements various strategies of dividing a DAG (direct acyclic graph) into blocks of nodes that satisfy certain criteria. It works both with the :class:`~qiskit.dagcircuit.DAGCircuit` and :class:`~qiskit.dagcircuit.DAGDependency` representations of a DAG, where DagDependency takes into account commutativity between nodes. Collecting nodes from DAGDependency generally leads to more optimal results, but is slower, as it requires to construct a DAGDependency beforehand. Thus, DAGCircuit should be used with lower transpiler settings, and DAGDependency should be used with higher transpiler settings. In general, there are multiple ways to collect maximal blocks. The approaches used here are of the form 'starting from the input nodes of a DAG, greedily collect the largest block of nodes that match certain criteria'. For additional details, see https://github.com/Qiskit/qiskit-terra/issues/5775. dagDAGCircuit | DAGDependencyc||_d|_d|_d|_t |t r d|_dSt |tr d|_dStd)z Args: dag (Union[DAGCircuit, DAGDependency]): The input DAG. Raises: DAGCircuitError: the input object is not a DAG. NFTz not a DAG.) r_pending_nodes _in_degree_collect_from_back isinstanceris_dag_dependencyrrselfrs V/granary/edev/quantum/lib/python3.11/site-packages/qiskit/dagcircuit/collect_blocks.py__init__zBlockCollector.__init__.srCGDH"' c: & & 0%*D " " " ] + + 0%)D " " "",// /cg|_i|_|D]N}t||}||j|<|dkr|j|OdS)a+For an efficient implementation, for every node we keep the number of its unprocessed immediate predecessors (called ``_in_degree``). This ``_in_degree`` is set up at the start and updated throughout the algorithm. A node is leaf (or input) node iff its ``_in_degree`` is 0. When a node is (marked as) collected, the ``_in_degree`` of each of its immediate successor is updated by subtracting 1. Additionally, ``_pending_nodes`` explicitly keeps the list of nodes whose ``_in_degree`` is 0. rN)rr _op_nodeslen _direct_predsappend)rnodedegs r_setup_in_degreesz BlockCollector._setup_in_degreesEs~!NN$$ 1 1Dd((..//C$'DOD !axx#**4000  1 1rreturn Iterable[DAGOpNode | DAGDepNode]ct|js|jS|jS)zReturns DAG nodes.)rrop_nodes get_nodesrs rr!zBlockCollector._op_nodesWs5% (8$$&& &8%%'' 'rcjjsOjr$dj|DSdj|DSjr+fdj|jDSfdj|jDS)zReturns direct predecessors of a node. This function takes into account the direction of collecting blocks, that is node's predecessors when collecting backwards are the direct successors of a node in the DAG. c<g|]}t|t|Srr .0preds r z0BlockCollector._direct_preds..e)bbbjQUW`FaFabbbbrc<g|]}t|t|Sr0r1r2s rr5z0BlockCollector._direct_preds..g)ddd SWYbHcHcddddrcDg|]}j|Sr0rget_noder3pred_idrs rr5z0BlockCollector._direct_preds..j9H%%g..rcDg|]}j|Sr0r:r<s rr5z0BlockCollector._direct_preds..or>r)rrr successors predecessorsdirect_successorsnode_iddirect_predecessorsrr%s` rr#zBlockCollector._direct_preds^s % & ebb)<))>t)D)Ddddd& #'8#=#=dl#K#K #'8#?#? #M#MrcjjsOjr$dj|DSdj|DSjr+fdj|jDSfdj|jDS)zReturns direct successors of a node. This function takes into account the direction of collecting blocks, that is node's successors when collecting backwards are the direct predecessors of a node in the DAG. c<g|]}t|t|Sr0r1r3succs rr5z0BlockCollector._direct_succs..{r8rc<g|]}t|t|Sr0r1rHs rr5z0BlockCollector._direct_succs..}r6rcDg|]}j|Sr0r:r3succ_idrs rr5z0BlockCollector._direct_succs..r>rcDg|]}j|Sr0r:rLs rr5z0BlockCollector._direct_succs..r>r)rrrrAr@rDrCrBrEs` r _direct_succszBlockCollector._direct_succsts % & cdd)>)>t)D)Dddddbb)<)v|j||}||S)aIteratively collects the largest block of input nodes (that is, nodes with ``_in_degree`` equal to 0) that match a given filtering function. Examples of this include collecting blocks of swap gates, blocks of linear gates (CXs and SWAPs), blocks of Clifford gates, blocks of single-qubit gates, blocks of two-qubit gates, etc. Here 'iteratively' means that once a node is collected, the ``_in_degree`` of each of its immediate successor is decreased by 1, allowing more nodes to become input and to be eligible for collecting into the current block. Returns the block of collected nodes. r r)rr$rOr)rrR current_blockunprocessed_pending_nodesnew_pending_nodesr%sucs rcollect_matching_blockz%BlockCollector.collect_matching_blocks $($7!  ( : " 1 5 59T?? 5!((... $11$77::,,,1,,,?3/144-44S999: '..t4444(9 %( :rTFcLfd}||_|g}|rU|||}|r|||U|r+g} |D]$} | t | %| }|r=g} |D]6} | t| 7| }|jrd|dddD}fd|D}|S)atCollects all blocks that match a given filtering function filter_fn. This iteratively finds the largest block that does not match filter_fn, then the largest block that matches filter_fn, and so on, until no more uncollected nodes remain. Intuitively, finding larger blocks of non-matching nodes helps to find larger blocks of matching nodes later on. After the blocks are collected, they can be optionally refined. The option ``split_blocks`` allows to split collected blocks into sub-blocks over disjoint qubit subsets. The option ``split_layers`` allows to split collected blocks into layers of non-overlapping instructions. The option ``min_block_size`` specifies the minimum number of gates in the block for the block to be collected. By default, blocks are collected in the direction from the inputs towards the outputs of the circuit. The option ``collect_from_back`` allows to change this direction, that is collect blocks from the outputs towards the inputs of the circuit. Returns the list of matching blocks only. c| S)z"Returns the opposite of filter_fn.r0)r%rRs r not_filter_fnzABlockCollector.collect_all_matching_blocks..not_filter_fns y& &rc$g|] }|dddS)Nr0)r3blocks rr5z>BlockCollector.collect_all_matching_blocks..s"NNNuuTTrT{NNNrNr_c:g|]}t|k|Sr0)r")r3r`min_block_sizes rr5z>BlockCollector.collect_all_matching_blocks..s)^^^UU~A]A]5A]A]A]r) rr'rQrYr$extendsplit_block_into_layers BlockSplitterrun) rrR split_blocksrb split_layerscollect_from_backr]matching_blocksmatching_block tmp_blocksr`s ` ` rcollect_all_matching_blocksz*BlockCollector.collect_all_matching_blockss6 ' ' ' ' ' #4    ?A**,, 7  ' ' 6 6 6!88CCN 7&&~666 **,, 7  )J( B B!!"9%"@"@AAAA(O  )J( > >!!-//"5"5e"<"<====(O  " ONN"8MNNNO_^^^o^^^rN)rr)r(r))rRrr(rS)TrZFF) __name__ __module__ __qualname____doc__rr'r!r#rOrQrYrmr0rrrrs"0000.111$((((,,,,,!!!!L CCCCCCrrc*eZdZdZdZdZdZdZdS)rezSplits a block of nodes into sub-blocks over disjoint qubits. The implementation is based on the Disjoint Set Union data structure.c"i|_i|_dSN)leadergroupr-s rrzBlockSplitter.__init__s  rc||jvr||j|<g|j|<|S|j||kr|S||j||j|<|j|S)z Find in DSU.)rurv find_leader)rindexs rrxzBlockSplitter.find_leadersq  # #!&DK  "DJu L ;u  & &L!--dk%.@AA E{5!!rc||}||}||krdSt|j|t|j|kr||}}||j|<|j||j||j|dS)z Union in DSU.N)rxr"rvrurcclear)rindex1index2leader1leader2s r union_leaderszBlockSplitter.union_leaders s""6**""6** g   F tz'" # #c$*W*=&>&> > >&WG& G 7""4:g#6777 7!!#####rcn|D]j}|j}|s |d}|ddD]}||||j|||kg}|jD]+\}}||kr ||j|,|S)z;Splits block of nodes into sub-blocks over disjoint qubits.rr N)qargsrrvrxr$ruitems)rr`r%indicesfirstryblocksitems rrfzBlockSplitter.runs = =DjG AJE  1 1""5%0000 Jt''.. / 6 6t < < < <;,,.. 1 1KE4}} dj/000 rN)rnrorprqrrxrrfr0rrreres\MM " " " $ $ $rrer`rScig}|D]}t|j}||jt |jdd}|'|t |jtfd|D}t||kr(| gt||k(|D] }|dz|< || ||S)zSplits a block of nodes into sub-blocks of non-overlapping instructions (or, in other words, into depth-1 sub-blocks). _conditionNc3DK|]}|dVdS)rN)get)r3bit bit_depthss r z*split_block_into_layers..9s1CC3 sA..CCCCCCrr ) setrupdatecargsgetattropr clbitsmaxr"r$)r`layersr%cur_bitscond cur_depthrrs @rrdrd*s"$J13F''tz?? ###tw d33   OO/55< = = =CCCC(CCCCC &kkY&& MM"   &kkY&& , ,C'!mJsOOy  &&&& MrceZdZdZdZdZdS)BlockCollapserzThis class implements various strategies of consolidating blocks of nodes in a DAG (direct acyclic graph). It works both with the :class:`~qiskit.dagcircuit.DAGCircuit` and :class:`~qiskit.dagcircuit.DAGDependency` DAG representations. c||_dS)zZ Args: dag (Union[DAGCircuit, DAGDependency]): The input DAG. N)rrs rrzBlockCollapser.__init__Ks rc dt|jjDdt|jjD|D]}t }t }t }|D]}||j||jt|j dd}|]|t|jt|dtr| |dt|fd} t|fd} t| | } |D]} | | d t| D} | d t| D|D]W}| t%|j |j|j}t|j dd}| |j|X|| }|j||| d |jS) zFor each block, constructs a quantum circuit containing instructions in the block, then uses collapse_fn to collapse this circuit into a single operation. ci|]\}}|| Sr0r0r3idxwires r z8BlockCollapser.collapse_to_operation..WsRRR)#tD#RRRrci|]\}}|| Sr0r0rs rrz8BlockCollapser.collapse_to_operation..Xs W W WysDs W W WrrNrc|Srtr0xglobal_index_maps rz6BlockCollapser.collapse_to_operation..n =Ma=Pr)keyc|Srtr0rs rrz6BlockCollapser.collapse_to_operation..orrci|]\}}|| Sr0r0r3ixqbs rrz8BlockCollapser.collapse_to_operation..xsJJJvr2BJJJrci|]\}}|| Sr0r0rs rrz8BlockCollapser.collapse_to_operation..ys O O OFBR O O OrF) cycle_check) enumeraterqubitsrrrrrrrr rr addsortedr add_registerr$rc_ifreplace_block_with_op)rr collapse_fnr` cur_qubits cur_clbits cur_clregsr%r sorted_qubits sorted_clbitsqcreg wire_pos_map instructionsrrs @rcollapse_to_operationz$BlockCollapser.collapse_to_operationSsySRy7Q7QRRR W WIdhors[77""""""........((((((UUUUUUUUUUUU::::::2222222222''''''XXXXXXXXv00000000f4CCCCCCCCCCr