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

cirq/ops/pauli_string.py

@@ -23,18 +23,14 @@ from typing import (
     Any,
     Callable,
     cast,
-    Dict,
     Generic,
     ItemsView,
     Iterable,
     Iterator,
     KeysView,
-    List,
     Mapping,
-    Optional,
     overload,
     Sequence,
-    Tuple,
     TYPE_CHECKING,
     TypeVar,
     Union,
@@ -164,7 +160,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
     def __init__(
         self,
         *contents: cirq.PAULI_STRING_LIKE,
-        qubit_pauli_map: Optional[Dict[TKey, cirq.Pauli]] = None,
+        qubit_pauli_map: dict[TKey, cirq.Pauli] | None = None,
         coefficient: cirq.TParamValComplex = 1,
     ):
         """Initializes a new `PauliString` operation.
@@ -192,8 +188,8 @@ class PauliString(raw_types.Operation, Generic[TKey]):
                 if not isinstance(v, pauli_gates.Pauli):
                     raise TypeError(f'{v} is not a Pauli')
 
-        self._qubit_pauli_map: Dict[TKey, cirq.Pauli] = qubit_pauli_map or {}
-        self._coefficient: Union[cirq.TParamValComplex, sympy.Expr] = (
+        self._qubit_pauli_map: dict[TKey, cirq.Pauli] = qubit_pauli_map or {}
+        self._coefficient: cirq.TParamValComplex | sympy.Expr = (
             coefficient if isinstance(coefficient, sympy.Expr) else complex(coefficient)
         )
         if contents:
@@ -213,7 +209,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
 
         return (frozenset(self._qubit_pauli_map.items()), self._coefficient)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             # JSON requires mappings to have string keys.
             'qubit_pauli_map': list(self._qubit_pauli_map.items()),
@@ -238,39 +234,33 @@ class PauliString(raw_types.Operation, Generic[TKey]):
 
     # pylint: disable=function-redefined
     @overload
-    def get(self, key: Any, default: None = None) -> Optional[pauli_gates.Pauli]:
+    def get(self, key: Any, default: None = None) -> pauli_gates.Pauli | None:
         pass
 
     @overload
-    def get(self, key: Any, default: TDefault) -> Union[pauli_gates.Pauli, TDefault]:
+    def get(self, key: Any, default: TDefault) -> pauli_gates.Pauli | TDefault:
         pass
 
-    def get(
-        self, key: Any, default: Optional[TDefault] = None
-    ) -> Union[pauli_gates.Pauli, TDefault, None]:
+    def get(self, key: Any, default: TDefault | None = None) -> pauli_gates.Pauli | TDefault | None:
         """Returns the `cirq.Pauli` operation acting on qubit `key` or `default` if none exists."""
         return self._qubit_pauli_map.get(key, default)
 
     @overload
-    def __mul__(
-        self, other: cirq.PauliString[TKeyOther]
-    ) -> cirq.PauliString[Union[TKey, TKeyOther]]:
+    def __mul__(self, other: cirq.PauliString[TKeyOther]) -> cirq.PauliString[TKey | TKeyOther]:
         pass
 
     @overload
     def __mul__(
         self, other: Mapping[TKeyOther, cirq.PAULI_GATE_LIKE]
-    ) -> cirq.PauliString[Union[TKey, TKeyOther]]:
+    ) -> cirq.PauliString[TKey | TKeyOther]:
         pass
 
     @overload
-    def __mul__(
-        self, other: Iterable[cirq.PAULI_STRING_LIKE]
-    ) -> cirq.PauliString[Union[TKey, cirq.Qid]]:
+    def __mul__(self, other: Iterable[cirq.PAULI_STRING_LIKE]) -> cirq.PauliString[TKey | cirq.Qid]:
         pass
 
     @overload
-    def __mul__(self, other: cirq.Operation) -> cirq.PauliString[Union[TKey, cirq.Qid]]:
+    def __mul__(self, other: cirq.Operation) -> cirq.PauliString[TKey | cirq.Qid]:
         pass
 
     @overload
@@ -296,12 +286,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
     @property
     def gate(self) -> cirq.DensePauliString:
         """Returns a `cirq.DensePauliString`"""
-        order: List[Optional[pauli_gates.Pauli]] = [
-            None,
-            pauli_gates.X,
-            pauli_gates.Y,
-            pauli_gates.Z,
-        ]
+        order: list[pauli_gates.Pauli | None] = [None, pauli_gates.X, pauli_gates.Y, pauli_gates.Z]
         from cirq.ops.dense_pauli_string import DensePauliString
 
         return DensePauliString(
@@ -359,11 +344,11 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         return self._qubit_pauli_map.keys()
 
     @property
-    def qubits(self) -> Tuple[TKey, ...]:
+    def qubits(self) -> tuple[TKey, ...]:
         """Returns a tuple of qubits on which this pauli string acts."""
         return tuple(self.keys())
 
-    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> List[str]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> list[str]:
         if not len(self._qubit_pauli_map):
             return NotImplemented
 
@@ -485,7 +470,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
 
         return prefix + '*'.join(factors)
 
-    def matrix(self, qubits: Optional[Iterable[TKey]] = None) -> np.ndarray:
+    def matrix(self, qubits: Iterable[TKey] | None = None) -> np.ndarray:
         """Returns the matrix of self in computational basis of qubits.
 
         Args:
@@ -509,7 +494,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             return False
         return abs(1 - abs(cast(complex, self.coefficient))) < 1e-6
 
-    def _unitary_(self) -> Optional[np.ndarray]:
+    def _unitary_(self) -> np.ndarray | None:
         if not self._has_unitary_():
             return None
         return self.matrix()
@@ -743,7 +728,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
 
     def zip_items(
         self, other: cirq.PauliString[TKey]
-    ) -> Iterator[Tuple[TKey, Tuple[pauli_gates.Pauli, pauli_gates.Pauli]]]:
+    ) -> Iterator[tuple[TKey, tuple[pauli_gates.Pauli, pauli_gates.Pauli]]]:
         """Combines pauli operations from pauli strings in a qubit-by-qubit fashion.
 
         For every qubit that has a `cirq.Pauli` operation acting on it in both `self` and `other`,
@@ -762,7 +747,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
 
     def zip_paulis(
         self, other: cirq.PauliString
-    ) -> Iterator[Tuple[pauli_gates.Pauli, pauli_gates.Pauli]]:
+    ) -> Iterator[tuple[pauli_gates.Pauli, pauli_gates.Pauli]]:
         """Combines pauli operations from pauli strings in a qubit-by-qubit fashion.
 
         For every qubit that has a `cirq.Pauli` operation acting on it in both `self` and `other`,
@@ -777,9 +762,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         """
         return (paulis for qubit, paulis in self.zip_items(other))
 
-    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 not isinstance(other, PauliString):
             return NotImplemented
         return sum(not protocols.commutes(p0, p1) for p0, p1 in self.zip_paulis(other)) % 2 == 0
@@ -865,7 +848,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             )
         return NotImplemented
 
-    def map_qubits(self, qubit_map: Dict[TKey, TKeyNew]) -> cirq.PauliString[TKeyNew]:
+    def map_qubits(self, qubit_map: dict[TKey, TKeyNew]) -> cirq.PauliString[TKeyNew]:
         """Replaces every qubit `q` in `self.qubits` with `qubit_map[q]`.
 
         Args:
@@ -1124,7 +1107,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
 
 
 def _validate_qubit_mapping(
-    qubit_map: Mapping[TKey, int], pauli_qubits: Tuple[TKey, ...], num_state_qubits: int
+    qubit_map: Mapping[TKey, int], pauli_qubits: tuple[TKey, ...], num_state_qubits: int
 ) -> None:
     """Validates that a qubit map is a valid mapping.
 
@@ -1233,7 +1216,7 @@ class SingleQubitPauliStringGateOperation(  # type: ignore
     def __neg__(self):
         return -self._as_pauli_string()
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['pauli', 'qubit'])
 
     @classmethod
@@ -1260,7 +1243,7 @@ class MutablePauliString(Generic[TKey]):
         self,
         *contents: cirq.PAULI_STRING_LIKE,
         coefficient: cirq.TParamValComplex = 1,
-        pauli_int_dict: Optional[Dict[TKey, int]] = None,
+        pauli_int_dict: dict[TKey, int] | None = None,
     ):
         """Initializes a new `MutablePauliString`.
 
@@ -1282,14 +1265,14 @@ class MutablePauliString(Generic[TKey]):
         Raises:
             ValueError: If the `pauli_int_dict` has integer values `v` not satisfying `1 <= v <= 3`.
         """
-        self.coefficient: Union[sympy.Expr, cirq.TParamValComplex] = (
+        self.coefficient: sympy.Expr | cirq.TParamValComplex = (
             coefficient if isinstance(coefficient, sympy.Expr) else complex(coefficient)
         )
         if pauli_int_dict is not None:
             for v in pauli_int_dict.values():
                 if not 1 <= v <= 3:
                     raise ValueError(f"Value {v} of pauli_int_dict must be between 1 and 3.")
-        self.pauli_int_dict: Dict[TKey, int] = {} if pauli_int_dict is None else pauli_int_dict
+        self.pauli_int_dict: dict[TKey, int] = {} if pauli_int_dict is None else pauli_int_dict
         if contents:
             self.inplace_left_multiply_by(contents)
 
@@ -1345,7 +1328,7 @@ class MutablePauliString(Generic[TKey]):
             coefficient=self.coefficient, pauli_int_dict=dict(self.pauli_int_dict)
         )
 
-    def items(self) -> Iterator[Tuple[TKey, cirq.Pauli]]:
+    def items(self) -> Iterator[tuple[TKey, cirq.Pauli]]:
         """Returns (cirq.Qid, cirq.Pauli) pairs representing 1-qubit operations of pauli string."""
         for k, v in self.pauli_int_dict.items():
             yield k, _INT_TO_PAULI[v - 1]
@@ -1368,14 +1351,14 @@ class MutablePauliString(Generic[TKey]):
 
     # pylint: disable=function-redefined
     @overload
-    def get(self, key: TKey, default: None = None) -> Union[cirq.Pauli, None]:
+    def get(self, key: TKey, default: None = None) -> cirq.Pauli | None:
         pass
 
     @overload
-    def get(self, key: TKey, default: TDefault) -> Union[cirq.Pauli, TDefault]:
+    def get(self, key: TKey, default: TDefault) -> cirq.Pauli | TDefault:
         pass
 
-    def get(self, key: TKey, default=None) -> Union[cirq.Pauli, TDefault, None]:
+    def get(self, key: TKey, default=None) -> cirq.Pauli | TDefault | None:
         """Returns the `cirq.Pauli` operation acting on qubit `key` or `default` if none exists."""
         result = self.pauli_int_dict.get(key, None)
         return default if result is None else _INT_TO_PAULI[result - 1]
@@ -1519,7 +1502,7 @@ class MutablePauliString(Generic[TKey]):
             raise TypeError(f"{other!r} is not cirq.PAULI_STRING_LIKE.")
         return self
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             # JSON requires mappings to have string keys.
             'pauli_int_dict': list(self.pauli_int_dict.items()),
@@ -1618,7 +1601,7 @@ class MutablePauliString(Generic[TKey]):
         return f'{self.frozen()!r}.mutable_copy()'
 
 
-def _decompose_into_cliffords(op: cirq.Operation) -> List[cirq.Operation]:
+def _decompose_into_cliffords(op: cirq.Operation) -> list[cirq.Operation]:
     # An operation that can be ignored?
     if isinstance(op.gate, global_phase_op.GlobalPhaseGate):
         return []
@@ -1653,7 +1636,7 @@ _x = cast(pauli_gates.Pauli, pauli_gates.X)  # type: ignore
 _y = cast(pauli_gates.Pauli, pauli_gates.Y)  # type: ignore
 _z = cast(pauli_gates.Pauli, pauli_gates.Z)  # type: ignore
 
-PAULI_GATE_LIKE_TO_INDEX_MAP: Dict[cirq.PAULI_GATE_LIKE, int] = {
+PAULI_GATE_LIKE_TO_INDEX_MAP: dict[cirq.PAULI_GATE_LIKE, int] = {
     _i: 0,
     _x: 1,
     _y: 2,
@@ -1672,11 +1655,11 @@ PAULI_GATE_LIKE_TO_INDEX_MAP: Dict[cirq.PAULI_GATE_LIKE, int] = {
     3: 3,
 }
 
-_INT_TO_PAULI_OR_IDENTITY: List[Union[cirq.Pauli, cirq.IdentityGate]] = [_i, _x, _y, _z]
-_INT_TO_PAULI: List[cirq.Pauli] = [_x, _y, _z]
+_INT_TO_PAULI_OR_IDENTITY: list[cirq.Pauli | cirq.IdentityGate] = [_i, _x, _y, _z]
+_INT_TO_PAULI: list[cirq.Pauli] = [_x, _y, _z]
 
 
-PAULI_GATE_LIKE_TO_GATE_MAP: Dict[cirq.PAULI_GATE_LIKE, Union[cirq.Pauli, cirq.IdentityGate]] = {
+PAULI_GATE_LIKE_TO_GATE_MAP: dict[cirq.PAULI_GATE_LIKE, cirq.Pauli | cirq.IdentityGate] = {
     k: _INT_TO_PAULI_OR_IDENTITY[v] for k, v in PAULI_GATE_LIKE_TO_INDEX_MAP.items()
 }
 

cirq/ops/pauli_string_phasor.py

@@ -15,17 +15,7 @@
 from __future__ import annotations
 
 import numbers
-from typing import (
-    AbstractSet,
-    cast,
-    Dict,
-    Iterable,
-    Iterator,
-    Optional,
-    Sequence,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import AbstractSet, cast, Iterable, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import protocols, value
 from cirq._compat import deprecated, proper_repr
@@ -65,7 +55,7 @@ class PauliStringPhasor(gate_operation.GateOperation):
     def __init__(
         self,
         pauli_string: ps.PauliString,
-        qubits: Optional[Sequence[cirq.Qid]] = None,
+        qubits: Sequence[cirq.Qid] | None = None,
         *,
         exponent_neg: cirq.TParamVal = 1,
         exponent_pos: cirq.TParamVal = 0,
@@ -145,7 +135,7 @@ class PauliStringPhasor(gate_operation.GateOperation):
             )
         return False
 
-    def map_qubits(self, qubit_map: Dict[raw_types.Qid, raw_types.Qid]) -> PauliStringPhasor:
+    def map_qubits(self, qubit_map: dict[raw_types.Qid, raw_types.Qid]) -> PauliStringPhasor:
         """Maps the qubits inside the PauliStringPhasor.
 
         Args:
@@ -355,7 +345,7 @@ class PauliStringPhasorGate(raw_types.Gate):
             return rel1 == rel2 and self.dense_pauli_string == other.dense_pauli_string
         return False
 
-    def __pow__(self, exponent: Union[float, sympy.Symbol]) -> PauliStringPhasorGate:
+    def __pow__(self, exponent: float | sympy.Symbol) -> PauliStringPhasorGate:
         pn = protocols.mul(self.exponent_neg, exponent, None)
         pp = protocols.mul(self.exponent_pos, exponent, None)
         if pn is None or pp is None:

cirq/ops/pauli_string_raw_types.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import abc
-from typing import Any, Dict, Sequence, Tuple, TYPE_CHECKING
+from typing import Any, Sequence, TYPE_CHECKING
 
 from typing_extensions import Self
 
@@ -43,7 +43,7 @@ class PauliStringGateOperation(raw_types.Operation, metaclass=abc.ABCMeta):
         return self.map_qubits(dict(zip(self.pauli_string.qubits, new_qubits)))
 
     @abc.abstractmethod
-    def map_qubits(self, qubit_map: Dict[raw_types.Qid, raw_types.Qid]) -> Self:
+    def map_qubits(self, qubit_map: dict[raw_types.Qid, raw_types.Qid]) -> Self:
         """Return an equivalent operation on new qubits with its Pauli string
         mapped to new qubits.
 
@@ -51,7 +51,7 @@ class PauliStringGateOperation(raw_types.Operation, metaclass=abc.ABCMeta):
         """
 
     @property
-    def qubits(self) -> Tuple[raw_types.Qid, ...]:
+    def qubits(self) -> tuple[raw_types.Qid, ...]:
         return tuple(self.pauli_string)
 
     def _pauli_string_diagram_info(

cirq/ops/pauli_sum_exponential.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterator, Tuple, TYPE_CHECKING
+from typing import Any, Iterator, TYPE_CHECKING
 
 import numpy as np
 
@@ -68,7 +68,7 @@ class PauliSumExponential:
         self._pauli_sum = pauli_sum
 
     @property
-    def qubits(self) -> Tuple[cirq.Qid, ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         return self._pauli_sum.qubits
 
     def _value_equality_values_(self) -> Any:

cirq/ops/permutation_gate.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Iterator, Sequence, Tuple, TYPE_CHECKING
+from typing import Any, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import protocols, value
 from cirq.ops import raw_types, swap_gates
@@ -63,7 +63,7 @@ class QubitPermutationGate(raw_types.Gate):
         self._permutation = tuple(permutation)
 
     @property
-    def permutation(self) -> Tuple[int, ...]:
+    def permutation(self) -> tuple[int, ...]:
         return self._permutation
 
     def _value_equality_values_(self):
@@ -106,13 +106,13 @@ class QubitPermutationGate(raw_types.Gate):
         args.available_buffer[...] = args.target_tensor.transpose(permuted_axes)
         return args.available_buffer
 
-    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str, ...]:
         return tuple(f'[{i}>{self.permutation[i]}]' for i in range(len(self.permutation)))
 
     def __repr__(self) -> str:
         return f'cirq.QubitPermutationGate(permutation={self.permutation!r})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, attribute_names=['permutation'])
 
     @classmethod

cirq/ops/phased_iswap_gate.py

@@ -15,7 +15,7 @@
 
 from __future__ import annotations
 
-from typing import AbstractSet, Any, cast, Dict, Iterator, List, Optional, Sequence, Tuple, Union
+from typing import AbstractSet, Any, cast, Iterator, Sequence
 
 import numpy as np
 import sympy
@@ -62,8 +62,8 @@ class PhasedISwapPowGate(eigen_gate.EigenGate):
     def __init__(
         self,
         *,
-        phase_exponent: Union[float, sympy.Expr] = 0.25,
-        exponent: Union[float, sympy.Expr] = 1.0,
+        phase_exponent: float | sympy.Expr = 0.25,
+        exponent: float | sympy.Expr = 1.0,
         global_shift: float = 0.0,
     ):
         """Inits PhasedISwapPowGate.
@@ -81,13 +81,13 @@ class PhasedISwapPowGate(eigen_gate.EigenGate):
         super().__init__(exponent=exponent, global_shift=global_shift)
 
     @property
-    def phase_exponent(self) -> Union[float, sympy.Expr]:
+    def phase_exponent(self) -> float | sympy.Expr:
         return self._phase_exponent
 
     def _num_qubits_(self) -> int:
         return 2
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'phase_exponent': self._phase_exponent,
             'exponent': self._exponent,
@@ -126,20 +126,20 @@ class PhasedISwapPowGate(eigen_gate.EigenGate):
             phase_exponent=self.phase_exponent, exponent=exponent, global_shift=self.global_shift
         )
 
-    def _eigen_shifts(self) -> List[float]:
+    def _eigen_shifts(self) -> list[float]:
         return [0.0, +0.5, -0.5]
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         phase = np.exp(1j * np.pi * self.phase_exponent)
         phase_matrix = np.diag([1, phase, phase.conjugate(), 1])
         inverse_phase_matrix = np.conjugate(phase_matrix)
-        eigen_components: List[Tuple[float, np.ndarray]] = []
+        eigen_components: list[tuple[float, np.ndarray]] = []
         for eigenvalue, projector in self._iswap._eigen_components():
             new_projector = phase_matrix @ projector @ inverse_phase_matrix
             eigen_components.append((eigenvalue, new_projector))
         return eigen_components
 
-    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 NotImplemented
 

cirq/ops/phased_x_gate.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 import math
 import numbers
 from types import NotImplementedType
-from typing import AbstractSet, Any, cast, Dict, Optional, Sequence, Tuple, Union
+from typing import AbstractSet, Any, cast, Sequence
 
 import numpy as np
 import sympy
@@ -51,8 +51,8 @@ class PhasedXPowGate(raw_types.Gate):
     def __init__(
         self,
         *,
-        phase_exponent: Union[float, sympy.Expr],
-        exponent: Union[float, sympy.Expr] = 1.0,
+        phase_exponent: float | sympy.Expr,
+        exponent: float | sympy.Expr = 1.0,
         global_shift: float = 0.0,
     ) -> None:
         """Inits PhasedXPowGate.
@@ -67,7 +67,7 @@ class PhasedXPowGate(raw_types.Gate):
         self._exponent = exponent
         self._global_shift = global_shift
 
-    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 cirq.is_parameterized(self):
             return None
 
@@ -103,12 +103,12 @@ class PhasedXPowGate(raw_types.Gate):
         return z**-1, x, z
 
     @property
-    def exponent(self) -> Union[float, sympy.Expr]:
+    def exponent(self) -> float | sympy.Expr:
         """The exponent on the central X gate conjugated by the Z gates."""
         return self._exponent
 
     @property
-    def phase_exponent(self) -> Union[float, sympy.Expr]:
+    def phase_exponent(self) -> float | sympy.Expr:
         """The exponent on the Z gates conjugating the X gate."""
         return self._phase_exponent
 
@@ -116,7 +116,7 @@ class PhasedXPowGate(raw_types.Gate):
     def global_shift(self) -> float:
         return self._global_shift
 
-    def __pow__(self, exponent: Union[float, sympy.Expr]) -> PhasedXPowGate:
+    def __pow__(self, exponent: float | sympy.Expr) -> PhasedXPowGate:
         new_exponent = protocols.mul(self._exponent, exponent, NotImplemented)
         if new_exponent is NotImplemented:
             return NotImplemented  # pragma: no cover
@@ -126,7 +126,7 @@ class PhasedXPowGate(raw_types.Gate):
             global_shift=self._global_shift,
         )
 
-    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))
@@ -134,7 +134,7 @@ class PhasedXPowGate(raw_types.Gate):
     def _has_unitary_(self):
         return not self._is_parameterized_()
 
-    def _unitary_(self) -> Optional[Union[np.ndarray, NotImplementedType]]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType | None:
         """See `cirq.SupportsUnitary`."""
         if self._is_parameterized_():
             return None
@@ -243,5 +243,5 @@ class PhasedXPowGate(raw_types.Gate):
     def _value_equality_values_(self):
         return self.phase_exponent, self._canonical_exponent, self._global_shift
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['phase_exponent', 'exponent', 'global_shift'])

cirq/ops/phased_x_z_gate.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import numbers
-from typing import AbstractSet, Any, Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import AbstractSet, Any, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -52,9 +52,9 @@ class PhasedXZGate(raw_types.Gate):
     def __init__(
         self,
         *,
-        x_exponent: Union[float, sympy.Expr],
-        z_exponent: Union[float, sympy.Expr],
-        axis_phase_exponent: Union[float, sympy.Expr],
+        x_exponent: float | sympy.Expr,
+        z_exponent: float | sympy.Expr,
+        axis_phase_exponent: float | sympy.Expr,
     ) -> None:
         """Inits PhasedXZGate.
 
@@ -128,15 +128,15 @@ class PhasedXZGate(raw_types.Gate):
         return PhasedXZGate(x_exponent=x, z_exponent=z, axis_phase_exponent=a)
 
     @property
-    def x_exponent(self) -> Union[float, sympy.Expr]:
+    def x_exponent(self) -> float | sympy.Expr:
         return self._x_exponent
 
     @property
-    def z_exponent(self) -> Union[float, sympy.Expr]:
+    def z_exponent(self) -> float | sympy.Expr:
         return self._z_exponent
 
     @property
-    def axis_phase_exponent(self) -> Union[float, sympy.Expr]:
+    def axis_phase_exponent(self) -> float | sympy.Expr:
         return self._axis_phase_exponent
 
     def _value_equality_values_(self):
@@ -159,14 +159,14 @@ class PhasedXZGate(raw_types.Gate):
             x_exponent=rotation, axis_phase_exponent=-pre_phase, z_exponent=post_phase + pre_phase
         )._canonical()
 
-    def with_z_exponent(self, z_exponent: Union[float, sympy.Expr]) -> cirq.PhasedXZGate:
+    def with_z_exponent(self, z_exponent: float | sympy.Expr) -> cirq.PhasedXZGate:
         return PhasedXZGate(
             axis_phase_exponent=self._axis_phase_exponent,
             x_exponent=self._x_exponent,
             z_exponent=z_exponent,
         )
 
-    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         from cirq.circuits import qasm_output
 
         qasm_gate = qasm_output.QasmUGate(
@@ -182,7 +182,7 @@ class PhasedXZGate(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:
         """See `cirq.SupportsUnitary`."""
         if self._is_parameterized_():
             return None
@@ -300,7 +300,7 @@ class PhasedXZGate(raw_types.Gate):
             f'z_exponent={proper_repr(self._z_exponent)})'
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(
             self, ['axis_phase_exponent', 'x_exponent', 'z_exponent']
         )

cirq/ops/projector.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import itertools
 import math
-from typing import Any, Dict, Iterable, List, Mapping, Optional, TYPE_CHECKING
+from typing import Any, Iterable, Mapping, TYPE_CHECKING
 
 import numpy as np
 from scipy.sparse import csr_matrix
@@ -26,7 +26,7 @@ def _check_qids_dimension(qids):
 class ProjectorString:
     """Mapping of `cirq.Qid` to measurement values (with a coefficient) representing a projector."""
 
-    def __init__(self, projector_dict: Dict[cirq.Qid, int], coefficient: complex = 1):
+    def __init__(self, projector_dict: dict[cirq.Qid, int], coefficient: complex = 1):
         """Constructor for ProjectorString
 
         Args:
@@ -39,14 +39,14 @@ class ProjectorString:
         self._coefficient = complex(coefficient)
 
     @property
-    def projector_dict(self) -> Dict[cirq.Qid, int]:
+    def projector_dict(self) -> dict[cirq.Qid, int]:
         return self._projector_dict
 
     @property
     def coefficient(self) -> complex:
         return self._coefficient
 
-    def matrix(self, projector_qids: Optional[Iterable[cirq.Qid]] = None) -> csr_matrix:
+    def matrix(self, projector_qids: Iterable[cirq.Qid] | None = None) -> csr_matrix:
         """Returns the matrix of self in computational basis of qubits.
 
         Args:
@@ -82,7 +82,7 @@ class ProjectorString:
 
     def _get_idx_to_keep(self, qid_map: Mapping[cirq.Qid, int]):
         num_qubits = len(qid_map)
-        idx_to_keep: List[Any] = [slice(0, 2)] * num_qubits
+        idx_to_keep: list[Any] = [slice(0, 2)] * num_qubits
         for q in self.projector_dict.keys():
             idx_to_keep[qid_map[q]] = self.projector_dict[q]
         return tuple(idx_to_keep)
@@ -138,7 +138,7 @@ class ProjectorString:
             + f"coefficient={self._coefficient})"
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'projector_dict': list(self._projector_dict.items()),
             'coefficient': self._coefficient,