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

qiskit/circuit/classicalfunction/classical_function_visitor.py

@@ -83,7 +83,7 @@ class ClassicalFunctionVisitor(ast.NodeVisitor):
         """Uses ClassicalFunctionVisitor.bitops to extend self._network"""
         bitop = ClassicalFunctionVisitor.bitops.get(type(op))
         if not bitop:
-            raise ClassicalFunctionParseError("Unknown binop.op %s" % op)
+            raise ClassicalFunctionParseError(f"Unknown binop.op {op}")
         binop = getattr(self._network, bitop)
 
         left_type, left_signal = values[0]
@@ -112,19 +112,19 @@ class ClassicalFunctionVisitor(ast.NodeVisitor):
         operand_type, operand_signal = self.visit(node.operand)
         if operand_type != "Int1":
             raise ClassicalFunctionCompilerTypeError(
-                "UntaryOp.op %s only support operation on Int1s for now" % node.op
+                f"UntaryOp.op {node.op} only support operation on Int1s for now"
             )
         bitop = ClassicalFunctionVisitor.bitops.get(type(node.op))
         if not bitop:
             raise ClassicalFunctionCompilerTypeError(
-                "UntaryOp.op %s does not operate with Int1 type " % node.op
+                f"UntaryOp.op {node.op} does not operate with Int1 type "
             )
         return "Int1", getattr(self._network, bitop)(operand_signal)
 
     def visit_Name(self, node):
         """Reduce variable names."""
         if node.id not in self.scopes[-1]:
-            raise ClassicalFunctionParseError("out of scope: %s" % node.id)
+            raise ClassicalFunctionParseError(f"out of scope: {node.id}")
         return self.scopes[-1][node.id]
 
     def generic_visit(self, node):
@@ -143,7 +143,7 @@ class ClassicalFunctionVisitor(ast.NodeVisitor):
             ),
         ):
             return super().generic_visit(node)
-        raise ClassicalFunctionParseError("Unknown node: %s" % type(node))
+        raise ClassicalFunctionParseError(f"Unknown node: {type(node)}")
 
     def extend_scope(self, args_node: _ast.arguments) -> None:
         """Add the arguments to the scope"""

qiskit/circuit/classicalfunction/utils.py

@@ -47,7 +47,7 @@ def _convert_tweedledum_operator(op):
         if op.kind() == "py_operator":
             return op.py_op()
         else:
-            raise RuntimeError("Unrecognized operator: %s" % op.kind())
+            raise RuntimeError(f"Unrecognized operator: {op.kind()}")
 
     # TODO: need to deal with cbits too!
     if op.num_controls() > 0:

qiskit/circuit/classicalregister.py

@@ -43,7 +43,7 @@ class Clbit(Bit):
             super().__init__(register, index)
         else:
             raise CircuitError(
-                "Clbit needs a ClassicalRegister and %s was provided" % type(register).__name__
+                f"Clbit needs a ClassicalRegister and {type(register).__name__} was provided"
             )
 
 

qiskit/circuit/commutation_checker.py

@@ -13,7 +13,7 @@
 """Code from commutative_analysis pass that checks commutation relations between DAG nodes."""
 
 from functools import lru_cache
-from typing import List, Union
+from typing import List, Union, Set, Optional
 import numpy as np
 
 from qiskit import QiskitError
@@ -25,6 +25,27 @@ from qiskit.quantum_info.operators import Operator
 _skipped_op_names = {"measure", "reset", "delay", "initialize"}
 _no_cache_op_names = {"annotated"}
 
+_supported_ops = {
+    "h",
+    "x",
+    "y",
+    "z",
+    "sx",
+    "sxdg",
+    "t",
+    "tdg",
+    "s",
+    "sdg",
+    "cx",
+    "cy",
+    "cz",
+    "swap",
+    "iswap",
+    "ecr",
+    "ccx",
+    "cswap",
+}
+
 
 @lru_cache(maxsize=None)
 def _identity_op(num_qubits):
@@ -42,7 +63,13 @@ class CommutationChecker:
     evicting from the cache less useful entries, etc.
     """
 
-    def __init__(self, standard_gate_commutations: dict = None, cache_max_entries: int = 10**6):
+    def __init__(
+        self,
+        standard_gate_commutations: dict = None,
+        cache_max_entries: int = 10**6,
+        *,
+        gates: Optional[Set[str]] = None,
+    ):
         super().__init__()
         if standard_gate_commutations is None:
             self._standard_commutations = {}
@@ -56,6 +83,24 @@ class CommutationChecker:
         self._current_cache_entries = 0
         self._cache_miss = 0
         self._cache_hit = 0
+        self._gate_names = gates
+
+    def commute_nodes(
+        self,
+        op1,
+        op2,
+        max_num_qubits: int = 3,
+    ) -> bool:
+        """Checks if two DAGOpNodes commute."""
+        qargs1 = op1.qargs
+        cargs1 = op2.cargs
+        if not op1.is_standard_gate():
+            op1 = op1.op
+        qargs2 = op2.qargs
+        cargs2 = op2.cargs
+        if not op2.is_standard_gate():
+            op2 = op2.op
+        return self.commute(op1, qargs1, cargs1, op2, qargs2, cargs2, max_num_qubits)
 
     def commute(
         self,
@@ -86,6 +131,11 @@ class CommutationChecker:
         Returns:
             bool: whether two operations commute.
         """
+        # Skip gates that are not specified.
+        if self._gate_names is not None:
+            if op1.name not in self._gate_names or op2.name not in self._gate_names:
+                return False
+
         structural_commutation = _commutation_precheck(
             op1, qargs1, cargs1, op2, qargs2, cargs2, max_num_qubits
         )
@@ -214,53 +264,38 @@ def _hashable_parameters(params):
     return ("fallback", str(params))
 
 
-def is_commutation_supported(op):
+def is_commutation_supported(op, qargs, max_num_qubits):
     """
     Filter operations whose commutation is not supported due to bugs in transpiler passes invoking
     commutation analysis.
     Args:
-        op (Operation): operation to be checked for commutation relation
+        op (Operation): operation to be checked for commutation relation.
+        qargs (list[Qubit]): qubits the operation acts on.
+        max_num_qubits (int): The maximum number of qubits to check commutativity for.
+
     Return:
         True if determining the commutation of op is currently supported
     """
-    # Bug in CommutativeCancellation, e.g. see gh-8553
-    if getattr(op, "condition", False):
+    # If the number of qubits is beyond what we check, stop here and do not even check in the
+    # pre-defined supported operations
+    if len(qargs) > max_num_qubits:
         return False
 
+    # Check if the operation is pre-approved, otherwise go through the checks
+    if op.name in _supported_ops:
+        return True
+
     # Commutation of ControlFlow gates also not supported yet. This may be pending a control flow graph.
     if op.name in CONTROL_FLOW_OP_NAMES:
         return False
 
-    return True
-
-
-def is_commutation_skipped(op, qargs, max_num_qubits):
-    """
-    Filter operations whose commutation will not be determined.
-    Args:
-        op (Operation): operation to be checked for commutation relation
-        qargs (List): operation qubits
-        max_num_qubits (int): the maximum number of qubits to consider, the check may be skipped if
-                the number of qubits for either operation exceeds this amount.
-    Return:
-        True if determining the commutation of op is currently not supported
-    """
-    if (
-        len(qargs) > max_num_qubits
-        or getattr(op, "_directive", False)
-        or op.name in _skipped_op_names
-    ):
-        return True
+    if getattr(op, "_directive", False) or op.name in _skipped_op_names:
+        return False
 
     if getattr(op, "is_parameterized", False) and op.is_parameterized():
-        return True
-
-    # we can proceed if op has defined: to_operator, to_matrix and __array__, or if its definition can be
-    # recursively resolved by operations that have a matrix. We check this by constructing an Operator.
-    if (hasattr(op, "to_matrix") and hasattr(op, "__array__")) or hasattr(op, "to_operator"):
         return False
 
-    return False
+    return True
 
 
 def _commutation_precheck(
@@ -272,13 +307,14 @@ def _commutation_precheck(
     cargs2: List,
     max_num_qubits,
 ):
-    if not is_commutation_supported(op1) or not is_commutation_supported(op2):
+    # Bug in CommutativeCancellation, e.g. see gh-8553
+    if getattr(op1, "condition", False) or getattr(op2, "condition", False):
         return False
 
     if set(qargs1).isdisjoint(qargs2) and set(cargs1).isdisjoint(cargs2):
         return True
 
-    if is_commutation_skipped(op1, qargs1, max_num_qubits) or is_commutation_skipped(
+    if not is_commutation_supported(op1, qargs1, max_num_qubits) or not is_commutation_supported(
         op2, qargs2, max_num_qubits
     ):
         return False
@@ -386,7 +422,10 @@ def _query_commutation(
             first_params = getattr(first_op, "params", [])
             second_params = getattr(second_op, "params", [])
             return commutation_after_placement.get(
-                (_hashable_parameters(first_params), _hashable_parameters(second_params)),
+                (
+                    _hashable_parameters(first_params),
+                    _hashable_parameters(second_params),
+                ),
                 None,
             )
         else:
@@ -409,6 +448,15 @@ def _commute_matmul(
     first_qarg = tuple(qarg[q] for q in first_qargs)
     second_qarg = tuple(qarg[q] for q in second_qargs)
 
+    from qiskit.dagcircuit.dagnode import DAGOpNode
+
+    # If we have a DAGOpNode here we've received a StandardGate definition from
+    # rust and we can manually pull the matrix to use for the Operators
+    if isinstance(first_ops, DAGOpNode):
+        first_ops = first_ops.matrix
+    if isinstance(second_op, DAGOpNode):
+        second_op = second_op.matrix
+
     # try to generate an Operator out of op, if this succeeds we can determine commutativity, otherwise
     # return false
     try:

qiskit/circuit/controlflow/_builder_utils.py

@@ -127,7 +127,7 @@ def unify_circuit_resources(circuits: Iterable[QuantumCircuit]) -> Iterable[Quan
     This function will preferentially try to mutate its inputs if they share an ordering, but if
     not, it will rebuild two new circuits.  This is to avoid coupling too tightly to the inner
     class; there is no real support for deleting or re-ordering bits within a :obj:`.QuantumCircuit`
-    context, and we don't want to rely on the *current* behaviour of the private APIs, since they
+    context, and we don't want to rely on the *current* behavior of the private APIs, since they
     are very liable to change.  No matter the method used, circuits with unified bits and registers
     are returned.
     """

qiskit/circuit/controlflow/builder.py

@@ -13,7 +13,7 @@
 """Builder types for the basic control-flow constructs."""
 
 # This file is in circuit.controlflow rather than the root of circuit because the constructs here
-# are only intended to be localised to constructing the control flow instructions.  We anticipate
+# are only intended to be localized to constructing the control flow instructions.  We anticipate
 # having a far more complete builder of all circuits, with more classical control and creation, in
 # the future.
 
@@ -57,7 +57,9 @@ class CircuitScopeInterface(abc.ABC):
         """Indexable view onto the :class:`.CircuitInstruction`s backing this scope."""
 
     @abc.abstractmethod
-    def append(self, instruction: CircuitInstruction) -> CircuitInstruction:
+    def append(
+        self, instruction: CircuitInstruction, *, _standard_gate=False
+    ) -> CircuitInstruction:
         """Low-level 'append' primitive; this may assume that the qubits, clbits and operation are
         all valid for the circuit.
 
@@ -204,7 +206,7 @@ class InstructionPlaceholder(Instruction, abc.ABC):
     When appending a placeholder instruction into a circuit scope, you should create the
     placeholder, and then ask it what resources it should be considered as using from the start by
     calling :meth:`.InstructionPlaceholder.placeholder_instructions`.  This set will be a subset of
-    the final resources it asks for, but it is used for initialising resources that *must* be
+    the final resources it asks for, but it is used for initializing resources that *must* be
     supplied, such as the bits used in the conditions of placeholder ``if`` statements.
 
     .. warning::
@@ -358,7 +360,7 @@ class ControlFlowBuilderBlock(CircuitScopeInterface):
                 which use a classical register as their condition.
             allow_jumps: Whether this builder scope should allow ``break`` and ``continue``
                 statements within it.  This is intended to help give sensible error messages when
-                dangerous behaviour is encountered, such as using ``break`` inside an ``if`` context
+                dangerous behavior is encountered, such as using ``break`` inside an ``if`` context
                 manager that is not within a ``for`` manager.  This can only be safe if the user is
                 going to place the resulting :obj:`.QuantumCircuit` inside a :obj:`.ForLoopOp` that
                 uses *exactly* the same set of resources.  We cannot verify this from within the
@@ -393,7 +395,7 @@ class ControlFlowBuilderBlock(CircuitScopeInterface):
     def allow_jumps(self):
         """Whether this builder scope should allow ``break`` and ``continue`` statements within it.
 
-        This is intended to help give sensible error messages when dangerous behaviour is
+        This is intended to help give sensible error messages when dangerous behavior is
         encountered, such as using ``break`` inside an ``if`` context manager that is not within a
         ``for`` manager.  This can only be safe if the user is going to place the resulting
         :obj:`.QuantumCircuit` inside a :obj:`.ForLoopOp` that uses *exactly* the same set of
@@ -420,7 +422,9 @@ class ControlFlowBuilderBlock(CircuitScopeInterface):
                 " because it is not in a loop."
             )
 
-    def append(self, instruction: CircuitInstruction) -> CircuitInstruction:
+    def append(
+        self, instruction: CircuitInstruction, *, _standard_gate: bool = False
+    ) -> CircuitInstruction:
         if self._forbidden_message is not None:
             raise CircuitError(self._forbidden_message)
         if not self._allow_jumps:

qiskit/circuit/controlflow/if_else.py

@@ -199,7 +199,7 @@ class IfElsePlaceholder(InstructionPlaceholder):
         super().__init__(
             "if_else", len(self.__resources.qubits), len(self.__resources.clbits), [], label=label
         )
-        # Set the condition after super().__init__() has initialised it to None.
+        # Set the condition after super().__init__() has initialized it to None.
         self.condition = validate_condition(condition)
 
     def with_false_block(self, false_block: ControlFlowBuilderBlock) -> "IfElsePlaceholder":
@@ -236,7 +236,7 @@ class IfElsePlaceholder(InstructionPlaceholder):
     def _calculate_placeholder_resources(self) -> InstructionResources:
         """Get the placeholder resources (see :meth:`.placeholder_resources`).
 
-        This is a separate function because we use the resources during the initialisation to
+        This is a separate function because we use the resources during the initialization to
         determine how we should set our ``num_qubits`` and ``num_clbits``, so we implement the
         public version as a cache access for efficiency.
         """

qiskit/circuit/controlflow/switch_case.py

@@ -94,7 +94,7 @@ class SwitchCaseOp(ControlFlowOp):
         it's easier for things like `assign_parameters`, which need to touch each circuit object
         exactly once, to function."""
         self._label_spec: List[Tuple[Union[int, Literal[CASE_DEFAULT]], ...]] = []
-        """List of the normalised jump value specifiers.  This is a list of tuples, where each tuple
+        """List of the normalized jump value specifiers.  This is a list of tuples, where each tuple
         contains the values, and the indexing is the same as the values of `_case_map` and
         `_params`."""
         self._params = []

qiskit/circuit/delay.py

@@ -32,7 +32,7 @@ class Delay(Instruction):
             unit: the unit of the duration.  Must be ``"dt"`` or an SI-prefixed seconds unit.
         """
         if unit not in {"s", "ms", "us", "ns", "ps", "dt"}:
-            raise CircuitError("Unknown unit %s is specified." % unit)
+            raise CircuitError(f"Unknown unit {unit} is specified.")
 
         super().__init__("delay", 1, 0, params=[duration], unit=unit)
 

qiskit/circuit/duration.py

@@ -35,8 +35,8 @@ def duration_in_dt(duration_in_sec: float, dt_in_sec: float) -> int:
     rounding_error = abs(duration_in_sec - res * dt_in_sec)
     if rounding_error > 1e-15:
         warnings.warn(
-            "Duration is rounded to %d [dt] = %e [s] from %e [s]"
-            % (res, res * dt_in_sec, duration_in_sec),
+            f"Duration is rounded to {res:d} [dt] = {res * dt_in_sec:e} [s] "
+            f"from {duration_in_sec:e} [s]",
             UserWarning,
         )
     return res

qiskit/circuit/equivalence.py

@@ -249,7 +249,7 @@ class EquivalenceLibrary:
                     )
                     node_map[decomp_basis] = decomp_basis_node
 
-                label = "{}\n{}".format(str(params), str(decomp) if num_qubits <= 5 else "...")
+                label = f"{str(params)}\n{str(decomp) if num_qubits <= 5 else '...'}"
                 graph.add_edge(
                     node_map[basis],
                     node_map[decomp_basis],
@@ -273,8 +273,8 @@ def _raise_if_param_mismatch(gate_params, circuit_parameters):
     if set(gate_parameters) != circuit_parameters:
         raise CircuitError(
             "Cannot add equivalence between circuit and gate "
-            "of different parameters. Gate params: {}. "
-            "Circuit params: {}.".format(gate_parameters, circuit_parameters)
+            f"of different parameters. Gate params: {gate_parameters}. "
+            f"Circuit params: {circuit_parameters}."
         )
 
 
@@ -282,10 +282,8 @@ def _raise_if_shape_mismatch(gate, circuit):
     if gate.num_qubits != circuit.num_qubits or gate.num_clbits != circuit.num_clbits:
         raise CircuitError(
             "Cannot add equivalence between circuit and gate "
-            "of different shapes. Gate: {} qubits and {} clbits. "
-            "Circuit: {} qubits and {} clbits.".format(
-                gate.num_qubits, gate.num_clbits, circuit.num_qubits, circuit.num_clbits
-            )
+            f"of different shapes. Gate: {gate.num_qubits} qubits and {gate.num_clbits} clbits. "
+            f"Circuit: {circuit.num_qubits} qubits and {circuit.num_clbits} clbits."
         )
 
 

qiskit/circuit/gate.py

@@ -104,10 +104,9 @@ class Gate(Instruction):
         num_ctrl_qubits: int = 1,
         label: str | None = None,
         ctrl_state: int | str | None = None,
-        annotated: bool = False,
+        annotated: bool | None = None,
     ):
-        """
-        Return the controlled version of itself.
+        """Return the controlled version of itself.
 
         Implemented either as a controlled gate (ref. :class:`.ControlledGate`)
         or as an annotated operation (ref. :class:`.AnnotatedOperation`).
@@ -118,8 +117,12 @@ class Gate(Instruction):
                 operation.
             ctrl_state: the control state in decimal or as a bitstring
                 (e.g. ``'111'``). If ``None``, use ``2**num_ctrl_qubits-1``.
-            annotated: indicates whether the controlled gate can be implemented
-                as an annotated gate.
+            annotated: indicates whether the controlled gate is implemented
+                as an annotated gate. If ``None``, this is set to ``False``
+                if the controlled gate can directly be constructed, and otherwise
+                set to ``True``. This allows defering the construction process in case the
+                synthesis of the controlled gate requires more information (e.g.
+                values of unbound parameters).
 
         Returns:
             Controlled version of the given operation.
@@ -127,7 +130,7 @@ class Gate(Instruction):
         Raises:
             QiskitError: unrecognized mode or invalid ctrl_state
         """
-        if not annotated:
+        if not annotated:  # captures both None and False
             # pylint: disable=cyclic-import
             from .add_control import add_control
 
@@ -177,7 +180,7 @@ class Gate(Instruction):
             for arg in zip(*qargs):
                 yield list(arg), []
         else:
-            raise CircuitError("Not sure how to combine these qubit arguments:\n %s\n" % qargs)
+            raise CircuitError(f"Not sure how to combine these qubit arguments:\n {qargs}\n")
 
     def broadcast_arguments(self, qargs: list, cargs: list) -> Iterable[tuple[list, list]]:
         """Validation and handling of the arguments and its relationship.
@@ -236,7 +239,7 @@ class Gate(Instruction):
         elif len(qargs) >= 3:
             return Gate._broadcast_3_or_more_args(qargs)
         else:
-            raise CircuitError("This gate cannot handle %i arguments" % len(qargs))
+            raise CircuitError(f"This gate cannot handle {len(qargs)} arguments")
 
     def validate_parameter(self, parameter):
         """Gate parameters should be int, float, or ParameterExpression"""

qiskit/circuit/instruction.py

@@ -34,6 +34,7 @@ The circuit itself keeps this context.
 from __future__ import annotations
 
 import copy
+import warnings
 from itertools import zip_longest
 import math
 from typing import List, Type
@@ -47,7 +48,7 @@ from qiskit.circuit.parameter import ParameterExpression
 from qiskit.circuit.operation import Operation
 
 from qiskit.circuit.annotated_operation import AnnotatedOperation, InverseModifier
-
+from qiskit.utils import deprecate_func
 
 _CUTOFF_PRECISION = 1e-10
 
@@ -58,6 +59,7 @@ class Instruction(Operation):
     # Class attribute to treat like barrier for transpiler, unroller, drawer
     # NOTE: Using this attribute may change in the future (See issue # 5811)
     _directive = False
+    _standard_gate = None
 
     def __init__(self, name, num_qubits, num_clbits, params, duration=None, unit="dt", label=None):
         """Create a new instruction.
@@ -80,7 +82,7 @@ class Instruction(Operation):
             raise CircuitError("num_qubits and num_clbits must be integer.")
         if num_qubits < 0 or num_clbits < 0:
             raise CircuitError(
-                "bad instruction dimensions: %d qubits, %d clbits." % num_qubits, num_clbits
+                f"bad instruction dimensions: {num_qubits} qubits, {num_clbits} clbits."
             )
         self._name = name
         self._num_qubits = num_qubits
@@ -114,12 +116,12 @@ class Instruction(Operation):
         The "base class" of an instruction is the lowest class in its inheritance tree that the
         object should be considered entirely compatible with for _all_ circuit applications.  This
         typically means that the subclass is defined purely to offer some sort of programmer
-        convenience over the base class, and the base class is the "true" class for a behavioural
+        convenience over the base class, and the base class is the "true" class for a behavioral
         perspective.  In particular, you should *not* override :attr:`base_class` if you are
         defining a custom version of an instruction that will be implemented differently by
-        hardware, such as an alternative measurement strategy, or a version of a parametrised gate
+        hardware, such as an alternative measurement strategy, or a version of a parametrized gate
         with a particular set of parameters for the purposes of distinguishing it in a
-        :class:`.Target` from the full parametrised gate.
+        :class:`.Target` from the full parametrized gate.
 
         This is often exactly equivalent to ``type(obj)``, except in the case of singleton instances
         of standard-library instructions.  These singleton instances are special subclasses of their
@@ -187,11 +189,12 @@ class Instruction(Operation):
             return False
 
         for self_param, other_param in zip_longest(self.params, other.params):
-            try:
+            if isinstance(self_param, numpy.ndarray):
+                if numpy.array_equal(self_param, other_param):
+                    continue
+            else:
                 if self_param == other_param:
                     continue
-            except ValueError:
-                pass
 
             try:
                 self_asarray = numpy.asarray(self_param)
@@ -221,8 +224,9 @@ class Instruction(Operation):
             str: A representation of the Instruction instance with the name,
                  number of qubits, classical bits and params( if any )
         """
-        return "Instruction(name='{}', num_qubits={}, num_clbits={}, params={})".format(
-            self.name, self.num_qubits, self.num_clbits, self.params
+        return (
+            f"Instruction(name='{self.name}', num_qubits={self.num_qubits}, "
+            f"num_clbits={self.num_clbits}, params={self.params})"
         )
 
     def soft_compare(self, other: "Instruction") -> bool:
@@ -298,7 +302,7 @@ class Instruction(Operation):
         """Return whether the :class:`Instruction` contains :ref:`compile-time parameters
         <circuit-compile-time-parameters>`."""
         return any(
-            isinstance(param, ParameterExpression) and param.parameters for param in self.params
+            isinstance(param, ParameterExpression) and param.parameters for param in self._params
         )
 
     @property
@@ -356,9 +360,23 @@ class Instruction(Operation):
         """Set the time unit of duration."""
         self._unit = unit
 
+    @deprecate_func(
+        since="1.2",
+        removal_timeline="in the 2.0 release",
+        additional_msg="The `Qobj` class and related functionality are part of the deprecated "
+        "`BackendV1` workflow,  and no longer necessary for `BackendV2`. If a user "
+        "workflow requires `Qobj` it likely relies on deprecated functionality and "
+        "should be updated to use `BackendV2`.",
+    )
     def assemble(self):
         """Assemble a QasmQobjInstruction"""
-        instruction = QasmQobjInstruction(name=self.name)
+        return self._assemble()
+
+    def _assemble(self):
+        with warnings.catch_warnings():
+            # The class QasmQobjInstruction is deprecated
+            warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+            instruction = QasmQobjInstruction(name=self.name)
         # Evaluate parameters
         if self.params:
             params = [x.evalf(x) if hasattr(x, "evalf") else x for x in self.params]
@@ -455,7 +473,7 @@ class Instruction(Operation):
             return AnnotatedOperation(self, InverseModifier())
 
         if self.definition is None:
-            raise CircuitError("inverse() not implemented for %s." % self.name)
+            raise CircuitError(f"inverse() not implemented for {self.name}.")
 
         from qiskit.circuit import Gate  # pylint: disable=cyclic-import
 

qiskit/circuit/instructionset.py

@@ -140,13 +140,10 @@ class InstructionSet:
             )
         if self._requester is not None:
             classical = self._requester(classical)
-        for instruction in self._instructions:
+        for idx, instruction in enumerate(self._instructions):
             if isinstance(instruction, CircuitInstruction):
                 updated = instruction.operation.c_if(classical, val)
-                if updated is not instruction.operation:
-                    raise CircuitError(
-                        "SingletonGate instances can only be added to InstructionSet via _add_ref"
-                    )
+                self._instructions[idx] = instruction.replace(operation=updated)
             else:
                 data, idx = instruction
                 instruction = data[idx]

qiskit/circuit/library/__init__.py

@@ -226,6 +226,7 @@ the computational basis and the Fourier basis.
    :template: autosummary/class_no_inherited_members.rst
 
    QFT
+   QFTGate
 
 Arithmetic Circuits
 ===================
@@ -523,7 +524,7 @@ from .boolean_logic import (
     XOR,
     InnerProduct,
 )
-from .basis_change import QFT
+from .basis_change import QFT, QFTGate
 from .arithmetic import (
     FunctionalPauliRotations,
     LinearPauliRotations,

qiskit/circuit/library/arithmetic/linear_amplitude_function.py

@@ -119,7 +119,7 @@ class LinearAmplitudeFunction(QuantumCircuit):
         self._image = image
         self._rescaling_factor = rescaling_factor
 
-        # do rescalings
+        # do rescaling
         a, b = domain
         c, d = image
 

qiskit/circuit/library/arithmetic/linear_pauli_rotations.py

@@ -153,7 +153,7 @@ class LinearPauliRotations(FunctionalPauliRotations):
             if raise_on_failure:
                 raise CircuitError(
                     "Not enough qubits in the circuit, need at least "
-                    "{}.".format(self.num_state_qubits + 1)
+                    f"{self.num_state_qubits + 1}."
                 )
 
         return valid

qiskit/circuit/library/arithmetic/piecewise_chebyshev.py

@@ -122,7 +122,7 @@ class PiecewiseChebyshev(BlueprintCircuit):
             if raise_on_failure:
                 raise CircuitError(
                     "Not enough qubits in the circuit, need at least "
-                    "{}.".format(self.num_state_qubits + 1)
+                    f"{self.num_state_qubits + 1}."
                 )
 
         return valid