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

cirq/ops/fourier_transform.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import AbstractSet, Any, Dict, Union
+from typing import AbstractSet, Any
 
 import numpy as np
 import sympy
@@ -54,7 +54,7 @@ class QuantumFourierTransformGate(raw_types.Gate):
         self._num_qubits = num_qubits
         self._without_reverse = without_reverse
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'num_qubits': self._num_qubits, 'without_reverse': self._without_reverse}
 
     def _value_equality_values_(self):
@@ -112,15 +112,15 @@ class PhaseGradientGate(raw_types.Gate):
     This gate makes up a portion of the quantum fourier transform.
     """
 
-    def __init__(self, *, num_qubits: int, exponent: Union[float, sympy.Basic]):
+    def __init__(self, *, num_qubits: int, exponent: float | sympy.Basic):
         self._num_qubits = num_qubits
         self._exponent = exponent
 
     @property
-    def exponent(self) -> Union[float, sympy.Basic]:
+    def exponent(self) -> float | sympy.Basic:
         return self._exponent
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'num_qubits': self._num_qubits, 'exponent': self.exponent}
 
     def _value_equality_values_(self):

cirq/ops/fsim_gate.py

@@ -26,7 +26,7 @@ from __future__ import annotations
 
 import cmath
 import math
-from typing import AbstractSet, Any, Dict, Iterator, Optional, Tuple
+from typing import AbstractSet, Any, Iterator
 
 import numpy as np
 import sympy
@@ -131,7 +131,7 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
     def _has_unitary_(self):
         return not self._is_parameterized_()
 
-    def _unitary_(self) -> Optional[np.ndarray]:
+    def _unitary_(self) -> np.ndarray | None:
         if self._is_parameterized_():
             return None
         a = math.cos(self.theta)
@@ -171,7 +171,7 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
             protocols.resolve_parameters(self.phi, resolver, recursive),
         )
 
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | None:
         if cirq.is_parameterized(self):
             return None
         if self.theta != 0:
@@ -196,7 +196,7 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         yield yy(a, b)
         yield cirq.CZ(a, b) ** (-self.phi / np.pi)
 
-    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str, ...]:
         t = args.format_radians(self.theta)
         p = args.format_radians(self.phi)
         return f'FSim({t}, {p})', f'FSim({t}, {p})'
@@ -209,7 +209,7 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         p = proper_repr(self.phi)
         return f'cirq.FSimGate(theta={t}, phi={p})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['theta', 'phi'])
 
 
@@ -326,8 +326,8 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
     def from_fsim_rz(
         theta: cirq.TParamVal,
         phi: cirq.TParamVal,
-        rz_angles_before: Tuple[cirq.TParamVal, cirq.TParamVal],
-        rz_angles_after: Tuple[cirq.TParamVal, cirq.TParamVal],
+        rz_angles_before: tuple[cirq.TParamVal, cirq.TParamVal],
+        rz_angles_after: tuple[cirq.TParamVal, cirq.TParamVal],
     ) -> PhasedFSimGate:
         """Creates PhasedFSimGate using an alternate parametrization.
 
@@ -349,7 +349,7 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         return PhasedFSimGate(theta, zeta, chi, gamma, phi)
 
     @staticmethod
-    def from_matrix(u: np.ndarray) -> Optional[PhasedFSimGate]:
+    def from_matrix(u: np.ndarray) -> PhasedFSimGate | None:
         """Contruct a PhasedFSimGate from unitary.
 
         Args:
@@ -388,14 +388,14 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         return None
 
     @property
-    def rz_angles_before(self) -> Tuple[cirq.TParamVal, cirq.TParamVal]:
+    def rz_angles_before(self) -> tuple[cirq.TParamVal, cirq.TParamVal]:
         """Returns 2-tuple of phase angles applied to qubits before FSimGate."""
         b0 = (-self.gamma + self.zeta + self.chi) / 2.0
         b1 = (-self.gamma - self.zeta - self.chi) / 2.0
         return b0, b1
 
     @property
-    def rz_angles_after(self) -> Tuple[cirq.TParamVal, cirq.TParamVal]:
+    def rz_angles_after(self) -> tuple[cirq.TParamVal, cirq.TParamVal]:
         """Returns 2-tuple of phase angles applied to qubits after FSimGate."""
         a0 = (-self.gamma + self.zeta - self.chi) / 2.0
         a1 = (-self.gamma - self.zeta + self.chi) / 2.0
@@ -434,7 +434,7 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
     def _has_unitary_(self):
         return not self._is_parameterized_()
 
-    def _unitary_(self) -> Optional[np.ndarray]:
+    def _unitary_(self) -> np.ndarray | None:
         if self._is_parameterized_():
             return None
         a = math.cos(self.theta)
@@ -467,7 +467,7 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
             protocols.resolve_parameters(self.phi, resolver, recursive),
         )
 
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | None:
         if cirq.is_parameterized(self):
             return None
         oi = args.subspace_index(0b01)
@@ -515,7 +515,7 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
         yield cirq.Z(q0) ** to_exponent(after[0])
         yield cirq.Z(q1) ** to_exponent(after[1])
 
-    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str, ...]:
         theta = args.format_radians(self.theta)
         zeta = args.format_radians(self.zeta)
         chi = args.format_radians(self.chi)
@@ -537,7 +537,7 @@ class PhasedFSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
             f'gamma={gamma}, phi={phi})'
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['theta', 'zeta', 'chi', 'gamma', 'phi'])
 
     def _num_qubits_(self) -> int:

cirq/ops/gate_operation.py

@@ -19,22 +19,7 @@ from __future__ import annotations
 import re
 import warnings
 from types import NotImplementedType
-from typing import (
-    AbstractSet,
-    Any,
-    cast,
-    Collection,
-    Dict,
-    FrozenSet,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
-)
+from typing import AbstractSet, Any, cast, Collection, Mapping, Sequence, TYPE_CHECKING, TypeVar
 
 from typing_extensions import Self
 
@@ -71,7 +56,7 @@ class GateOperation(raw_types.Operation):
         return self._gate
 
     @property
-    def qubits(self) -> Tuple[cirq.Qid, ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         """The qubits targeted by the operation."""
         return self._qubits
 
@@ -93,7 +78,7 @@ class GateOperation(raw_types.Operation):
             return self
         return new_gate.on(*self.qubits)
 
-    def _with_key_path_(self, path: Tuple[str, ...]):
+    def _with_key_path_(self, path: tuple[str, ...]):
         new_gate = protocols.with_key_path(self.gate, path)
         if new_gate is NotImplemented:
             return NotImplemented
@@ -102,7 +87,7 @@ class GateOperation(raw_types.Operation):
             return self
         return new_gate.on(*self.qubits)
 
-    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]):
+    def _with_key_path_prefix_(self, prefix: tuple[str, ...]):
         new_gate = protocols.with_key_path_prefix(self.gate, prefix)
         if new_gate is NotImplemented:
             return NotImplemented
@@ -112,7 +97,7 @@ class GateOperation(raw_types.Operation):
         return new_gate.on(*self.qubits)
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
+        self, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey]
     ):
         new_gate = protocols.with_rescoped_keys(self.gate, path, bindable_keys)
         if new_gate is self.gate:
@@ -140,15 +125,15 @@ class GateOperation(raw_types.Operation):
         qubits = ', '.join(str(e) for e in self.qubits)
         return f'{self.gate}({qubits})' if qubits else str(self.gate)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['gate', 'qubits'])
 
     def _group_interchangeable_qubits(
         self,
-    ) -> Tuple[Union[cirq.Qid, Tuple[int, FrozenSet[cirq.Qid]]], ...]:
+    ) -> tuple[cirq.Qid | tuple[int, frozenset[cirq.Qid]], ...]:
         if not isinstance(self.gate, gate_features.InterchangeableQubitsGate):
             return self.qubits
-        groups: Dict[int, List[cirq.Qid]] = {}
+        groups: dict[int, list[cirq.Qid]] = {}
         for i, q in enumerate(self.qubits):
             k = self.gate.qubit_index_to_equivalence_group_key(i)
             groups.setdefault(k, []).append(q)
@@ -167,7 +152,7 @@ class GateOperation(raw_types.Operation):
         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_with_qubits(
             self.gate, self.qubits, NotImplemented, flatten=False, context=context
@@ -181,7 +166,7 @@ class GateOperation(raw_types.Operation):
 
     def _apply_unitary_(
         self, args: protocols.ApplyUnitaryArgs
-    ) -> Union[np.ndarray, None, NotImplementedType]:
+    ) -> np.ndarray | None | NotImplementedType:
         getter = getattr(self.gate, '_apply_unitary_', None)
         if getter is not None:
             return getter(args)
@@ -193,15 +178,13 @@ class GateOperation(raw_types.Operation):
             return getter()
         return NotImplemented
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         getter = getattr(self.gate, '_unitary_', None)
         if getter is not None:
             return getter()
         return 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:
         commutes = self.gate._commutes_on_qids_(self.qubits, other, atol=atol)
         if commutes is not NotImplemented:
             return commutes
@@ -214,7 +197,7 @@ class GateOperation(raw_types.Operation):
             return getter()
         return NotImplemented
 
-    def _mixture_(self) -> Sequence[Tuple[float, Any]]:
+    def _mixture_(self) -> Sequence[tuple[float, Any]]:
         getter = getattr(self.gate, '_mixture_', None)
         if getter is not None:
             return getter()
@@ -222,7 +205,7 @@ class GateOperation(raw_types.Operation):
 
     def _apply_channel_(
         self, args: protocols.ApplyChannelArgs
-    ) -> Union[np.ndarray, None, NotImplementedType]:
+    ) -> np.ndarray | None | NotImplementedType:
         getter = getattr(self.gate, '_apply_channel_', None)
         if getter is not None:
             return getter(args)
@@ -234,40 +217,38 @@ class GateOperation(raw_types.Operation):
             return getter()
         return NotImplemented
 
-    def _kraus_(self) -> Union[Tuple[np.ndarray], NotImplementedType]:
+    def _kraus_(self) -> tuple[np.ndarray] | NotImplementedType:
         getter = getattr(self.gate, '_kraus_', None)
         if getter is not None:
             return getter()
         return NotImplemented
 
-    def _is_measurement_(self) -> Optional[bool]:
+    def _is_measurement_(self) -> bool | None:
         getter = getattr(self.gate, '_is_measurement_', None)
         if getter is not None:
             return getter()
         # Let the protocol handle the fallback.
         return NotImplemented
 
-    def _measurement_key_name_(self) -> Optional[str]:
+    def _measurement_key_name_(self) -> str | None:
         getter = getattr(self.gate, '_measurement_key_name_', None)
         if getter is not None:
             return getter()
         return NotImplemented
 
-    def _measurement_key_names_(self) -> Union[FrozenSet[str], NotImplementedType, None]:
+    def _measurement_key_names_(self) -> frozenset[str] | NotImplementedType | None:
         getter = getattr(self.gate, '_measurement_key_names_', None)
         if getter is not None:
             return getter()
         return NotImplemented
 
-    def _measurement_key_obj_(self) -> Optional[cirq.MeasurementKey]:
+    def _measurement_key_obj_(self) -> cirq.MeasurementKey | None:
         getter = getattr(self.gate, '_measurement_key_obj_', None)
         if getter is not None:
             return getter()
         return NotImplemented
 
-    def _measurement_key_objs_(
-        self,
-    ) -> Union[FrozenSet[cirq.MeasurementKey], NotImplementedType, None]:
+    def _measurement_key_objs_(self) -> frozenset[cirq.MeasurementKey] | NotImplementedType | None:
         getter = getattr(self.gate, '_measurement_key_objs_', None)
         if getter is not None:
             return getter()
@@ -347,7 +328,7 @@ class GateOperation(raw_types.Operation):
     def __rmul__(self, other: Any) -> Any:
         return self.gate._rmul_with_qubits(self._qubits, other)
 
-    def _qasm_(self, args: protocols.QasmArgs) -> Optional[str]:
+    def _qasm_(self, args: protocols.QasmArgs) -> str | None:
         if isinstance(self.gate, ops.GlobalPhaseGate):
             warnings.warn(
                 "OpenQASM 2.0 does not support global phase."
@@ -360,7 +341,7 @@ class GateOperation(raw_types.Operation):
 
     def _equal_up_to_global_phase_(
         self, other: Any, atol: float = 1e-8
-    ) -> Union[NotImplementedType, bool]:
+    ) -> NotImplementedType | bool:
         if not isinstance(other, type(self)):
             return NotImplemented
         if self._group_interchangeable_qubits() != other._group_interchangeable_qubits():
@@ -370,9 +351,7 @@ class GateOperation(raw_types.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

cirq/ops/gateset.py

@@ -16,20 +16,7 @@
 
 from __future__ import annotations
 
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Dict,
-    FrozenSet,
-    Hashable,
-    List,
-    Optional,
-    Sequence,
-    Type,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, Callable, cast, Hashable, Sequence, TYPE_CHECKING
 
 from cirq import protocols, value
 from cirq.ops import global_phase_op, op_tree, raw_types
@@ -39,8 +26,7 @@ if TYPE_CHECKING:
 
 
 def _gate_str(
-    gate: Union[raw_types.Gate, Type[raw_types.Gate], cirq.GateFamily],
-    gettr: Callable[[Any], str] = str,
+    gate: raw_types.Gate | type[raw_types.Gate] | cirq.GateFamily, gettr: Callable[[Any], str] = str
 ) -> str:
     return gettr(gate) if not isinstance(gate, type) else f'{gate.__module__}.{gate.__name__}'
 
@@ -114,10 +100,10 @@ class GateFamily:
 
     def __init__(
         self,
-        gate: Union[Type[raw_types.Gate], raw_types.Gate],
+        gate: type[raw_types.Gate] | raw_types.Gate,
         *,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
+        name: str | None = None,
+        description: str | None = None,
         ignore_global_phase: bool = True,
         tags_to_accept: Sequence[Hashable] = (),
         tags_to_ignore: Sequence[Hashable] = (),
@@ -166,7 +152,7 @@ class GateFamily:
     def _gate_str(self, gettr: Callable[[Any], str] = str) -> str:
         return _gate_str(self.gate, gettr)
 
-    def _gate_json(self) -> Union[raw_types.Gate, str]:
+    def _gate_json(self) -> raw_types.Gate | str:
         return self.gate if not isinstance(self.gate, type) else protocols.json_cirq_type(self.gate)
 
     def _default_name(self) -> str:
@@ -188,7 +174,7 @@ class GateFamily:
         )
 
     @property
-    def gate(self) -> Union[Type[raw_types.Gate], raw_types.Gate]:
+    def gate(self) -> type[raw_types.Gate] | raw_types.Gate:
         return self._gate
 
     @property
@@ -200,11 +186,11 @@ class GateFamily:
         return self._description
 
     @property
-    def tags_to_accept(self) -> FrozenSet[Hashable]:
+    def tags_to_accept(self) -> frozenset[Hashable]:
         return self._tags_to_accept
 
     @property
-    def tags_to_ignore(self) -> FrozenSet[Hashable]:
+    def tags_to_ignore(self) -> frozenset[Hashable]:
         return self._tags_to_ignore
 
     def _predicate(self, gate: raw_types.Gate) -> bool:
@@ -227,7 +213,7 @@ class GateFamily:
             )
         return isinstance(gate, self.gate)
 
-    def __contains__(self, item: Union[raw_types.Gate, raw_types.Operation]) -> bool:
+    def __contains__(self, item: raw_types.Gate | raw_types.Operation) -> bool:
         if self._tags_to_accept and (
             not isinstance(item, raw_types.Operation) or self._tags_to_accept.isdisjoint(item.tags)
         ):
@@ -270,8 +256,8 @@ class GateFamily:
             self._tags_to_ignore,
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
-        d: Dict[str, Any] = {
+    def _json_dict_(self) -> dict[str, Any]:
+        d: dict[str, Any] = {
             'gate': self._gate_json(),
             'name': self.name,
             'description': self.description,
@@ -321,8 +307,8 @@ class Gateset:
 
     def __init__(
         self,
-        *gates: Union[Type[raw_types.Gate], raw_types.Gate, GateFamily],
-        name: Optional[str] = None,
+        *gates: type[raw_types.Gate] | raw_types.Gate | GateFamily,
+        name: str | None = None,
         unroll_circuit_op: bool = True,
     ) -> None:
         """Init Gateset.
@@ -346,10 +332,10 @@ class Gateset:
         """
         self._name = name
         self._unroll_circuit_op = unroll_circuit_op
-        self._instance_gate_families: Dict[raw_types.Gate, GateFamily] = {}
-        self._type_gate_families: Dict[Type[raw_types.Gate], GateFamily] = {}
+        self._instance_gate_families: dict[raw_types.Gate, GateFamily] = {}
+        self._type_gate_families: dict[type[raw_types.Gate], GateFamily] = {}
         self._gates_repr_str = ", ".join([_gate_str(g, repr) for g in gates])
-        unique_gate_list: List[GateFamily] = list(
+        unique_gate_list: list[GateFamily] = list(
             dict.fromkeys(g if isinstance(g, GateFamily) else GateFamily(gate=g) for g in gates)
         )
 
@@ -363,15 +349,15 @@ class Gateset:
         self._gates = frozenset(unique_gate_list)
 
     @property
-    def name(self) -> Optional[str]:
+    def name(self) -> str | None:
         return self._name
 
     @property
-    def gates(self) -> FrozenSet[GateFamily]:
+    def gates(self) -> frozenset[GateFamily]:
         return self._gates
 
     def with_params(
-        self, *, name: Optional[str] = None, unroll_circuit_op: Optional[bool] = None
+        self, *, name: str | None = None, unroll_circuit_op: bool | None = None
     ) -> Gateset:
         """Returns a copy of this Gateset with identical gates and new values for named arguments.
 
@@ -397,7 +383,7 @@ class Gateset:
         gates = self.gates
         return Gateset(*gates, name=name, unroll_circuit_op=cast(bool, unroll_circuit_op))
 
-    def __contains__(self, item: Union[raw_types.Gate, raw_types.Operation]) -> bool:
+    def __contains__(self, item: raw_types.Gate | raw_types.Operation) -> bool:
         r"""Check for containment of a given Gate/Operation in this Gateset.
 
         Containment checks are handled as follows:
@@ -447,7 +433,7 @@ class Gateset:
 
         return any(item in gate_family for gate_family in self._gates)
 
-    def validate(self, circuit_or_optree: Union[cirq.AbstractCircuit, op_tree.OP_TREE]) -> bool:
+    def validate(self, circuit_or_optree: cirq.AbstractCircuit | op_tree.OP_TREE) -> bool:
         """Validates gates forming `circuit_or_optree` should be contained in Gateset.
 
         Args:
@@ -512,7 +498,7 @@ class Gateset:
             header += self.name
         return f'{header}\n' + "\n\n".join([str(g) for g in self._unique_gate_list])
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'gates': self._unique_gate_list,
             'name': self.name,

cirq/ops/gateset_test.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import re
-from typing import cast, List, Tuple
+from typing import cast
 
 import numpy as np
 import pytest
@@ -26,7 +26,7 @@ from cirq._compat import proper_repr
 
 
 class CustomXPowGate(cirq.EigenGate):
-    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.5], [0.5, 0.5]])), (1, np.array([[0.5, -0.5], [-0.5, 0.5]]))]
 
     def __str__(self) -> str:

cirq/ops/global_phase_op.py

@@ -16,7 +16,7 @@
 from __future__ import annotations
 
 from types import NotImplementedType
-from typing import AbstractSet, Any, cast, Collection, Dict, Optional, Sequence, Tuple, Union
+from typing import AbstractSet, Any, cast, Collection, Sequence
 
 import numpy as np
 import sympy
@@ -50,12 +50,12 @@ class GlobalPhaseGate(raw_types.Gate):
             return GlobalPhaseGate(self.coefficient**power)
         return NotImplemented
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         if not self._has_unitary_():
             return NotImplemented
         return np.array([[self.coefficient]])
 
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         if not self._has_unitary_():
             return NotImplemented
         assert not cirq.is_parameterized(self)
@@ -74,10 +74,10 @@ class GlobalPhaseGate(raw_types.Gate):
     def _op_repr_(self, qubits: Sequence[cirq.Qid]) -> str:
         return f'cirq.global_phase_operation({proper_repr(self.coefficient)})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['coefficient'])
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return tuple()
 
     def _is_parameterized_(self) -> bool:
@@ -94,11 +94,9 @@ class GlobalPhaseGate(raw_types.Gate):
 
     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:
         result = super().controlled(num_controls, control_values, control_qid_shape)
         if (

cirq/ops/greedy_qubit_manager.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Iterable, List, Set, TYPE_CHECKING
+from typing import Iterable, TYPE_CHECKING
 
 from cirq.ops import named_qubit, qid_util, qubit_manager
 
@@ -51,8 +51,8 @@ class GreedyQubitManager(qubit_manager.QubitManager):
             maximize_reuse: Flag to control a FIFO vs LIFO strategy, defaults to False (FIFO).
         """
         self._prefix = prefix
-        self._used_qubits: Set[cirq.Qid] = set()
-        self._free_qubits: List[cirq.Qid] = []
+        self._used_qubits: set[cirq.Qid] = set()
+        self._free_qubits: list[cirq.Qid] = []
         self._size = 0
         self.maximize_reuse = maximize_reuse
         self.resize(size)
@@ -63,13 +63,13 @@ class GreedyQubitManager(qubit_manager.QubitManager):
     def resize(self, new_size: int, dim: int = 2) -> None:
         if new_size <= self._size:
             return
-        new_qubits: List[cirq.Qid] = [
+        new_qubits: list[cirq.Qid] = [
             self._allocate_qid(f'{self._prefix}_{s}', dim) for s in range(self._size, new_size)
         ]
         self._free_qubits = new_qubits + self._free_qubits
         self._size = new_size
 
-    def qalloc(self, n: int, dim: int = 2) -> List[cirq.Qid]:
+    def qalloc(self, n: int, dim: int = 2) -> list[cirq.Qid]:
         if not n:
             return []
         self.resize(self._size + n - len(self._free_qubits), dim=dim)
@@ -84,5 +84,5 @@ class GreedyQubitManager(qubit_manager.QubitManager):
         self._used_qubits = self._used_qubits.difference(qs)
         self._free_qubits.extend(qs)
 
-    def qborrow(self, n: int, dim: int = 2) -> List[cirq.Qid]:
+    def qborrow(self, n: int, dim: int = 2) -> list[cirq.Qid]:
         return self.qalloc(n, dim)