qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/transpiler/passes/optimization/consolidate_blocks.py

@@ -0,0 +1,232 @@
+# 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.
+
+"""Replace each block of consecutive gates by a single Unitary node."""
+from __future__ import annotations
+
+import numpy as np
+
+from qiskit.circuit.classicalregister import ClassicalRegister
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.dagcircuit.dagnode import DAGOpNode
+from qiskit.quantum_info import Operator
+from qiskit.synthesis.two_qubit import TwoQubitBasisDecomposer
+from qiskit.circuit.library.generalized_gates.unitary import UnitaryGate
+from qiskit.circuit.library.standard_gates import CXGate
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passmanager import PassManager
+from qiskit.transpiler.passes.synthesis import unitary_synthesis
+from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
+from qiskit._accelerate.convert_2q_block_matrix import blocks_to_matrix
+from qiskit.exceptions import QiskitError
+
+from .collect_1q_runs import Collect1qRuns
+from .collect_2q_blocks import Collect2qBlocks
+
+
+class ConsolidateBlocks(TransformationPass):
+    """Replace each block of consecutive gates by a single Unitary node.
+
+    Pass to consolidate sequences of uninterrupted gates acting on
+    the same qubits into a Unitary node, to be resynthesized later,
+    to a potentially more optimal subcircuit.
+
+    Notes:
+        This pass assumes that the 'blocks_list' property that it reads is
+        given such that blocks are in topological order. The blocks are
+        collected by a previous pass, such as `Collect2qBlocks`.
+    """
+
+    def __init__(
+        self,
+        kak_basis_gate=None,
+        force_consolidate=False,
+        basis_gates=None,
+        approximation_degree=1.0,
+        target=None,
+    ):
+        """ConsolidateBlocks initializer.
+
+        If ``kak_basis_gate`` is not ``None`` it will be used as the basis gate for KAK decomposition.
+        Otherwise, if ``basis_gates`` is not ``None`` a basis gate will be chosen from this list.
+        Otherwise, the basis gate will be :class:`.CXGate`.
+
+        Args:
+            kak_basis_gate (Gate): Basis gate for KAK decomposition.
+            force_consolidate (bool): Force block consolidation.
+            basis_gates (List(str)): Basis gates from which to choose a KAK gate.
+            approximation_degree (float): a float between :math:`[0.0, 1.0]`. Lower approximates more.
+            target (Target): The target object for the compilation target backend.
+        """
+        super().__init__()
+        self.basis_gates = None
+        self.target = target
+        if basis_gates is not None:
+            self.basis_gates = set(basis_gates)
+        self.force_consolidate = force_consolidate
+
+        if kak_basis_gate is not None:
+            self.decomposer = TwoQubitBasisDecomposer(kak_basis_gate)
+        elif basis_gates is not None:
+            self.decomposer = unitary_synthesis._decomposer_2q_from_basis_gates(
+                basis_gates, approximation_degree=approximation_degree
+            )
+        else:
+            self.decomposer = TwoQubitBasisDecomposer(CXGate())
+
+    def run(self, dag):
+        """Run the ConsolidateBlocks pass on `dag`.
+
+        Iterate over each block and replace it with an equivalent Unitary
+        on the same wires.
+        """
+        if self.decomposer is None:
+            return dag
+
+        blocks = self.property_set["block_list"] or []
+        basis_gate_name = self.decomposer.gate.name
+        all_block_gates = set()
+        for block in blocks:
+            if len(block) == 1 and self._check_not_in_basis(dag, block[0].name, block[0].qargs):
+                all_block_gates.add(block[0])
+                dag.substitute_node(block[0], UnitaryGate(block[0].op.to_matrix()))
+            else:
+                basis_count = 0
+                outside_basis = False
+                block_qargs = set()
+                block_cargs = set()
+                for nd in block:
+                    block_qargs |= set(nd.qargs)
+                    if isinstance(nd, DAGOpNode) and getattr(nd, "condition", None):
+                        block_cargs |= set(getattr(nd, "condition", None)[0])
+                    all_block_gates.add(nd)
+                block_index_map = self._block_qargs_to_indices(dag, block_qargs)
+                for nd in block:
+                    if nd.name == basis_gate_name:
+                        basis_count += 1
+                    if self._check_not_in_basis(dag, nd.name, nd.qargs):
+                        outside_basis = True
+                if len(block_qargs) > 2:
+                    q = QuantumRegister(len(block_qargs))
+                    qc = QuantumCircuit(q)
+                    if block_cargs:
+                        c = ClassicalRegister(len(block_cargs))
+                        qc.add_register(c)
+                    for nd in block:
+                        qc.append(nd.op, [q[block_index_map[i]] for i in nd.qargs])
+                    unitary = UnitaryGate(Operator(qc), check_input=False)
+                else:
+                    try:
+                        matrix = blocks_to_matrix(block, block_index_map)
+                    except QiskitError:
+                        # If building a matrix for the block fails we should not consolidate it
+                        # because there is nothing we can do with it.
+                        continue
+                    unitary = UnitaryGate(matrix, check_input=False)
+
+                max_2q_depth = 20  # If depth > 20, there will be 1q gates to consolidate.
+                if (  # pylint: disable=too-many-boolean-expressions
+                    self.force_consolidate
+                    or unitary.num_qubits > 2
+                    or self.decomposer.num_basis_gates(matrix) < basis_count
+                    or len(block) > max_2q_depth
+                    or ((self.basis_gates is not None) and outside_basis)
+                    or ((self.target is not None) and outside_basis)
+                ):
+                    identity = np.eye(2**unitary.num_qubits)
+                    if np.allclose(identity, unitary.to_matrix()):
+                        for node in block:
+                            dag.remove_op_node(node)
+                    else:
+                        dag.replace_block_with_op(
+                            block, unitary, block_index_map, cycle_check=False
+                        )
+        # If 1q runs are collected before consolidate those too
+        runs = self.property_set["run_list"] or []
+        identity_1q = np.eye(2)
+        for run in runs:
+            if any(gate in all_block_gates for gate in run):
+                continue
+            if len(run) == 1 and not self._check_not_in_basis(dag, run[0].name, run[0].qargs):
+                dag.substitute_node(run[0], UnitaryGate(run[0].op.to_matrix(), check_input=False))
+            else:
+                qubit = run[0].qargs[0]
+                operator = run[0].op.to_matrix()
+                already_in_block = False
+                for gate in run[1:]:
+                    if gate in all_block_gates:
+                        already_in_block = True
+                    operator = gate.op.to_matrix().dot(operator)
+                if already_in_block:
+                    continue
+                unitary = UnitaryGate(operator, check_input=False)
+                if np.allclose(identity_1q, unitary.to_matrix()):
+                    for node in run:
+                        dag.remove_op_node(node)
+                else:
+                    dag.replace_block_with_op(run, unitary, {qubit: 0}, cycle_check=False)
+
+        dag = self._handle_control_flow_ops(dag)
+
+        # Clear collected blocks and runs as they are no longer valid after consolidation
+        if "run_list" in self.property_set:
+            del self.property_set["run_list"]
+        if "block_list" in self.property_set:
+            del self.property_set["block_list"]
+
+        return dag
+
+    def _handle_control_flow_ops(self, dag):
+        """
+        This is similar to transpiler/passes/utils/control_flow.py except that the
+        collect blocks is redone for the control flow blocks.
+        """
+
+        pass_manager = PassManager()
+        if "run_list" in self.property_set:
+            pass_manager.append(Collect1qRuns())
+        if "block_list" in self.property_set:
+            pass_manager.append(Collect2qBlocks())
+
+        pass_manager.append(self)
+        for node in dag.op_nodes():
+            if node.name not in CONTROL_FLOW_OP_NAMES:
+                continue
+            dag.substitute_node(
+                node,
+                node.op.replace_blocks(pass_manager.run(block) for block in node.op.blocks),
+                propagate_condition=False,
+            )
+        return dag
+
+    def _check_not_in_basis(self, dag, gate_name, qargs):
+        if self.target is not None:
+            return not self.target.instruction_supported(
+                gate_name, tuple(dag.find_bit(qubit).index for qubit in qargs)
+            )
+        else:
+            return self.basis_gates and gate_name not in self.basis_gates
+
+    def _block_qargs_to_indices(self, dag, block_qargs):
+        """Map each qubit in block_qargs to its wire position among the block's wires.
+        Args:
+            block_qargs (list): list of qubits that a block acts on
+            global_index_map (dict): mapping from each qubit in the
+                circuit to its wire position within that circuit
+        Returns:
+            dict: mapping from qarg to position in block
+        """
+        block_indices = [dag.find_bit(q).index for q in block_qargs]
+        ordered_block_indices = {bit: index for index, bit in enumerate(sorted(block_indices))}
+        block_positions = {q: ordered_block_indices[dag.find_bit(q).index] for q in block_qargs}
+        return block_positions

qiskit/transpiler/passes/optimization/cx_cancellation.py

@@ -0,0 +1,65 @@
+# 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.
+
+"""Cancel back-to-back ``cx`` gates in dag."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils import control_flow
+from qiskit.utils.deprecation import deprecate_func
+
+
+class CXCancellation(TransformationPass):
+    """Cancel back-to-back ``cx`` gates in dag."""
+
+    @deprecate_func(
+        additional_msg=(
+            "Instead, use :class:`~.InverseCancellation`, which is a more generic pass."
+        ),
+        since="1.1.0",
+    )
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @control_flow.trivial_recurse
+    def run(self, dag):
+        """Run the CXCancellation pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): the directed acyclic graph to run on.
+
+        Returns:
+            DAGCircuit: Transformed DAG.
+        """
+        cx_runs = dag.collect_runs(["cx"])
+        for cx_run in cx_runs:
+            # Although one `cx_run` will always have the same set of qubits,
+            # the order of these qubits matters (CXi_j != CXj_i).
+            # Therefore, we have to partition each run into chunks where the qargs
+            # are in the same order, and only cancel out CXs within each chunk.
+            partitions = []
+            chunk = []
+            for i in range(len(cx_run) - 1):
+                chunk.append(cx_run[i])
+                if cx_run[i].qargs != cx_run[i + 1].qargs:
+                    partitions.append(chunk)
+                    chunk = []
+            chunk.append(cx_run[-1])
+            partitions.append(chunk)
+
+            # Remove an even number of CX gates from each chunk
+            for chunk in partitions:
+                if len(chunk) % 2 == 0:
+                    dag.remove_op_node(chunk[0])
+                for node in chunk[1:]:
+                    dag.remove_op_node(node)
+
+        return dag

qiskit/transpiler/passes/optimization/echo_rzx_weyl_decomposition.py

@@ -0,0 +1,160 @@
+# 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.
+
+"""Weyl decomposition of two-qubit gates in terms of echoed cross-resonance gates."""
+
+from typing import Tuple
+
+from qiskit.circuit import QuantumRegister
+from qiskit.circuit.library.standard_gates import RZXGate, HGate, XGate
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.layout import Layout
+from qiskit.transpiler.passes.calibration.rzx_builder import _check_calibration_type, CRCalType
+
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.converters import circuit_to_dag
+
+
+class EchoRZXWeylDecomposition(TransformationPass):
+    """Rewrite two-qubit gates using the Weyl decomposition.
+
+    This transpiler pass rewrites two-qubit gates in terms of echoed cross-resonance gates according
+    to the Weyl decomposition. A two-qubit gate will be replaced with at most six non-echoed RZXGates.
+    Each pair of RZXGates forms an echoed RZXGate.
+    """
+
+    def __init__(self, instruction_schedule_map=None, target=None):
+        """EchoRZXWeylDecomposition pass.
+
+        Args:
+            instruction_schedule_map (InstructionScheduleMap): the mapping from circuit
+                :class:`~.circuit.Instruction` names and arguments to :class:`.Schedule`\\ s.
+            target (Target): The :class:`~.Target` representing the target backend, if both
+                ``instruction_schedule_map`` and ``target`` are specified then this argument will take
+                precedence and ``instruction_schedule_map`` will be ignored.
+        """
+        super().__init__()
+        self._inst_map = instruction_schedule_map
+        if target is not None:
+            self._inst_map = target.instruction_schedule_map()
+
+    def _is_native(self, qubit_pair: Tuple) -> bool:
+        """Return the direction of the qubit pair that is native."""
+        cal_type, _, _ = _check_calibration_type(self._inst_map, qubit_pair)
+        return cal_type in [
+            CRCalType.ECR_CX_FORWARD,
+            CRCalType.ECR_FORWARD,
+            CRCalType.DIRECT_CX_FORWARD,
+        ]
+
+    @staticmethod
+    def _echo_rzx_dag(theta):
+        """Return the following circuit
+
+        .. parsed-literal::
+
+                 ┌───────────────┐┌───┐┌────────────────┐┌───┐
+            q_0: ┤0              ├┤ X ├┤0               ├┤ X ├
+                 │  Rzx(theta/2) │└───┘│  Rzx(-theta/2) │└───┘
+            q_1: ┤1              ├─────┤1               ├─────
+                 └───────────────┘     └────────────────┘
+        """
+        rzx_dag = DAGCircuit()
+        qr = QuantumRegister(2)
+        rzx_dag.add_qreg(qr)
+        rzx_dag.apply_operation_back(RZXGate(theta / 2), [qr[0], qr[1]], [])
+        rzx_dag.apply_operation_back(XGate(), [qr[0]], [])
+        rzx_dag.apply_operation_back(RZXGate(-theta / 2), [qr[0], qr[1]], [])
+        rzx_dag.apply_operation_back(XGate(), [qr[0]], [])
+        return rzx_dag
+
+    @staticmethod
+    def _reverse_echo_rzx_dag(theta):
+        """Return the following circuit
+
+        .. parsed-literal::
+
+                 ┌───┐┌───────────────┐     ┌────────────────┐┌───┐
+            q_0: ┤ H ├┤1              ├─────┤1               ├┤ H ├─────
+                 ├───┤│  Rzx(theta/2) │┌───┐│  Rzx(-theta/2) │├───┤┌───┐
+            q_1: ┤ H ├┤0              ├┤ X ├┤0               ├┤ X ├┤ H ├
+                 └───┘└───────────────┘└───┘└────────────────┘└───┘└───┘
+        """
+        reverse_rzx_dag = DAGCircuit()
+        qr = QuantumRegister(2)
+        reverse_rzx_dag.add_qreg(qr)
+        reverse_rzx_dag.apply_operation_back(HGate(), [qr[0]], [])
+        reverse_rzx_dag.apply_operation_back(HGate(), [qr[1]], [])
+        reverse_rzx_dag.apply_operation_back(RZXGate(theta / 2), [qr[1], qr[0]], [])
+        reverse_rzx_dag.apply_operation_back(XGate(), [qr[1]], [])
+        reverse_rzx_dag.apply_operation_back(RZXGate(-theta / 2), [qr[1], qr[0]], [])
+        reverse_rzx_dag.apply_operation_back(XGate(), [qr[1]], [])
+        reverse_rzx_dag.apply_operation_back(HGate(), [qr[0]], [])
+        reverse_rzx_dag.apply_operation_back(HGate(), [qr[1]], [])
+        return reverse_rzx_dag
+
+    def run(self, dag: DAGCircuit):
+        """Run the EchoRZXWeylDecomposition pass on `dag`.
+
+        Rewrites two-qubit gates in an arbitrary circuit in terms of echoed cross-resonance
+        gates by computing the Weyl decomposition of the corresponding unitary. Modifies the
+        input dag.
+
+        Args:
+            dag (DAGCircuit): DAG to rewrite.
+
+        Returns:
+            DAGCircuit: The modified dag.
+
+        Raises:
+            TranspilerError: If the circuit cannot be rewritten.
+        """
+
+        # pylint: disable=cyclic-import
+        from qiskit.quantum_info import Operator
+        from qiskit.synthesis.two_qubit.two_qubit_decompose import TwoQubitControlledUDecomposer
+
+        if len(dag.qregs) > 1:
+            raise TranspilerError(
+                "EchoRZXWeylDecomposition expects a single qreg input DAG,"
+                f"but input DAG had qregs: {dag.qregs}."
+            )
+
+        trivial_layout = Layout.generate_trivial_layout(*dag.qregs.values())
+
+        decomposer = TwoQubitControlledUDecomposer(RZXGate)
+
+        for node in dag.two_qubit_ops():
+
+            unitary = Operator(node.op).data
+            dag_weyl = circuit_to_dag(decomposer(unitary))
+            dag.substitute_node_with_dag(node, dag_weyl)
+
+        for node in dag.two_qubit_ops():
+            if node.name == "rzx":
+                control = node.qargs[0]
+                target = node.qargs[1]
+
+                physical_q0 = trivial_layout[control]
+                physical_q1 = trivial_layout[target]
+
+                is_native = self._is_native((physical_q0, physical_q1))
+
+                theta = node.op.params[0]
+                if is_native:
+                    dag.substitute_node_with_dag(node, self._echo_rzx_dag(theta))
+                else:
+                    dag.substitute_node_with_dag(node, self._reverse_echo_rzx_dag(theta))
+
+        return dag

qiskit/transpiler/passes/optimization/elide_permutations.py

@@ -0,0 +1,114 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+
+"""Remove any swap gates in the circuit by pushing it through into a qubit permutation."""
+
+import logging
+
+from qiskit.circuit.library.standard_gates import SwapGate
+from qiskit.circuit.library.generalized_gates import PermutationGate
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.layout import Layout
+
+logger = logging.getLogger(__name__)
+
+
+class ElidePermutations(TransformationPass):
+    r"""Remove permutation operations from a pre-layout circuit
+
+    This pass is intended to be run before a layout (mapping virtual qubits
+    to physical qubits) is set during the transpilation pipeline. This
+    pass iterates over the :class:`~.DAGCircuit` and when a :class:`~.SwapGate`
+    or :class:`~.PermutationGate` are encountered it permutes the virtual qubits in
+    the circuit and removes the swap gate. This will effectively remove any
+    :class:`~SwapGate`\s or :class:`~PermutationGate` in the circuit prior to running
+    layout. If this pass is run after a layout has been set it will become a no-op
+    (and log a warning) as this optimization is not sound after physical qubits are
+    selected and there are connectivity constraints to adhere to.
+
+    For tracking purposes this pass sets 3 values in the property set if there
+    are any :class:`~.SwapGate` or :class:`~.PermutationGate` objects in the circuit
+    and the pass isn't a no-op.
+
+    * ``original_layout``: The trivial :class:`~.Layout` for the input to this pass being run
+    * ``original_qubit_indices``: The mapping of qubit objects to positional indices for the state
+        of the circuit as input to this pass.
+    * ``virtual_permutation_layout``: A :class:`~.Layout` object mapping input qubits to the output
+        state after eliding permutations.
+
+    These three properties are needed for the transpiler to track the permutations in the out
+    :attr:`.QuantumCircuit.layout` attribute. The elision of permutations is equivalent to a
+    ``final_layout`` set by routing and all three of these attributes are needed in the case
+    """
+
+    def run(self, dag):
+        """Run the ElidePermutations pass on ``dag``.
+
+        Args:
+            dag (DAGCircuit): the DAG to be optimized.
+
+        Returns:
+            DAGCircuit: the optimized DAG.
+        """
+        if self.property_set["layout"] is not None:
+            logger.warning(
+                "ElidePermutations is not valid after a layout has been set. This indicates "
+                "an invalid pass manager construction."
+            )
+            return dag
+
+        op_count = dag.count_ops(recurse=False)
+        if op_count.get("swap", 0) == 0 and op_count.get("permutation", 0) == 0:
+            return dag
+
+        new_dag = dag.copy_empty_like()
+        qubit_mapping = list(range(len(dag.qubits)))
+
+        def _apply_mapping(qargs):
+            return tuple(dag.qubits[qubit_mapping[dag.find_bit(qubit).index]] for qubit in qargs)
+
+        for node in dag.topological_op_nodes():
+            if not isinstance(node.op, (SwapGate, PermutationGate)):
+                new_dag.apply_operation_back(
+                    node.op, _apply_mapping(node.qargs), node.cargs, check=False
+                )
+            elif getattr(node.op, "condition", None) is not None:
+                new_dag.apply_operation_back(
+                    node.op, _apply_mapping(node.qargs), node.cargs, check=False
+                )
+            elif isinstance(node.op, SwapGate):
+                index_0 = dag.find_bit(node.qargs[0]).index
+                index_1 = dag.find_bit(node.qargs[1]).index
+                qubit_mapping[index_1], qubit_mapping[index_0] = (
+                    qubit_mapping[index_0],
+                    qubit_mapping[index_1],
+                )
+            elif isinstance(node.op, PermutationGate):
+                starting_indices = [qubit_mapping[dag.find_bit(qarg).index] for qarg in node.qargs]
+                pattern = node.op.params[0]
+                pattern_indices = [qubit_mapping[idx] for idx in pattern]
+                for i, j in zip(starting_indices, pattern_indices):
+                    qubit_mapping[i] = j
+        input_qubit_mapping = {qubit: index for index, qubit in enumerate(dag.qubits)}
+        self.property_set["original_layout"] = Layout(input_qubit_mapping)
+        if self.property_set["original_qubit_indices"] is None:
+            self.property_set["original_qubit_indices"] = input_qubit_mapping
+
+        new_layout = Layout({dag.qubits[out]: idx for idx, out in enumerate(qubit_mapping)})
+        if current_layout := self.property_set["virtual_permutation_layout"]:
+            self.property_set["virtual_permutation_layout"] = new_layout.compose(
+                current_layout.inverse(dag.qubits, dag.qubits), dag.qubits
+            )
+        else:
+            self.property_set["virtual_permutation_layout"] = new_layout
+        return new_dag