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

cirq/ops/common_gates.py

@@ -28,7 +28,7 @@ raised to a power (i.e. cirq.H**0.5). See the definition in EigenGate.
 from __future__ import annotations
 
 from types import NotImplementedType
-from typing import Any, cast, Collection, Dict, List, Optional, Sequence, Tuple, Union
+from typing import Any, cast, Collection, Sequence
 
 import numpy as np
 import sympy
@@ -75,7 +75,7 @@ class XPowGate(eigen_gate.EigenGate):
     `cirq.X`, the Pauli X gate, is an instance of this gate at `exponent=1`.
     """
 
-    _eigencomponents: Dict[int, List[Tuple[float, np.ndarray]]] = {}
+    _eigencomponents: dict[int, list[tuple[float, np.ndarray]]] = {}
 
     def __init__(
         self, *, exponent: value.TParamVal = 1.0, global_shift: float = 0.0, dimension: int = 2
@@ -114,7 +114,7 @@ class XPowGate(eigen_gate.EigenGate):
     def _num_qubits_(self) -> int:
         return 1
 
-    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray | None:
         if self._exponent != 1 or self._dimension != 2:
             return NotImplemented
         zero = args.subspace_index(0)
@@ -134,10 +134,10 @@ class XPowGate(eigen_gate.EigenGate):
         """Returns an equal-up-global-phase standardized form of the gate."""
         return XPowGate(exponent=self._exponent, dimension=self._dimension)
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return (self._dimension,)
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         if self._dimension not in XPowGate._eigencomponents:
             components = []
             root = 1j ** (4 / self._dimension)
@@ -167,18 +167,16 @@ class XPowGate(eigen_gate.EigenGate):
             return SingleQubitCliffordGate.X_nsqrt.on(*qubits)
         return NotImplemented  # pragma: no cover
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if self._is_parameterized_() or self._dimension != 2:
             return None
         return abs(np.sin(self._exponent * 0.5 * np.pi))
 
     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,
     ) -> raw_types.Gate:
         """Returns a controlled `XPowGate`, using a `CXPowGate` where possible.
 
@@ -255,12 +253,12 @@ class XPowGate(eigen_gate.EigenGate):
 
     def _circuit_diagram_info_(
         self, args: cirq.CircuitDiagramInfoArgs
-    ) -> Union[str, protocols.CircuitDiagramInfo]:
+    ) -> str | protocols.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(
             wire_symbols=('X',), 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:
         args.validate_version('2.0', '3.0')
         if self._global_shift == 0:
             if self._exponent == 1:
@@ -279,7 +277,7 @@ class XPowGate(eigen_gate.EigenGate):
         """See `cirq.SupportsPhase`."""
         return _phased_x_or_pauli_gate(exponent=self._exponent, phase_exponent=phase_turns * 2)
 
-    def _has_stabilizer_effect_(self) -> Optional[bool]:
+    def _has_stabilizer_effect_(self) -> bool | None:
         if self._is_parameterized_() or self._dimension != 2:
             return None
         return self.exponent % 0.5 == 0
@@ -306,7 +304,7 @@ class XPowGate(eigen_gate.EigenGate):
         all_args = ', '.join(args)
         return f'cirq.XPowGate({all_args})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         d = protocols.obj_to_dict_helper(self, ['exponent', 'global_shift'])
         if self.dimension != 2:
             d['dimension'] = self.dimension
@@ -342,7 +340,7 @@ class Rx(XPowGate):
 
     def _circuit_diagram_info_(
         self, args: cirq.CircuitDiagramInfoArgs
-    ) -> Union[str, protocols.CircuitDiagramInfo]:
+    ) -> str | protocols.CircuitDiagramInfo:
         angle_str = self._format_exponent_as_angle(args)
         return f'Rx({angle_str})'
 
@@ -354,11 +352,11 @@ class Rx(XPowGate):
     def __repr__(self) -> str:
         return f'cirq.Rx(rads={proper_repr(self._rads)})'
 
-    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         args.validate_version('2.0', '3.0')
         return args.format('rx({0:half_turns}) {1};\n', self._exponent, qubits[0])
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'rads': self._rads}
 
     @classmethod
@@ -400,7 +398,7 @@ class YPowGate(eigen_gate.EigenGate):
     def _num_qubits_(self) -> int:
         return 1
 
-    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
         zero = args.subspace_index(0)
@@ -433,13 +431,13 @@ class YPowGate(eigen_gate.EigenGate):
             return SingleQubitCliffordGate.Y_nsqrt.on(*qubits)
         return NotImplemented  # pragma: no cover
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [
             (0, np.array([[0.5, -0.5j], [0.5j, 0.5]])),
             (1, np.array([[0.5, 0.5j], [-0.5j, 0.5]])),
         ]
 
-    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))
@@ -452,12 +450,12 @@ class YPowGate(eigen_gate.EigenGate):
 
     def _circuit_diagram_info_(
         self, args: cirq.CircuitDiagramInfoArgs
-    ) -> Union[str, protocols.CircuitDiagramInfo]:
+    ) -> str | protocols.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(
             wire_symbols=('Y',), 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:
         args.validate_version('2.0', '3.0')
         if self._exponent == 1 and self.global_shift != -0.5:
             return args.format('y {0};\n', qubits[0])
@@ -474,7 +472,7 @@ class YPowGate(eigen_gate.EigenGate):
             exponent=self._exponent, phase_exponent=0.5 + phase_turns * 2
         )
 
-    def _has_stabilizer_effect_(self) -> Optional[bool]:
+    def _has_stabilizer_effect_(self) -> bool | None:
         if self._is_parameterized_():
             return None
         return self.exponent % 0.5 == 0
@@ -527,7 +525,7 @@ class Ry(YPowGate):
 
     def _circuit_diagram_info_(
         self, args: cirq.CircuitDiagramInfoArgs
-    ) -> Union[str, protocols.CircuitDiagramInfo]:
+    ) -> str | protocols.CircuitDiagramInfo:
         angle_str = self._format_exponent_as_angle(args)
         return f'Ry({angle_str})'
 
@@ -539,11 +537,11 @@ class Ry(YPowGate):
     def __repr__(self) -> str:
         return f'cirq.Ry(rads={proper_repr(self._rads)})'
 
-    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         args.validate_version('2.0', '3.0')
         return args.format('ry({0:half_turns}) {1};\n', self._exponent, qubits[0])
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'rads': self._rads}
 
     @classmethod
@@ -573,7 +571,7 @@ class ZPowGate(eigen_gate.EigenGate):
     `cirq.Z`, the Pauli Z gate, is an instance of this gate at `exponent=1`.
     """
 
-    _eigencomponents: Dict[int, List[Tuple[float, np.ndarray]]] = {}
+    _eigencomponents: dict[int, list[tuple[float, np.ndarray]]] = {}
 
     def __init__(
         self, *, exponent: value.TParamVal = 1.0, global_shift: float = 0.0, dimension: int = 2
@@ -612,7 +610,7 @@ class ZPowGate(eigen_gate.EigenGate):
     def _num_qubits_(self) -> int:
         return 1
 
-    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray | None:
         if protocols.is_parameterized(self):
             return None
 
@@ -648,11 +646,9 @@ class ZPowGate(eigen_gate.EigenGate):
 
     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,
     ) -> raw_types.Gate:
         """Returns a controlled `ZPowGate`, using a `CZPowGate` where possible.
 
@@ -719,10 +715,10 @@ class ZPowGate(eigen_gate.EigenGate):
             )
         return result
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return (self._dimension,)
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         if self._dimension not in ZPowGate._eigencomponents:
             components = []
             for i in range(self._dimension):
@@ -738,7 +734,7 @@ class ZPowGate(eigen_gate.EigenGate):
             exponent=exponent, global_shift=self._global_shift, dimension=self._dimension
         )
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if self._is_parameterized_() or self._dimension != 2:
             return None
         return abs(np.sin(self._exponent * 0.5 * np.pi))
@@ -754,14 +750,14 @@ class ZPowGate(eigen_gate.EigenGate):
     def _phase_by_(self, phase_turns: float, qubit_index: int):
         return self
 
-    def _has_stabilizer_effect_(self) -> Optional[bool]:
+    def _has_stabilizer_effect_(self) -> bool | None:
         if self._is_parameterized_() or self._dimension != 2:
             return None
         return self.exponent % 0.5 == 0
 
     def _circuit_diagram_info_(
         self, args: cirq.CircuitDiagramInfoArgs
-    ) -> Union[str, protocols.CircuitDiagramInfo]:
+    ) -> str | protocols.CircuitDiagramInfo:
         e = self._diagram_exponent(args)
         if e in [-0.25, 0.25]:
             return protocols.CircuitDiagramInfo(wire_symbols=('T',), exponent=cast(float, e) * 4)
@@ -771,7 +767,7 @@ class ZPowGate(eigen_gate.EigenGate):
 
         return protocols.CircuitDiagramInfo(wire_symbols=('Z',), exponent=e)
 
-    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         args.validate_version('2.0', '3.0')
 
         if self.global_shift == 0:
@@ -827,7 +823,7 @@ class ZPowGate(eigen_gate.EigenGate):
 
     def _commutes_on_qids_(
         self, qids: Sequence[cirq.Qid], other: Any, *, atol: float = 1e-8
-    ) -> Union[bool, NotImplementedType, None]:
+    ) -> bool | NotImplementedType | None:
         from cirq.ops.parity_gates import ZZPowGate
 
         if not isinstance(other, raw_types.Operation):
@@ -836,7 +832,7 @@ class ZPowGate(eigen_gate.EigenGate):
             return NotImplemented
         return True
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         d = protocols.obj_to_dict_helper(self, ['exponent', 'global_shift'])
         if self.dimension != 2:
             d['dimension'] = self.dimension
@@ -872,7 +868,7 @@ class Rz(ZPowGate):
 
     def _circuit_diagram_info_(
         self, args: cirq.CircuitDiagramInfoArgs
-    ) -> Union[str, protocols.CircuitDiagramInfo]:
+    ) -> str | protocols.CircuitDiagramInfo:
         angle_str = self._format_exponent_as_angle(args)
         return f'Rz({angle_str})'
 
@@ -884,11 +880,11 @@ class Rz(ZPowGate):
     def __repr__(self) -> str:
         return f'cirq.Rz(rads={proper_repr(self._rads)})'
 
-    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         args.validate_version('2.0', '3.0')
         return args.format('rz({0:half_turns}) {1};\n', self._exponent, qubits[0])
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'rads': self._rads}
 
     @classmethod
@@ -919,7 +915,7 @@ class HPowGate(eigen_gate.EigenGate):
     `cirq.H`, the Hadamard gate, is an instance of this gate at `exponent=1`.
     """
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         s = np.sqrt(2)
 
         component0 = np.array([[3 + 2 * s, 1 + s], [1 + s, 1]]) / (4 + 2 * s)
@@ -931,7 +927,7 @@ class HPowGate(eigen_gate.EigenGate):
     def _num_qubits_(self) -> int:
         return 1
 
-    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))
@@ -958,7 +954,7 @@ class HPowGate(eigen_gate.EigenGate):
             return []
         return NotImplemented  # pragma: no cover
 
-    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
 
@@ -988,7 +984,7 @@ class HPowGate(eigen_gate.EigenGate):
             wire_symbols=('H',), 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:
         args.validate_version('2.0', '3.0')
         if self._exponent == 0:
             return args.format('id {0};\n', qubits[0])
@@ -1003,7 +999,7 @@ class HPowGate(eigen_gate.EigenGate):
             qubits[0],
         )
 
-    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
@@ -1054,17 +1050,15 @@ class CZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
             return []
         return NotImplemented  # pragma: no cover
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 1, 1, 0])), (1, np.diag([0, 0, 0, 1]))]
 
-    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 _apply_unitary_(
-        self, args: protocols.ApplyUnitaryArgs
-    ) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         if protocols.is_parameterized(self):
             return NotImplemented
 
@@ -1096,11 +1090,9 @@ class CZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
 
     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,
     ) -> raw_types.Gate:
         """Returns a controlled `CZPowGate`, using a `CCZPowGate` where possible.
 
@@ -1172,13 +1164,13 @@ class CZPowGate(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')
         return args.format('cz {0},{1};\n', qubits[0], qubits[1])
 
-    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
@@ -1253,13 +1245,13 @@ class CXPowGate(eigen_gate.EigenGate):
         yield cirq.CZPowGate(exponent=self._exponent, global_shift=self.global_shift).on(c, t)
         yield YPowGate(exponent=0.5).on(t)
 
-    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], [0, 1, 0, 0], [0, 0, 0.5, 0.5], [0, 0, 0.5, 0.5]])),
             (1, np.array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0.5, -0.5], [0, 0, -0.5, 0.5]])),
         ]
 
-    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))
@@ -1269,7 +1261,7 @@ class CXPowGate(eigen_gate.EigenGate):
             wire_symbols=('@', 'X'), exponent=self._diagram_exponent(args), exponent_qubit_index=1
         )
 
-    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
 
@@ -1300,11 +1292,9 @@ class CXPowGate(eigen_gate.EigenGate):
 
     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,
     ) -> raw_types.Gate:
         """Returns a controlled `CXPowGate`, using a `CCXPowGate` where possible.
 
@@ -1371,13 +1361,13 @@ class CXPowGate(eigen_gate.EigenGate):
             )
         return result
 
-    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')
         return args.format('cx {0},{1};\n', qubits[0], qubits[1])
 
-    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
@@ -1525,8 +1515,8 @@ document(
 
 
 def _phased_x_or_pauli_gate(
-    exponent: Union[float, sympy.Expr], phase_exponent: Union[float, sympy.Expr]
-) -> Union[cirq.PhasedXPowGate, cirq.XPowGate, cirq.YPowGate]:
+    exponent: float | sympy.Expr, phase_exponent: float | sympy.Expr
+) -> cirq.PhasedXPowGate | cirq.XPowGate | cirq.YPowGate:
     """Return PhasedXPowGate or X or Y gate if equivalent at the given phase_exponent."""
     if not isinstance(phase_exponent, sympy.Expr) or phase_exponent.is_constant():
         half_turns = value.canonicalize_half_turns(float(phase_exponent))

cirq/ops/control_values.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import abc
 import itertools
 from functools import cached_property
-from typing import Any, Collection, Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, Collection, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import protocols, value
 
@@ -67,7 +67,7 @@ class AbstractControlValues(abc.ABC):
         """Returns the number of qubits for which control values are stored by this object."""
 
     @abc.abstractmethod
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         """Returns a dictionary used for serializing this object."""
 
     @abc.abstractmethod
@@ -75,7 +75,7 @@ class AbstractControlValues(abc.ABC):
         """Returns information used to draw this object in circuit diagrams."""
 
     @abc.abstractmethod
-    def __iter__(self) -> Iterator[Tuple[int, ...]]:
+    def __iter__(self) -> Iterator[tuple[int, ...]]:
         """Iterator on internal representation of control values used by the derived classes.
 
         Note: Be careful that the terms iterated upon by this iterator will have different
@@ -141,8 +141,8 @@ class AbstractControlValues(abc.ABC):
 class ProductOfSums(AbstractControlValues):
     """Represents control values as N OR (sum) clauses, each of which applies to one qubit."""
 
-    def __init__(self, data: Sequence[Union[int, Collection[int]]]):
-        self._qubit_sums: Tuple[Tuple[int, ...], ...] = tuple(
+    def __init__(self, data: Sequence[int | Collection[int]]):
+        self._qubit_sums: tuple[tuple[int, ...], ...] = tuple(
             (cv,) if isinstance(cv, int) else tuple(sorted(set(cv))) for cv in data
         )
 
@@ -150,7 +150,7 @@ class ProductOfSums(AbstractControlValues):
     def is_trivial(self) -> bool:
         return self._qubit_sums == ((1,),) * self._num_qubits_()
 
-    def __iter__(self) -> Iterator[Tuple[int, ...]]:
+    def __iter__(self) -> Iterator[tuple[int, ...]]:
         return iter(self._qubit_sums)
 
     def expand(self) -> SumOfProducts:
@@ -162,7 +162,7 @@ class ProductOfSums(AbstractControlValues):
     def _num_qubits_(self) -> int:
         return len(self._qubit_sums)
 
-    def __getitem__(self, key: Union[int, slice]) -> Union[ProductOfSums, Tuple[int, ...]]:
+    def __getitem__(self, key: int | slice) -> ProductOfSums | tuple[int, ...]:
         if isinstance(key, slice):
             return ProductOfSums(self._qubit_sums[key])
         return self._qubit_sums[key]
@@ -194,7 +194,7 @@ class ProductOfSums(AbstractControlValues):
 
         return ''.join(get_prefix(t) for t in self._qubit_sums)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {"data": self._qubit_sums}
 
     def __and__(self, other: AbstractControlValues) -> AbstractControlValues:
@@ -241,8 +241,8 @@ class SumOfProducts(AbstractControlValues):
         >>> nand_cop = cirq.X(q2).controlled_by(q0, q1, control_values=nand_control_values)
     """
 
-    def __init__(self, data: Collection[Sequence[int]], *, name: Optional[str] = None):
-        self._conjunctions: Tuple[Tuple[int, ...], ...] = tuple(
+    def __init__(self, data: Collection[Sequence[int]], *, name: str | None = None):
+        self._conjunctions: tuple[tuple[int, ...], ...] = tuple(
             sorted(set(tuple(cv) for cv in data))
         )
         self._name = name
@@ -259,7 +259,7 @@ class SumOfProducts(AbstractControlValues):
     def expand(self) -> SumOfProducts:
         return self
 
-    def __iter__(self) -> Iterator[Tuple[int, ...]]:
+    def __iter__(self) -> Iterator[tuple[int, ...]]:
         """Returns the combinations tracked by the object."""
         return iter(self._conjunctions)
 
@@ -313,5 +313,5 @@ class SumOfProducts(AbstractControlValues):
                         f' of range [0, {qid_shapes[q_i]}) for control qubit number <{q_i}>.'
                     )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'data': self._conjunctions, 'name': self._name}

cirq/ops/controlled_gate.py

@@ -15,18 +15,7 @@
 from __future__ import annotations
 
 from types import 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
 
@@ -60,11 +49,9 @@ class ControlledGate(raw_types.Gate):
     def __init__(
         self,
         sub_gate: cirq.Gate,
-        num_controls: Optional[int] = None,
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
-        control_qid_shape: Optional[Sequence[int]] = None,
+        num_controls: int | None = None,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
+        control_qid_shape: Sequence[int] | None = None,
     ) -> None:
         """Initializes the controlled gate. If no arguments are specified for
            the controls, defaults to a single qubit control.
@@ -135,7 +122,7 @@ class ControlledGate(raw_types.Gate):
             self._sub_gate = sub_gate
 
     @property
-    def control_qid_shape(self) -> Tuple[int, ...]:
+    def control_qid_shape(self) -> tuple[int, ...]:
         return self._control_qid_shape
 
     @property
@@ -149,17 +136,15 @@ class ControlledGate(raw_types.Gate):
     def num_controls(self) -> int:
         return len(self.control_qid_shape)
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return self.control_qid_shape + protocols.qid_shape(self.sub_gate)
 
-    def _decompose_(
-        self, qubits: Tuple[cirq.Qid, ...]
-    ) -> Union[None, NotImplementedType, cirq.OP_TREE]:
+    def _decompose_(self, qubits: tuple[cirq.Qid, ...]) -> None | NotImplementedType | cirq.OP_TREE:
         return self._decompose_with_context_(qubits)
 
     def _decompose_with_context_(
-        self, qubits: Tuple[cirq.Qid, ...], context: Optional[cirq.DecompositionContext] = None
-    ) -> Union[None, NotImplementedType, cirq.OP_TREE]:
+        self, qubits: tuple[cirq.Qid, ...], context: cirq.DecompositionContext | None = None
+    ) -> None | NotImplementedType | cirq.OP_TREE:
         control_qubits = list(qubits[: self.num_controls()])
         if (
             protocols.has_unitary(self.sub_gate)
@@ -167,7 +152,7 @@ class ControlledGate(raw_types.Gate):
             and self._qid_shape_() == (2,) * len(self._qid_shape_())
             and isinstance(self.control_values, cv.ProductOfSums)
         ):
-            invert_ops: List[cirq.Operation] = []
+            invert_ops: list[cirq.Operation] = []
             for cvals, cqbit in zip(self.control_values, qubits[: self.num_controls()]):
                 if set(cvals) == {0}:
                     invert_ops.append(common_gates.X(cqbit))
@@ -260,7 +245,7 @@ class ControlledGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return protocols.has_unitary(self.sub_gate)
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         qubits = line_qubit.LineQid.for_gate(self)
         op = self.sub_gate.on(*qubits[self.num_controls() :])
         c_op = cop.ControlledOperation(qubits[: self.num_controls()], op, self.control_values)
@@ -270,7 +255,7 @@ class ControlledGate(raw_types.Gate):
     def _has_mixture_(self) -> bool:
         return protocols.has_mixture(self.sub_gate)
 
-    def _mixture_(self) -> Union[Sequence[tuple[float, np.ndarray]], NotImplementedType]:
+    def _mixture_(self) -> Sequence[tuple[float, np.ndarray]] | NotImplementedType:
         qubits = line_qubit.LineQid.for_gate(self)
         op = self.sub_gate.on(*qubits[self.num_controls() :])
         c_op = cop.ControlledOperation(qubits[: self.num_controls()], op, self.control_values)
@@ -302,7 +287,7 @@ class ControlledGate(raw_types.Gate):
             control_qid_shape=self.control_qid_shape,
         )
 
-    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_gate, default=None)
@@ -353,7 +338,7 @@ class ControlledGate(raw_types.Gate):
             f'control_qid_shape={self.control_qid_shape!r})'
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'control_values': self.control_values,
             'control_qid_shape': self.control_qid_shape,
@@ -361,7 +346,7 @@ class ControlledGate(raw_types.Gate):
         }
 
 
-def _validate_sub_object(sub_object: Union[cirq.Gate, cirq.Operation]):
+def _validate_sub_object(sub_object: cirq.Gate | cirq.Operation):
     if protocols.is_measurement(sub_object):
         raise ValueError(f'Cannot control measurement {sub_object}')
     if not protocols.has_mixture(sub_object) and not protocols.is_parameterized(sub_object):