qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/transpiler/passes/utils/gate_direction.py

@@ -0,0 +1,349 @@
+# 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.
+
+"""Rearrange the direction of the cx nodes to match the directed coupling map."""
+
+from math import pi
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.exceptions import TranspilerError
+
+from qiskit.converters import dag_to_circuit, circuit_to_dag
+from qiskit.circuit import QuantumRegister, ControlFlowOp
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
+from qiskit.circuit.library.standard_gates import (
+    SGate,
+    SdgGate,
+    SXGate,
+    HGate,
+    CXGate,
+    CZGate,
+    ECRGate,
+    RXXGate,
+    RYYGate,
+    RZZGate,
+    RZXGate,
+    SwapGate,
+)
+
+
+def _swap_node_qargs(node):
+    return DAGOpNode(node.op, node.qargs[::-1], node.cargs)
+
+
+class GateDirection(TransformationPass):
+    """Modify asymmetric gates to match the hardware coupling direction.
+
+    This pass makes use of the following identities::
+
+                             ┌───┐┌───┐┌───┐
+        q_0: ──■──      q_0: ┤ H ├┤ X ├┤ H ├
+             ┌─┴─┐  =        ├───┤└─┬─┘├───┤
+        q_1: ┤ X ├      q_1: ┤ H ├──■──┤ H ├
+             └───┘           └───┘     └───┘
+
+
+                          global phase: 3π/2
+             ┌──────┐           ┌───┐ ┌────┐┌─────┐┌──────┐┌───┐
+        q_0: ┤0     ├     q_0: ─┤ S ├─┤ √X ├┤ Sdg ├┤1     ├┤ H ├
+             │  ECR │  =       ┌┴───┴┐├────┤└┬───┬┘│  Ecr │├───┤
+        q_1: ┤1     ├     q_1: ┤ Sdg ├┤ √X ├─┤ S ├─┤0     ├┤ H ├
+             └──────┘          └─────┘└────┘ └───┘ └──────┘└───┘
+
+
+             ┌──────┐          ┌───┐┌──────┐┌───┐
+        q_0: ┤0     ├     q_0: ┤ H ├┤1     ├┤ H ├
+             │  RZX │  =       ├───┤│  RZX │├───┤
+        q_1: ┤1     ├     q_1: ┤ H ├┤0     ├┤ H ├
+             └──────┘          └───┘└──────┘└───┘
+
+    This pass assumes that the positions of the qubits in the :attr:`.DAGCircuit.qubits` attribute
+    are the physical qubit indices. For example if ``dag.qubits[0]`` is qubit 0 in the
+    :class:`.CouplingMap` or :class:`.Target`.
+    """
+
+    _KNOWN_REPLACEMENTS = frozenset(["cx", "cz", "ecr", "swap", "rzx", "rxx", "ryy", "rzz"])
+
+    def __init__(self, coupling_map, target=None):
+        """GateDirection pass.
+
+        Args:
+            coupling_map (CouplingMap): Directed graph represented a coupling map.
+            target (Target): The backend target to use for this pass. If this is specified
+                it will be used instead of the coupling map
+        """
+        super().__init__()
+        self.coupling_map = coupling_map
+        self.target = target
+
+        # Create the replacement dag and associated register.
+        self._cx_dag = DAGCircuit()
+        qr = QuantumRegister(2)
+        self._cx_dag.add_qreg(qr)
+        self._cx_dag.apply_operation_back(HGate(), [qr[0]], [])
+        self._cx_dag.apply_operation_back(HGate(), [qr[1]], [])
+        self._cx_dag.apply_operation_back(CXGate(), [qr[1], qr[0]], [])
+        self._cx_dag.apply_operation_back(HGate(), [qr[0]], [])
+        self._cx_dag.apply_operation_back(HGate(), [qr[1]], [])
+
+        # This is done in terms of less-efficient S/SX/Sdg gates instead of the more natural
+        # `RY(pi /2)` so we have a chance for basis translation to keep things in a discrete basis
+        # during resynthesis, if that's what's being asked for.
+        self._ecr_dag = DAGCircuit()
+        qr = QuantumRegister(2)
+        self._ecr_dag.global_phase = -pi / 2
+        self._ecr_dag.add_qreg(qr)
+        self._ecr_dag.apply_operation_back(SGate(), [qr[0]], [])
+        self._ecr_dag.apply_operation_back(SXGate(), [qr[0]], [])
+        self._ecr_dag.apply_operation_back(SdgGate(), [qr[0]], [])
+        self._ecr_dag.apply_operation_back(SdgGate(), [qr[1]], [])
+        self._ecr_dag.apply_operation_back(SXGate(), [qr[1]], [])
+        self._ecr_dag.apply_operation_back(SGate(), [qr[1]], [])
+        self._ecr_dag.apply_operation_back(ECRGate(), [qr[1], qr[0]], [])
+        self._ecr_dag.apply_operation_back(HGate(), [qr[0]], [])
+        self._ecr_dag.apply_operation_back(HGate(), [qr[1]], [])
+
+        self._cz_dag = DAGCircuit()
+        qr = QuantumRegister(2)
+        self._cz_dag.add_qreg(qr)
+        self._cz_dag.apply_operation_back(CZGate(), [qr[1], qr[0]], [])
+
+        self._swap_dag = DAGCircuit()
+        qr = QuantumRegister(2)
+        self._swap_dag.add_qreg(qr)
+        self._swap_dag.apply_operation_back(SwapGate(), [qr[1], qr[0]], [])
+
+        # If adding more replacements (either static or dynamic), also update the class variable
+        # `_KNOWN_REPLACMENTS` to include them in the error messages.
+        self._static_replacements = {
+            "cx": self._cx_dag,
+            "cz": self._cz_dag,
+            "ecr": self._ecr_dag,
+            "swap": self._swap_dag,
+        }
+
+    @staticmethod
+    def _rzx_dag(parameter):
+        _rzx_dag = DAGCircuit()
+        qr = QuantumRegister(2)
+        _rzx_dag.add_qreg(qr)
+        _rzx_dag.apply_operation_back(HGate(), [qr[0]], [])
+        _rzx_dag.apply_operation_back(HGate(), [qr[1]], [])
+        _rzx_dag.apply_operation_back(RZXGate(parameter), [qr[1], qr[0]], [])
+        _rzx_dag.apply_operation_back(HGate(), [qr[0]], [])
+        _rzx_dag.apply_operation_back(HGate(), [qr[1]], [])
+        return _rzx_dag
+
+    @staticmethod
+    def _rxx_dag(parameter):
+        _rxx_dag = DAGCircuit()
+        qr = QuantumRegister(2)
+        _rxx_dag.add_qreg(qr)
+        _rxx_dag.apply_operation_back(RXXGate(parameter), [qr[1], qr[0]], [])
+        return _rxx_dag
+
+    @staticmethod
+    def _ryy_dag(parameter):
+        _ryy_dag = DAGCircuit()
+        qr = QuantumRegister(2)
+        _ryy_dag.add_qreg(qr)
+        _ryy_dag.apply_operation_back(RYYGate(parameter), [qr[1], qr[0]], [])
+        return _ryy_dag
+
+    @staticmethod
+    def _rzz_dag(parameter):
+        _rzz_dag = DAGCircuit()
+        qr = QuantumRegister(2)
+        _rzz_dag.add_qreg(qr)
+        _rzz_dag.apply_operation_back(RZZGate(parameter), [qr[1], qr[0]], [])
+        return _rzz_dag
+
+    def _run_coupling_map(self, dag, wire_map, edges=None):
+        if edges is None:
+            edges = set(self.coupling_map.get_edges())
+        if not edges:
+            return dag
+        # Don't include directives to avoid things like barrier, which are assumed always supported.
+        for node in dag.op_nodes(include_directives=False):
+            if isinstance(node.op, ControlFlowOp):
+                new_op = node.op.replace_blocks(
+                    dag_to_circuit(
+                        self._run_coupling_map(
+                            circuit_to_dag(block),
+                            {
+                                inner: wire_map[outer]
+                                for outer, inner in zip(node.qargs, block.qubits)
+                            },
+                            edges,
+                        )
+                    )
+                    for block in node.op.blocks
+                )
+                dag.substitute_node(node, new_op, propagate_condition=False)
+                continue
+            if len(node.qargs) != 2:
+                continue
+            if dag.has_calibration_for(node):
+                continue
+            qargs = (wire_map[node.qargs[0]], wire_map[node.qargs[1]])
+            if qargs not in edges and (qargs[1], qargs[0]) not in edges:
+                raise TranspilerError(
+                    f"The circuit requires a connection between physical qubits {qargs}"
+                )
+            if qargs not in edges:
+                replacement = self._static_replacements.get(node.name)
+                if replacement is not None:
+                    dag.substitute_node_with_dag(node, replacement)
+                elif node.name == "rzx":
+                    dag.substitute_node_with_dag(node, self._rzx_dag(*node.op.params))
+                elif node.name == "rxx":
+                    dag.substitute_node_with_dag(node, self._rxx_dag(*node.op.params))
+                elif node.name == "ryy":
+                    dag.substitute_node_with_dag(node, self._ryy_dag(*node.op.params))
+                elif node.name == "rzz":
+                    dag.substitute_node_with_dag(node, self._rzz_dag(*node.op.params))
+                else:
+                    raise TranspilerError(
+                        f"'{node.name}' would be supported on '{qargs}' if the direction were"
+                        f" swapped, but no rules are known to do that."
+                        f" {list(self._KNOWN_REPLACEMENTS)} can be automatically flipped."
+                    )
+        return dag
+
+    def _run_target(self, dag, wire_map):
+        # Don't include directives to avoid things like barrier, which are assumed always supported.
+        for node in dag.op_nodes(include_directives=False):
+            if isinstance(node.op, ControlFlowOp):
+                new_op = node.op.replace_blocks(
+                    dag_to_circuit(
+                        self._run_target(
+                            circuit_to_dag(block),
+                            {
+                                inner: wire_map[outer]
+                                for outer, inner in zip(node.qargs, block.qubits)
+                            },
+                        )
+                    )
+                    for block in node.op.blocks
+                )
+                dag.substitute_node(node, new_op, propagate_condition=False)
+                continue
+            if len(node.qargs) != 2:
+                continue
+            if dag.has_calibration_for(node):
+                continue
+            qargs = (wire_map[node.qargs[0]], wire_map[node.qargs[1]])
+            swapped = (qargs[1], qargs[0])
+            if node.name in self._static_replacements:
+                if self.target.instruction_supported(node.name, qargs):
+                    continue
+                if self.target.instruction_supported(node.name, swapped):
+                    dag.substitute_node_with_dag(node, self._static_replacements[node.name])
+                else:
+                    raise TranspilerError(
+                        f"The circuit requires a connection between physical qubits {qargs}"
+                        f" for {node.name}"
+                    )
+            elif node.name == "rzx":
+                if self.target.instruction_supported(
+                    qargs=qargs, operation_class=RZXGate, parameters=node.op.params
+                ):
+                    continue
+                if self.target.instruction_supported(
+                    qargs=swapped, operation_class=RZXGate, parameters=node.op.params
+                ):
+                    dag.substitute_node_with_dag(node, self._rzx_dag(*node.op.params))
+                else:
+                    raise TranspilerError(
+                        f"The circuit requires a connection between physical qubits {qargs}"
+                        f" for {node.name}"
+                    )
+            elif node.name == "rxx":
+                if self.target.instruction_supported(
+                    qargs=qargs, operation_class=RXXGate, parameters=node.op.params
+                ):
+                    continue
+                if self.target.instruction_supported(
+                    qargs=swapped, operation_class=RXXGate, parameters=node.op.params
+                ):
+                    dag.substitute_node_with_dag(node, self._rxx_dag(*node.op.params))
+                else:
+                    raise TranspilerError(
+                        f"The circuit requires a connection between physical qubits {qargs}"
+                        f" for {node.name}"
+                    )
+            elif node.name == "ryy":
+                if self.target.instruction_supported(
+                    qargs=qargs, operation_class=RYYGate, parameters=node.op.params
+                ):
+                    continue
+                if self.target.instruction_supported(
+                    qargs=swapped, operation_class=RYYGate, parameters=node.op.params
+                ):
+                    dag.substitute_node_with_dag(node, self._ryy_dag(*node.op.params))
+                else:
+                    raise TranspilerError(
+                        f"The circuit requires a connection between physical qubits {qargs}"
+                        f" for {node.name}"
+                    )
+            elif node.name == "rzz":
+                if self.target.instruction_supported(
+                    qargs=qargs, operation_class=RZZGate, parameters=node.op.params
+                ):
+                    continue
+                if self.target.instruction_supported(
+                    qargs=swapped, operation_class=RZZGate, parameters=node.op.params
+                ):
+                    dag.substitute_node_with_dag(node, self._rzz_dag(*node.op.params))
+                else:
+                    raise TranspilerError(
+                        f"The circuit requires a connection between physical qubits {qargs}"
+                        f" for {node.name}"
+                    )
+            elif self.target.instruction_supported(node.name, qargs):
+                continue
+            elif self.target.instruction_supported(node.name, swapped) or dag.has_calibration_for(
+                _swap_node_qargs(node)
+            ):
+                raise TranspilerError(
+                    f"'{node.name}' would be supported on '{qargs}' if the direction were"
+                    f" swapped, but no rules are known to do that."
+                    f" {list(self._KNOWN_REPLACEMENTS)} can be automatically flipped."
+                )
+            else:
+                raise TranspilerError(
+                    f"'{node.name}' with parameters '{node.op.params}' is not supported on qubits"
+                    f" '{qargs}' in either direction."
+                )
+
+        return dag
+
+    def run(self, dag):
+        """Run the GateDirection pass on `dag`.
+
+        Flips the cx nodes to match the directed coupling map. Modifies the
+        input dag.
+
+        Args:
+            dag (DAGCircuit): DAG to map.
+
+        Returns:
+            DAGCircuit: The rearranged dag for the coupling map
+
+        Raises:
+            TranspilerError: If the circuit cannot be mapped just by flipping the
+                cx nodes.
+        """
+        layout_map = {bit: i for i, bit in enumerate(dag.qubits)}
+        if self.target is None:
+            return self._run_coupling_map(dag, layout_map)
+        return self._run_target(dag, layout_map)

qiskit/transpiler/passes/utils/gates_basis.py

@@ -0,0 +1,74 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# 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.
+
+"""Check if all gates in the DAGCircuit are in the specified basis gates."""
+
+from qiskit.converters import circuit_to_dag
+from qiskit.transpiler.basepasses import AnalysisPass
+
+
+class GatesInBasis(AnalysisPass):
+    """Check if all gates in a DAG are in a given set of gates"""
+
+    def __init__(self, basis_gates=None, target=None):
+        """Initialize the GatesInBasis pass.
+
+        Args:
+            basis_gates (list): The list of strings representing the set of basis gates.
+            target (Target): The target representing the backend. If specified
+                this will be used instead of the ``basis_gates`` parameter
+        """
+        super().__init__()
+        self._basis_gates = None
+        if basis_gates is not None:
+            self._basis_gates = set(basis_gates).union(
+                {"measure", "reset", "barrier", "snapshot", "delay", "store"}
+            )
+        self._target = target
+
+    def run(self, dag):
+        """Run the GatesInBasis pass on `dag`."""
+        if self._basis_gates is None and self._target is None:
+            self.property_set["all_gates_in_basis"] = True
+            return
+        gates_out_of_basis = False
+        if self._target is not None:
+
+            def _visit_target(dag, wire_map):
+                for gate in dag.op_nodes():
+                    # Barrier and store are assumed universal and supported by all backends
+                    if gate.name in ("barrier", "store"):
+                        continue
+                    if not self._target.instruction_supported(
+                        gate.name, tuple(wire_map[bit] for bit in gate.qargs)
+                    ):
+                        return True
+                    # Control-flow ops still need to be supported, so don't skip them in the
+                    # previous checks.
+                    if gate.is_control_flow():
+                        for block in gate.op.blocks:
+                            inner_wire_map = {
+                                inner: wire_map[outer]
+                                for outer, inner in zip(gate.qargs, block.qubits)
+                            }
+                            if _visit_target(circuit_to_dag(block), inner_wire_map):
+                                return True
+                return False
+
+            qubit_map = {qubit: index for index, qubit in enumerate(dag.qubits)}
+            gates_out_of_basis = _visit_target(dag, qubit_map)
+        else:
+            for gate in dag.count_ops(recurse=True):
+                if gate not in self._basis_gates:
+                    gates_out_of_basis = True
+                    break
+        self.property_set["all_gates_in_basis"] = not gates_out_of_basis

qiskit/transpiler/passes/utils/merge_adjacent_barriers.py

@@ -0,0 +1,162 @@
+# 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.
+
+"""Return a circuit with any adjacent barriers merged together."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.circuit.barrier import Barrier
+
+
+class MergeAdjacentBarriers(TransformationPass):
+    """Return a circuit with any adjacent barriers merged together.
+
+    Only barriers which can be merged without affecting the barrier structure
+    of the DAG will be merged.
+
+    Not all redundant barriers will necessarily be merged, only adjacent
+    barriers are merged.
+
+    For example, the circuit::
+
+        qr = QuantumRegister(3, 'q')
+        circuit = QuantumCircuit(qr)
+        circuit.barrier(qr[0])
+        circuit.barrier(qr[1])
+        circuit.barrier(qr)
+
+    Will be transformed into a circuit corresponding to::
+
+        circuit.barrier(qr[0])
+        circuit.barrier(qr)
+
+    i.e,
+
+    .. parsed-literal::
+              ░  ░             ░  ░
+        q_0: ─░──░─      q_0: ─░──░─
+              ░  ░             ░  ░
+        q_1: ─░──░─  =>  q_1: ────░─
+              ░  ░                ░
+        q_2: ────░─      q_2: ────░─
+                 ░
+
+    after one iteration of the pass. These two barriers were not merged by the
+    first pass as they are not adjacent in the initial circuit.
+
+    The pass then can be reapplied to merge the newly adjacent barriers.
+    """
+
+    def run(self, dag):
+        """Run the MergeAdjacentBarriers pass on `dag`."""
+        indices = {qubit: index for index, qubit in enumerate(dag.qubits)}
+
+        # sorted to so that they are in the order they appear in the DAG
+        # so ancestors/descendants makes sense
+        barriers = [nd for nd in dag.topological_op_nodes() if nd.name == "barrier"]
+
+        # get dict of barrier merges
+        node_to_barrier_qubits = MergeAdjacentBarriers._collect_potential_merges(dag, barriers)
+
+        if not node_to_barrier_qubits:
+            return dag
+
+        for barrier in barriers:
+            if barrier in node_to_barrier_qubits:
+                barrier_to_add, nodes = node_to_barrier_qubits[barrier]
+                dag.replace_block_with_op(
+                    nodes, barrier_to_add, wire_pos_map=indices, cycle_check=False
+                )
+
+        return dag
+
+    @staticmethod
+    def _collect_potential_merges(dag, barriers):
+        """Return the potential merges.
+
+        Returns a dict of DAGOpNode: (Barrier, [DAGOpNode]) objects, where the barrier needs to be
+        inserted where the corresponding index DAGOpNode appears in the main DAG, in replacement of
+        the listed DAGOpNodes.
+        """
+        # if only got 1 or 0 barriers then can't merge
+        if len(barriers) < 2:
+            return None
+
+        # mapping from the node that will be the main barrier to the
+        # barrier object that gets built up
+        node_to_barrier_qubits = {}
+
+        # Start from the first barrier
+        current_barrier = barriers[0]
+        end_of_barrier = current_barrier
+        current_barrier_nodes = [current_barrier]
+
+        current_qubits = set(current_barrier.qargs)
+        current_ancestors = dag.ancestors(current_barrier)
+        current_descendants = dag.descendants(current_barrier)
+
+        barrier_to_add = Barrier(len(current_qubits))
+
+        for next_barrier in barriers[1:]:
+
+            # Ensure barriers are adjacent before checking if they are mergeable.
+            if dag._has_edge(end_of_barrier._node_id, next_barrier._node_id):
+
+                # Remove all barriers that have already been included in this new barrier from the
+                # set of ancestors/descendants as they will be removed from the new DAG when it is
+                # created.
+                next_ancestors = {
+                    nd for nd in dag.ancestors(next_barrier) if nd not in current_barrier_nodes
+                }
+                next_descendants = {
+                    nd for nd in dag.descendants(next_barrier) if nd not in current_barrier_nodes
+                }
+                next_qubits = set(next_barrier.qargs)
+
+                if (
+                    not current_qubits.isdisjoint(next_qubits)
+                    and current_ancestors.isdisjoint(next_descendants)
+                    and current_descendants.isdisjoint(next_ancestors)
+                ):
+
+                    # can be merged
+                    current_ancestors = current_ancestors | next_ancestors
+                    current_descendants = current_descendants | next_descendants
+                    current_qubits = current_qubits | next_qubits
+
+                    # update the barrier that will be added back to include this barrier
+                    barrier_to_add = Barrier(len(current_qubits))
+
+                    end_of_barrier = next_barrier
+                    current_barrier_nodes.append(end_of_barrier)
+                    continue
+
+            # Fallback if barriers are not adjacent or not mergeable.
+
+            # store the previously made barrier
+            if barrier_to_add:
+                node_to_barrier_qubits[end_of_barrier] = (barrier_to_add, current_barrier_nodes)
+
+            # reset the properties
+            current_qubits = set(next_barrier.qargs)
+            current_ancestors = dag.ancestors(next_barrier)
+            current_descendants = dag.descendants(next_barrier)
+
+            barrier_to_add = Barrier(len(current_qubits))
+            current_barrier_nodes = []
+
+            end_of_barrier = next_barrier
+            current_barrier_nodes.append(end_of_barrier)
+
+        if barrier_to_add:
+            node_to_barrier_qubits[end_of_barrier] = (barrier_to_add, current_barrier_nodes)
+
+        return node_to_barrier_qubits