qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.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,175 @@
+# 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.circuit.equivalence_library import EquivalenceLibrary
+from qiskit.converters import circuit_to_dag
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
+from qiskit.exceptions import QiskitError
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.basis.basis_translator import BasisTranslator
+from qiskit.transpiler.target import Target
+
+
+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,88 @@
+# 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):
+                dag.substitute_node(
+                    node, control_flow.map_blocks(self.run, node.op), propagate_condition=False
+                )
+                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 physical 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. "
+                    f"No rule to expand instruction {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,109 @@
+# 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
+
+        device_insts = {"measure", "reset", "barrier", "snapshot", "delay", "store"}
+        if self._target is None:
+            device_insts |= set(self._basis_gates)
+
+        for node in dag.op_nodes():
+            if isinstance(node.op, ControlFlowOp):
+                dag.substitute_node(
+                    node, control_flow.map_blocks(self.run, node.op), propagate_condition=False
+                )
+                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:
+                if self._target is not None:
+                    inst_supported = self._target.instruction_supported(
+                        operation_name=node.op.name,
+                        qargs=tuple(dag.find_bit(x).index for x in node.qargs),
+                    )
+                else:
+                    inst_supported = 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(
+                    f"Cannot unroll the circuit to the given basis, {str(self._basis_gates)}. "
+                    f"Instruction {node.op.name} not found in equivalence library "
+                    "and no rule found to expand."
+                )
+
+            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/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

qiskit/transpiler/passes/calibration/base_builder.py

@@ -0,0 +1,79 @@
+# 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.
+
+"""Calibration builder base class."""
+
+from abc import abstractmethod
+from typing import List, Union
+
+from qiskit.circuit import Instruction as CircuitInst
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.pulse import Schedule, ScheduleBlock
+from qiskit.pulse.calibration_entries import CalibrationPublisher
+from qiskit.transpiler.basepasses import TransformationPass
+
+from .exceptions import CalibrationNotAvailable
+
+
+class CalibrationBuilder(TransformationPass):
+    """Abstract base class to inject calibrations into circuits."""
+
+    @abstractmethod
+    def supported(self, node_op: CircuitInst, qubits: List) -> bool:
+        """Determine if a given node supports the calibration.
+
+        Args:
+            node_op: Target instruction object.
+            qubits: Integer qubit indices to check.
+
+        Returns:
+            Return ``True`` is calibration can be provided.
+        """
+
+    @abstractmethod
+    def get_calibration(self, node_op: CircuitInst, qubits: List) -> Union[Schedule, ScheduleBlock]:
+        """Gets the calibrated schedule for the given instruction and qubits.
+
+        Args:
+            node_op: Target instruction object.
+            qubits: Integer qubit indices to check.
+
+        Returns:
+            Return Schedule of target gate instruction.
+        """
+
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
+        """Run the calibration adder pass on `dag`.
+
+        Args:
+            dag: DAG to schedule.
+
+        Returns:
+            A DAG with calibrations added to it.
+        """
+        for node in dag.gate_nodes():
+            qubits = [dag.find_bit(q).index for q in node.qargs]
+
+            if self.supported(node.op, qubits) and not dag.has_calibration_for(node):
+                # calibration can be provided and no user-defined calibration is already provided
+                try:
+                    schedule = self.get_calibration(node.op, qubits)
+                except CalibrationNotAvailable:
+                    # Fail in schedule generation. Just ignore.
+                    continue
+                publisher = schedule.metadata.get("publisher", CalibrationPublisher.QISKIT)
+
+                # add calibration if it is not backend default
+                if publisher != CalibrationPublisher.BACKEND_PROVIDER:
+                    dag.add_calibration(gate=node.op, qubits=qubits, schedule=schedule)
+
+        return dag

qiskit/transpiler/passes/calibration/builders.py

@@ -0,0 +1,20 @@
+# 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.
+
+"""Calibration creators."""
+
+# TODO This import path will be deprecated.
+
+# pylint: disable=unused-import
+from .pulse_gate import PulseGates
+from .rzx_builder import RZXCalibrationBuilder, RZXCalibrationBuilderNoEcho
+from .rx_builder import RXCalibrationBuilder

qiskit/transpiler/passes/calibration/exceptions.py

@@ -0,0 +1,22 @@
+# 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.
+
+"""Exception for errors raised by the calibration pass module."""
+from qiskit.exceptions import QiskitError
+
+
+class CalibrationNotAvailable(QiskitError):
+    """Raised when calibration generation fails.
+
+    .. note::
+        This error is meant to caught by CalibrationBuilder and ignored.
+    """