qiskit 1.4.2__cp39-abi3-win_amd64.whl → 2.0.0rc2__cp39-abi3-win_amd64.whl

qiskit/transpiler/passes/calibration/rzx_templates.py

@@ -1,58 +0,0 @@
-# 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.
-
-"""
-Convenience function to load RZXGate based templates.
-"""
-
-from enum import Enum
-from typing import List, Dict
-from qiskit.utils import deprecate_func
-
-from qiskit.circuit.library.templates import rzx
-
-
-@deprecate_func(
-    since="1.4",
-    removal_timeline="in Qiskit 2.0",
-    additional_msg="Use the functions in "
-    "qiskit.circuit.library.templates.rzx instead to generate rzx templates",
-)
-def rzx_templates(template_list: List[str] = None) -> Dict:
-    """Convenience function to get the cost_dict and templates for template matching.
-
-    Args:
-        template_list: List of instruction names.
-
-    Returns:
-        Decomposition templates and cost values.
-    """
-
-    class RZXTemplateMap(Enum):
-        """Mapping of instruction name to decomposition template."""
-
-        ZZ1 = rzx.rzx_zz1()
-        ZZ2 = rzx.rzx_zz2()
-        ZZ3 = rzx.rzx_zz3()
-        YZ = rzx.rzx_yz()
-        XZ = rzx.rzx_xz()
-        CY = rzx.rzx_cy()
-
-    if template_list is None:
-        template_list = ["zz1", "zz2", "zz3", "yz", "xz", "cy"]
-
-    templates = [RZXTemplateMap[gate.upper()].value for gate in template_list]
-    cost_dict = {"rzx": 0, "cx": 6, "rz": 0, "sx": 1, "p": 0, "h": 1, "rx": 1, "ry": 1}
-
-    rzx_dict = {"template_list": templates, "user_cost_dict": cost_dict}
-
-    return rzx_dict

qiskit/transpiler/passes/optimization/cx_cancellation.py

@@ -1,65 +0,0 @@
-# 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

@@ -1,162 +0,0 @@
-# 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.utils.deprecate_pulse import deprecate_pulse_dependency
-
-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.
-    """
-
-    @deprecate_pulse_dependency
-    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
-
-        .. code-block:: text
-
-                 ┌───────────────┐┌───┐┌────────────────┐┌───┐
-            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
-
-        .. code-block:: text
-
-                 ┌───┐┌───────────────┐     ┌────────────────┐┌───┐
-            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/normalize_rx_angle.py

@@ -1,157 +0,0 @@
-# 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.
-
-"""Performs three optimizations to reduce the number of pulse calibrations for
-the single-pulse RX gates:
-Wrap RX Gate rotation angles into [0, pi] by sandwiching them with RZ gates.
-Convert RX(pi/2) to SX, and RX(pi) to X if the calibrations exist in the target.
-Quantize the RX rotation angles by assigning the same value for the angles
-that differ within a resolution provided by the user.
-"""
-
-import numpy as np
-
-from qiskit.utils import deprecate_func
-
-from qiskit.transpiler.basepasses import TransformationPass
-from qiskit.dagcircuit import DAGCircuit
-from qiskit.circuit.library.standard_gates import RXGate, RZGate, SXGate, XGate
-
-
-class NormalizeRXAngle(TransformationPass):
-    """Normalize theta parameter of RXGate instruction.
-
-    The parameter normalization is performed with following steps.
-
-    1) Wrap RX Gate theta into [0, pi]. When theta is negative value, the gate is
-    decomposed into the following sequence.
-
-    .. code-block::
-
-          ┌───────┐┌─────────┐┌────────┐
-       q: ┤ Rz(π) ├┤ Rx(|θ|) ├┤ Rz(-π) ├
-          └───────┘└─────────┘└────────┘
-
-    2) If the operation is supported by target, convert RX(pi/2) to SX, and RX(pi) to X.
-
-    3) Quantize theta value according to the user-specified resolution.
-
-    This will help reduce the size of calibration data sent over the wire,
-    and allow us to exploit the more accurate, hardware-calibrated pulses.
-    Note that pulse calibration might be attached per each rotation angle.
-    """
-
-    @deprecate_func(
-        since="1.4",
-        removal_timeline="in Qiskit 2.0",
-        additional_msg="This pass was used as pre-processing step of ``RXCalibrationBuilder``."
-        " With the removal of Pulse in Qiskit 2.0, this pass is no longer needed.",
-    )
-    def __init__(self, target=None, resolution_in_radian=0):
-        """NormalizeRXAngle initializer.
-
-        Args:
-            target (Target): The :class:`~.Target` representing the target backend.
-                If the target contains SX and X calibrations, this pass will replace the
-                corresponding RX gates with SX and X gates.
-            resolution_in_radian (float): Resolution for RX rotation angle quantization.
-                If set to zero, this pass won't modify the rotation angles in the given DAG.
-                (=Provides arbitrary-angle RX)
-        """
-        super().__init__()
-        self.target = target
-        self.resolution_in_radian = resolution_in_radian
-        self.already_generated = {}
-
-    def quantize_angles(self, qubit, original_angle):
-        """Quantize the RX rotation angles by assigning the same value for the angles
-        that differ within a resolution provided by the user.
-
-        Args:
-            qubit (qiskit.circuit.Qubit): This will be the dict key to access the list of
-                quantized rotation angles.
-            original_angle (float): Original rotation angle, before quantization.
-
-        Returns:
-            float: Quantized angle.
-        """
-
-        if (angles := self.already_generated.get(qubit)) is None:
-            self.already_generated[qubit] = np.array([original_angle])
-            return original_angle
-        similar_angles = angles[
-            np.isclose(angles, original_angle, atol=self.resolution_in_radian / 2)
-        ]
-        if similar_angles.size == 0:
-            self.already_generated[qubit] = np.append(angles, original_angle)
-            return original_angle
-        return float(similar_angles[0])
-
-    def run(self, dag):
-        """Run the NormalizeRXAngle pass on ``dag``.
-
-        Args:
-            dag (DAGCircuit): The DAG to be optimized.
-
-        Returns:
-            DAGCircuit: A DAG with RX gate calibration.
-        """
-
-        # Iterate over all op_nodes and replace RX if eligible for modification.
-        for op_node in dag.op_nodes():
-            if not isinstance(op_node.op, RXGate):
-                continue
-
-            raw_theta = op_node.op.params[0]
-            wrapped_theta = np.arctan2(np.sin(raw_theta), np.cos(raw_theta))  # [-pi, pi]
-
-            if self.resolution_in_radian:
-                wrapped_theta = self.quantize_angles(op_node.qargs[0], wrapped_theta)
-
-            half_pi_rotation = np.isclose(
-                abs(wrapped_theta), np.pi / 2, atol=self.resolution_in_radian / 2
-            )
-            pi_rotation = np.isclose(abs(wrapped_theta), np.pi, atol=self.resolution_in_radian / 2)
-
-            should_modify_node = (
-                (wrapped_theta != raw_theta)
-                or (wrapped_theta < 0)
-                or half_pi_rotation
-                or pi_rotation
-            )
-
-            if should_modify_node:
-                mini_dag = DAGCircuit()
-                mini_dag.add_qubits(op_node.qargs)
-
-                # new X-rotation gate with angle in [0, pi]
-                if half_pi_rotation:
-                    physical_qubit_idx = dag.find_bit(op_node.qargs[0]).index
-                    if self.target.instruction_supported("sx", (physical_qubit_idx,)):
-                        mini_dag.apply_operation_back(SXGate(), qargs=op_node.qargs)
-                elif pi_rotation:
-                    physical_qubit_idx = dag.find_bit(op_node.qargs[0]).index
-                    if self.target.instruction_supported("x", (physical_qubit_idx,)):
-                        mini_dag.apply_operation_back(XGate(), qargs=op_node.qargs)
-                else:
-                    mini_dag.apply_operation_back(
-                        RXGate(np.abs(wrapped_theta)), qargs=op_node.qargs
-                    )
-
-                # sandwich with RZ if the intended rotation angle was negative
-                if wrapped_theta < 0:
-                    mini_dag.apply_operation_front(RZGate(np.pi), qargs=op_node.qargs)
-                    mini_dag.apply_operation_back(RZGate(-np.pi), qargs=op_node.qargs)
-
-                dag.substitute_node_with_dag(node=op_node, input_dag=mini_dag, wires=op_node.qargs)
-
-        return dag