qiskit 1.3.0__cp39-abi3-win32.whl

qiskit/transpiler/passes/optimization/hoare_opt.py

@@ -0,0 +1,420 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# 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.
+
+"""Pass for Hoare logic circuit optimization."""
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.circuit import QuantumRegister, ControlledGate, Gate
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.circuit.library import UnitaryGate
+from qiskit.quantum_info.operators.predicates import matrix_equal
+from qiskit.circuit.exceptions import CircuitError
+from qiskit.circuit.library.standard_gates import CZGate, CU1Gate, MCU1Gate
+from qiskit.utils import optionals as _optionals
+
+
+@_optionals.HAS_Z3.require_in_instance
+class HoareOptimizer(TransformationPass):
+    """This is a transpiler pass using Hoare logic circuit optimization.
+    The inner workings of this are detailed in:
+    https://arxiv.org/abs/1810.00375
+    """
+
+    def __init__(self, size=10):
+        """
+        Args:
+            size (int): size of gate cache, in number of gates
+        Raises:
+            MissingOptionalLibraryError: if unable to import z3 solver
+        """
+        # This module is just a script that adds several post conditions onto existing classes.
+        from . import _gate_extension
+
+        super().__init__()
+        self.solver = None
+        self.variables = None
+        self.gatenum = None
+        self.gatecache = None
+        self.varnum = None
+        self.size = size
+
+    def _gen_variable(self, qubit):
+        """After each gate generate a new unique variable name for each of the
+            qubits, using scheme: 'q[id]_[gatenum]', e.g. q1_0 -> q1_1 -> q1_2,
+                                                          q2_0 -> q2_1
+        Args:
+            qubit (Qubit): qubit to generate new variable for
+        Returns:
+            BoolRef: z3 variable of qubit state
+        """
+        import z3
+
+        varname = "q" + str(qubit) + "_" + str(self.gatenum[qubit])
+        var = z3.Bool(varname)
+        self.gatenum[qubit] += 1
+        self.variables[qubit].append(var)
+        return var
+
+    def _initialize(self, dag):
+        """create boolean variables for each qubit and apply qb == 0 condition
+        Args:
+            dag (DAGCircuit): input DAG to get qubits from
+        """
+        import z3
+
+        for qbt in dag.qubits:
+            self.gatenum[qbt] = 0
+            self.variables[qbt] = []
+            self.gatecache[qbt] = []
+            self.varnum[qbt] = {}
+            x = self._gen_variable(qbt)
+            self.solver.add(z3.Not(x))
+
+    def _add_postconditions(self, gate, ctrl_ones, trgtqb, trgtvar):
+        """create boolean variables for each qubit the gate is applied to
+            and apply the relevant post conditions.
+            a gate rotating out of the z-basis will not have any valid
+            post-conditions, in which case the qubit state is unknown
+        Args:
+            gate (Gate): gate to inspect
+            ctrl_ones (BoolRef): z3 condition asserting all control qubits to 1
+            trgtqb (list((QuantumRegister, int))): list of target qubits
+            trgtvar (list(BoolRef)): z3 variables corresponding to latest state
+                                     of target qubits
+        """
+        import z3
+
+        new_vars = []
+        for qbt in trgtqb:
+            new_vars.append(self._gen_variable(qbt))
+
+        try:
+            self.solver.add(z3.Implies(ctrl_ones, gate._postconditions(*(trgtvar + new_vars))))
+        except AttributeError:
+            pass
+
+        for i, tvar in enumerate(trgtvar):
+            self.solver.add(z3.Implies(z3.Not(ctrl_ones), new_vars[i] == tvar))
+
+    def _test_gate(self, gate, ctrl_ones, trgtvar):
+        """use z3 sat solver to determine triviality of gate
+        Args:
+            gate (Gate): gate to inspect
+            ctrl_ones (BoolRef): z3 condition asserting all control qubits to 1
+            trgtvar (list(BoolRef)): z3 variables corresponding to latest state
+                                     of target qubits
+        Returns:
+            bool: if gate is trivial
+        """
+        import z3
+
+        trivial = False
+        self.solver.push()
+
+        try:
+            triv_cond = gate._trivial_if(*trgtvar)
+        except AttributeError:
+            self.solver.add(ctrl_ones)
+            trivial = self.solver.check() == z3.unsat
+        else:
+            if isinstance(triv_cond, bool):
+                if triv_cond and len(trgtvar) == 1:
+                    self.solver.add(z3.Not(z3.And(ctrl_ones, trgtvar[0])))
+                    sol1 = self.solver.check() == z3.unsat
+                    self.solver.pop()
+                    self.solver.push()
+                    self.solver.add(z3.And(ctrl_ones, trgtvar[0]))
+                    sol2 = self.solver.check() == z3.unsat
+                    trivial = sol1 or sol2
+            else:
+                self.solver.add(z3.And(ctrl_ones, z3.Not(triv_cond)))
+                trivial = self.solver.check() == z3.unsat
+
+        self.solver.pop()
+        return trivial
+
+    def _remove_control(self, gate, ctrlvar, trgtvar):
+        """use z3 sat solver to determine if all control qubits are in 1 state,
+             and if so replace the Controlled - U by U.
+        Args:
+            gate (Gate): gate to inspect
+            ctrlvar (list(BoolRef)): z3 variables corresponding to latest state
+                                     of control qubits
+            trgtvar (list(BoolRef)): z3 variables corresponding to latest state
+                                     of target qubits
+        Returns:
+            Tuple(bool, DAGCircuit, List)::
+              * bool:if controlled gate can be replaced.
+              * DAGCircuit: with U applied to the target qubits.
+              * List: with indices of target qubits.
+        """
+        remove = False
+
+        qarg = QuantumRegister(gate.num_qubits)
+        dag = DAGCircuit()
+        dag.add_qreg(qarg)
+
+        qb = list(range(len(ctrlvar), gate.num_qubits))  # last qubits as target.
+
+        if isinstance(gate, ControlledGate):
+            remove = self._check_removal(ctrlvar)
+
+        # try with other qubit as 'target'.
+        if isinstance(gate, (CZGate, CU1Gate, MCU1Gate)):
+            while not remove and qb[0] > 0:
+                qb[0] = qb[0] - 1
+                ctrl_vars = ctrlvar[: qb[0]] + ctrlvar[qb[0] + 1 :] + trgtvar
+                remove = self._check_removal(ctrl_vars)
+
+        if remove:
+            qubits = [qarg[qi] for qi in qb]
+            dag.apply_operation_back(gate.base_gate, qubits)
+
+        return remove, dag, qb
+
+    def _check_removal(self, ctrlvar):
+        import z3
+
+        ctrl_ones = z3.And(*ctrlvar)
+
+        self.solver.push()
+        self.solver.add(z3.Not(ctrl_ones))
+        remove = self.solver.check() == z3.unsat
+        self.solver.pop()
+
+        return remove
+
+    def _traverse_dag(self, dag):
+        """traverse DAG in topological order
+            for each gate check: if any control is 0, or
+                                 if triviality conditions are satisfied
+            if yes remove gate from dag
+            apply postconditions of gate
+        Args:
+            dag (DAGCircuit): input DAG to optimize in place
+        """
+        import z3
+
+        # Pre-generate all DAG nodes, since we later iterate over them, while
+        # potentially modifying and removing some of them.
+        nodes = list(dag.topological_op_nodes())
+        for node in nodes:
+            gate = node.op
+            _, ctrlvar, trgtqb, trgtvar = self._seperate_ctrl_trgt(node)
+
+            ctrl_ones = z3.And(*ctrlvar)
+
+            remove_ctrl, new_dag, _ = self._remove_control(gate, ctrlvar, trgtvar)
+
+            if remove_ctrl:
+                # We are replacing a node by a new node over a smaller number of qubits.
+                # This can be done using substitute_node_with_dag, which furthermore returns
+                # a mapping from old node ids to new nodes.
+                mapped_nodes = dag.substitute_node_with_dag(node, new_dag)
+                node = next(iter(mapped_nodes.values()))
+                gate = node.op
+                _, ctrlvar, trgtqb, trgtvar = self._seperate_ctrl_trgt(node)
+
+                ctrl_ones = z3.And(*ctrlvar)
+
+            trivial = self._test_gate(gate, ctrl_ones, trgtvar)
+            if trivial:
+                dag.remove_op_node(node)
+            elif self.size > 1:
+                for qbt in node.qargs:
+                    self.gatecache[qbt].append(node)
+                    self.varnum[qbt][node] = self.gatenum[qbt] - 1
+                for qbt in node.qargs:
+                    if len(self.gatecache[qbt]) >= self.size:
+                        self._multigate_opt(dag, qbt)
+
+            self._add_postconditions(gate, ctrl_ones, trgtqb, trgtvar)
+
+    def _remove_successive_identity(self, dag, qubit, from_idx=None):
+        """remove gates that have the same set of target qubits, follow each
+            other immediately on these target qubits, and combine to the
+            identity (consider sequences of length 2 for now)
+        Args:
+            dag (DAGCircuit): the directed acyclic graph to run on.
+            qubit (Qubit): qubit cache to inspect
+            from_idx (int): only gates whose indexes in the cache are larger
+                            than this value can be removed
+        """
+        i = 0
+        while i < len(self.gatecache[qubit]) - 1:
+            append = True
+            node1 = self.gatecache[qubit][i]
+            node2 = self.gatecache[qubit][i + 1]
+            trgtqb1 = self._seperate_ctrl_trgt(node1)[2]
+            trgtqb2 = self._seperate_ctrl_trgt(node2)[2]
+            i += 1
+
+            if trgtqb1 != trgtqb2:
+                continue
+            try:
+                for qbt in trgtqb1:
+                    idx = self.gatecache[qbt].index(node1)
+                    if self.gatecache[qbt][idx + 1] is not node2:
+                        append = False
+            except (IndexError, ValueError):
+                continue
+
+            seq = [node1, node2]
+            if append and self._is_identity(seq) and self._seq_as_one(seq):
+                i += 1
+                for node in seq:
+                    dag.remove_op_node(node)
+                    if from_idx is None or self.gatecache[qubit].index(node) > from_idx:
+                        for qbt in node.qargs:
+                            self.gatecache[qbt].remove(node)
+
+    def _is_identity(self, sequence):
+        """determine whether the sequence of gates combines to the identity
+            (consider sequences of length 2 for now)
+        Args:
+            sequence (list(DAGOpNode)): gate sequence to inspect
+        Returns:
+            bool: if gate sequence combines to identity
+        """
+        assert len(sequence) == 2
+        # some Instructions (e.g measurements) may not have an inverse.
+        try:
+            gate1, gate2 = sequence[0].op, sequence[1].op.inverse()
+        except CircuitError:
+            return False
+        par1, par2 = gate1.params, gate2.params
+        def1, def2 = gate1.definition, gate2.definition
+
+        if isinstance(gate1, ControlledGate):
+            gate1 = gate1.base_gate
+        gate1 = gate1.base_class
+        if isinstance(gate2, ControlledGate):
+            gate2 = gate2.base_gate
+        gate2 = gate2.base_class
+
+        # equality of gates can be determined via type and parameters, unless
+        # the gates have no specific type, in which case definition is used
+        # or they are unitary gates, in which case matrix equality is used
+        if gate1 is Gate and gate2 is Gate:
+            return def1 == def2 and def1 and def2
+        elif gate1 is UnitaryGate and gate2 is UnitaryGate:
+            return matrix_equal(par1[0], par2[0], ignore_phase=True)
+
+        return gate1 == gate2 and par1 == par2
+
+    def _seq_as_one(self, sequence):
+        """use z3 solver to determine if the gates in the sequence are either
+            all executed or none of them are executed, based on control qubits
+            (consider sequences of length 2 for now)
+        Args:
+            sequence (list(DAGOpNode)): gate sequence to inspect
+        Returns:
+            bool: if gate sequence is only executed completely or not at all
+        """
+        from z3 import Or, And, Not
+        import z3
+
+        assert len(sequence) == 2
+        ctrlvar1 = self._seperate_ctrl_trgt(sequence[0])[1]
+        ctrlvar2 = self._seperate_ctrl_trgt(sequence[1])[1]
+
+        self.solver.push()
+        self.solver.add(
+            Or(And(And(*ctrlvar1), Not(And(*ctrlvar2))), And(Not(And(*ctrlvar1)), And(*ctrlvar2)))
+        )
+        res = self.solver.check() == z3.unsat
+        self.solver.pop()
+
+        return res
+
+    def _multigate_opt(self, dag, qubit, max_idx=None, dnt_rec=None):
+        """
+        Args:
+            dag (DAGCircuit): the directed acyclic graph to run on.
+            qubit (Qubit): qubit whose gate cache is to be optimized
+            max_idx (int): a value indicates a recursive call, optimize
+                           and remove gates up to this point in the cache
+            dnt_rec (list(int)): don't recurse on these qubit caches (again)
+        """
+        if not self.gatecache[qubit]:
+            return
+
+        # try to optimize this qubit's pipeline
+        self._remove_successive_identity(dag, qubit, max_idx)
+        if len(self.gatecache[qubit]) < self.size and max_idx is None:
+            # unless in a rec call, we are done if the cache isn't full
+            return
+        elif max_idx is None:
+            # need to remove at least one gate from cache, so remove oldest
+            max_idx = 0
+            dnt_rec = set()
+            dnt_rec.add(qubit)
+            gates_tbr = [self.gatecache[qubit][0]]
+        else:
+            # need to remove all gates up to max_idx (in reverse order)
+            gates_tbr = self.gatecache[qubit][max_idx::-1]
+
+        for node in gates_tbr:
+            # for rec call, only look at qubits that haven't been optimized yet
+            new_qb = [x for x in node.qargs if x not in dnt_rec]
+            dnt_rec.update(new_qb)
+            for qbt in new_qb:
+                idx = self.gatecache[qbt].index(node)
+                # recursive chain to optimize all gates in this qubit's cache
+                self._multigate_opt(dag, qbt, max_idx=idx, dnt_rec=dnt_rec)
+        # truncate gatecache for this qubit to after above gate
+        self.gatecache[qubit] = self.gatecache[qubit][max_idx + 1 :]
+
+    def _seperate_ctrl_trgt(self, node):
+        """Get the target qubits and control qubits if available,
+        as well as their respective z3 variables.
+        """
+        gate = node.op
+        if isinstance(gate, ControlledGate):
+            numctrl = gate.num_ctrl_qubits
+        else:
+            numctrl = 0
+        ctrlqb = node.qargs[:numctrl]
+        trgtqb = node.qargs[numctrl:]
+        try:
+            ctrlvar = [self.variables[qb][self.varnum[qb][node]] for qb in ctrlqb]
+            trgtvar = [self.variables[qb][self.varnum[qb][node]] for qb in trgtqb]
+        except KeyError:
+            ctrlvar = [self.variables[qb][-1] for qb in ctrlqb]
+            trgtvar = [self.variables[qb][-1] for qb in trgtqb]
+        return (ctrlqb, ctrlvar, trgtqb, trgtvar)
+
+    def _reset(self):
+        """Reset HoareOptimize internal state,
+        so it can be run multiple times.
+        """
+        import z3
+
+        self.solver = z3.Solver()
+        self.variables = {}
+        self.gatenum = {}
+        self.gatecache = {}
+        self.varnum = {}
+
+    def run(self, dag):
+        """
+        Args:
+            dag (DAGCircuit): the directed acyclic graph to run on.
+        Returns:
+            DAGCircuit: Transformed DAG.
+        """
+        self._reset()
+        self._initialize(dag)
+        self._traverse_dag(dag)
+        if self.size > 1:
+            for qbt in dag.qubits:
+                self._multigate_opt(dag, qbt)
+        return dag

qiskit/transpiler/passes/optimization/inverse_cancellation.py

@@ -0,0 +1,95 @@
+# 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.
+
+"""
+A generic InverseCancellation pass for any set of gate-inverse pairs.
+"""
+from typing import List, Tuple, Union
+
+from qiskit.circuit import Gate
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.passes.utils import control_flow
+
+from qiskit._accelerate.inverse_cancellation import inverse_cancellation
+
+
+class InverseCancellation(TransformationPass):
+    """Cancel specific Gates which are inverses of each other when they occur back-to-
+    back."""
+
+    def __init__(self, gates_to_cancel: List[Union[Gate, Tuple[Gate, Gate]]]):
+        """Initialize InverseCancellation pass.
+
+        Args:
+            gates_to_cancel: List describing the gates to cancel. Each element of the
+                list is either a single gate or a pair of gates. If a single gate, then
+                it should be self-inverse. If a pair of gates, then the gates in the
+                pair should be inverses of each other.
+
+        Raises:
+            TranspilerError: Input is not a self-inverse gate or a pair of inverse gates.
+        """
+
+        for gates in gates_to_cancel:
+            if isinstance(gates, Gate):
+                if gates != gates.inverse():
+                    raise TranspilerError(f"Gate {gates.name} is not self-inverse")
+            elif isinstance(gates, tuple):
+                if len(gates) != 2:
+                    raise TranspilerError(
+                        f"Too many or too few inputs: {gates}. Only two are allowed."
+                    )
+                if gates[0] != gates[1].inverse():
+                    raise TranspilerError(
+                        f"Gate {gates[0].name} and {gates[1].name} are not inverse."
+                    )
+            else:
+                raise TranspilerError(
+                    f"InverseCancellation pass does not take input type {type(gates)}. Input must be"
+                    " a Gate."
+                )
+
+        self.self_inverse_gates = []
+        self.inverse_gate_pairs = []
+        self.self_inverse_gate_names = set()
+        self.inverse_gate_pairs_names = set()
+
+        for gates in gates_to_cancel:
+            if isinstance(gates, Gate):
+                self.self_inverse_gates.append(gates)
+                self.self_inverse_gate_names.add(gates.name)
+            else:
+                self.inverse_gate_pairs.append(gates)
+                self.inverse_gate_pairs_names.update(x.name for x in gates)
+
+        super().__init__()
+
+    @control_flow.trivial_recurse
+    def run(self, dag: DAGCircuit):
+        """Run the InverseCancellation pass on `dag`.
+
+        Args:
+            dag: the directed acyclic graph to run on.
+
+        Returns:
+            DAGCircuit: Transformed DAG.
+        """
+        inverse_cancellation(
+            dag,
+            self.inverse_gate_pairs,
+            self.self_inverse_gates,
+            self.inverse_gate_pairs_names,
+            self.self_inverse_gate_names,
+        )
+        return dag

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 by assigning the same value for the angles
+that differ within 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):
+    """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.
+    """
+
+    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