qiskit 1.1.2__cp38-abi3-macosx_10_9_universal2.whl → 1.2.0rc1__cp38-abi3-macosx_10_9_universal2.whl

qiskit/synthesis/two_qubit/two_qubit_decompose.py

@@ -35,7 +35,7 @@ import logging
 
 import numpy as np
 
-from qiskit.circuit import QuantumRegister, QuantumCircuit, Gate
+from qiskit.circuit import QuantumRegister, QuantumCircuit, Gate, CircuitInstruction
 from qiskit.circuit.library.standard_gates import (
     CXGate,
     U3Gate,
@@ -60,7 +60,7 @@ from qiskit.utils.deprecation import deprecate_func
 from qiskit._accelerate import two_qubit_decompose
 
 if TYPE_CHECKING:
-    from qiskit.dagcircuit.dagcircuit import DAGCircuit
+    from qiskit.dagcircuit.dagcircuit import DAGCircuit, DAGOpNode
 
 logger = logging.getLogger(__name__)
 
@@ -116,7 +116,7 @@ def decompose_two_qubit_product_gate(special_unitary_matrix: np.ndarray):
     if deviation > 1.0e-13:
         raise QiskitError(
             "decompose_two_qubit_product_gate: decomposition failed: "
-            "deviation too large: {}".format(deviation)
+            f"deviation too large: {deviation}"
         )
 
     return L, R, phase
@@ -230,13 +230,10 @@ class TwoQubitWeylDecomposition:
         self, *, euler_basis: str | None = None, simplify: bool = False, atol: float = DEFAULT_ATOL
     ) -> QuantumCircuit:
         """Returns Weyl decomposition in circuit form."""
-        circuit_sequence = self._inner_decomposition.circuit(
+        circuit_data = self._inner_decomposition.circuit(
             euler_basis=euler_basis, simplify=simplify, atol=atol
         )
-        circ = QuantumCircuit(2, global_phase=circuit_sequence.global_phase)
-        for name, params, qubits in circuit_sequence:
-            getattr(circ, name)(*params, *qubits)
-        return circ
+        return QuantumCircuit._from_circuit_data(circuit_data)
 
     def actual_fidelity(self, **kwargs) -> float:
         """Calculates the actual fidelity of the decomposed circuit to the input unitary."""
@@ -641,47 +638,58 @@ class TwoQubitBasisDecomposer:
             QiskitError: if ``pulse_optimize`` is True but we don't know how to do it.
         """
 
-        sequence = self._inner_decomposer(
-            np.asarray(unitary, dtype=complex),
-            basis_fidelity,
-            approximate,
-            _num_basis_uses=_num_basis_uses,
-        )
-        q = QuantumRegister(2)
         if use_dag:
-            from qiskit.dagcircuit.dagcircuit import DAGCircuit
+            from qiskit.dagcircuit.dagcircuit import DAGCircuit, DAGOpNode
+
+            sequence = self._inner_decomposer(
+                np.asarray(unitary, dtype=complex),
+                basis_fidelity,
+                approximate,
+                _num_basis_uses=_num_basis_uses,
+            )
+            q = QuantumRegister(2)
 
             dag = DAGCircuit()
             dag.global_phase = sequence.global_phase
             dag.add_qreg(q)
-            for name, params, qubits in sequence:
-                if name == "USER_GATE":
+            for gate, params, qubits in sequence:
+                if gate is None:
                     dag.apply_operation_back(self.gate, tuple(q[x] for x in qubits), check=False)
                 else:
-                    gate = GATE_NAME_MAP[name](*params)
-                    dag.apply_operation_back(gate, tuple(q[x] for x in qubits), check=False)
+                    op = CircuitInstruction.from_standard(
+                        gate, qubits=tuple(q[x] for x in qubits), params=params
+                    )
+                    node = DAGOpNode.from_instruction(op, dag=dag)
+                    dag._apply_op_node_back(node)
             return dag
         else:
-            circ = QuantumCircuit(q, global_phase=sequence.global_phase)
-            for name, params, qubits in sequence:
-                try:
-                    getattr(circ, name)(*params, *qubits)
-                except AttributeError as exc:
-                    if name == "USER_GATE":
-                        circ.append(self.gate, qubits)
-                    elif name == "u3":
-                        gate = U3Gate(*params)
-                        circ.append(gate, qubits)
-                    elif name == "u2":
-                        gate = U2Gate(*params)
-                        circ.append(gate, qubits)
-                    elif name == "u1":
-                        gate = U1Gate(*params)
-                        circ.append(gate, qubits)
+            if getattr(self.gate, "_standard_gate", None):
+                circ_data = self._inner_decomposer.to_circuit(
+                    np.asarray(unitary, dtype=complex),
+                    self.gate,
+                    basis_fidelity,
+                    approximate,
+                    _num_basis_uses=_num_basis_uses,
+                )
+                return QuantumCircuit._from_circuit_data(circ_data)
+            else:
+                sequence = self._inner_decomposer(
+                    np.asarray(unitary, dtype=complex),
+                    basis_fidelity,
+                    approximate,
+                    _num_basis_uses=_num_basis_uses,
+                )
+                q = QuantumRegister(2)
+                circ = QuantumCircuit(q, global_phase=sequence.global_phase)
+                for gate, params, qubits in sequence:
+                    if gate is None:
+                        circ._append(self.gate, qargs=tuple(q[x] for x in qubits))
                     else:
-                        raise QiskitError(f"Unknown gate {name}") from exc
-
-            return circ
+                        inst = CircuitInstruction.from_standard(
+                            gate, qubits=tuple(q[x] for x in qubits), params=params
+                        )
+                        circ._append(inst)
+                return circ
 
     def traces(self, target):
         r"""
@@ -691,98 +699,9 @@ class TwoQubitBasisDecomposer:
         return self._inner_decomposer.traces(target._inner_decomposition)
 
 
-class TwoQubitDecomposeUpToDiagonal:
-    """
-    Class to decompose two qubit unitaries into the product of a diagonal gate
-    and another unitary gate which can be represented by two CX gates instead of the
-    usual three. This can be used when neighboring gates commute with the diagonal to
-    potentially reduce overall CX count.
-    """
-
-    def __init__(self):
-        sy = np.array([[0, -1j], [1j, 0]])
-        self.sysy = np.kron(sy, sy)
-
-    def _u4_to_su4(self, u4):
-        phase_factor = np.conj(np.linalg.det(u4) ** (-1 / u4.shape[0]))
-        su4 = u4 / phase_factor
-        return su4, cmath.phase(phase_factor)
-
-    def _gamma(self, mat):
-        """
-        proposition II.1: this invariant characterizes when two operators in U(4),
-        say u, v, are equivalent up to single qubit gates:
-
-           u ≡ v -> Det(γ(u)) = Det(±(γ(v)))
-        """
-        sumat, _ = self._u4_to_su4(mat)
-        sysy = self.sysy
-        return sumat @ sysy @ sumat.T @ sysy
-
-    def _cx0_test(self, mat):
-        # proposition III.1: zero cx sufficient
-        gamma = self._gamma(mat)
-        evals = np.linalg.eigvals(gamma)
-        return np.all(np.isclose(evals, np.ones(4)))
-
-    def _cx1_test(self, mat):
-        # proposition III.2: one cx sufficient
-        gamma = self._gamma(mat)
-        evals = np.linalg.eigvals(gamma)
-        uvals, ucnts = np.unique(np.round(evals, 10), return_counts=True)
-        return (
-            len(uvals) == 2
-            and all(ucnts == 2)
-            and all((np.isclose(x, 1j)) or np.isclose(x, -1j) for x in uvals)
-        )
-
-    def _cx2_test(self, mat):
-        # proposition III.3: two cx sufficient
-        gamma = self._gamma(mat)
-        return np.isclose(np.trace(gamma).imag, 0)
-
-    def _real_trace_transform(self, mat):
-        """
-        Determine diagonal gate such that
-
-        U3 = D U2
-
-        Where U3 is a general two-qubit gate which takes 3 cnots, D is a
-        diagonal gate, and U2 is a gate which takes 2 cnots.
-        """
-        a1 = (
-            -mat[1, 3] * mat[2, 0]
-            + mat[1, 2] * mat[2, 1]
-            + mat[1, 1] * mat[2, 2]
-            - mat[1, 0] * mat[2, 3]
-        )
-        a2 = (
-            mat[0, 3] * mat[3, 0]
-            - mat[0, 2] * mat[3, 1]
-            - mat[0, 1] * mat[3, 2]
-            + mat[0, 0] * mat[3, 3]
-        )
-        theta = 0  # arbitrary
-        phi = 0  # arbitrary
-        psi = np.arctan2(a1.imag + a2.imag, a1.real - a2.real) - phi
-        diag = np.diag(np.exp(-1j * np.array([theta, phi, psi, -(theta + phi + psi)])))
-        return diag
-
-    def __call__(self, mat):
-        """do the decomposition"""
-        su4, phase = self._u4_to_su4(mat)
-        real_map = self._real_trace_transform(su4)
-        mapped_su4 = real_map @ su4
-        if not self._cx2_test(mapped_su4):
-            warnings.warn("Unitary decomposition up to diagonal may use an additionl CX gate.")
-        circ = two_qubit_cnot_decompose(mapped_su4)
-        circ.global_phase += phase
-        return real_map.conj(), circ
-
-
 # This weird duplicated lazy structure is for backwards compatibility; Qiskit has historically
 # always made ``two_qubit_cnot_decompose`` available publicly immediately on import, but it's quite
-# expensive to construct, and we want to defer the obejct's creation until it's actually used.  We
+# expensive to construct, and we want to defer the object's creation until it's actually used.  We
 # only need to pass through the public methods that take `self` as a parameter.  Using `__getattr__`
 # doesn't work because it is only called if the normal resolution methods fail.  Using
 # `__getattribute__` is too messy for a simple one-off use object.

qiskit/synthesis/unitary/aqc/cnot_structures.py

@@ -133,7 +133,7 @@ def _get_connectivity(num_qubits: int, connectivity: str) -> dict:
         links = {i: list(range(num_qubits)) for i in range(num_qubits)}
 
     elif connectivity == "line":
-        # Every qubit is connected to its immediate neighbours only.
+        # Every qubit is connected to its immediate neighbors only.
         links = {i: [i - 1, i, i + 1] for i in range(1, num_qubits - 1)}
 
         # first qubit

qiskit/synthesis/unitary/qsd.py

@@ -30,6 +30,7 @@ from qiskit.circuit.library.standard_gates import CXGate
 from qiskit.circuit.library.generalized_gates.uc_pauli_rot import UCPauliRotGate, _EPS
 from qiskit.circuit.library.generalized_gates.ucry import UCRYGate
 from qiskit.circuit.library.generalized_gates.ucrz import UCRZGate
+from qiskit._accelerate.two_qubit_decompose import two_qubit_decompose_up_to_diagonal
 
 
 def qs_decomposition(
@@ -253,7 +254,7 @@ def _apply_a2(circ):
     from qiskit.quantum_info import Operator
     from qiskit.circuit.library.generalized_gates.unitary import UnitaryGate
 
-    decomposer = two_qubit_decompose.TwoQubitDecomposeUpToDiagonal()
+    decomposer = two_qubit_decompose_up_to_diagonal
     ccirc = transpile(circ, basis_gates=["u", "cx", "qsd2q"], optimization_level=0)
     ind2q = []
     # collect 2q instrs
@@ -269,13 +270,14 @@ def _apply_a2(circ):
     # rolling over diagonals
     ind2 = None  # lint
     for ind1, ind2 in zip(ind2q[0:-1:], ind2q[1::]):
-        # get neigboring 2q gates separated by controls
+        # get neighboring 2q gates separated by controls
         instr1 = ccirc.data[ind1]
         mat1 = Operator(instr1.operation).data
         instr2 = ccirc.data[ind2]
         mat2 = Operator(instr2.operation).data
         # rollover
-        dmat, qc2cx = decomposer(mat1)
+        dmat, qc2cx_data = decomposer(mat1)
+        qc2cx = QuantumCircuit._from_circuit_data(qc2cx_data)
         ccirc.data[ind1] = instr1.replace(operation=qc2cx.to_gate())
         mat2 = mat2 @ dmat
         ccirc.data[ind2] = instr2.replace(UnitaryGate(mat2))

qiskit/transpiler/__init__.py

@@ -1277,6 +1277,7 @@ from .basepasses import AnalysisPass, TransformationPass
 from .coupling import CouplingMap
 from .layout import Layout, TranspileLayout
 from .instruction_durations import InstructionDurations
+from .preset_passmanagers import generate_preset_pass_manager
 from .target import Target
 from .target import InstructionProperties
 from .target import QubitProperties

qiskit/transpiler/basepasses.py

@@ -87,7 +87,7 @@ class BasePass(GenericPass, metaclass=MetaPass):
         return hash(self) == hash(other)
 
     @abstractmethod
-    def run(self, dag: DAGCircuit):  # pylint: disable=arguments-differ
+    def run(self, dag: DAGCircuit):  # pylint:disable=arguments-renamed
         """Run a pass on the DAGCircuit. This is implemented by the pass developer.
 
         Args:

qiskit/transpiler/coupling.py

@@ -101,7 +101,7 @@ class CouplingMap:
             raise CouplingError("Physical qubits should be integers.")
         if physical_qubit in self.physical_qubits:
             raise CouplingError(
-                "The physical qubit %s is already in the coupling graph" % physical_qubit
+                f"The physical qubit {physical_qubit} is already in the coupling graph"
             )
         self.graph.add_node(physical_qubit)
         self._dist_matrix = None  # invalidate
@@ -188,9 +188,9 @@ class CouplingMap:
             CouplingError: if the qubits do not exist in the CouplingMap
         """
         if physical_qubit1 >= self.size():
-            raise CouplingError("%s not in coupling graph" % physical_qubit1)
+            raise CouplingError(f"{physical_qubit1} not in coupling graph")
         if physical_qubit2 >= self.size():
-            raise CouplingError("%s not in coupling graph" % physical_qubit2)
+            raise CouplingError(f"{physical_qubit2} not in coupling graph")
         self.compute_distance_matrix()
         res = self._dist_matrix[physical_qubit1, physical_qubit2]
         if res == math.inf:

qiskit/transpiler/instruction_durations.py

@@ -15,8 +15,7 @@ from __future__ import annotations
 from typing import Optional, List, Tuple, Union, Iterable
 
 import qiskit.circuit
-from qiskit.circuit import Barrier, Delay
-from qiskit.circuit import Instruction, ParameterExpression
+from qiskit.circuit import Barrier, Delay, Instruction, ParameterExpression
 from qiskit.circuit.duration import duration_in_dt
 from qiskit.providers import Backend
 from qiskit.transpiler.exceptions import TranspilerError

qiskit/transpiler/layout.py

@@ -98,8 +98,8 @@ class Layout:
             virtual = value1
         else:
             raise LayoutError(
-                "The map (%s -> %s) has to be a (Bit -> integer)"
-                " or the other way around." % (type(value1), type(value2))
+                f"The map ({type(value1)} -> {type(value2)}) has to be a (Bit -> integer)"
+                " or the other way around."
             )
         return virtual, physical
 
@@ -137,7 +137,7 @@ class Layout:
         else:
             raise LayoutError(
                 "The key to remove should be of the form"
-                " Qubit or integer) and %s was provided" % (type(key),)
+                f" Qubit or integer) and {type(key)} was provided"
             )
 
     def __len__(self):

qiskit/transpiler/passes/__init__.py

@@ -91,6 +91,7 @@ Optimizations
    ElidePermutations
    NormalizeRXAngle
    OptimizeAnnotated
+   Split2QUnitaries
 
 Calibration
 =============
@@ -244,6 +245,7 @@ from .optimization import OptimizeCliffords
 from .optimization import ElidePermutations
 from .optimization import NormalizeRXAngle
 from .optimization import OptimizeAnnotated
+from .optimization import Split2QUnitaries
 
 # circuit analysis
 from .analysis import ResourceEstimation

qiskit/transpiler/passes/basis/basis_translator.py

@@ -30,11 +30,12 @@ from qiskit.circuit import (
     QuantumCircuit,
     ParameterExpression,
 )
-from qiskit.dagcircuit import DAGCircuit
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
 from qiskit.converters import circuit_to_dag, dag_to_circuit
 from qiskit.circuit.equivalence import Key, NodeData
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
 
 logger = logging.getLogger(__name__)
 
@@ -207,7 +208,7 @@ class BasisTranslator(TransformationPass):
                     "target basis is not universal or there are additional equivalence rules "
                     "needed in the EquivalenceLibrary being used. For more details on this "
                     "error see: "
-                    "https://docs.quantum.ibm.com/api/qiskit/transpiler_passes."
+                    "https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes."
                     "BasisTranslator#translation-errors"
                 )
 
@@ -225,7 +226,7 @@ class BasisTranslator(TransformationPass):
                 f"basis: {list(target_basis)}. This likely means the target basis is not universal "
                 "or there are additional equivalence rules needed in the EquivalenceLibrary being "
                 "used. For more details on this error see: "
-                "https://docs.quantum.ibm.com/api/qiskit/transpiler_passes."
+                "https://docs.quantum.ibm.com/api/qiskit/qiskit.transpiler.passes."
                 "BasisTranslator#translation-errors"
             )
 
@@ -248,72 +249,85 @@ class BasisTranslator(TransformationPass):
         replace_start_time = time.time()
 
         def apply_translation(dag, wire_map):
-            dag_updated = False
-            for node in dag.op_nodes():
+            is_updated = False
+            out_dag = dag.copy_empty_like()
+            for node in dag.topological_op_nodes():
                 node_qargs = tuple(wire_map[bit] for bit in node.qargs)
                 qubit_set = frozenset(node_qargs)
                 if node.name in target_basis or len(node.qargs) < self._min_qubits:
-                    if isinstance(node.op, ControlFlowOp):
+                    if node.name in CONTROL_FLOW_OP_NAMES:
                         flow_blocks = []
                         for block in node.op.blocks:
                             dag_block = circuit_to_dag(block)
-                            dag_updated = apply_translation(
+                            updated_dag, is_updated = apply_translation(
                                 dag_block,
                                 {
                                     inner: wire_map[outer]
                                     for inner, outer in zip(block.qubits, node.qargs)
                                 },
                             )
-                            if dag_updated:
-                                flow_circ_block = dag_to_circuit(dag_block)
+                            if is_updated:
+                                flow_circ_block = dag_to_circuit(updated_dag)
                             else:
                                 flow_circ_block = block
                             flow_blocks.append(flow_circ_block)
                         node.op = node.op.replace_blocks(flow_blocks)
+                    out_dag.apply_operation_back(node.op, node.qargs, node.cargs, check=False)
                     continue
                 if (
                     node_qargs in self._qargs_with_non_global_operation
                     and node.name in self._qargs_with_non_global_operation[node_qargs]
                 ):
+                    out_dag.apply_operation_back(node.op, node.qargs, node.cargs, check=False)
                     continue
 
                 if dag.has_calibration_for(node):
+                    out_dag.apply_operation_back(node.op, node.qargs, node.cargs, check=False)
                     continue
                 if qubit_set in extra_instr_map:
-                    self._replace_node(dag, node, extra_instr_map[qubit_set])
-                elif (node.op.name, node.op.num_qubits) in instr_map:
-                    self._replace_node(dag, node, instr_map)
+                    self._replace_node(out_dag, node, extra_instr_map[qubit_set])
+                elif (node.name, node.num_qubits) in instr_map:
+                    self._replace_node(out_dag, node, instr_map)
                 else:
                     raise TranspilerError(f"BasisTranslator did not map {node.name}.")
-                dag_updated = True
-            return dag_updated
+                is_updated = True
+            return out_dag, is_updated
 
-        apply_translation(dag, qarg_indices)
+        out_dag, _ = apply_translation(dag, qarg_indices)
         replace_end_time = time.time()
         logger.info(
             "Basis translation instructions replaced in %.3fs.",
             replace_end_time - replace_start_time,
         )
 
-        return dag
+        return out_dag
 
     def _replace_node(self, dag, node, instr_map):
-        target_params, target_dag = instr_map[node.op.name, node.op.num_qubits]
-        if len(node.op.params) != len(target_params):
+        target_params, target_dag = instr_map[node.name, node.num_qubits]
+        if len(node.params) != len(target_params):
             raise TranspilerError(
                 "Translation num_params not equal to op num_params."
-                "Op: {} {} Translation: {}\n{}".format(
-                    node.op.params, node.op.name, target_params, target_dag
-                )
+                f"Op: {node.params} {node.name} Translation: {target_params}\n{target_dag}"
             )
-        if node.op.params:
-            parameter_map = dict(zip(target_params, node.op.params))
-            bound_target_dag = target_dag.copy_empty_like()
+        if node.params:
+            parameter_map = dict(zip(target_params, node.params))
             for inner_node in target_dag.topological_op_nodes():
-                if any(isinstance(x, ParameterExpression) for x in inner_node.op.params):
-                    new_op = inner_node.op.copy()
+                new_node = DAGOpNode.from_instruction(
+                    inner_node._to_circuit_instruction(),
+                    dag=target_dag,
+                )
+                new_node.qargs = tuple(
+                    node.qargs[target_dag.find_bit(x).index] for x in inner_node.qargs
+                )
+                new_node.cargs = tuple(
+                    node.cargs[target_dag.find_bit(x).index] for x in inner_node.cargs
+                )
+
+                if not new_node.is_standard_gate():
+                    new_node.op = new_node.op.copy()
+                if any(isinstance(x, ParameterExpression) for x in inner_node.params):
                     new_params = []
-                    for param in new_op.params:
+                    for param in new_node.params:
                         if not isinstance(param, ParameterExpression):
                             new_params.append(param)
                         else:
@@ -327,10 +341,11 @@ class BasisTranslator(TransformationPass):
                             if not new_value.parameters:
                                 new_value = new_value.numeric()
                             new_params.append(new_value)
-                    new_op.params = new_params
-                else:
-                    new_op = inner_node.op
-                bound_target_dag.apply_operation_back(new_op, inner_node.qargs, inner_node.cargs)
+                    new_node.params = new_params
+                    if not new_node.is_standard_gate():
+                        new_node.op.params = new_params
+                dag._apply_op_node_back(new_node)
+
             if isinstance(target_dag.global_phase, ParameterExpression):
                 old_phase = target_dag.global_phase
                 bind_dict = {x: parameter_map[x] for x in old_phase.parameters}
@@ -338,31 +353,37 @@ class BasisTranslator(TransformationPass):
                     new_phase = old_phase
                     for x in bind_dict.items():
                         new_phase = new_phase.assign(*x)
-
                 else:
                     new_phase = old_phase.bind(bind_dict)
                 if not new_phase.parameters:
                     new_phase = new_phase.numeric()
                     if isinstance(new_phase, complex):
                         raise TranspilerError(f"Global phase must be real, but got '{new_phase}'")
-                bound_target_dag.global_phase = new_phase
-        else:
-            bound_target_dag = target_dag
-
-        if len(bound_target_dag.op_nodes()) == 1 and len(
-            bound_target_dag.op_nodes()[0].qargs
-        ) == len(node.qargs):
-            dag_op = bound_target_dag.op_nodes()[0].op
-            # dag_op may be the same instance as other ops in the dag,
-            # so if there is a condition, need to copy
-            if getattr(node.op, "condition", None):
-                dag_op = dag_op.copy()
-            dag.substitute_node(node, dag_op, inplace=True)
-
-            if bound_target_dag.global_phase:
-                dag.global_phase += bound_target_dag.global_phase
+                dag.global_phase += new_phase
+
         else:
-            dag.substitute_node_with_dag(node, bound_target_dag)
+            for inner_node in target_dag.topological_op_nodes():
+                new_node = DAGOpNode.from_instruction(
+                    inner_node._to_circuit_instruction(),
+                    dag=target_dag,
+                )
+                new_node.qargs = tuple(
+                    node.qargs[target_dag.find_bit(x).index] for x in inner_node.qargs
+                )
+                new_node.cargs = tuple(
+                    node.cargs[target_dag.find_bit(x).index] for x in inner_node.cargs
+                )
+                if not new_node.is_standard_gate:
+                    new_node.op = new_node.op.copy()
+                # dag_op may be the same instance as other ops in the dag,
+                # so if there is a condition, need to copy
+                if getattr(node.op, "condition", None):
+                    new_node_op = new_node.op.to_mutable()
+                    new_node_op.condition = node.op.condition
+                    new_node.op = new_node_op
+                dag._apply_op_node_back(new_node)
+            if target_dag.global_phase:
+                dag.global_phase += target_dag.global_phase
 
     @singledispatchmethod
     def _extract_basis(self, circuit):
@@ -372,8 +393,8 @@ class BasisTranslator(TransformationPass):
     def _(self, dag: DAGCircuit):
         for node in dag.op_nodes():
             if not dag.has_calibration_for(node) and len(node.qargs) >= self._min_qubits:
-                yield (node.name, node.op.num_qubits)
-            if isinstance(node.op, ControlFlowOp):
+                yield (node.name, node.num_qubits)
+            if node.name in CONTROL_FLOW_OP_NAMES:
                 for block in node.op.blocks:
                     yield from self._extract_basis(block)
 
@@ -414,10 +435,10 @@ class BasisTranslator(TransformationPass):
                 frozenset(qargs).issuperset(incomplete_qargs)
                 for incomplete_qargs in self._qargs_with_non_global_operation
             ):
-                qargs_local_source_basis[frozenset(qargs)].add((node.name, node.op.num_qubits))
+                qargs_local_source_basis[frozenset(qargs)].add((node.name, node.num_qubits))
             else:
-                source_basis.add((node.name, node.op.num_qubits))
-            if isinstance(node.op, ControlFlowOp):
+                source_basis.add((node.name, node.num_qubits))
+            if node.name in CONTROL_FLOW_OP_NAMES:
                 for block in node.op.blocks:
                     block_dag = circuit_to_dag(block)
                     source_basis, qargs_local_source_basis = self._extract_basis_target(
@@ -468,7 +489,7 @@ class BasisSearchVisitor(rustworkx.visit.DijkstraVisitor):
                 score,
             )
             self._basis_transforms.append((gate.name, gate.num_qubits, rule.params, rule.circuit))
-        # we can stop the search if we have found all gates in the original ciruit.
+        # we can stop the search if we have found all gates in the original circuit.
         if not self._source_gates_remain:
             # if we start from source gates and apply `basis_transforms` in reverse order, we'll end
             # up with gates in the target basis. Note though that `basis_transforms` may include
@@ -512,7 +533,7 @@ class BasisSearchVisitor(rustworkx.visit.DijkstraVisitor):
 
         cost_tot = 0
         for instruction in edge_data.rule.circuit:
-            key = Key(name=instruction.operation.name, num_qubits=len(instruction.qubits))
+            key = Key(name=instruction.name, num_qubits=len(instruction.qubits))
             cost_tot += self._opt_cost_map[key]
 
         return cost_tot - self._opt_cost_map[edge_data.source]
@@ -550,7 +571,7 @@ def _basis_search(equiv_lib, source_basis, target_basis):
     if not source_basis:
         return []
 
-    # This is only neccessary since gates in target basis are currently reported by
+    # This is only necessary since gates in target basis are currently reported by
     # their names and we need to have in addition the number of qubits they act on.
     target_basis_keys = [key for key in equiv_lib.keys() if key.name in target_basis]
 
@@ -630,7 +651,7 @@ def _compose_transforms(basis_transforms, source_basis, source_dag):
             doomed_nodes = [
                 node
                 for node in dag.op_nodes()
-                if (node.op.name, node.op.num_qubits) == (gate_name, gate_num_qubits)
+                if (node.name, node.num_qubits) == (gate_name, gate_num_qubits)
             ]
 
             if doomed_nodes and logger.isEnabledFor(logging.DEBUG):
@@ -644,9 +665,7 @@ def _compose_transforms(basis_transforms, source_basis, source_dag):
 
             for node in doomed_nodes:
 
-                replacement = equiv.assign_parameters(
-                    dict(zip_longest(equiv_params, node.op.params))
-                )
+                replacement = equiv.assign_parameters(dict(zip_longest(equiv_params, node.params)))
 
                 replacement_dag = circuit_to_dag(replacement)
 
@@ -668,8 +687,8 @@ def _get_example_gates(source_dag):
     def recurse(dag, example_gates=None):
         example_gates = example_gates or {}
         for node in dag.op_nodes():
-            example_gates[(node.op.name, node.op.num_qubits)] = node.op
-            if isinstance(node.op, ControlFlowOp):
+            example_gates[(node.name, node.num_qubits)] = node
+            if node.name in CONTROL_FLOW_OP_NAMES:
                 for block in node.op.blocks:
                     example_gates = recurse(circuit_to_dag(block), example_gates)
         return example_gates