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

cirq/ops/controlled_gate_test.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 from types import EllipsisType, NotImplementedType
-from typing import Any, cast, Optional, Sequence, Tuple, Union
+from typing import Any, cast, Sequence, Union
 
 import numpy as np
 import pytest
@@ -25,7 +25,7 @@ import cirq
 
 
 class GateUsingWorkspaceForApplyUnitary(cirq.testing.SingleQubitGate):
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         args.available_buffer[...] = args.target_tensor
         args.target_tensor[...] = 0
         return args.available_buffer
@@ -44,10 +44,10 @@ class GateAllocatingNewSpaceForResult(cirq.testing.SingleQubitGate):
     def __init__(self):
         self._matrix = cirq.testing.random_unitary(2, random_state=4321)
 
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         assert len(args.axes) == 1
         a = args.axes[0]
-        seed = cast(Tuple[Union[int, slice, EllipsisType], ...], (slice(None),))
+        seed = cast(tuple[Union[int, slice, EllipsisType], ...], (slice(None),))
         zero = seed * a + (0, Ellipsis)
         one = seed * a + (1, Ellipsis)
         result = np.zeros(args.target_tensor.shape, args.target_tensor.dtype)
@@ -475,7 +475,7 @@ def test_nontrivial_controlled_gate_is_consistent(
 def _test_controlled_gate_is_consistent(
     gate: cirq.Gate,
     should_decompose_to_target: bool,
-    control_qid_shape: Optional[Sequence[int]] = None,
+    control_qid_shape: Sequence[int] | None = None,
     control_values: Any = None,
 ):
     cgate = cirq.ControlledGate(

cirq/ops/controlled_operation.py

@@ -15,18 +15,7 @@
 from __future__ import annotations
 
 from types import EllipsisType, NotImplementedType
-from typing import (
-    AbstractSet,
-    Any,
-    Collection,
-    Dict,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import AbstractSet, Any, Collection, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -57,9 +46,7 @@ class ControlledOperation(raw_types.Operation):
         self,
         controls: Sequence[cirq.Qid],
         sub_operation: cirq.Operation,
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
     ):
         """Initializes the controlled operation.
 
@@ -116,7 +103,7 @@ class ControlledOperation(raw_types.Operation):
             self._control_values = self._control_values & sub_operation.control_values
 
     @property
-    def controls(self) -> Tuple[cirq.Qid, ...]:
+    def controls(self) -> tuple[cirq.Qid, ...]:
         return self._controls
 
     @property
@@ -128,7 +115,7 @@ class ControlledOperation(raw_types.Operation):
         return self._sub_operation
 
     @property
-    def gate(self) -> Optional[cirq.ControlledGate]:
+    def gate(self) -> cirq.ControlledGate | None:
         if self.sub_operation.gate is None:
             return None
         return controlled_gate.ControlledGate(
@@ -150,7 +137,7 @@ class ControlledOperation(raw_types.Operation):
     def _decompose_(self):
         return self._decompose_with_context_()
 
-    def _decompose_with_context_(self, context: Optional[cirq.DecompositionContext] = None):
+    def _decompose_with_context_(self, context: cirq.DecompositionContext | None = None):
         result = protocols.decompose_once_with_qubits(
             self.gate, self.qubits, NotImplemented, flatten=False, context=context
         )
@@ -183,7 +170,7 @@ class ControlledOperation(raw_types.Operation):
         sub_n = len(args.axes) - n
         sub_axes = args.axes[n:]
         for control_vals in self.control_values.expand():
-            active: Tuple[Union[EllipsisType, slice], ...] = (
+            active: tuple[EllipsisType | slice, ...] = (
                 ...,
                 *(slice(v, v + 1) for v in control_vals),
                 *(slice(None),) * sub_n,
@@ -209,7 +196,7 @@ class ControlledOperation(raw_types.Operation):
     def _has_unitary_(self) -> bool:
         return protocols.has_unitary(self.sub_operation)
 
-    def _qasm_(self, args: cirq.QasmArgs) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs) -> str | None:
         if (
             hasattr(self._sub_operation, "gate")
             and len(self._controls) == 1
@@ -246,7 +233,7 @@ class ControlledOperation(raw_types.Operation):
             tensor[active] = sub_tensor  # type: ignore[index]
         return tensor.reshape((np.prod(qid_shape, dtype=np.int64).item(),) * 2)
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         sub_matrix = protocols.unitary(self.sub_operation, None)
         if sub_matrix is None:
             return NotImplemented
@@ -255,7 +242,7 @@ class ControlledOperation(raw_types.Operation):
     def _has_mixture_(self) -> bool:
         return protocols.has_mixture(self.sub_operation)
 
-    def _mixture_(self) -> Optional[List[Tuple[float, np.ndarray]]]:
+    def _mixture_(self) -> list[tuple[float, np.ndarray]] | None:
         sub_mixture = protocols.mixture(self.sub_operation, None)
         if sub_mixture is None:
             return None
@@ -294,7 +281,7 @@ class ControlledOperation(raw_types.Operation):
         new_sub_op = protocols.resolve_parameters(self.sub_operation, resolver, recursive)
         return ControlledOperation(self.controls, new_sub_op, self.control_values)
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if self._is_parameterized_():
             return None
         u = protocols.unitary(self.sub_operation, default=None)
@@ -311,7 +298,7 @@ class ControlledOperation(raw_types.Operation):
 
     def _circuit_diagram_info_(
         self, args: cirq.CircuitDiagramInfoArgs
-    ) -> Optional[protocols.CircuitDiagramInfo]:
+    ) -> protocols.CircuitDiagramInfo | None:
         n = len(self.controls)
 
         sub_args = protocols.CircuitDiagramInfoArgs(
@@ -346,7 +333,7 @@ class ControlledOperation(raw_types.Operation):
             exponent_qubit_index=exponent_qubit_index,
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'controls': self.controls,
             'control_values': self.control_values,

cirq/ops/controlled_operation_test.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import itertools
 import re
 from types import EllipsisType, NotImplementedType
-from typing import cast, Tuple, Union
+from typing import cast, Union
 
 import numpy as np
 import pytest
@@ -28,7 +28,7 @@ from cirq import protocols
 
 
 class GateUsingWorkspaceForApplyUnitary(cirq.testing.SingleQubitGate):
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         args.available_buffer[...] = args.target_tensor
         args.target_tensor[...] = 0
         return args.available_buffer
@@ -47,10 +47,10 @@ class GateAllocatingNewSpaceForResult(cirq.testing.SingleQubitGate):
     def __init__(self):
         self._matrix = cirq.testing.random_unitary(2, random_state=1234)
 
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         assert len(args.axes) == 1
         a = args.axes[0]
-        seed = cast(Tuple[Union[int, slice, EllipsisType], ...], (slice(None),))
+        seed = cast(tuple[Union[int, slice, EllipsisType], ...], (slice(None),))
         zero = seed * a + (0, Ellipsis)
         one = seed * a + (1, Ellipsis)
         result = np.zeros(args.target_tensor.shape, args.target_tensor.dtype)
@@ -157,7 +157,7 @@ def test_str():
 
     class SingleQubitOp(cirq.Operation):
         @property
-        def qubits(self) -> Tuple[cirq.Qid, ...]:
+        def qubits(self) -> tuple[cirq.Qid, ...]:
             return ()
 
         def with_qubits(self, *new_qubits: cirq.Qid):

cirq/ops/dense_pauli_string.py

@@ -22,16 +22,11 @@ from typing import (
     Any,
     Callable,
     cast,
-    Dict,
     Iterable,
     Iterator,
-    List,
-    Optional,
     overload,
     Sequence,
-    Tuple,
     TYPE_CHECKING,
-    Union,
 )
 
 import numpy as np
@@ -47,7 +42,7 @@ if TYPE_CHECKING:
 
 # Order is important! Index equals numeric value.
 PAULI_CHARS = 'IXYZ'
-PAULI_GATES: List[Union[cirq.Pauli, cirq.IdentityGate]] = [
+PAULI_GATES: list[cirq.Pauli | cirq.IdentityGate] = [
     identity.I,
     pauli_gates.X,
     pauli_gates.Y,
@@ -86,7 +81,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
 
     def __init__(
         self,
-        pauli_mask: Union[Iterable[cirq.PAULI_GATE_LIKE], np.ndarray],
+        pauli_mask: Iterable[cirq.PAULI_GATE_LIKE] | np.ndarray,
         *,
         coefficient: cirq.TParamValComplex = 1,
     ):
@@ -105,7 +100,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
                 values are supported.
         """
         self._pauli_mask = _as_pauli_mask(pauli_mask)
-        self._coefficient: Union[complex, sympy.Expr] = (
+        self._coefficient: complex | sympy.Expr = (
             coefficient if isinstance(coefficient, sympy.Expr) else complex(coefficient)
         )
         if type(self) != MutableDensePauliString:
@@ -122,7 +117,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         """A complex coefficient or symbol."""
         return self._coefficient
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['pauli_mask', 'coefficient'])
 
     def _value_equality_values_(self):
@@ -165,14 +160,14 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
             return False
         return abs(1 - abs(cast(complex, self.coefficient))) < 1e-8
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         if not self._has_unitary_():
             return NotImplemented
         return self.coefficient * linalg.kron(
             *[protocols.unitary(PAULI_GATES[p]) for p in self.pauli_mask]
         )
 
-    def _apply_unitary_(self, args) -> Union[np.ndarray, None, NotImplementedType]:
+    def _apply_unitary_(self, args) -> np.ndarray | None | NotImplementedType:
         if not self._has_unitary_():
             return NotImplemented
         from cirq import devices
@@ -181,7 +176,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         decomposed_ops = cast(Iterable['cirq.OP_TREE'], self._decompose_(qubits))
         return protocols.apply_unitaries(decomposed_ops, qubits, args)
 
-    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Union[NotImplementedType, cirq.OP_TREE]:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> NotImplementedType | cirq.OP_TREE:
         if not self._has_unitary_():
             return NotImplemented
         result = [PAULI_GATES[p].on(q) for p, q in zip(self.pauli_mask, qubits) if p]
@@ -203,7 +198,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
     def __pos__(self):
         return self
 
-    def __pow__(self, power: float) -> Union[NotImplementedType, Self]:
+    def __pow__(self, power: float) -> NotImplementedType | Self:
         concrete_class = type(self)
         if isinstance(power, int):
             i_group = [1, +1j, -1, -1j]
@@ -218,7 +213,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         return NotImplemented
 
     @overload
-    def __getitem__(self, item: int) -> Union[cirq.Pauli, cirq.IdentityGate]:
+    def __getitem__(self, item: int) -> cirq.Pauli | cirq.IdentityGate:
         pass
 
     @overload
@@ -234,7 +229,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
 
         raise TypeError(f'indices must be integers or slices, not {type(item)}')
 
-    def __iter__(self) -> Iterator[Union[cirq.Pauli, cirq.IdentityGate]]:
+    def __iter__(self) -> Iterator[cirq.Pauli | cirq.IdentityGate]:
         for i in range(len(self)):
             yield self[i]
 
@@ -326,7 +321,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
     def on(self, *qubits: cirq.Qid) -> cirq.PauliString:
         return self.sparse(qubits)
 
-    def sparse(self, qubits: Optional[Sequence[cirq.Qid]] = None) -> cirq.PauliString:
+    def sparse(self, qubits: Sequence[cirq.Qid] | None = None) -> cirq.PauliString:
         """A `cirq.PauliString` version of this dense pauli string.
 
         Args:
@@ -373,9 +368,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
             f'coefficient={proper_repr(self.coefficient)})'
         )
 
-    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:
         if isinstance(other, BaseDensePauliString):
             n = min(len(self.pauli_mask), len(other.pauli_mask))
             phase = _vectorized_pauli_mul_phase(self.pauli_mask[:n], other.pauli_mask[:n])
@@ -403,8 +396,8 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def copy(
         self,
-        coefficient: Optional[cirq.TParamValComplex] = None,
-        pauli_mask: Union[None, str, Iterable[int], np.ndarray] = None,
+        coefficient: cirq.TParamValComplex | None = None,
+        pauli_mask: None | str | Iterable[int] | np.ndarray = None,
     ) -> Self:
         """Returns a copy with possibly modified contents.
 
@@ -459,8 +452,8 @@ class DensePauliString(BaseDensePauliString):
 
     def copy(
         self,
-        coefficient: Optional[cirq.TParamValComplex] = None,
-        pauli_mask: Union[None, str, Iterable[int], np.ndarray] = None,
+        coefficient: cirq.TParamValComplex | None = None,
+        pauli_mask: None | str | Iterable[int] | np.ndarray = None,
     ) -> DensePauliString:
         if pauli_mask is None and (coefficient is None or coefficient == self.coefficient):
             return self
@@ -494,9 +487,7 @@ class MutableDensePauliString(BaseDensePauliString):
 
     @overload
     def __setitem__(
-        self,
-        key: slice,
-        value: Union[Iterable[cirq.PAULI_GATE_LIKE], np.ndarray, BaseDensePauliString],
+        self, key: slice, value: Iterable[cirq.PAULI_GATE_LIKE] | np.ndarray | BaseDensePauliString
     ) -> Self:
         pass
 
@@ -559,8 +550,8 @@ class MutableDensePauliString(BaseDensePauliString):
 
     def copy(
         self,
-        coefficient: Optional[cirq.TParamValComplex] = None,
-        pauli_mask: Union[None, str, Iterable[int], np.ndarray] = None,
+        coefficient: cirq.TParamValComplex | None = None,
+        pauli_mask: None | str | Iterable[int] | np.ndarray = None,
     ) -> MutableDensePauliString:
         return MutableDensePauliString(
             coefficient=self.coefficient if coefficient is None else coefficient,
@@ -574,7 +565,7 @@ class MutableDensePauliString(BaseDensePauliString):
         return self.coefficient, tuple(PAULI_CHARS[p] for p in self.pauli_mask)
 
     @classmethod
-    def inline_gaussian_elimination(cls, rows: List[MutableDensePauliString]) -> None:
+    def inline_gaussian_elimination(cls, rows: list[MutableDensePauliString]) -> None:
         if not rows:
             return
 
@@ -616,13 +607,13 @@ def _pauli_index(val: cirq.PAULI_GATE_LIKE) -> int:
     return m[val]
 
 
-def _as_pauli_mask(val: Union[Iterable[cirq.PAULI_GATE_LIKE], np.ndarray]) -> np.ndarray:
+def _as_pauli_mask(val: Iterable[cirq.PAULI_GATE_LIKE] | np.ndarray) -> np.ndarray:
     if isinstance(val, np.ndarray):
         return np.asarray(val, dtype=np.uint8)
     return np.array([_pauli_index(v) for v in val], dtype=np.uint8)
 
 
-def _attempt_value_to_pauli_index(v: cirq.Operation) -> Optional[Tuple[int, int]]:
+def _attempt_value_to_pauli_index(v: cirq.Operation) -> tuple[int, int] | None:
     if not isinstance(v, raw_types.Operation):
         return None
 
@@ -641,9 +632,7 @@ def _attempt_value_to_pauli_index(v: cirq.Operation) -> Optional[Tuple[int, int]
     return pauli_string.PAULI_GATE_LIKE_TO_INDEX_MAP[v.gate], q.x
 
 
-def _vectorized_pauli_mul_phase(
-    lhs: Union[int, np.ndarray], rhs: Union[int, np.ndarray]
-) -> complex:
+def _vectorized_pauli_mul_phase(lhs: int | np.ndarray, rhs: int | np.ndarray) -> complex:
     """Computes the leading coefficient of a pauli string multiplication.
 
     The two inputs must have the same length. They must follow the convention

cirq/ops/dense_pauli_string_test.py

@@ -15,7 +15,6 @@
 from __future__ import annotations
 
 import numbers
-from typing import List
 
 import numpy as np
 import pytest
@@ -547,7 +546,7 @@ def test_copy():
 
 
 def test_gaussian_elimination():
-    def table(*rows: str) -> List[cirq.MutableDensePauliString]:
+    def table(*rows: str) -> list[cirq.MutableDensePauliString]:
         coefs = {'i': 1j, '-': -1, '+': 1}
         return [
             cirq.MutableDensePauliString(row[1:].replace('.', 'I'), coefficient=coefs[row[0]])

cirq/ops/diagonal_gate.py

@@ -20,18 +20,7 @@ passed as a list.
 
 from __future__ import annotations
 
-from typing import (
-    AbstractSet,
-    Any,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import AbstractSet, Any, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -44,7 +33,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def _fast_walsh_hadamard_transform(a: Tuple[Any, ...]) -> np.ndarray:
+def _fast_walsh_hadamard_transform(a: tuple[Any, ...]) -> np.ndarray:
     """Fast Walsh–Hadamard Transform of an array."""
     h = 1
     a_ = np.array(a)
@@ -59,7 +48,7 @@ def _fast_walsh_hadamard_transform(a: Tuple[Any, ...]) -> np.ndarray:
     return a_
 
 
-def _gen_gray_code(n: int) -> Iterator[Tuple[int, int]]:
+def _gen_gray_code(n: int) -> Iterator[tuple[int, int]]:
     """Generate the Gray Code from 0 to 2^n-1.
 
     Each iteration yields a two-tuple, `(gray_code, bit_flip)`. `gray_code` is the decimal
@@ -94,10 +83,10 @@ class DiagonalGate(raw_types.Gate):
                 If these values are $(x_0, x_1, \ldots , x_N)$ then the unitary
                 has diagonal values $(e^{i x_0}, e^{i x_1}, \ldots, e^{i x_N})$.
         """
-        self._diag_angles_radians: Tuple[cirq.TParamVal, ...] = tuple(diag_angles_radians)
+        self._diag_angles_radians: tuple[cirq.TParamVal, ...] = tuple(diag_angles_radians)
 
     @property
-    def diag_angles_radians(self) -> Tuple[cirq.TParamVal, ...]:
+    def diag_angles_radians(self) -> tuple[cirq.TParamVal, ...]:
         return self._diag_angles_radians
 
     def _num_qubits_(self):
@@ -119,7 +108,7 @@ class DiagonalGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return not self._is_parameterized_()
 
-    def _unitary_(self) -> Optional[np.ndarray]:
+    def _unitary_(self) -> np.ndarray | None:
         if self._is_parameterized_():
             return None
         return np.diag([np.exp(1j * angle) for angle in self._diag_angles_radians])
@@ -162,7 +151,7 @@ class DiagonalGate(raw_types.Gate):
 
     def _decompose_for_basis(
         self, index: int, bit_flip: int, theta: cirq.TParamVal, qubits: Sequence[cirq.Qid]
-    ) -> Iterator[Union[cirq.ZPowGate, cirq.CXPowGate]]:
+    ) -> Iterator[cirq.ZPowGate | cirq.CXPowGate]:
         if index == 0:
             return
         largest_digit = self._num_qubits_() - (len(bin(index)) - 2)
@@ -200,14 +189,14 @@ class DiagonalGate(raw_types.Gate):
         # decomposed gates. On its own it is not physically observable. However, if using this
         # diagonal gate for sub-system like controlled gate, it is no longer equivalent. Hence,
         # we add global phase.
-        decomposed_circ: List[Any] = [
+        decomposed_circ: list[Any] = [
             global_phase_op.global_phase_operation(1j ** (2 * hat_angles[0] / np.pi))
         ]
         for i, bit_flip in _gen_gray_code(n):
             decomposed_circ.extend(self._decompose_for_basis(i, bit_flip, -hat_angles[i], qubits))
         return decomposed_circ
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, attribute_names=["diag_angles_radians"])
 
     def __repr__(self) -> str:

cirq/ops/diagonal_gate_test.py

@@ -14,15 +14,13 @@
 
 from __future__ import annotations
 
-from typing import List
-
 import numpy as np
 import pytest
 import sympy
 
 import cirq
 
-_candidate_angles: List[float] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53]
+_candidate_angles: list[float] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53]
 
 
 @pytest.mark.parametrize(

cirq/ops/eigen_gate.py

@@ -19,19 +19,7 @@ import fractions
 import math
 import numbers
 from types import NotImplementedType
-from typing import (
-    AbstractSet,
-    Any,
-    cast,
-    Dict,
-    Iterable,
-    List,
-    NamedTuple,
-    Optional,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import AbstractSet, Any, cast, Iterable, NamedTuple, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -219,7 +207,7 @@ class EigenGate(raw_types.Gate):
         return args.format_radians(radians=2 * pi * exponent / order)
 
     # virtual method
-    def _eigen_shifts(self) -> List[float]:
+    def _eigen_shifts(self) -> list[float]:
         """Describes the eigenvalues of the gate's matrix.
 
         By default, this just extracts the shifts by calling
@@ -235,7 +223,7 @@ class EigenGate(raw_types.Gate):
         return [e[0] for e in self._eigen_components()]
 
     @abc.abstractmethod
-    def _eigen_components(self) -> List[Union[EigenComponent, Tuple[float, np.ndarray]]]:
+    def _eigen_components(self) -> list[EigenComponent | tuple[float, np.ndarray]]:
         """Describes the eigendecomposition of the gate's matrix.
 
         Returns:
@@ -287,7 +275,7 @@ class EigenGate(raw_types.Gate):
                 ]
         """
 
-    def _period(self) -> Optional[float]:
+    def _period(self) -> float | None:
         """Determines how the exponent parameter is canonicalized when equating.
 
         Returns:
@@ -300,7 +288,7 @@ class EigenGate(raw_types.Gate):
         real_periods = [abs(2 / e) for e in exponents if e != 0]
         return _approximate_common_period(real_periods)
 
-    def __pow__(self, exponent: Union[float, sympy.Symbol]) -> EigenGate:
+    def __pow__(self, exponent: float | sympy.Symbol) -> EigenGate:
         new_exponent = protocols.mul(self._exponent, exponent, NotImplemented)
         if new_exponent is NotImplemented:
             return NotImplemented  # pragma: no cover
@@ -320,7 +308,7 @@ class EigenGate(raw_types.Gate):
         shifts = (f(self._exponent) * f(self._global_shift + e) for e in self._eigen_shifts())
         return tuple(s if symbolic(s) else value.PeriodicValue(f(s), 2) for s in shifts)
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if protocols.is_parameterized(self._exponent):
             return None
         angles = np.pi * (np.array(self._eigen_shifts()) * self._exponent % 2)
@@ -329,7 +317,7 @@ class EigenGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return not self._is_parameterized_()
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         if self._is_parameterized_():
             return NotImplemented
         e = cast(float, self._exponent)
@@ -372,7 +360,7 @@ class EigenGate(raw_types.Gate):
         other_without_phase._global_shift = 0
         return protocols.approx_eq(self_without_phase, other_without_phase, atol=atol)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['exponent', 'global_shift'])
 
     def _measurement_key_objs_(self):
@@ -387,8 +375,8 @@ def _lcm(vals: Iterable[int]) -> int:
 
 
 def _approximate_common_period(
-    periods: List[float], approx_denom: int = 60, reject_atol: float = 1e-8
-) -> Optional[float]:
+    periods: list[float], approx_denom: int = 60, reject_atol: float = 1e-8
+) -> float | None:
     """Finds a value that is nearly an integer multiple of multiple periods.
 
     The returned value should be the smallest non-negative number with this
@@ -432,7 +420,7 @@ def _approximate_common_period(
     return common
 
 
-def _common_rational_period(rational_periods: List[fractions.Fraction]) -> fractions.Fraction:
+def _common_rational_period(rational_periods: list[fractions.Fraction]) -> fractions.Fraction:
     """Finds the least common integer multiple of some fractions.
 
     The solution is the smallest positive integer c such that there

cirq/ops/eigen_gate_test.py

@@ -14,8 +14,6 @@
 
 from __future__ import annotations
 
-from typing import List, Tuple
-
 import numpy as np
 import pytest
 import sympy
@@ -43,7 +41,7 @@ class CExpZinGate(cirq.EigenGate, cirq.testing.TwoQubitGate):
     def _with_exponent(self, exponent):
         return CExpZinGate(exponent)
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [
             (0, np.diag([1, 1, 0, 0])),
             (0.5, np.diag([0, 0, 1, 0])),
@@ -56,7 +54,7 @@ class ZGateDef(cirq.EigenGate, cirq.testing.SingleQubitGate):
     def exponent(self):
         return self._exponent
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 0])), (1, np.diag([0, 1]))]
 
 
@@ -210,7 +208,7 @@ def test_period():
             self.c = c
             self.d = d
 
-        def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+        def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
             return [
                 (self.a, np.diag([1, 0, 0, 0])),
                 (self.b, np.diag([0, 1, 0, 0])),
@@ -261,7 +259,7 @@ def test_trace_distance_bound():
         def _num_qubits_(self):  # pragma: no cover
             return 1
 
-        def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+        def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
             return [(0, np.array([[1, 0], [0, 0]])), (12, np.array([[0, 0], [0, 1]]))]
 
     for numerator in range(13):
@@ -353,7 +351,7 @@ def test_resolve_parameters(resolve_fn):
 
 def test_diagram_period():
     class ShiftyGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
-        def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+        def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
             raise NotImplementedError()
 
         def __init__(self, e, *shifts):
@@ -390,7 +388,7 @@ class WeightedZPowGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
         self.weight = weight
         super().__init__(**kwargs)
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 0])), (self.weight, np.diag([0, 1]))]
 
     def _with_exponent(self, exponent):