cirq-core 1.6.0.dev20250520054601__py3-none-any.whl → 1.6.0.dev20250520183459__py3-none-any.whl

cirq/ops/qubit_manager.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import abc
 import dataclasses
-from typing import Iterable, List, Tuple, TYPE_CHECKING
+from typing import Iterable, TYPE_CHECKING
 
 from cirq.ops import raw_types
 
@@ -26,11 +26,11 @@ if TYPE_CHECKING:
 
 class QubitManager(metaclass=abc.ABCMeta):
     @abc.abstractmethod
-    def qalloc(self, n: int, dim: int = 2) -> List[cirq.Qid]:
+    def qalloc(self, n: int, dim: int = 2) -> list[cirq.Qid]:
         """Allocate `n` clean qubits, i.e. qubits guaranteed to be in state |0>."""
 
     @abc.abstractmethod
-    def qborrow(self, n: int, dim: int = 2) -> List[cirq.Qid]:
+    def qborrow(self, n: int, dim: int = 2) -> list[cirq.Qid]:
         """Allocate `n` dirty qubits, i.e. the returned qubits can be in any state."""
 
     @abc.abstractmethod
@@ -44,7 +44,7 @@ class _BaseAncillaQid(raw_types.Qid):
     dim: int = 2
     prefix: str = ''
 
-    def _comparison_key(self) -> Tuple[str, int]:
+    def _comparison_key(self) -> tuple[str, int]:
         return self.prefix, self.id
 
     @property
@@ -84,11 +84,11 @@ class SimpleQubitManager(QubitManager):
         self._borrow_id = 0
         self._prefix = prefix
 
-    def qalloc(self, n: int, dim: int = 2) -> List[cirq.Qid]:
+    def qalloc(self, n: int, dim: int = 2) -> list[cirq.Qid]:
         self._clean_id += n
         return [CleanQubit(i, dim, self._prefix) for i in range(self._clean_id - n, self._clean_id)]
 
-    def qborrow(self, n: int, dim: int = 2) -> List[cirq.Qid]:
+    def qborrow(self, n: int, dim: int = 2) -> list[cirq.Qid]:
         self._borrow_id = self._borrow_id + n
         return [
             BorrowableQubit(i, dim, self._prefix)

cirq/ops/qubit_order.py

@@ -15,7 +15,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable, Iterable, Optional, Tuple, TYPE_CHECKING, TypeVar
+from typing import Any, Callable, Iterable, Optional, TYPE_CHECKING, TypeVar
 
 if TYPE_CHECKING:
     import cirq
@@ -28,7 +28,7 @@ TExternalQubit = TypeVar('TExternalQubit')
 class QubitOrder:
     """Defines the kronecker product order of qubits."""
 
-    def __init__(self, explicit_func: Callable[[Iterable[cirq.Qid]], Tuple[cirq.Qid, ...]]) -> None:
+    def __init__(self, explicit_func: Callable[[Iterable[cirq.Qid]], tuple[cirq.Qid, ...]]) -> None:
         self._explicit_func = explicit_func
 
     DEFAULT: QubitOrder
@@ -87,7 +87,7 @@ class QubitOrder:
         """
         return QubitOrder(lambda qubits: tuple(sorted(qubits, key=key)))
 
-    def order_for(self, qubits: Iterable[cirq.Qid]) -> Tuple[cirq.Qid, ...]:
+    def order_for(self, qubits: Iterable[cirq.Qid]) -> tuple[cirq.Qid, ...]:
         """Returns a qubit tuple ordered corresponding to the basis.
 
         Args:

cirq/ops/random_gate_channel.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import numbers
-from typing import AbstractSet, Any, cast, Dict, Optional, SupportsFloat, Tuple, TYPE_CHECKING
+from typing import AbstractSet, Any, cast, SupportsFloat, TYPE_CHECKING
 
 import numpy as np
 
@@ -54,7 +54,7 @@ class RandomGateChannel(raw_types.Gate):
     def probability(self) -> cirq.TParamVal:
         return self._probability
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return protocols.qid_shape(self.sub_gate)
 
     def _value_equality_values_(self):
@@ -123,7 +123,7 @@ class RandomGateChannel(raw_types.Gate):
             result *= float(self.probability)
         return result
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['sub_gate', 'probability'])
 
     @classmethod
@@ -132,7 +132,7 @@ class RandomGateChannel(raw_types.Gate):
 
     def _circuit_diagram_info_(
         self, args: cirq.CircuitDiagramInfoArgs
-    ) -> Optional[cirq.CircuitDiagramInfo]:
+    ) -> cirq.CircuitDiagramInfo | None:
         result = protocols.circuit_diagram_info(self.sub_gate, args, None)
         if result is None:
             return None

cirq/ops/raw_types.py

@@ -25,17 +25,11 @@ from typing import (
     Callable,
     cast,
     Collection,
-    Dict,
-    FrozenSet,
     Hashable,
     Iterable,
-    List,
     Mapping,
-    Optional,
     Sequence,
-    Tuple,
     TYPE_CHECKING,
-    Union,
 )
 
 import numpy as np
@@ -118,7 +112,7 @@ class Qid(metaclass=abc.ABCMeta):
     def __hash__(self) -> int:
         return hash((Qid, self._comparison_key()))
 
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         # clear cached hash value when pickling, see #6674
         state = self.__dict__
         hash_attr = _method_cache_name(self.__hash__)
@@ -191,7 +185,7 @@ class _QubitAsQid(Qid):
     def __str__(self) -> str:
         return f'{self.qubit!s} (d={self.dimension})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['qubit', 'dimension'])
 
 
@@ -244,7 +238,7 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
         """
         return ops.gate_operation.GateOperation(self, qubits)
 
-    def on_each(self, *targets: Union[Qid, Iterable[Any]]) -> List[cirq.Operation]:
+    def on_each(self, *targets: Qid | Iterable[Any]) -> list[cirq.Operation]:
         """Returns a list of operations applying the gate to all targets.
 
         Args:
@@ -262,7 +256,7 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
                 If the gate qubit number is incompatible.
             TypeError: If a single target is supplied and it is not iterable.
         """
-        operations: List[cirq.Operation] = []
+        operations: list[cirq.Operation] = []
         if self._num_qubits_() > 1:
             iterator: Iterable = targets
             if len(targets) == 1:
@@ -323,16 +317,12 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
         """
         return ops.linear_combinations.LinearCombinationOfGates({self: coefficient})
 
-    def __add__(
-        self, other: Union[Gate, cirq.LinearCombinationOfGates]
-    ) -> cirq.LinearCombinationOfGates:
+    def __add__(self, other: Gate | cirq.LinearCombinationOfGates) -> cirq.LinearCombinationOfGates:
         if isinstance(other, Gate):
             return self.wrap_in_linear_combination() + other.wrap_in_linear_combination()
         return self.wrap_in_linear_combination() + other
 
-    def __sub__(
-        self, other: Union[Gate, cirq.LinearCombinationOfGates]
-    ) -> cirq.LinearCombinationOfGates:
+    def __sub__(self, other: Gate | cirq.LinearCombinationOfGates) -> cirq.LinearCombinationOfGates:
         if isinstance(other, Gate):
             return self.wrap_in_linear_combination() - other.wrap_in_linear_combination()
         return self.wrap_in_linear_combination() - other
@@ -388,11 +378,9 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
 
     def controlled(
         self,
-        num_controls: Optional[int] = None,
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
-        control_qid_shape: Optional[Tuple[int, ...]] = None,
+        num_controls: int | None = None,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
+        control_qid_shape: tuple[int, ...] | None = None,
     ) -> Gate:
         """Returns a controlled version of this gate. If no arguments are
         specified, defaults to a single qubit control.
@@ -430,7 +418,7 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
     def _backwards_compatibility_num_qubits(self) -> int:
         return protocols.num_qubits(self)
 
-    def _has_stabilizer_effect_(self) -> Optional[bool]:
+    def _has_stabilizer_effect_(self) -> bool | None:
         return NotImplemented
 
     @value.alternative(requires='_num_qubits_', implementation=_backwards_compatibility_num_qubits)
@@ -453,14 +441,14 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
         """The number of qubits this gate acts on."""
         raise NotImplementedError
 
-    def _default_shape_from_num_qubits(self) -> Tuple[int, ...]:
+    def _default_shape_from_num_qubits(self) -> tuple[int, ...]:
         num_qubits = self._num_qubits_()
         if num_qubits is NotImplemented:
             return NotImplemented
         return (2,) * num_qubits
 
     @value.alternative(requires='_num_qubits_', implementation=_default_shape_from_num_qubits)
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         """Returns a Tuple containing the number of quantum levels of each qid
         the gate acts on.  E.g. (2, 2, 2) for the three-qubit CCZ gate and
         (3, 3) for a 2-qutrit ternary gate.
@@ -469,7 +457,7 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
 
     def _equal_up_to_global_phase_(
         self, other: Any, atol: float = 1e-8
-    ) -> Union[NotImplementedType, bool]:
+    ) -> NotImplementedType | bool:
         """Default fallback for gates that do not implement this protocol."""
         try:
             return protocols.equal_up_to_global_phase(
@@ -481,12 +469,10 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
 
     def _commutes_on_qids_(
         self, qids: Sequence[cirq.Qid], other: Any, *, atol: float = 1e-8
-    ) -> Union[bool, NotImplementedType, None]:
+    ) -> bool | NotImplementedType | None:
         return NotImplemented
 
-    def _commutes_(
-        self, other: Any, *, atol: float = 1e-8
-    ) -> Union[None, NotImplementedType, bool]:
+    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> None | NotImplementedType | bool:
         if not isinstance(other, Gate):
             return NotImplemented
         if protocols.qid_shape(self) != protocols.qid_shape(other):
@@ -495,15 +481,15 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
         qs = line_qubit.LineQid.for_qid_shape(protocols.qid_shape(self))
         return protocols.commutes(self(*qs), other(*qs))
 
-    def _mul_with_qubits(self, qubits: Tuple[cirq.Qid, ...], other):
+    def _mul_with_qubits(self, qubits: tuple[cirq.Qid, ...], other):
         """cirq.GateOperation.__mul__ delegates to this method."""
         return NotImplemented
 
-    def _rmul_with_qubits(self, qubits: Tuple[cirq.Qid, ...], other):
+    def _rmul_with_qubits(self, qubits: tuple[cirq.Qid, ...], other):
         """cirq.GateOperation.__rmul__ delegates to this method."""
         return NotImplemented
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, attribute_names=[])
 
 
@@ -515,12 +501,12 @@ class Operation(metaclass=abc.ABCMeta):
     """
 
     @property
-    def gate(self) -> Optional[cirq.Gate]:
+    def gate(self) -> cirq.Gate | None:
         return None
 
     @property
     @abc.abstractmethod
-    def qubits(self) -> Tuple[cirq.Qid, ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         raise NotImplementedError()
 
     def _num_qubits_(self) -> int:
@@ -531,7 +517,7 @@ class Operation(metaclass=abc.ABCMeta):
         return len(self.qubits)
 
     @cached_method
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return protocols.qid_shape(self.qubits)
 
     @abc.abstractmethod
@@ -545,7 +531,7 @@ class Operation(metaclass=abc.ABCMeta):
         """
 
     @property
-    def tags(self) -> Tuple[Hashable, ...]:
+    def tags(self) -> tuple[Hashable, ...]:
         """Returns a tuple of the operation's tags."""
         return ()
 
@@ -580,7 +566,7 @@ class Operation(metaclass=abc.ABCMeta):
         return TaggedOperation(self, *new_tags)
 
     def transform_qubits(
-        self, qubit_map: Union[Dict[cirq.Qid, cirq.Qid], Callable[[cirq.Qid], cirq.Qid]]
+        self, qubit_map: dict[cirq.Qid, cirq.Qid] | Callable[[cirq.Qid], cirq.Qid]
     ) -> Self:
         """Returns the same operation, but with different qubits.
 
@@ -626,9 +612,7 @@ class Operation(metaclass=abc.ABCMeta):
     def controlled_by(
         self,
         *control_qubits: cirq.Qid,
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
     ) -> cirq.Operation:
         """Returns a controlled version of this operation. If no control_qubits
            are specified, returns self.
@@ -685,21 +669,19 @@ class Operation(metaclass=abc.ABCMeta):
         if __cirq_debug__.get():
             _validate_qid_shape(self, qubits)
 
-    def _commutes_(
-        self, other: Any, *, atol: float = 1e-8
-    ) -> Union[bool, NotImplementedType, None]:
+    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> bool | NotImplementedType | None:
         """Determine if this Operation commutes with the object"""
         if not isinstance(other, Operation):
             return NotImplemented
         return _operations_commutes_impl([self], [other], atol=atol)
 
     @property
-    def classical_controls(self) -> FrozenSet[cirq.Condition]:
+    def classical_controls(self) -> frozenset[cirq.Condition]:
         """The classical controls gating this operation."""
         return frozenset()
 
     def with_classical_controls(
-        self, *conditions: Union[str, cirq.MeasurementKey, cirq.Condition, sympy.Expr]
+        self, *conditions: str | cirq.MeasurementKey | cirq.Condition | sympy.Expr
     ) -> cirq.Operation:
         """Returns a classically controlled version of this operation.
 
@@ -780,11 +762,11 @@ class TaggedOperation(Operation):
         return self._sub_operation
 
     @property
-    def qubits(self) -> Tuple[cirq.Qid, ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         return self.sub_operation.qubits
 
     @property
-    def gate(self) -> Optional[cirq.Gate]:
+    def gate(self) -> cirq.Gate | None:
         return self.sub_operation.gate
 
     def with_qubits(self, *new_qubits: cirq.Qid):
@@ -799,16 +781,14 @@ class TaggedOperation(Operation):
     def controlled_by(
         self,
         *control_qubits: cirq.Qid,
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
     ) -> cirq.Operation:
         if len(control_qubits) == 0:
             return self
         return self.sub_operation.controlled_by(*control_qubits, control_values=control_values)
 
     @property
-    def tags(self) -> Tuple[Hashable, ...]:
+    def tags(self) -> tuple[Hashable, ...]:
         """Returns a tuple of the operation's tags."""
         return self._tags
 
@@ -845,14 +825,14 @@ class TaggedOperation(Operation):
     def _from_json_dict_(cls, sub_operation, tags, **kwargs):
         return cls(sub_operation, *tags)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['sub_operation', 'tags'])
 
     def _decompose_(self) -> cirq.OP_TREE:
         return self._decompose_with_context_()
 
     def _decompose_with_context_(
-        self, context: Optional[cirq.DecompositionContext] = None
+        self, context: cirq.DecompositionContext | None = None
     ) -> cirq.OP_TREE:
         return protocols.decompose_once(
             self.sub_operation, default=None, flatten=False, context=context
@@ -863,41 +843,39 @@ class TaggedOperation(Operation):
 
     def _apply_unitary_(
         self, args: protocols.ApplyUnitaryArgs
-    ) -> Union[np.ndarray, None, NotImplementedType]:
+    ) -> np.ndarray | None | NotImplementedType:
         return protocols.apply_unitary(self.sub_operation, args, default=None)
 
     @cached_method
     def _has_unitary_(self) -> bool:
         return protocols.has_unitary(self.sub_operation)
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         return protocols.unitary(self.sub_operation, NotImplemented)
 
-    def _commutes_(
-        self, other: Any, *, atol: float = 1e-8
-    ) -> Union[bool, NotImplementedType, None]:
+    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> bool | NotImplementedType | None:
         return protocols.commutes(self.sub_operation, other, atol=atol)
 
     @cached_method
     def _has_mixture_(self) -> bool:
         return protocols.has_mixture(self.sub_operation)
 
-    def _mixture_(self) -> Sequence[Tuple[float, Any]]:
+    def _mixture_(self) -> Sequence[tuple[float, Any]]:
         return protocols.mixture(self.sub_operation, NotImplemented)
 
     @cached_method
     def _has_kraus_(self) -> bool:
         return protocols.has_kraus(self.sub_operation)
 
-    def _kraus_(self) -> Union[Tuple[np.ndarray, ...], NotImplementedType]:
+    def _kraus_(self) -> tuple[np.ndarray, ...] | NotImplementedType:
         return protocols.kraus(self.sub_operation, NotImplemented)
 
     @cached_method
-    def _measurement_key_names_(self) -> FrozenSet[str]:
+    def _measurement_key_names_(self) -> frozenset[str]:
         return protocols.measurement_key_names(self.sub_operation)
 
     @cached_method
-    def _measurement_key_objs_(self) -> FrozenSet[cirq.MeasurementKey]:
+    def _measurement_key_objs_(self) -> frozenset[cirq.MeasurementKey]:
         return protocols.measurement_key_objs(self.sub_operation)
 
     @cached_method
@@ -960,16 +938,16 @@ class TaggedOperation(Operation):
     def __rmul__(self, other: Any) -> Any:
         return other * self.sub_operation
 
-    def _qasm_(self, args: protocols.QasmArgs) -> Optional[str]:
+    def _qasm_(self, args: protocols.QasmArgs) -> str | None:
         return protocols.qasm(self.sub_operation, args=args, default=None)
 
     def _equal_up_to_global_phase_(
         self, other: Any, atol: float = 1e-8
-    ) -> Union[NotImplementedType, bool]:
+    ) -> NotImplementedType | bool:
         return protocols.equal_up_to_global_phase(self.sub_operation, other, atol=atol)
 
     @property
-    def classical_controls(self) -> FrozenSet[cirq.Condition]:
+    def classical_controls(self) -> frozenset[cirq.Condition]:
         return self.sub_operation.classical_controls
 
     def without_classical_controls(self) -> cirq.Operation:
@@ -977,13 +955,13 @@ class TaggedOperation(Operation):
         return self if new_sub_operation is self.sub_operation else new_sub_operation
 
     def with_classical_controls(
-        self, *conditions: Union[str, cirq.MeasurementKey, cirq.Condition, sympy.Expr]
+        self, *conditions: str | cirq.MeasurementKey | cirq.Condition | sympy.Expr
     ) -> cirq.Operation:
         if not conditions:
             return self
         return self.sub_operation.with_classical_controls(*conditions)
 
-    def _control_keys_(self) -> FrozenSet[cirq.MeasurementKey]:
+    def _control_keys_(self) -> frozenset[cirq.MeasurementKey]:
         return protocols.control_keys(self.sub_operation)
 
 
@@ -1008,7 +986,7 @@ class _InverseCompositeGate(Gate):
         return self._decompose_with_context_(qubits)
 
     def _decompose_with_context_(
-        self, qubits: Sequence[cirq.Qid], context: Optional[cirq.DecompositionContext] = None
+        self, qubits: Sequence[cirq.Qid], context: cirq.DecompositionContext | None = None
     ) -> cirq.OP_TREE:
         return protocols.inverse(
             protocols.decompose_once_with_qubits(self._original, qubits, context=context)
@@ -1054,7 +1032,7 @@ class _InverseCompositeGate(Gate):
     def __str__(self) -> str:
         return f'{self._original!s}†'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'original': self._original}
 
 
@@ -1083,7 +1061,7 @@ def _validate_qid_shape(val: Any, qubits: Sequence[cirq.Qid]) -> None:
 
 def _operations_commutes_impl(
     ops1: Collection[Operation], ops2: Collection[Operation], *, atol: float
-) -> Union[bool, NotImplementedType]:
+) -> bool | NotImplementedType:
     """Determine if two collections of non-overlapping Operations commute.
 
     This function implements the commutes protocol for the Operation and Moment classes

cirq/ops/state_preparation_channel.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Iterable, Tuple, TYPE_CHECKING
+from typing import Any, Iterable, TYPE_CHECKING
 
 import numpy as np
 
@@ -59,7 +59,7 @@ class StatePreparationChannel(raw_types.Gate):
         it involves measurement."""
         return False
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         """Converts the gate object into a serializable dictionary"""
         return {'target_state': self._state.tolist(), 'name': self._name}
 
@@ -79,7 +79,7 @@ class StatePreparationChannel(raw_types.Gate):
     def _num_qubits_(self) -> int:
         return self._num_qubits
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return self._qid_shape
 
     def _circuit_diagram_info_(self, _args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:

cirq/ops/swap_gates.py

@@ -27,7 +27,7 @@ EigenGate.
 
 from __future__ import annotations
 
-from typing import cast, List, Optional, Tuple, TYPE_CHECKING
+from typing import cast, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -83,7 +83,7 @@ class SwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate)
         )
         yield common_gates.CNOT(a, b)
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         # yapf: disable
         return [
             (0, np.array([[1, 0,   0,   0],
@@ -97,17 +97,17 @@ class SwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate)
         ]
         # yapf: enable
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if self._is_parameterized_():
             return None
         return abs(np.sin(self._exponent * 0.5 * np.pi))
 
-    def _has_stabilizer_effect_(self) -> Optional[bool]:
+    def _has_stabilizer_effect_(self) -> bool | None:
         if self._is_parameterized_():
             return None
         return self.exponent % 1 == 0
 
-    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray | None:
         if self._exponent != 1:
             return NotImplemented
 
@@ -145,7 +145,7 @@ class SwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate)
             wire_symbols=('×', '×'), exponent=self._diagram_exponent(args)
         )
 
-    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         if self._exponent != 1:
             return None  # Don't have an equivalent gate in QASM
         args.validate_version('2.0', '3.0')
@@ -204,7 +204,7 @@ class ISwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate
     def _num_qubits_(self) -> int:
         return 2
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         # yapf: disable
         return [
             (0, np.diag([1, 0, 0, 1])),
@@ -219,7 +219,7 @@ class ISwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate
         ]
         # yapf: enable
 
-    def _has_stabilizer_effect_(self) -> Optional[bool]:
+    def _has_stabilizer_effect_(self) -> bool | None:
         if self._is_parameterized_():
             return None
         return self.exponent % 1 == 0
@@ -240,7 +240,7 @@ class ISwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate
         yield common_gates.H(a)
         yield common_gates.CNOT(a, b)
 
-    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray | None:
         if self._exponent != 1:
             return NotImplemented
 

cirq/ops/tags.py

@@ -16,8 +16,6 @@
 
 from __future__ import annotations
 
-from typing import Dict
-
 
 class VirtualTag:
     """A `cirq.TaggedOperation` tag indicating that the operation is virtual.
@@ -42,7 +40,7 @@ class VirtualTag:
     def __repr__(self) -> str:
         return 'cirq.VirtualTag()'
 
-    def _json_dict_(self) -> Dict[str, str]:
+    def _json_dict_(self) -> dict[str, str]:
         return {}
 
     def __hash__(self):
@@ -65,7 +63,7 @@ class RoutingSwapTag:
     def __repr__(self) -> str:
         return 'cirq.RoutingSwapTag()'
 
-    def _json_dict_(self) -> Dict[str, str]:
+    def _json_dict_(self) -> dict[str, str]:
         return {}
 
     def __hash__(self):