qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/transpiler/passes/optimization/collect_multiqubit_blocks.py

@@ -0,0 +1,227 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Collect sequences of uninterrupted gates acting on a number of qubits."""
+
+from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.circuit import Gate
+from qiskit.dagcircuit import DAGOpNode, DAGInNode
+
+
+class CollectMultiQBlocks(AnalysisPass):
+    """Collect sequences of uninterrupted gates acting on groups of qubits.
+    ``max_block_size`` specifies the maximum number of qubits that can be acted upon
+    by any single group of gates
+
+    Traverse the DAG and find blocks of gates that act consecutively on
+    groups of qubits. Write the blocks to ``property_set`` as a list of blocks
+    of the form::
+
+        [[g0, g1, g2], [g4, g5]]
+
+    Blocks are reported in a valid topological order. Further, the gates
+    within each block are also reported in topological order
+    Some gates may not be present in any block (e.g. if the number
+    of operands is greater than ``max_block_size``)
+
+    A Disjoint Set Union data structure (DSU) is used to maintain blocks as
+    gates are processed. This data structure points each qubit to a set at all
+    times and the sets correspond to current blocks. These change over time
+    and the data structure allows these changes to be done quickly.
+    """
+
+    def __init__(self, max_block_size=2):
+        super().__init__()
+        self.parent = {}  # parent array for the union
+
+        # the dicts belowed are keyed by a qubit signifying the root of a
+        #    set in the DSU data structure
+        self.bit_groups = {}  # current groups of bits stored at top of trees
+        self.gate_groups = {}  # current gate lists for the groups
+
+        self.max_block_size = max_block_size  # maximum block size
+
+    def find_set(self, index):
+        """DSU function for finding root of set of items
+        If my parent is myself, I am the root. Otherwise we recursively
+        find the root for my parent. After that, we assign my parent to be
+        my root, saving recursion in the future.
+        """
+
+        if index not in self.parent:
+            self.parent[index] = index
+            self.bit_groups[index] = [index]
+            self.gate_groups[index] = []
+        if self.parent[index] == index:
+            return index
+        self.parent[index] = self.find_set(self.parent[index])
+        return self.parent[index]
+
+    def union_set(self, set1, set2):
+        """DSU function for unioning two sets together
+        Find the roots of each set. Then assign one to have the other
+        as its parent, thus liking the sets.
+        Merges smaller set into larger set in order to have better runtime
+        """
+
+        set1 = self.find_set(set1)
+        set2 = self.find_set(set2)
+        if set1 == set2:
+            return
+        if len(self.gate_groups[set1]) < len(self.gate_groups[set2]):
+            set1, set2 = set2, set1
+        self.parent[set2] = set1
+        self.gate_groups[set1].extend(self.gate_groups[set2])
+        self.bit_groups[set1].extend(self.bit_groups[set2])
+        self.gate_groups[set2].clear()
+        self.bit_groups[set2].clear()
+
+    def run(self, dag):
+        """Run the CollectMultiQBlocks pass on `dag`.
+
+        The blocks contain "op" nodes in topological sort order
+        such that all gates in a block act on the same set of
+        qubits and are adjacent in the circuit.
+
+        The blocks are built by examining predecessors and successors of
+        "cx" gates in the circuit. u1, u2, u3, cx, id gates will be included.
+
+        After the execution, ``property_set['block_list']`` is set to
+        a list of tuples of ``DAGNode`` objects
+        """
+
+        self.parent = {}  # reset all variables on run
+        self.bit_groups = {}
+        self.gate_groups = {}
+
+        block_list = []
+
+        def collect_key(x):
+            """special key function for topological ordering.
+            Heuristic for this is to push all gates involving measurement
+            or barriers, etc. as far back as possible (because they force
+            blocks to end). After that, we process gates in order of lowest
+            number of qubits acted on to largest number of qubits acted on
+            because these have less chance of increasing the size of blocks
+            The key also processes all the non operation notes first so that
+            input nodes do not mess with the top sort of op nodes
+            """
+            if isinstance(x, DAGInNode):
+                return "a"
+            if not isinstance(x, DAGOpNode):
+                return "d"
+            if isinstance(x.op, Gate):
+                if x.op.is_parameterized() or getattr(x.op, "condition", None) is not None:
+                    return "c"
+                return "b" + chr(ord("a") + len(x.qargs))
+            return "d"
+
+        op_nodes = dag.topological_op_nodes(key=collect_key)
+
+        for nd in op_nodes:
+            can_process = True
+            makes_too_big = False
+
+            # check if the node is a gate and if it is parameterized
+            if (
+                getattr(nd.op, "condition", None) is not None
+                or nd.op.is_parameterized()
+                or not isinstance(nd.op, Gate)
+            ):
+                can_process = False
+
+            cur_qubits = {dag.find_bit(bit).index for bit in nd.qargs}
+
+            if can_process:
+                # if the gate is valid, check if grouping up the bits
+                # in the gate would fit within our desired max size
+                c_tops = set()
+                for bit in cur_qubits:
+                    c_tops.add(self.find_set(bit))
+                tot_size = 0
+                for group in c_tops:
+                    tot_size += len(self.bit_groups[group])
+                if tot_size > self.max_block_size:
+                    makes_too_big = True
+
+            if not can_process:
+                # resolve the case where we cannot process this node
+                for bit in cur_qubits:
+                    # create a gate out of me
+                    bit = self.find_set(bit)
+                    if len(self.gate_groups[bit]) == 0:
+                        continue
+                    block_list.append(self.gate_groups[bit][:])
+                    cur_set = set(self.bit_groups[bit])
+                    for v in cur_set:
+                        # reset this bit
+                        self.parent[v] = v
+                        self.bit_groups[v] = [v]
+                        self.gate_groups[v] = []
+
+            if makes_too_big:
+                # adding in all of the new qubits would make the group too big
+                # we must block off sub portions of the groups until the new
+                # group would no longer be too big
+                savings = {}
+                tot_size = 0
+                for bit in cur_qubits:
+                    top = self.find_set(bit)
+                    if top in savings:
+                        savings[top] = savings[top] - 1
+                    else:
+                        savings[top] = len(self.bit_groups[top]) - 1
+                        tot_size += len(self.bit_groups[top])
+                slist = []
+                for item, value in savings.items():
+                    slist.append((value, item))
+                slist.sort(reverse=True)
+                savings_need = tot_size - self.max_block_size
+                for item in slist:
+                    # remove groups until the size created would be acceptable
+                    # start with blocking out the group that would decrease
+                    # the new size the most. This heuristic for which blocks we
+                    # create does not necessarily give the optimal blocking. Other
+                    # heuristics may be worth considering
+                    if savings_need > 0:
+                        savings_need = savings_need - item[0]
+                        if len(self.gate_groups[item[1]]) >= 1:
+                            block_list.append(self.gate_groups[item[1]][:])
+                        cur_set = set(self.bit_groups[item[1]])
+                        for v in cur_set:
+                            self.parent[v] = v
+                            self.bit_groups[v] = [v]
+                            self.gate_groups[v] = []
+
+            if can_process:
+                # if the operation is a gate, either skip it if it is too large
+                # or group up all of the qubits involved in the gate
+                if len(cur_qubits) > self.max_block_size:
+                    # gates acting on more qubits than max_block_size cannot
+                    #   be a part of any block and thus we skip them here.
+                    # we have already finalized the blocks involving the gate's
+                    #   qubits in the above makes_too_big block
+                    continue  # unable to be part of a group
+                prev = -1
+                for bit in cur_qubits:
+                    if prev != -1:
+                        self.union_set(prev, bit)
+                    prev = bit
+                self.gate_groups[self.find_set(prev)].append(nd)
+        # need to turn all groups that still exist into their own blocks
+        for index in self.parent:
+            if self.parent[index] == index and len(self.gate_groups[index]) != 0:
+                block_list.append(self.gate_groups[index][:])
+
+        self.property_set["block_list"] = block_list
+
+        return dag

qiskit/transpiler/passes/optimization/commutation_analysis.py

@@ -0,0 +1,93 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2023.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Analysis pass to find commutation relations between DAG nodes."""
+
+from collections import defaultdict
+
+from qiskit.dagcircuit import DAGOpNode
+from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.circuit.commutation_checker import CommutationChecker
+
+
+class CommutationAnalysis(AnalysisPass):
+    """Analysis pass to find commutation relations between DAG nodes.
+
+    ``property_set['commutation_set']`` is a dictionary that describes
+    the commutation relations on a given wire, all the gates on a wire
+    are grouped into a set of gates that commute.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.comm_checker = CommutationChecker()
+
+    def run(self, dag):
+        """Run the CommutationAnalysis pass on `dag`.
+
+        Run the pass on the DAG, and write the discovered commutation relations
+        into the ``property_set``.
+        """
+        # Initiate the commutation set
+        self.property_set["commutation_set"] = defaultdict(list)
+
+        # Build a dictionary to keep track of the gates on each qubit
+        # The key with format (wire) will store the lists of commutation sets
+        # The key with format (node, wire) will store the index of the commutation set
+        # on the specified wire, thus, for example:
+        # self.property_set['commutation_set'][wire][(node, wire)] will give the
+        # commutation set that contains node.
+
+        for wire in dag.wires:
+            self.property_set["commutation_set"][wire] = []
+
+        # Add edges to the dictionary for each qubit
+        for node in dag.topological_op_nodes():
+            for (_, _, edge_wire) in dag.edges(node):
+                self.property_set["commutation_set"][(node, edge_wire)] = -1
+
+        # Construct the commutation set
+        for wire in dag.wires:
+
+            for current_gate in dag.nodes_on_wire(wire):
+
+                current_comm_set = self.property_set["commutation_set"][wire]
+                if not current_comm_set:
+                    current_comm_set.append([current_gate])
+
+                if current_gate not in current_comm_set[-1]:
+                    does_commute = True
+
+                    # Check if the current gate commutes with all the gates in the current block
+                    for prev_gate in current_comm_set[-1]:
+                        does_commute = (
+                            isinstance(current_gate, DAGOpNode)
+                            and isinstance(prev_gate, DAGOpNode)
+                            and self.comm_checker.commute(
+                                current_gate.op,
+                                current_gate.qargs,
+                                current_gate.cargs,
+                                prev_gate.op,
+                                prev_gate.qargs,
+                                prev_gate.cargs,
+                            )
+                        )
+                        if not does_commute:
+                            break
+
+                    if does_commute:
+                        current_comm_set[-1].append(current_gate)
+                    else:
+                        current_comm_set.append([current_gate])
+
+                temp_len = len(current_comm_set)
+                self.property_set["commutation_set"][(current_gate, wire)] = temp_len - 1

qiskit/transpiler/passes/optimization/commutative_cancellation.py

@@ -0,0 +1,207 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Cancel the redundant (self-adjoint) gates through commutation relations."""
+
+from collections import defaultdict
+import numpy as np
+
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passmanager import PassManager
+from qiskit.transpiler.passes.optimization.commutation_analysis import CommutationAnalysis
+from qiskit.dagcircuit import DAGCircuit, DAGInNode, DAGOutNode
+from qiskit.circuit.library.standard_gates.u1 import U1Gate
+from qiskit.circuit.library.standard_gates.rx import RXGate
+from qiskit.circuit.library.standard_gates.p import PhaseGate
+from qiskit.circuit.library.standard_gates.rz import RZGate
+from qiskit.circuit import ControlFlowOp
+
+
+_CUTOFF_PRECISION = 1e-5
+
+
+class CommutativeCancellation(TransformationPass):
+    """Cancel the redundant (self-adjoint) gates through commutation relations.
+
+    Pass for cancelling self-inverse gates/rotations. The cancellation utilizes
+    the commutation relations in the circuit. Gates considered include::
+
+        H, X, Y, Z, CX, CY, CZ
+    """
+
+    def __init__(self, basis_gates=None, target=None):
+        """
+        CommutativeCancellation initializer.
+
+        Args:
+            basis_gates (list[str]): Basis gates to consider, e.g.
+                ``['u3', 'cx']``. For the effects of this pass, the basis is
+                the set intersection between the ``basis_gates`` parameter
+                and the gates in the dag.
+            target (Target): The :class:`~.Target` representing the target backend, if both
+                ``basis_gates`` and ``target`` are specified then this argument will take
+                precedence and ``basis_gates`` will be ignored.
+        """
+        super().__init__()
+        if basis_gates:
+            self.basis = set(basis_gates)
+        else:
+            self.basis = set()
+        if target is not None:
+            self.basis = set(target.operation_names)
+
+        self._var_z_map = {"rz": RZGate, "p": PhaseGate, "u1": U1Gate}
+        self.requires.append(CommutationAnalysis())
+
+    def run(self, dag):
+        """Run the CommutativeCancellation pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): the DAG to be optimized.
+
+        Returns:
+            DAGCircuit: the optimized DAG.
+
+        Raises:
+            TranspilerError: when the 1-qubit rotation gates are not found
+        """
+        var_z_gate = None
+        z_var_gates = [gate for gate in dag.count_ops().keys() if gate in self._var_z_map]
+        if z_var_gates:
+            # priortize z gates in circuit
+            var_z_gate = self._var_z_map[next(iter(z_var_gates))]
+        else:
+            z_var_gates = [gate for gate in self.basis if gate in self._var_z_map]
+            if z_var_gates:
+                var_z_gate = self._var_z_map[next(iter(z_var_gates))]
+
+        # Now the gates supported are hard-coded
+        q_gate_list = ["cx", "cy", "cz", "h", "y"]
+
+        # Gate sets to be cancelled
+        cancellation_sets = defaultdict(lambda: [])
+
+        # Traverse each qubit to generate the cancel dictionaries
+        # Cancel dictionaries:
+        #  - For 1-qubit gates the key is (gate_type, qubit_id, commutation_set_id),
+        #    the value is the list of gates that share the same gate type, qubit, commutation set.
+        #  - For 2qbit gates the key: (gate_type, first_qbit, sec_qbit, first commutation_set_id,
+        #    sec_commutation_set_id), the value is the list gates that share the same gate type,
+        #    qubits and commutation sets.
+        for wire in dag.wires:
+            wire_commutation_set = self.property_set["commutation_set"][wire]
+
+            for com_set_idx, com_set in enumerate(wire_commutation_set):
+                if isinstance(com_set[0], (DAGInNode, DAGOutNode)):
+                    continue
+                for node in com_set:
+                    num_qargs = len(node.qargs)
+                    if num_qargs == 1 and node.name in q_gate_list:
+                        cancellation_sets[(node.name, wire, com_set_idx)].append(node)
+                    if num_qargs == 1 and node.name in ["p", "z", "u1", "rz", "t", "s"]:
+                        cancellation_sets[("z_rotation", wire, com_set_idx)].append(node)
+                    if num_qargs == 1 and node.name in ["rx", "x"]:
+                        cancellation_sets[("x_rotation", wire, com_set_idx)].append(node)
+                    # Don't deal with Y rotation, because Y rotation doesn't commute with CNOT, so
+                    # it should be dealt with by optimized1qgate pass
+                    elif num_qargs == 2 and node.qargs[0] == wire:
+                        second_qarg = node.qargs[1]
+                        q2_key = (
+                            node.name,
+                            wire,
+                            second_qarg,
+                            com_set_idx,
+                            self.property_set["commutation_set"][(node, second_qarg)],
+                        )
+                        cancellation_sets[q2_key].append(node)
+
+        for cancel_set_key in cancellation_sets:
+            if cancel_set_key[0] == "z_rotation" and var_z_gate is None:
+                continue
+            set_len = len(cancellation_sets[cancel_set_key])
+            if set_len > 1 and cancel_set_key[0] in q_gate_list:
+                gates_to_cancel = cancellation_sets[cancel_set_key]
+                for c_node in gates_to_cancel[: (set_len // 2) * 2]:
+                    dag.remove_op_node(c_node)
+
+            elif set_len > 1 and cancel_set_key[0] in ["z_rotation", "x_rotation"]:
+                run = cancellation_sets[cancel_set_key]
+                run_qarg = run[0].qargs[0]
+                total_angle = 0.0  # lambda
+                total_phase = 0.0
+                for current_node in run:
+                    if (
+                        getattr(current_node.op, "condition", None) is not None
+                        or len(current_node.qargs) != 1
+                        or current_node.qargs[0] != run_qarg
+                    ):
+                        raise TranspilerError("internal error")
+
+                    if current_node.name in ["p", "u1", "rz", "rx"]:
+                        current_angle = float(current_node.op.params[0])
+                    elif current_node.name in ["z", "x"]:
+                        current_angle = np.pi
+                    elif current_node.name == "t":
+                        current_angle = np.pi / 4
+                    elif current_node.name == "s":
+                        current_angle = np.pi / 2
+
+                    # Compose gates
+                    total_angle = current_angle + total_angle
+                    if current_node.op.definition:
+                        total_phase += current_node.op.definition.global_phase
+
+                # Replace the data of the first node in the run
+                if cancel_set_key[0] == "z_rotation":
+                    new_op = var_z_gate(total_angle)
+                elif cancel_set_key[0] == "x_rotation":
+                    new_op = RXGate(total_angle)
+
+                new_op_phase = 0
+                if np.mod(total_angle, (2 * np.pi)) > _CUTOFF_PRECISION:
+                    new_qarg = QuantumRegister(1, "q")
+                    new_dag = DAGCircuit()
+                    new_dag.add_qreg(new_qarg)
+                    new_dag.apply_operation_back(new_op, [new_qarg[0]])
+                    dag.substitute_node_with_dag(run[0], new_dag)
+                    if new_op.definition:
+                        new_op_phase = new_op.definition.global_phase
+
+                dag.global_phase = total_phase - new_op_phase
+
+                # Delete the other nodes in the run
+                for current_node in run[1:]:
+                    dag.remove_op_node(current_node)
+
+                if np.mod(total_angle, (2 * np.pi)) < _CUTOFF_PRECISION:
+                    dag.remove_op_node(run[0])
+
+        dag = self._handle_control_flow_ops(dag)
+
+        return dag
+
+    def _handle_control_flow_ops(self, dag):
+        """
+        This is similar to transpiler/passes/utils/control_flow.py except that the
+        commutation analysis is redone for the control flow blocks.
+        """
+
+        pass_manager = PassManager([CommutationAnalysis(), self])
+        for node in dag.op_nodes(ControlFlowOp):
+            mapped_blocks = []
+            for block in node.op.blocks:
+                new_circ = pass_manager.run(block)
+                mapped_blocks.append(new_circ)
+            node.op = node.op.replace_blocks(mapped_blocks)
+        return dag

qiskit/transpiler/passes/optimization/commutative_inverse_cancellation.py

@@ -0,0 +1,97 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Cancel pairs of inverse gates exploiting commutation relations."""
+
+
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.circuit.commutation_checker import CommutationChecker
+
+
+class CommutativeInverseCancellation(TransformationPass):
+    """Cancel pairs of inverse gates exploiting commutation relations."""
+
+    def _skip_node(self, node):
+        """Returns True if we should skip this node for the analysis."""
+        if not isinstance(node, DAGOpNode):
+            return True
+
+        # We are currently taking an over-conservative approach with respect to which nodes
+        # can be inverses of which other nodes, and do not allow reductions for barriers, measures,
+        # conditional gates or parameterized gates. Possibly both this and commutativity
+        # checking can be extended to cover additional cases.
+        if getattr(node.op, "_directive", False) or node.name in {"measure", "reset", "delay"}:
+            return True
+        if getattr(node.op, "condition", None):
+            return True
+        if node.op.is_parameterized():
+            return True
+        # ToDo: possibly also skip nodes on too many qubits
+        return False
+
+    def run(self, dag: DAGCircuit):
+        """
+        Run the CommutativeInverseCancellation pass on `dag`.
+
+        Args:
+            dag: the directed acyclic graph to run on.
+
+        Returns:
+            DAGCircuit: Transformed DAG.
+        """
+        topo_sorted_nodes = list(dag.topological_op_nodes())
+
+        circ_size = len(topo_sorted_nodes)
+
+        removed = [False for _ in range(circ_size)]
+
+        cc = CommutationChecker()
+
+        for idx1 in range(0, circ_size):
+            if self._skip_node(topo_sorted_nodes[idx1]):
+                continue
+
+            matched_idx2 = -1
+
+            for idx2 in range(idx1 - 1, -1, -1):
+                if removed[idx2]:
+                    continue
+
+                if (
+                    not self._skip_node(topo_sorted_nodes[idx2])
+                    and topo_sorted_nodes[idx2].qargs == topo_sorted_nodes[idx1].qargs
+                    and topo_sorted_nodes[idx2].cargs == topo_sorted_nodes[idx1].cargs
+                    and topo_sorted_nodes[idx2].op == topo_sorted_nodes[idx1].op.inverse()
+                ):
+                    matched_idx2 = idx2
+                    break
+
+                if not cc.commute(
+                    topo_sorted_nodes[idx1].op,
+                    topo_sorted_nodes[idx1].qargs,
+                    topo_sorted_nodes[idx1].cargs,
+                    topo_sorted_nodes[idx2].op,
+                    topo_sorted_nodes[idx2].qargs,
+                    topo_sorted_nodes[idx2].cargs,
+                ):
+                    break
+
+            if matched_idx2 != -1:
+                removed[idx1] = True
+                removed[matched_idx2] = True
+
+        for idx in range(circ_size):
+            if removed[idx]:
+                dag.remove_op_node(topo_sorted_nodes[idx])
+
+        return dag