qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/transpiler/passes/basis/decompose.py

@@ -0,0 +1,98 @@
+# 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.
+
+"""Expand a gate in a circuit using its decomposition rules."""
+from typing import Type, Union, List, Optional
+from fnmatch import fnmatch
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
+from qiskit.converters.circuit_to_dag import circuit_to_dag
+from qiskit.circuit.gate import Gate
+
+
+class Decompose(TransformationPass):
+    """Expand a gate in a circuit using its decomposition rules."""
+
+    def __init__(
+        self,
+        gates_to_decompose: Optional[Union[Type[Gate], List[Type[Gate]], List[str], str]] = None,
+    ) -> None:
+        """Decompose initializer.
+
+        Args:
+            gates_to_decompose: optional subset of gates to be decomposed,
+                identified by gate label, name or type. Defaults to all gates.
+        """
+        super().__init__()
+        self.gates_to_decompose = gates_to_decompose
+
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
+        """Run the Decompose pass on `dag`.
+
+        Args:
+            dag: input dag.
+
+        Returns:
+            output dag where ``gate`` was expanded.
+        """
+        # Walk through the DAG and expand each non-basis node
+        for node in dag.op_nodes():
+            if self._should_decompose(node):
+                if getattr(node.op, "definition", None) is None:
+                    continue
+                # TODO: allow choosing among multiple decomposition rules
+                rule = node.op.definition.data
+                if (
+                    len(rule) == 1
+                    and len(node.qargs) == len(rule[0].qubits) == 1  # to preserve gate order
+                    and len(node.cargs) == len(rule[0].clbits) == 0
+                ):
+                    if node.op.definition.global_phase:
+                        dag.global_phase += node.op.definition.global_phase
+                    dag.substitute_node(node, rule[0].operation, inplace=True)
+                else:
+                    decomposition = circuit_to_dag(node.op.definition)
+                    dag.substitute_node_with_dag(node, decomposition)
+
+        return dag
+
+    def _should_decompose(self, node) -> bool:
+        """Call a decomposition pass on this circuit,
+        to decompose one level (shallow decompose)."""
+        if self.gates_to_decompose is None:  # check if no gates given
+            return True
+
+        if not isinstance(self.gates_to_decompose, list):
+            gates = [self.gates_to_decompose]
+        else:
+            gates = self.gates_to_decompose
+
+        strings_list = [s for s in gates if isinstance(s, str)]
+        gate_type_list = [g for g in gates if isinstance(g, type)]
+
+        if (
+            getattr(node.op, "label", None) is not None
+            and node.op.label != ""
+            and (  # check if label or label wildcard is given
+                node.op.label in gates or any(fnmatch(node.op.label, p) for p in strings_list)
+            )
+        ):
+            return True
+        elif node.name in gates or any(  # check if name or name wildcard is given
+            fnmatch(node.name, p) for p in strings_list
+        ):
+            return True
+        elif any(isinstance(node.op, op) for op in gate_type_list):  # check if Gate type given
+            return True
+        else:
+            return False

qiskit/transpiler/passes/basis/translate_parameterized.py

@@ -0,0 +1,177 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# 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.
+
+"""Translate parameterized gates only, and leave others as they are."""
+
+from __future__ import annotations
+
+from qiskit.circuit import Instruction, ParameterExpression, Qubit, Clbit
+from qiskit.converters import circuit_to_dag
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
+from qiskit.circuit.equivalence_library import EquivalenceLibrary
+from qiskit.exceptions import QiskitError
+from qiskit.transpiler import Target
+
+from qiskit.transpiler.basepasses import TransformationPass
+
+from .basis_translator import BasisTranslator
+
+
+class TranslateParameterizedGates(TransformationPass):
+    """Translate parameterized gates to a supported basis set.
+
+    Once a parameterized instruction is found that is not in the ``supported_gates`` list,
+    the instruction is decomposed one level and the parameterized sub-blocks are recursively
+    decomposed. The recursion is stopped once all parameterized gates are in ``supported_gates``,
+    or if a gate has no definition and a translation to the basis is attempted (this might happen
+    e.g. for the ``UGate`` if it's not in the specified gate list).
+
+    Example:
+
+        The following, multiply nested circuit::
+
+            from qiskit.circuit import QuantumCircuit, ParameterVector
+            from qiskit.transpiler.passes import TranslateParameterizedGates
+
+            x = ParameterVector("x", 4)
+            block1 = QuantumCircuit(1)
+            block1.rx(x[0], 0)
+
+            sub_block = QuantumCircuit(2)
+            sub_block.cx(0, 1)
+            sub_block.rz(x[2], 0)
+
+            block2 = QuantumCircuit(2)
+            block2.ry(x[1], 0)
+            block2.append(sub_block.to_gate(), [0, 1])
+
+            block3 = QuantumCircuit(3)
+            block3.ccx(0, 1, 2)
+
+            circuit = QuantumCircuit(3)
+            circuit.append(block1.to_gate(), [1])
+            circuit.append(block2.to_gate(), [0, 1])
+            circuit.append(block3.to_gate(), [0, 1, 2])
+            circuit.cry(x[3], 0, 2)
+
+            supported_gates = ["rx", "ry", "rz", "cp", "crx", "cry", "crz"]
+            unrolled = TranslateParameterizedGates(supported_gates)(circuit)
+
+        is decomposed to::
+
+                 ┌──────────┐     ┌──────────┐┌─────────────┐
+            q_0: ┤ Ry(x[1]) ├──■──┤ Rz(x[2]) ├┤0            ├─────■──────
+                 ├──────────┤┌─┴─┐└──────────┘│             │     │
+            q_1: ┤ Rx(x[0]) ├┤ X ├────────────┤1 circuit-92 ├─────┼──────
+                 └──────────┘└───┘            │             │┌────┴─────┐
+            q_2: ─────────────────────────────┤2            ├┤ Ry(x[3]) ├
+                                              └─────────────┘└──────────┘
+
+    """
+
+    def __init__(
+        self,
+        supported_gates: list[str] | None = None,
+        equivalence_library: EquivalenceLibrary | None = None,
+        target: Target | None = None,
+    ) -> None:
+        """
+        Args:
+            supported_gates: A list of suppported basis gates specified as string. If ``None``,
+                a ``target`` must be provided.
+            equivalence_library: The equivalence library to translate the gates. Defaults
+                to the equivalence library of all Qiskit standard gates.
+            target: A :class:`.Target` containing the supported operations. If ``None``,
+                ``supported_gates`` must be set. Note that this argument takes precedence over
+                ``supported_gates``, if both are set.
+
+        Raises:
+            ValueError: If neither of ``supported_gates`` and ``target`` are passed.
+        """
+        super().__init__()
+
+        # get the default equivalence library, if none has been set
+        if equivalence_library is None:
+            from qiskit.circuit.library.standard_gates.equivalence_library import _sel
+
+            equivalence_library = _sel
+
+        # The target takes precedence over the supported_gates argument. If neither are set,
+        # raise an error.
+        if target is not None:
+            supported_gates = target.operation_names
+        elif supported_gates is None:
+            raise ValueError("One of ``supported_gates`` or ``target`` must be specified.")
+
+        self._supported_gates = supported_gates
+        self._target = target
+        self._translator = BasisTranslator(equivalence_library, supported_gates, target=target)
+
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
+        """Run the transpiler pass.
+
+        Args:
+            dag: The DAG circuit in which the parameterized gates should be unrolled.
+
+        Returns:
+            A DAG where the parameterized gates have been unrolled.
+
+        Raises:
+            QiskitError: If the circuit cannot be unrolled.
+        """
+        for node in dag.op_nodes():
+            # check whether it is parameterized and we need to decompose it
+            if _is_parameterized(node.op) and not _is_supported(
+                node, self._supported_gates, self._target
+            ):
+                definition = node.op.definition
+
+                if definition is not None:
+                    # recurse to unroll further parameterized blocks
+                    unrolled = self.run(circuit_to_dag(definition))
+                else:
+                    # if we hit a base case, try to translate to the specified basis
+                    try:
+                        unrolled = self._translator.run(_instruction_to_dag(node.op))
+                    except Exception as exc:
+                        raise QiskitError("Failed to translate final block.") from exc
+
+                # replace with unrolled (or translated) dag
+                dag.substitute_node_with_dag(node, unrolled)
+
+        return dag
+
+
+def _is_parameterized(op: Instruction) -> bool:
+    return any(
+        isinstance(param, ParameterExpression) and len(param.parameters) > 0 for param in op.params
+    )
+
+
+def _is_supported(node: DAGOpNode, supported_gates: list[str], target: Target | None) -> bool:
+    """Check whether the node is supported.
+
+    If the target is provided, check using the target, otherwise the supported_gates are used.
+    """
+    if target is not None:
+        return target.instruction_supported(node.op.name)
+
+    return node.op.name in supported_gates
+
+
+def _instruction_to_dag(op: Instruction) -> DAGCircuit:
+    dag = DAGCircuit()
+    dag.add_qubits([Qubit() for _ in range(op.num_qubits)])
+    dag.add_qubits([Clbit() for _ in range(op.num_clbits)])
+    dag.apply_operation_back(op, dag.qubits, dag.clbits, check=False)
+
+    return dag

qiskit/transpiler/passes/basis/unroll_3q_or_more.py

@@ -0,0 +1,86 @@
+# 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.
+
+"""Recursively expands 3q+ gates until the circuit only contains 2q or 1q gates."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils import control_flow
+from qiskit.exceptions import QiskitError
+from qiskit.circuit import ControlFlowOp
+from qiskit.converters.circuit_to_dag import circuit_to_dag
+
+
+class Unroll3qOrMore(TransformationPass):
+    """Recursively expands 3q+ gates until the circuit only contains 2q or 1q gates."""
+
+    def __init__(self, target=None, basis_gates=None):
+        """Initialize the Unroll3qOrMore pass
+
+        Args:
+            target (Target): The target object representing the compilation
+                target. If specified any multi-qubit instructions in the
+                circuit when the pass is run that are supported by the target
+                device will be left in place. If both this and ``basis_gates``
+                are specified only the target will be checked.
+            basis_gates (list): A list of basis gate names that the target
+                device supports. If specified any gate names in the circuit
+                which are present in this list will not be unrolled. If both
+                this and ``target`` are specified only the target will be used
+                for checking which gates are supported.
+        """
+        super().__init__()
+        self.target = target
+        self.basis_gates = None
+        if basis_gates is not None:
+            self.basis_gates = set(basis_gates)
+
+    def run(self, dag):
+        """Run the Unroll3qOrMore pass on `dag`.
+
+        Args:
+            dag(DAGCircuit): input dag
+        Returns:
+            DAGCircuit: output dag with maximum node degrees of 2
+        Raises:
+            QiskitError: if a 3q+ gate is not decomposable
+        """
+        for node in dag.multi_qubit_ops():
+            if dag.has_calibration_for(node):
+                continue
+
+            if isinstance(node.op, ControlFlowOp):
+                node.op = control_flow.map_blocks(self.run, node.op)
+                continue
+
+            if self.target is not None:
+                # Treat target instructions as global since this pass can be run
+                # prior to layout and routing we don't have phsyical qubits from
+                # the circuit yet
+                if node.name in self.target:
+                    continue
+            elif self.basis_gates is not None and node.name in self.basis_gates:
+                continue
+
+            # TODO: allow choosing other possible decompositions
+            rule = node.op.definition.data
+            if not rule:
+                if rule == []:  # empty node
+                    dag.remove_op_node(node)
+                    continue
+                raise QiskitError(
+                    "Cannot unroll all 3q or more gates. "
+                    "No rule to expand instruction %s." % node.op.name
+                )
+            decomposition = circuit_to_dag(node.op.definition, copy_operations=False)
+            decomposition = self.run(decomposition)  # recursively unroll
+            dag.substitute_node_with_dag(node, decomposition)
+        return dag

qiskit/transpiler/passes/basis/unroll_custom_definitions.py

@@ -0,0 +1,107 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# 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.
+
+"""Unrolls instructions with custom definitions."""
+
+from qiskit.exceptions import QiskitError
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils import control_flow
+from qiskit.circuit import ControlledGate, ControlFlowOp
+from qiskit.converters.circuit_to_dag import circuit_to_dag
+
+
+class UnrollCustomDefinitions(TransformationPass):
+    """Unrolls instructions with custom definitions."""
+
+    def __init__(self, equivalence_library, basis_gates=None, target=None, min_qubits=0):
+        """Unrolls instructions with custom definitions.
+
+        Args:
+            equivalence_library (EquivalenceLibrary): The equivalence library
+                which will be used by the BasisTranslator pass. (Instructions in
+                this library will not be unrolled by this pass.)
+            basis_gates (Optional[list[str]]): Target basis names to unroll to, e.g. ``['u3', 'cx']``.
+                Ignored if ``target`` is also specified.
+            target (Optional[Target]): The :class:`~.Target` object corresponding to the compilation
+                target. When specified, any argument specified for ``basis_gates`` is ignored.
+             min_qubits (int): The minimum number of qubits for operations in the input
+                 dag to translate.
+        """
+
+        super().__init__()
+        self._equiv_lib = equivalence_library
+        self._basis_gates = basis_gates
+        self._target = target
+        self._min_qubits = min_qubits
+
+    def run(self, dag):
+        """Run the UnrollCustomDefinitions pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): input dag
+
+        Raises:
+            QiskitError: if unable to unroll given the basis due to undefined
+            decomposition rules (such as a bad basis) or excessive recursion.
+
+        Returns:
+            DAGCircuit: output unrolled dag
+        """
+
+        if self._basis_gates is None and self._target is None:
+            return dag
+
+        if self._target is None:
+            basic_insts = {"measure", "reset", "barrier", "snapshot", "delay"}
+            device_insts = basic_insts | set(self._basis_gates)
+
+        for node in dag.op_nodes():
+            if isinstance(node.op, ControlFlowOp):
+                node.op = control_flow.map_blocks(self.run, node.op)
+                continue
+
+            if getattr(node.op, "_directive", False):
+                continue
+
+            if dag.has_calibration_for(node) or len(node.qargs) < self._min_qubits:
+                continue
+
+            controlled_gate_open_ctrl = isinstance(node.op, ControlledGate) and node.op._open_ctrl
+            if not controlled_gate_open_ctrl:
+                inst_supported = (
+                    self._target.instruction_supported(
+                        operation_name=node.op.name,
+                        qargs=tuple(dag.find_bit(x).index for x in node.qargs),
+                    )
+                    if self._target is not None
+                    else node.name in device_insts
+                )
+                if inst_supported or self._equiv_lib.has_entry(node.op):
+                    continue
+            try:
+                unrolled = getattr(node.op, "definition", None)
+            except TypeError as err:
+                raise QiskitError(f"Error decomposing node {node.name}: {err}") from err
+
+            if unrolled is None:
+                # opaque node
+                raise QiskitError(
+                    "Cannot unroll the circuit to the given basis, %s. "
+                    "Instruction %s not found in equivalence library "
+                    "and no rule found to expand." % (str(self._basis_gates), node.op.name)
+                )
+
+            decomposition = circuit_to_dag(unrolled, copy_operations=False)
+            unrolled_dag = self.run(decomposition)
+            dag.substitute_node_with_dag(node, unrolled_dag)
+
+        return dag

qiskit/transpiler/passes/basis/unroller.py

@@ -0,0 +1,145 @@
+# 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.
+
+"""Unroll a circuit to a given basis."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils import control_flow
+from qiskit.exceptions import QiskitError
+from qiskit.circuit import ControlledGate, ControlFlowOp
+from qiskit.converters.circuit_to_dag import circuit_to_dag
+from qiskit.utils.deprecation import deprecate_func
+
+
+class Unroller(TransformationPass):
+    """Unroll a circuit to a given basis.
+
+    Unroll (expand) non-basis, non-opaque instructions recursively
+    to a desired basis, using decomposition rules defined for each instruction.
+    """
+
+    @deprecate_func(
+        since="0.45.0",
+        additional_msg="This has been replaced by the `BasisTranslator` pass "
+        "and is going to be removed in Qiskit 1.0.",
+    )
+    def __init__(self, basis=None, target=None):
+        """Unroller initializer.
+
+        Args:
+            basis (list[str] or None): Target basis names to unroll to, e.g. `['u3', 'cx']` . If
+                None, does not unroll any gate.
+            target (Target):  The :class:`~.Target` representing the target backend, if both
+                ``basis`` and this are specified then this argument will take
+                precedence and ``basis`` will be ignored.
+        """
+        super().__init__()
+        self.basis = basis
+        self.target = target
+
+    def run(self, dag):
+        """Run the Unroller pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): input dag
+
+        Raises:
+            QiskitError: if unable to unroll given the basis due to undefined
+            decomposition rules (such as a bad basis) or excessive recursion.
+
+        Returns:
+            DAGCircuit: output unrolled dag
+        """
+        if self.basis is None and self.target is None:
+            return dag
+        # Walk through the DAG and expand each non-basis node
+        basic_insts = ["measure", "reset", "barrier", "snapshot", "delay"]
+        for node in dag.op_nodes():
+            if getattr(node.op, "_directive", False):
+                continue
+
+            run_qubits = None
+            if self.target is not None:
+                run_qubits = tuple(dag.find_bit(x).index for x in node.qargs)
+                if (
+                    self.target.instruction_supported(node.op.name, qargs=run_qubits)
+                    or node.op.name == "barrier"
+                ):
+                    if isinstance(node.op, ControlledGate) and node.op._open_ctrl:
+                        pass
+                    else:
+                        continue
+            else:
+                if node.name in basic_insts:
+                    # TODO: this is legacy behavior.Basis_insts should be removed that these
+                    #  instructions should be part of the device-reported basis. Currently, no
+                    #  backend reports "measure", for example.
+                    continue
+
+                if node.name in self.basis:  # If already a base, ignore.
+                    if isinstance(node.op, ControlledGate) and node.op._open_ctrl:
+                        pass
+                    else:
+                        continue
+
+            if isinstance(node.op, ControlFlowOp):
+                node.op = control_flow.map_blocks(self.run, node.op)
+                continue
+
+            try:
+                phase = node.op.definition.global_phase
+                rule = node.op.definition.data
+            except (TypeError, AttributeError) as err:
+                raise QiskitError(
+                    f"Error decomposing node of instruction '{node.name}': {err}. "
+                    f"Unable to define instruction '{node.name}' in the given basis."
+                ) from err
+
+            # Isometry gates definitions can have widths smaller than that of the
+            # original gate, in which case substitute_node will raise. Fall back
+            # to substitute_node_with_dag if an the width of the definition is
+            # different that the width of the node.
+            while rule and len(rule) == 1 and len(node.qargs) == len(rule[0].qubits) == 1:
+                if self.target is not None:
+                    if self.target.instruction_supported(rule[0].operation.name, run_qubits):
+                        dag.global_phase += phase
+                        dag.substitute_node(node, rule[0].operation, inplace=True)
+                        break
+                else:
+                    if rule[0].operation.name in self.basis:
+                        dag.global_phase += phase
+                        dag.substitute_node(node, rule[0].operation, inplace=True)
+                        break
+                try:
+                    phase += rule[0].operation.definition.global_phase
+                    rule = rule[0].operation.definition.data
+                except (TypeError, AttributeError) as err:
+                    raise QiskitError(
+                        f"Error decomposing node of instruction '{node.name}': {err}. "
+                        f"Unable to define instruction '{rule[0].operation.name}' in the basis."
+                    ) from err
+
+            else:
+                if not rule:
+                    if rule == []:  # empty node
+                        dag.remove_op_node(node)
+                        dag.global_phase += phase
+                        continue
+                    # opaque node
+                    raise QiskitError(
+                        "Cannot unroll the circuit to the given basis, %s. "
+                        "No rule to expand instruction %s." % (str(self.basis), node.op.name)
+                    )
+                decomposition = circuit_to_dag(node.op.definition)
+                unrolled_dag = self.run(decomposition)  # recursively unroll ops
+                dag.substitute_node_with_dag(node, unrolled_dag)
+        return dag

qiskit/transpiler/passes/calibration/__init__.py

@@ -0,0 +1,17 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""Module containing transpiler calibration passes."""
+
+from .pulse_gate import PulseGates
+from .rzx_builder import RZXCalibrationBuilder, RZXCalibrationBuilderNoEcho
+from .rx_builder import RXCalibrationBuilder