qiskit 1.3.0__cp39-abi3-win32.whl

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.
+    """

qiskit/transpiler/passes/calibration/pulse_gate.py

@@ -0,0 +1,100 @@
+# 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.
+
+"""Instruction schedule map reference pass."""
+
+from typing import List, Union
+
+from qiskit.circuit import Instruction as CircuitInst
+from qiskit.pulse import Schedule, ScheduleBlock
+from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap
+from qiskit.transpiler.target import Target
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
+
+from .base_builder import CalibrationBuilder
+
+
+class PulseGates(CalibrationBuilder):
+    """Pulse gate adding pass.
+
+    This pass adds gate calibrations from the supplied ``InstructionScheduleMap``
+    to a quantum circuit.
+
+    This pass checks each DAG circuit node and acquires a corresponding schedule from
+    the instruction schedule map object that may be provided by the target backend.
+    Because this map is a mutable object, the end-user can provide a configured backend to
+    execute the circuit with customized gate implementations.
+
+    This mapping object returns a schedule with "publisher" metadata which is an integer Enum
+    value representing who created the gate schedule.
+    If the gate schedule is provided by end-users, this pass attaches the schedule to
+    the DAG circuit as a calibration.
+
+    This pass allows users to easily override quantum circuit with custom gate definitions
+    without directly dealing with those schedules.
+
+    References
+        * [1] OpenQASM 3: A broader and deeper quantum assembly language
+          https://arxiv.org/abs/2104.14722
+    """
+
+    @deprecate_pulse_dependency
+    def __init__(
+        self,
+        inst_map: InstructionScheduleMap = None,
+        target: Target = None,
+    ):
+        """Create new pass.
+
+        Args:
+            inst_map: Instruction schedule map that user may override.
+            target: The :class:`~.Target` representing the target backend, if both
+                ``inst_map`` and ``target`` are specified then it updates instructions
+                in the ``target`` with ``inst_map``.
+        """
+        super().__init__()
+
+        if inst_map is None and target is None:
+            raise TranspilerError("inst_map and target cannot be None simulataneously.")
+
+        if target is None:
+            target = Target()
+            target.update_from_instruction_schedule_map(inst_map)
+        self.target = target
+
+    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.
+        """
+        return self.target._has_calibration(node_op.name, tuple(qubits))
+
+    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.
+
+        Raises:
+            TranspilerError: When node is parameterized and calibration is raw schedule object.
+        """
+        return self.target._get_calibration(node_op.name, tuple(qubits), *node_op.params)

qiskit/transpiler/passes/calibration/rx_builder.py

@@ -0,0 +1,164 @@
+# 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.
+
+"""Add single-pulse RX calibrations that are bootstrapped from the SX calibration."""
+
+from typing import Union
+from functools import lru_cache
+import numpy as np
+
+from qiskit.circuit import Instruction
+from qiskit.circuit.library.standard_gates import RXGate
+from qiskit.exceptions import QiskitError
+from qiskit.pulse import Schedule, ScheduleBlock, builder, ScalableSymbolicPulse
+from qiskit.pulse.channels import Channel
+from qiskit.pulse.library.symbolic_pulses import Drag
+from qiskit.transpiler.passes.calibration.base_builder import CalibrationBuilder
+from qiskit.transpiler.target import Target
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
+
+
+class RXCalibrationBuilder(CalibrationBuilder):
+    """Add single-pulse RX calibrations that are bootstrapped from the SX calibration.
+
+    .. note::
+
+        Requirement: NormalizeRXAngles pass (one of the optimization passes).
+
+    It is recommended to place this pass in the post-optimization stage of a passmanager.
+    A simple demo:
+
+    .. code-block:: python
+
+       from qiskit.providers.fake_provider import GenericBackendV2
+       from qiskit.transpiler import PassManager, PassManagerConfig
+       from qiskit.transpiler.preset_passmanagers import level_1_pass_manager
+       from qiskit.circuit import Parameter
+       from qiskit.circuit.library import QuantumVolume
+       from qiskit.circuit.library.standard_gates import RXGate
+
+       from qiskit.transpiler.passes import RXCalibrationBuilder
+
+       qv = QuantumVolume(4, 4, seed=1004)
+
+       # Transpiling with single pulse RX gates enabled
+       backend_with_single_pulse_rx = GenericBackendV2(5)
+       rx_inst_props = {}
+       for i in range(backend_with_single_pulse_rx.num_qubits):
+         rx_inst_props[(i,)] = None
+       backend_with_single_pulse_rx.target.add_instruction(RXGate(Parameter("theta")), rx_inst_props)
+       config_with_rx = PassManagerConfig.from_backend(backend=backend_with_single_pulse_rx)
+       pm_with_rx = level_1_pass_manager(pass_manager_config=config_with_rx)
+       rx_builder = RXCalibrationBuilder(target=backend_with_single_pulse_rx.target)
+       pm_with_rx.post_optimization = PassManager([rx_builder])
+       transpiled_circ_with_single_pulse_rx = pm_with_rx.run(qv)
+       transpiled_circ_with_single_pulse_rx.count_ops()
+
+       # Conventional transpilation: each RX gate is decomposed into a sequence with two SX gates
+       original_backend = GenericBackendV2(5)
+       original_config = PassManagerConfig.from_backend(backend=original_backend)
+       original_pm = level_1_pass_manager(pass_manager_config=original_config)
+       original_transpiled_circ = original_pm.run(qv)
+       original_transpiled_circ.count_ops()
+
+    References
+        * [1]: Gokhale et al. (2020), Optimized Quantum Compilation for
+          Near-Term Algorithms with OpenPulse.
+          `arXiv:2004.11205 <https://arxiv.org/abs/2004.11205>`
+    """
+
+    @deprecate_pulse_dependency
+    def __init__(
+        self,
+        target: Target = None,
+    ):
+        """Bootstrap single-pulse RX gate calibrations from the
+        (hardware-calibrated) SX gate calibration.
+
+        Args:
+            target (Target): Should contain a SX calibration that will be
+            used for bootstrapping RX calibrations.
+        """
+        from qiskit.transpiler.passes.optimization import NormalizeRXAngle
+
+        super().__init__()
+        self.target = target
+        self.already_generated = {}
+        self.requires = [NormalizeRXAngle(self.target)]
+
+    def supported(self, node_op: Instruction, qubits: list) -> bool:
+        """
+        Check if the calibration for SX gate exists and it's a single DRAG pulse.
+        """
+        return (
+            isinstance(node_op, RXGate)
+            and self.target._has_calibration("sx", tuple(qubits))
+            and (len(self.target._get_calibration("sx", tuple(qubits)).instructions) == 1)
+            and isinstance(
+                self.target._get_calibration("sx", tuple(qubits)).instructions[0][1].pulse,
+                ScalableSymbolicPulse,
+            )
+            and self.target._get_calibration("sx", tuple(qubits))
+            .instructions[0][1]
+            .pulse.pulse_type
+            == "Drag"
+        )
+
+    def get_calibration(self, node_op: Instruction, qubits: list) -> Union[Schedule, ScheduleBlock]:
+        """
+        Generate RX calibration for the rotation angle specified in node_op.
+        """
+        # already within [0, pi] by NormalizeRXAngles pass
+        angle = node_op.params[0]
+
+        try:
+            angle = float(angle)
+        except TypeError as ex:
+            raise QiskitError("Target rotation angle is not assigned.") from ex
+
+        params = (
+            self.target._get_calibration("sx", tuple(qubits))
+            .instructions[0][1]
+            .pulse.parameters.copy()
+        )
+        new_rx_sched = _create_rx_sched(
+            rx_angle=angle,
+            channel=self.target._get_calibration("sx", tuple(qubits)).channels[0],
+            duration=params["duration"],
+            amp=params["amp"],
+            sigma=params["sigma"],
+            beta=params["beta"],
+        )
+
+        return new_rx_sched
+
+
+@lru_cache
+def _create_rx_sched(
+    rx_angle: float,
+    duration: int,
+    amp: float,
+    sigma: float,
+    beta: float,
+    channel: Channel,
+):
+    """Generates (and caches) pulse calibrations for RX gates.
+    Assumes that the rotation angle is in [0, pi].
+    """
+    new_amp = rx_angle / (np.pi / 2) * amp
+    with builder.build() as new_rx_sched:
+        builder.play(
+            Drag(duration=duration, amp=new_amp, sigma=sigma, beta=beta, angle=0),
+            channel=channel,
+        )
+
+    return new_rx_sched