Add NormalizeRXAngle and RXCalibrationBuilder passes

qiskit/transpiler/passes/__init__.py

@@ -89,6 +89,7 @@
    EchoRZXWeylDecomposition
    ResetAfterMeasureSimplification
    OptimizeCliffords
+   NormalizeRXAngle
 
 Calibration
 =============
@@ -99,6 +100,7 @@
    PulseGates
    RZXCalibrationBuilder
    RZXCalibrationBuilderNoEcho
+   RXCalibrationBuilder
 
 Scheduling
 =============
@@ -234,6 +236,7 @@
 from .optimization import CollectCliffords
 from .optimization import ResetAfterMeasureSimplification
 from .optimization import OptimizeCliffords
+from .optimization import NormalizeRXAngle
 
 # circuit analysis
 from .analysis import ResourceEstimation
@@ -258,6 +261,7 @@
 from .calibration import PulseGates
 from .calibration import RZXCalibrationBuilder
 from .calibration import RZXCalibrationBuilderNoEcho
+from .calibration import RXCalibrationBuilder
 
 # circuit scheduling
 from .scheduling import TimeUnitConversion

qiskit/transpiler/passes/calibration/__init__.py

@@ -14,3 +14,4 @@
 
 from .pulse_gate import PulseGates
 from .rzx_builder import RZXCalibrationBuilder, RZXCalibrationBuilderNoEcho
+from .rx_builder import RXCalibrationBuilder

qiskit/transpiler/passes/calibration/builders.py

@@ -17,3 +17,4 @@
 # pylint: disable=unused-import
 from .pulse_gate import PulseGates
 from .rzx_builder import RZXCalibrationBuilder, RZXCalibrationBuilderNoEcho
+from .rx_builder import RXCalibrationBuilder

qiskit/transpiler/passes/calibration/rx_builder.py

@@ -0,0 +1,116 @@
+# 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.pulse import Schedule, ScheduleBlock, builder, DriveChannel
+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 import Target
+from qiskit.circuit.library.standard_gates import RXGate
+from qiskit.exceptions import QiskitError
+
+
+class RXCalibrationBuilder(CalibrationBuilder):
+    """Add single-pulse RX calibrations that are bootstrapped from the SX calibration.
+
+    .. note::
+        Requirement: NormalizeRXAngles pass (one of the optimization passes).
+
+    References
+        * [1]: Gokhale et al. (2020), Optimized Quantum Compilation for
+          Near-Term Algorithms with OpenPulse.
+          `arXiv:2004.11205 <https://arxiv.org/abs/2004.11205>`
+    """
+
+    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)]
+
+        if self.target.instruction_schedule_map() is None:
+            raise QiskitError("Calibrations can only be added to Pulse-enabled backends")
+
+    def supported(self, node_op: Instruction, qubits: list) -> bool:
+        """
+        Check if the calibration for SX gate exists.
+        """
+        return isinstance(node_op, RXGate) and self.target.has_calibration("sx", tuple(qubits))
+
+    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_identifier=DriveChannel(qubits[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_identifier: 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_identifier,
+        )
+
+    return new_rx_sched

qiskit/transpiler/passes/optimization/__init__.py

@@ -35,3 +35,4 @@
 from .reset_after_measure_simplification import ResetAfterMeasureSimplification
 from .optimize_cliffords import OptimizeCliffords
 from .collect_cliffords import CollectCliffords
+from .normalize_rx_angle import NormalizeRXAngle

qiskit/transpiler/passes/optimization/normalize_rx_angle.py

@@ -0,0 +1,149 @@
+# 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 using a resolution provided by the user.
+"""
+
+import numpy as np
+
+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):
+    """Wrap RX Gate rotation angles into [0, pi] by sandwiching them with RZ gates.
+    This will help reduce the size of calibration data,
+    as we won't have to keep separate, phase-flipped calibrations for negative rotation angles.
+    Moreover, if the calibrations exist in the target, convert RX(pi/2) to SX, and RX(pi) to X.
+    This will allow us to exploit the more accurate, hardware-calibrated pulses.
+    Lastly, quantize the RX rotation angles using a resolution provided by the user.
+    """
+
+    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 aribitary-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 using a resolution provided by the user.
+
+        Args:
+            qubit (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.
+        """
+
+        # check if there is already a calibration for a simliar angle
+        try:
+            angles = self.already_generated[qubit]  # 1d ndarray of already generated angles
+            quantized_angle = float(
+                angles[np.where(np.abs(angles - original_angle) < (self.resolution_in_radian / 2))]
+            )
+        except KeyError:
+            quantized_angle = original_angle
+            self.already_generated[qubit] = np.array([quantized_angle])
+        except TypeError:
+            quantized_angle = original_angle
+            self.already_generated[qubit] = np.append(
+                self.already_generated[qubit], quantized_angle
+            )
+
+        return quantized_angle
+
+    def run(self, dag):
+        """Run the NormalizeRXAngle pass on ``dag``. This pass consists of three parts:
+        normalize_rx_angles(), convert_to_hardware_sx_x(), quantize_rx_angles().
+
+        Args:
+            dag (DAGCircuit): The DAG to be optimized.
+
+        Returns:
+            DAGCircuit: A DAG where all RX rotation angles are within [0, pi].
+        """
+
+        # Iterate over all op_nodes and replace RX if eligible for modification.
+        for op_node in dag.op_nodes():
+            if not (op_node.op.name == "rx"):
+                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)
+            pi_rotation = np.isclose(abs(wrapped_theta), np.pi)
+
+            # get the physical qubit index to look up the SX or X calibrations
+            qubit = dag.find_bit(op_node.qargs[0]).index if half_pi_rotation | pi_rotation else None
+            try:
+                qubit = int(qubit)
+                find_bit_succeeded = True
+            except TypeError:
+                find_bit_succeeded = False
+
+            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
+                    and find_bit_succeeded
+                    and self.target.has_calibration("sx", (qubit,))
+                ):
+                    mini_dag.apply_operation_back(SXGate(), qargs=op_node.qargs)
+                elif (
+                    pi_rotation
+                    and find_bit_succeeded
+                    and self.target.has_calibration("x", (qubit,))
+                ):
+                    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

releasenotes/notes/single-pulse-rx-cal-347aadcee7bfe60b.yaml

@@ -0,0 +1,30 @@
+---
+features:
+  - |
+    Two new transpiler passes are added to generate single-pulse RX gate calibrations on the fly.
+    These single-pulse RX calibrations will reduce the gate time in half, as described in 
+    P.Gokhale et al, Optimized Quantum Compilation for Near-Term Algorithms with OpenPulse 
+    (2020), `arXiv:2004.11205 <https://arxiv.org/abs/2004.11205>`.
+
+    To reduce the amount of RX calibration data that needs to be generated,
+    :class:`~qiskit.transpiler.passes.optimization.normalize_rx_angle.NormalizeRXAngle`
+    performs three optimizations: wrapping RX gate rotation angles to [0, pi], 
+    replacing RX(pi/2) and RX(pi) with SX and X gates, and quantizing the rotation angles.
+    This pass is required to be run before 
+    :class:`~qiskit.transpiler.passes.calibration.rx_builder.RXCalibrationBuilder`,
+    which generates RX calibrations on the fly.
+
+    The details of the transpiler passes are as follows:
+    :class:`~qiskit.transpiler.passes.optimization.normalize_rx_angle.NormalizeRXAngle` wraps
+    RX gate rotation angles to [0, pi] by replacing an RX gate with negative rotation angle, RX(-theta),
+    with a sequence: RZ(pi)-RX(theta)-RZ(-pi). Moreover, the pass replaces RX(pi/2) with SX gate,
+    and RX(pi) with X gate. This will enable us to exploit the more accurate, hardware-calibrated
+    pulses. Lastly, the pass quantizes the rotation angles using a user-provided resolution.
+    If the resolution is set to 0, this pass will not perform any quantization.
+    :class:`~qiskit.transpiler.passes.calibration.rx_builder.RXCalibrationBuilder`
+    generates RX calibrations on the fly. The pulse calibrations are bootstrapped from 
+    the SX gate calibration in the target.
+    The amplitude is linearly scaled to achieve the desired arbitrary rotation angle.
+    Such single-pulse calibrations reduces the gate time in half, compared to the 
+    conventional sequence that consists of two SX pulses.
+    There could be an improvement in fidelity due to this reduction in gate time.

requirements-dev.txt

@@ -31,8 +31,8 @@ ddt>=1.2.0,!=1.4.0,!=1.4.3
 # components of Terra use some of its optional dependencies in order to document
 # themselves.  These are the requirements that are _only_ required for the docs
 # build, and are not used by Terra itself.
-Sphinx>=6.0
-qiskit-sphinx-theme~=1.14.0
+Sphinx>=6.0,<7.2
+qiskit-sphinx-theme~=1.15.0
 sphinx-design>=0.2.0
 nbsphinx~=0.9.2
 nbconvert~=7.7.1