Fix mypy errors (circuit)

qiskit/circuit/add_control.py

@@ -11,19 +11,19 @@
 # that they have been altered from the originals.
 
 """Add control to operation if supported."""
-
-from typing import Union, Optional
+from __future__ import annotations
 
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.extensions import UnitaryGate
 from . import ControlledGate, Gate, QuantumRegister, QuantumCircuit
+from ._utils import _ctrl_state_to_int
 
 
 def add_control(
-    operation: Union[Gate, ControlledGate],
+    operation: Gate | ControlledGate,
     num_ctrl_qubits: int,
-    label: Union[str, None],
-    ctrl_state: Union[int, str, None],
+    label: str | None,
+    ctrl_state: str | int | None,
 ) -> ControlledGate:
     """For standard gates, if the controlled version already exists in the
     library, it will be returned (e.g. XGate.control() = CnotGate().
@@ -51,8 +51,6 @@ def add_control(
         Controlled version of gate.
 
     """
-    if ctrl_state is None:
-        ctrl_state = 2**num_ctrl_qubits - 1
     if isinstance(operation, UnitaryGate):
         # attempt decomposition
         operation._define()
@@ -62,10 +60,10 @@ def add_control(
 
 
 def control(
-    operation: Union[Gate, ControlledGate],
-    num_ctrl_qubits: Optional[int] = 1,
-    label: Optional[Union[None, str]] = None,
-    ctrl_state: Optional[Union[None, int, str]] = None,
+    operation: Gate | ControlledGate,
+    num_ctrl_qubits: int | None = 1,
+    label: str | None = None,
+    ctrl_state: str | int | None = None,
 ) -> ControlledGate:
     """Return controlled version of gate using controlled rotations. This function
     first checks the name of the operation to see if it knows of a method from which
@@ -93,6 +91,8 @@ def control(
     # pylint: disable=cyclic-import
     from qiskit.circuit import controlledgate
 
+    ctrl_state = _ctrl_state_to_int(ctrl_state, num_ctrl_qubits)
+
     q_control = QuantumRegister(num_ctrl_qubits, name="control")
     q_target = QuantumRegister(operation.num_qubits, name="target")
     q_ancillae = None  # TODO: add

qiskit/circuit/controlflow/control_flow.py

@@ -12,8 +12,9 @@
 
 "Container to encapsulate all control flow operations."
 
+from __future__ import annotations
 from abc import ABC, abstractmethod
-from typing import Tuple, Iterable
+from typing import Iterable
 
 from qiskit.circuit import QuantumCircuit, Instruction
 
@@ -23,7 +24,7 @@ class ControlFlowOp(Instruction, ABC):
 
     @property
     @abstractmethod
-    def blocks(self) -> Tuple[QuantumCircuit, ...]:
+    def blocks(self) -> tuple[QuantumCircuit, ...]:
         """Tuple of QuantumCircuits which may be executed as part of the
         execution of this ControlFlowOp. May be parameterized by a loop
         parameter to be resolved at run time.

qiskit/circuit/controlledgate.py

@@ -12,8 +12,9 @@
 
 """Controlled unitary gate."""
 
+from __future__ import annotations
 import copy
-from typing import List, Optional, Union
+from typing import Optional, Union
 
 from qiskit.circuit.exceptions import CircuitError
 
@@ -31,7 +32,7 @@ def __init__(
         self,
         name: str,
         num_qubits: int,
-        params: List,
+        params: list,
         label: Optional[str] = None,
         num_ctrl_qubits: Optional[int] = 1,
         definition: Optional["QuantumCircuit"] = None,
@@ -103,7 +104,7 @@ def __init__(
         self._name = name
 
     @property
-    def definition(self) -> List:
+    def definition(self) -> QuantumCircuit:
         """Return definition in terms of other basic gates. If the gate has
         open controls, as determined from `self.ctrl_state`, the returned
         definition is conjugated with X without changing the internal

qiskit/circuit/gate.py

@@ -12,7 +12,8 @@
 
 """Unitary gate."""
 
-from typing import List, Optional, Union, Tuple
+from __future__ import annotations
+from typing import Any, Iterator, Iterable
 import numpy as np
 
 from qiskit.circuit.parameterexpression import ParameterExpression
@@ -24,7 +25,7 @@ class Gate(Instruction):
     """Unitary gate."""
 
     def __init__(
-        self, name: str, num_qubits: int, params: List, label: Optional[str] = None
+        self, name: str, num_qubits: int, params: list[Any], label: str | None = None
     ) -> None:
         """Create a new gate.
 
@@ -95,8 +96,8 @@ def _return_repeat(self, exponent: float) -> "Gate":
     def control(
         self,
         num_ctrl_qubits: int = 1,
-        label: Optional[str] = None,
-        ctrl_state: Optional[Union[int, str]] = None,
+        label: str | None = None,
+        ctrl_state: int | str | None = None,
     ):
         """Return controlled version of gate. See :class:`.ControlledGate` for usage.
 
@@ -120,7 +121,7 @@ def control(
         return add_control(self, num_ctrl_qubits, label, ctrl_state)
 
     @staticmethod
-    def _broadcast_single_argument(qarg: List) -> List:
+    def _broadcast_single_argument(qarg: list[Any]) -> Iterator[tuple[list[Any], list[Any]]]:
         """Expands a single argument.
 
         For example: [q[0], q[1]] -> [q[0]], [q[1]]
@@ -131,7 +132,9 @@ def _broadcast_single_argument(qarg: List) -> List:
             yield [arg0], []
 
     @staticmethod
-    def _broadcast_2_arguments(qarg0: List, qarg1: List) -> List:
+    def _broadcast_2_arguments(
+        qarg0: list[Any], qarg1: list[Any]
+    ) -> Iterator[tuple[list[Any], list[Any]]]:
         if len(qarg0) == len(qarg1):
             # [[q[0], q[1]], [r[0], r[1]]] -> [q[0], r[0]]
             #                              -> [q[1], r[1]]
@@ -153,14 +156,16 @@ def _broadcast_2_arguments(qarg0: List, qarg1: List) -> List:
             )
 
     @staticmethod
-    def _broadcast_3_or_more_args(qargs: List) -> List:
+    def _broadcast_3_or_more_args(qargs: list[Any]) -> Iterator[tuple[list[Any], list[Any]]]:
         if all(len(qarg) == len(qargs[0]) for qarg in qargs):
             for arg in zip(*qargs):
                 yield list(arg), []
         else:
             raise CircuitError("Not sure how to combine these qubit arguments:\n %s\n" % qargs)
 
-    def broadcast_arguments(self, qargs: List, cargs: List) -> Tuple[List, List]:
+    def broadcast_arguments(
+        self, qargs: list[Any], cargs: list[Any]
+    ) -> Iterable[tuple[list[Any], list[Any]]]:
         """Validation and handling of the arguments and its relationship.
 
         For example, ``cx([q[0],q[1]], q[2])`` means ``cx(q[0], q[2]); cx(q[1], q[2])``. This

qiskit/circuit/instructionset.py

@@ -14,9 +14,10 @@
 Instruction collection.
 """
 
+from __future__ import annotations
 import functools
 import warnings
-from typing import Callable, Optional, Tuple, Union
+from typing import Callable
 
 from qiskit.circuit.exceptions import CircuitError
 from .classicalregister import Clbit, ClassicalRegister
@@ -28,7 +29,9 @@
 # its creation, so caching this allows us to only pay the register-unrolling penalty once.  The
 # cache does not need to be large, because in general only one circuit is constructed at once.
 @functools.lru_cache(4)
-def _requester_from_cregs(cregs: Tuple[ClassicalRegister]) -> Callable:
+def _requester_from_cregs(
+    cregs: tuple[ClassicalRegister],
+) -> Callable[[Clbit | ClassicalRegister | int], ClassicalRegister | Clbit]:
     """Get a classical resource requester from an iterable of classical registers.
 
     This implements the deprecated functionality of constructing an :obj:`.InstructionSet` with a
@@ -60,7 +63,7 @@ def _requester_from_cregs(cregs: Tuple[ClassicalRegister]) -> Callable:
     clbit_set = frozenset(clbit_flat)
     creg_set = frozenset(cregs)
 
-    def requester(classical):
+    def requester(classical: Clbit | ClassicalRegister | int) -> ClassicalRegister | Clbit:
         if isinstance(classical, Clbit):
             if classical not in clbit_set:
                 raise CircuitError(
@@ -92,7 +95,12 @@ class InstructionSet:
 
     __slots__ = ("_instructions", "_requester")
 
-    def __init__(self, circuit_cregs=None, *, resource_requester: Optional[Callable] = None):
+    def __init__(
+        self,
+        circuit_cregs: list[ClassicalRegister] | None = None,
+        *,
+        resource_requester: Callable[..., ClassicalRegister | Clbit] | None = None,
+    ):
         """New collection of instructions.
 
         The context (``qargs`` and ``cargs`` that each instruction is attached to) is also stored
@@ -124,7 +132,7 @@ def __init__(self, circuit_cregs=None, *, resource_requester: Optional[Callable]
             CircuitError: if both ``resource_requester`` and ``circuit_cregs`` are passed.  Only one
                 of these may be passed, and it should be ``resource_requester``.
         """
-        self._instructions = []
+        self._instructions: list[CircuitInstruction] = []
         if circuit_cregs is not None:
             if resource_requester is not None:
                 raise CircuitError("Cannot pass both 'circuit_cregs' and 'resource_requester'.")
@@ -135,7 +143,9 @@ def __init__(self, circuit_cregs=None, *, resource_requester: Optional[Callable]
                 DeprecationWarning,
                 stacklevel=2,
             )
-            self._requester: Optional[Callable] = _requester_from_cregs(tuple(circuit_cregs))
+            self._requester: Callable[..., ClassicalRegister | Clbit] = _requester_from_cregs(
+                tuple(circuit_cregs)
+            )
         else:
             self._requester = resource_requester
 
@@ -163,7 +173,7 @@ def inverse(self):
             self._instructions[i] = instruction.replace(operation=instruction.operation.inverse())
         return self
 
-    def c_if(self, classical: Union[Clbit, ClassicalRegister, int], val: int) -> "InstructionSet":
+    def c_if(self, classical: Clbit | ClassicalRegister | int, val: int) -> "InstructionSet":
         """Set a classical equality condition on all the instructions in this set between the
         :obj:`.ClassicalRegister` or :obj:`.Clbit` ``classical`` and value ``val``.
 

qiskit/circuit/library/arithmetic/adders/vbe_ripple_carry_adder.py

@@ -11,6 +11,8 @@
 # that they have been altered from the originals.
 
 """Compute the sum of two qubit registers using Classical Addition."""
+from __future__ import annotations
+from qiskit.circuit.bit import Bit
 
 from qiskit.circuit import QuantumCircuit, QuantumRegister, AncillaRegister
 
@@ -78,12 +80,12 @@ def __init__(
         super().__init__(num_state_qubits, name=name)
 
         # define the input registers
-        registers = []
+        registers: list[QuantumRegister | list[Bit]] = []
         if kind == "full":
             qr_cin = QuantumRegister(1, name="cin")
             registers.append(qr_cin)
         else:
-            qr_cin = []
+            qr_cin = QuantumRegister(0)
 
         qr_a = QuantumRegister(num_state_qubits, name="a")
         qr_b = QuantumRegister(num_state_qubits, name="b")
@@ -94,15 +96,15 @@ def __init__(
             qr_cout = QuantumRegister(1, name="cout")
             registers.append(qr_cout)
         else:
-            qr_cout = []
+            qr_cout = QuantumRegister(0)
 
         self.add_register(*registers)
 
         if num_state_qubits > 1:
             qr_help = AncillaRegister(num_state_qubits - 1, name="helper")
             self.add_register(qr_help)
         else:
-            qr_help = []
+            qr_help = AncillaRegister(0)
 
         # the code is simplified a lot if we create a list of all carries and helpers
         carries = qr_cin[:] + qr_help[:] + qr_cout[:]

qiskit/circuit/library/arithmetic/integer_comparator.py

@@ -13,7 +13,7 @@
 
 """Integer Comparator."""
 
-from typing import List, Optional
+from __future__ import annotations
 import warnings
 import numpy as np
 
@@ -41,8 +41,8 @@ class IntegerComparator(BlueprintCircuit):
 
     def __init__(
         self,
-        num_state_qubits: Optional[int] = None,
-        value: Optional[int] = None,
+        num_state_qubits: int | None = None,
+        value: int | None = None,
         geq: bool = True,
         name: str = "cmp",
     ) -> None:
@@ -120,7 +120,7 @@ def num_state_qubits(self) -> int:
         return self._num_state_qubits
 
     @num_state_qubits.setter
-    def num_state_qubits(self, num_state_qubits: Optional[int]) -> None:
+    def num_state_qubits(self, num_state_qubits: int | None) -> None:
         """Set the number of state qubits.
 
         Note that this will change the quantum registers.
@@ -145,7 +145,7 @@ def num_state_qubits(self, num_state_qubits: Optional[int]) -> None:
                     qr_ancilla = AncillaRegister(num_ancillas)
                     self.add_register(qr_ancilla)
 
-    def _get_twos_complement(self) -> List[int]:
+    def _get_twos_complement(self) -> list[int]:
         """Returns the 2's complement of ``self.value`` as array.
 
         Returns:

qiskit/circuit/library/arithmetic/linear_amplitude_function.py

@@ -12,7 +12,7 @@
 
 """A class implementing a (piecewise-) linear function on qubit amplitudes."""
 
-from typing import Optional, List, Union, Tuple
+from __future__ import annotations
 import numpy as np
 from qiskit.circuit import QuantumCircuit
 
@@ -77,12 +77,12 @@ class LinearAmplitudeFunction(QuantumCircuit):
     def __init__(
         self,
         num_state_qubits: int,
-        slope: Union[float, List[float]],
-        offset: Union[float, List[float]],
-        domain: Tuple[float, float],
-        image: Tuple[float, float],
+        slope: float | list[float],
+        offset: float | list[float],
+        domain: tuple[float, float],
+        image: tuple[float, float],
         rescaling_factor: float = 1,
-        breakpoints: Optional[List[float]] = None,
+        breakpoints: list[float] | None = None,
         name: str = "F",
     ) -> None:
         r"""