cirq-core 1.5.0.dev20250409225226__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/qis/quantum_state_representation.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
-from typing import List, Sequence, Tuple, TYPE_CHECKING
+from typing import Sequence, TYPE_CHECKING
 
 import numpy as np
 from typing_extensions import Self
@@ -38,8 +40,8 @@ class QuantumStateRepresentation(metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
     def measure(
-        self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
-    ) -> List[int]:
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
+    ) -> list[int]:
         """Measures the state.
 
         Args:
@@ -50,10 +52,7 @@ class QuantumStateRepresentation(metaclass=abc.ABCMeta):
         """
 
     def sample(
-        self,
-        axes: Sequence[int],
-        repetitions: int = 1,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        self, axes: Sequence[int], repetitions: int = 1, seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
     ) -> np.ndarray:
         """Samples the state. Subclasses can override with more performant method.
 
@@ -75,7 +74,7 @@ class QuantumStateRepresentation(metaclass=abc.ABCMeta):
         """Joins two state spaces together."""
         raise NotImplementedError()
 
-    def factor(self, axes: Sequence[int], *, validate=True, atol=1e-07) -> Tuple[Self, Self]:
+    def factor(self, axes: Sequence[int], *, validate=True, atol=1e-07) -> tuple[Self, Self]:
         """Splits two state spaces after a measurement or reset."""
         raise NotImplementedError()
 

cirq/qis/states.py

@@ -14,8 +14,10 @@
 
 """Classes and methods for quantum states."""
 
+from __future__ import annotations
+
 import itertools
-from typing import Any, cast, Iterable, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
+from typing import Any, cast, Iterable, Sequence, TYPE_CHECKING, Union
 
 import numpy as np
 
@@ -62,9 +64,9 @@ class QuantumState:
     def __init__(
         self,
         data: np.ndarray,
-        qid_shape: Optional[Tuple[int, ...]] = None,
+        qid_shape: tuple[int, ...] | None = None,
         *,  # Force keyword arguments
-        dtype: Optional['DTypeLike'] = None,
+        dtype: DTypeLike | None = None,
         validate: bool = True,
         atol: float = 1e-7,
     ) -> None:
@@ -97,7 +99,7 @@ class QuantumState:
         return self._data
 
     @property
-    def qid_shape(self) -> Tuple[int, ...]:
+    def qid_shape(self) -> tuple[int, ...]:
         """The qid shape of the quantum state."""
         return self._qid_shape
 
@@ -106,7 +108,7 @@ class QuantumState:
         """The data type of the quantum state."""
         return self._data.dtype
 
-    def state_vector(self) -> Optional[np.ndarray]:
+    def state_vector(self) -> np.ndarray | None:
         """Return the state vector of this state.
 
         A state vector stores the amplitudes of a pure state as a
@@ -117,7 +119,7 @@ class QuantumState:
             return None
         return np.reshape(self.data, (self._dim,))
 
-    def state_tensor(self) -> Optional[np.ndarray]:
+    def state_tensor(self) -> np.ndarray | None:
         """Return the state tensor of this state.
 
         A state tensor stores the amplitudes of a pure state as an array with
@@ -156,7 +158,7 @@ class QuantumState:
         return self.data.shape == (self._dim, self._dim)
 
     def validate(
-        self, *, dtype: Optional['DTypeLike'] = None, atol=1e-7  # Force keyword arguments
+        self, *, dtype: DTypeLike | None = None, atol=1e-7  # Force keyword arguments
     ) -> None:
         """Check if this quantum state is valid.
 
@@ -188,12 +190,12 @@ class QuantumState:
 
 
 def quantum_state(
-    state: 'cirq.QUANTUM_STATE_LIKE',
-    qid_shape: Optional[Tuple[int, ...]] = None,
+    state: cirq.QUANTUM_STATE_LIKE,
+    qid_shape: tuple[int, ...] | None = None,
     *,  # Force keyword arguments
     copy: bool = False,
     validate: bool = True,
-    dtype: Optional['DTypeLike'] = None,
+    dtype: DTypeLike | None = None,
     atol: float = 1e-7,
 ) -> QuantumState:
     """Create a QuantumState object from a state-like object.
@@ -293,11 +295,11 @@ def quantum_state(
 
 def density_matrix(
     state: np.ndarray,
-    qid_shape: Optional[Tuple[int, ...]] = None,
+    qid_shape: tuple[int, ...] | None = None,
     *,  # Force keyword arguments
     copy: bool = False,
     validate: bool = True,
-    dtype: Optional['DTypeLike'] = None,
+    dtype: DTypeLike | None = None,
     atol: float = 1e-7,
 ) -> QuantumState:
     """Create a QuantumState object from a density matrix.
@@ -328,7 +330,7 @@ def density_matrix(
     )
 
 
-def _infer_qid_shape_from_dimension(dim: int) -> Tuple[int, ...]:
+def _infer_qid_shape_from_dimension(dim: int) -> tuple[int, ...]:
     if dim != 0 and dim & dim - 1 == 0:
         # dim is a power of 2, assume qubits
         n_qubits = dim.bit_length() - 1
@@ -350,7 +352,7 @@ _NON_INT_STATE_LIKE = Union[
 ]
 
 
-def infer_qid_shape(*states: 'cirq.QUANTUM_STATE_LIKE') -> Tuple[int, ...]:
+def infer_qid_shape(*states: cirq.QUANTUM_STATE_LIKE) -> tuple[int, ...]:
     """Infer the qid shape of a set of states.
 
     This is a heuristic to determine a qid shape compatible with all of the
@@ -375,8 +377,8 @@ def infer_qid_shape(*states: 'cirq.QUANTUM_STATE_LIKE') -> Tuple[int, ...]:
     if not states:
         raise ValueError('No states were specified.')
 
-    integer_states: List[int] = []
-    non_integer_states: List[_NON_INT_STATE_LIKE] = []
+    integer_states: list[int] = []
+    non_integer_states: list[_NON_INT_STATE_LIKE] = []
     for state in states:
         if isinstance(state, int):
             integer_states.append(state)
@@ -410,7 +412,7 @@ def infer_qid_shape(*states: 'cirq.QUANTUM_STATE_LIKE') -> Tuple[int, ...]:
     return qid_shape
 
 
-def _potential_qid_shapes(state: _NON_INT_STATE_LIKE) -> '_QidShapeSet':
+def _potential_qid_shapes(state: _NON_INT_STATE_LIKE) -> _QidShapeSet:
     """Return a set of qid shapes compatible with a given state."""
     if isinstance(state, QuantumState):
         return _QidShapeSet(explicit_qid_shapes={state.qid_shape})
@@ -446,9 +448,9 @@ class _QidShapeSet:
     def __init__(
         self,
         *,
-        explicit_qid_shapes: Optional[Set[Tuple[int, ...]]] = None,
-        unfactorized_total_dimension: Optional[int] = None,
-        min_qudit_dimensions: Optional[Tuple[int, ...]] = None,
+        explicit_qid_shapes: set[tuple[int, ...]] | None = None,
+        unfactorized_total_dimension: int | None = None,
+        min_qudit_dimensions: tuple[int, ...] | None = None,
     ) -> None:
         """Create a qid shape set.
 
@@ -472,7 +474,7 @@ class _QidShapeSet:
         self.unfactorized_total_dimension = unfactorized_total_dimension
         self.min_qudit_dimensions = min_qudit_dimensions
 
-    def intersection_subset(self, other: '_QidShapeSet'):
+    def intersection_subset(self, other: _QidShapeSet):
         """Return a subset of the intersection with other qid shape set."""
         explicit_qid_shapes = self.explicit_qid_shapes & other.explicit_qid_shapes
         unfactorized_total_dimension = None
@@ -537,7 +539,7 @@ class _QidShapeSet:
                 f'a Hilbert space dimension of {self.unfactorized_total_dimension}.'
             )
 
-    def infer_qid_shape(self) -> Optional[Tuple[int, ...]]:
+    def infer_qid_shape(self) -> tuple[int, ...] | None:
         """Return a qid shape from this set, or None."""
         self._raise_value_error_if_ambiguous()
         if self.unfactorized_total_dimension is not None:
@@ -548,8 +550,8 @@ class _QidShapeSet:
 
 
 def _intersection_explicit_with_unfactorized_qid_shapes(
-    explicit_qid_shapes: Set[Tuple[int, ...]], unfactorized_total_dimension: int
-) -> Set[Tuple[int, ...]]:
+    explicit_qid_shapes: set[tuple[int, ...]], unfactorized_total_dimension: int
+) -> set[tuple[int, ...]]:
     return {
         qid_shape
         for qid_shape in explicit_qid_shapes
@@ -558,8 +560,8 @@ def _intersection_explicit_with_unfactorized_qid_shapes(
 
 
 def _intersection_explicit_with_min_qudit_dims_qid_shapes(
-    explicit_qid_shapes: Set[Tuple[int, ...]], min_qudit_dimensions: Tuple[int, ...]
-) -> Set[Tuple[int, ...]]:
+    explicit_qid_shapes: set[tuple[int, ...]], min_qudit_dimensions: tuple[int, ...]
+) -> set[tuple[int, ...]]:
     return {
         qid_shape
         for qid_shape in explicit_qid_shapes
@@ -569,8 +571,8 @@ def _intersection_explicit_with_min_qudit_dims_qid_shapes(
 
 
 def _intersection_min_qudit_dims_qid_shapes(
-    min_qudit_dimensions1: Tuple[int, ...], min_qudit_dimensions2: Tuple[int, ...]
-) -> Optional[Tuple[int, ...]]:
+    min_qudit_dimensions1: tuple[int, ...], min_qudit_dimensions2: tuple[int, ...]
+) -> tuple[int, ...] | None:
     if len(min_qudit_dimensions1) == len(min_qudit_dimensions2):
         return tuple(
             max(dim1, dim2) for dim1, dim2 in zip(min_qudit_dimensions1, min_qudit_dimensions2)
@@ -579,7 +581,7 @@ def _intersection_min_qudit_dims_qid_shapes(
 
 
 def bloch_vector_from_state_vector(
-    state_vector: np.ndarray, index: int, qid_shape: Optional[Tuple[int, ...]] = None
+    state_vector: np.ndarray, index: int, qid_shape: tuple[int, ...] | None = None
 ) -> np.ndarray:
     """Returns the bloch vector of a qubit.
 
@@ -619,8 +621,8 @@ def bloch_vector_from_state_vector(
 
 def density_matrix_from_state_vector(
     state_vector: np.ndarray,
-    indices: Optional[Iterable[int]] = None,
-    qid_shape: Optional[Tuple[int, ...]] = None,
+    indices: Iterable[int] | None = None,
+    qid_shape: tuple[int, ...] | None = None,
 ) -> np.ndarray:
     r"""Returns the density matrix of the state vector.
 
@@ -682,8 +684,8 @@ def density_matrix_from_state_vector(
         state_vector,
         list(range(n_qubits)),
         np.conj(state_vector),
-        cast(List, sum_inds.tolist()),
-        indices + cast(List, sum_inds[indices].tolist()),
+        cast(list, sum_inds.tolist()),
+        indices + cast(list, sum_inds[indices].tolist()),
     )
     new_shape = np.prod([shape[i] for i in indices], dtype=np.int64)
 
@@ -691,7 +693,7 @@ def density_matrix_from_state_vector(
 
 
 def dirac_notation(
-    state_vector: np.ndarray, decimals: int = 2, qid_shape: Optional[Tuple[int, ...]] = None
+    state_vector: np.ndarray, decimals: int = 2, qid_shape: tuple[int, ...] | None = None
 ) -> str:
     """Returns the state vector as a string in Dirac notation.
 
@@ -761,11 +763,11 @@ def dirac_notation(
 
 
 def to_valid_state_vector(
-    state_rep: 'cirq.STATE_VECTOR_LIKE',
-    num_qubits: Optional[int] = None,
+    state_rep: cirq.STATE_VECTOR_LIKE,
+    num_qubits: int | None = None,
     *,  # Force keyword arguments
-    qid_shape: Optional[Sequence[int]] = None,
-    dtype: Optional['DTypeLike'] = None,
+    qid_shape: Sequence[int] | None = None,
+    dtype: DTypeLike | None = None,
     atol: float = 1e-7,
 ) -> np.ndarray:
     """Verifies the state_rep is valid and converts it to ndarray form.
@@ -830,7 +832,7 @@ def to_valid_state_vector(
 
 
 def _qudit_values_to_state_tensor(
-    *, state_vector: np.ndarray, qid_shape: Tuple[int, ...], dtype: Optional['DTypeLike']
+    *, state_vector: np.ndarray, qid_shape: tuple[int, ...], dtype: DTypeLike | None
 ) -> np.ndarray:
     for i in range(len(qid_shape)):
         s = state_vector[i]
@@ -862,8 +864,8 @@ def _qudit_values_to_state_tensor(
 def validate_normalized_state_vector(
     state_vector: np.ndarray,
     *,  # Force keyword arguments
-    qid_shape: Tuple[int, ...],
-    dtype: Optional['DTypeLike'] = None,
+    qid_shape: tuple[int, ...],
+    dtype: DTypeLike | None = None,
     atol: float = 1e-7,
 ) -> None:
     """Checks that the given state vector is valid.
@@ -894,8 +896,8 @@ def validate_normalized_state_vector(
 
 
 def validate_qid_shape(
-    state_vector: np.ndarray, qid_shape: Optional[Tuple[int, ...]]
-) -> Tuple[int, ...]:
+    state_vector: np.ndarray, qid_shape: tuple[int, ...] | None
+) -> tuple[int, ...]:
     """Validates the size of the given `state_vector` against the given shape.
 
     Returns:
@@ -928,11 +930,11 @@ def validate_indices(num_qubits: int, indices: Sequence[int]) -> None:
 
 
 def to_valid_density_matrix(
-    density_matrix_rep: Union[np.ndarray, 'cirq.STATE_VECTOR_LIKE'],
-    num_qubits: Optional[int] = None,
+    density_matrix_rep: np.ndarray | cirq.STATE_VECTOR_LIKE,
+    num_qubits: int | None = None,
     *,  # Force keyword arguments
-    qid_shape: Optional[Tuple[int, ...]] = None,
-    dtype: Optional['DTypeLike'] = None,
+    qid_shape: tuple[int, ...] | None = None,
+    dtype: DTypeLike | None = None,
     atol: float = 1e-7,
 ) -> np.ndarray:
     """Verifies the density_matrix_rep is valid and converts it to ndarray form.
@@ -980,8 +982,8 @@ def to_valid_density_matrix(
 def validate_density_matrix(
     density_matrix: np.ndarray,
     *,  # Force keyword arguments
-    qid_shape: Tuple[int, ...],
-    dtype: Optional['DTypeLike'] = None,
+    qid_shape: tuple[int, ...],
+    dtype: DTypeLike | None = None,
     atol: float = 1e-7,
 ) -> None:
     """Checks that the given density matrix is valid.
@@ -1021,8 +1023,8 @@ def validate_density_matrix(
 
 
 def _qid_shape_from_args(
-    num_qubits: Optional[int], qid_shape: Optional[Tuple[int, ...]]
-) -> Tuple[int, ...]:
+    num_qubits: int | None, qid_shape: tuple[int, ...] | None
+) -> tuple[int, ...]:
     """Returns either `(2,) * num_qubits` or `qid_shape`.
 
     Raises:
@@ -1033,7 +1035,7 @@ def _qid_shape_from_args(
             'Either the num_qubits or qid_shape argument must be specified. Both were None.'
         )
     if num_qubits is None:
-        return cast(Tuple[int, ...], qid_shape)
+        return cast(tuple[int, ...], qid_shape)
     if qid_shape is None:
         return (2,) * num_qubits
     if len(qid_shape) != num_qubits:
@@ -1046,10 +1048,10 @@ def _qid_shape_from_args(
 
 def one_hot(
     *,
-    index: Union[None, int, Sequence[int]] = None,
-    shape: Union[int, Sequence[int]],
+    index: None | int | Sequence[int] = None,
+    shape: int | Sequence[int],
     value: Any = 1,
-    dtype: 'DTypeLike',
+    dtype: DTypeLike,
 ) -> np.ndarray:
     """Returns a numpy array with all 0s and a single non-zero entry(default 1).
 
@@ -1070,7 +1072,7 @@ def one_hot(
     return result
 
 
-def eye_tensor(half_shape: Tuple[int, ...], *, dtype: 'DTypeLike') -> np.ndarray:
+def eye_tensor(half_shape: tuple[int, ...], *, dtype: DTypeLike) -> np.ndarray:
     """Returns an identity matrix reshaped into a tensor.
 
     Args:

cirq/qis/states_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 import pytest
 

cirq/sim/classical_simulator.py

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
 from copy import copy, deepcopy
-from typing import Any, Dict, Generic, List, Optional, Sequence, TYPE_CHECKING, Union
+from typing import Any, Generic, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -37,7 +38,7 @@ def _is_identity(action) -> bool:
 class ClassicalBasisState(qis.QuantumStateRepresentation):
     """Represents a classical basis state for efficient state evolution."""
 
-    def __init__(self, initial_state: Union[List[int], np.ndarray]):
+    def __init__(self, initial_state: list[int] | np.ndarray):
         """Initializes the ClassicalBasisState object.
 
         Args:
@@ -45,7 +46,7 @@ class ClassicalBasisState(qis.QuantumStateRepresentation):
         """
         self.basis = initial_state
 
-    def copy(self, deep_copy_buffers: bool = True) -> 'ClassicalBasisState':
+    def copy(self, deep_copy_buffers: bool = True) -> ClassicalBasisState:
         """Creates a copy of the ClassicalBasisState object.
 
         Args:
@@ -58,8 +59,8 @@ class ClassicalBasisState(qis.QuantumStateRepresentation):
         )
 
     def measure(
-        self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
-    ) -> List[int]:
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
+    ) -> list[int]:
         """Measures the density matrix.
 
         Args:
@@ -76,9 +77,9 @@ class ClassicalBasisSimState(SimulationState[ClassicalBasisState]):
 
     def __init__(
         self,
-        initial_state: Union[int, List[int]] = 0,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        initial_state: int | list[int] = 0,
+        qubits: Sequence[cirq.Qid] | None = None,
+        classical_data: cirq.ClassicalDataStore | None = None,
     ):
         """Initializes the ClassicalBasisSimState object.
 
@@ -89,23 +90,23 @@ class ClassicalBasisSimState(SimulationState[ClassicalBasisState]):
 
         Raises:
             ValueError: If qubits not provided and initial_state is int.
-                        If initial_state is not an int, List[int], or np.ndarray.
+                        If initial_state is not an int, list[int], or np.ndarray.
 
         An initial_state value of type integer is parsed in big endian order.
         """
         if isinstance(initial_state, int):
             if qubits is None:
-                raise ValueError('qubits must be provided if initial_state is not List[int]')
+                raise ValueError('qubits must be provided if initial_state is not list[int]')
             state = ClassicalBasisState(
                 big_endian_int_to_bits(initial_state, bit_count=len(qubits))
             )
         elif isinstance(initial_state, (list, np.ndarray)):
             state = ClassicalBasisState(initial_state)
         else:
-            raise ValueError('initial_state must be an int or List[int] or np.ndarray')
+            raise ValueError('initial_state must be an int or list[int] or np.ndarray')
         super().__init__(state=state, qubits=qubits, classical_data=classical_data)
 
-    def _act_on_fallback_(self, action, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True):
+    def _act_on_fallback_(self, action, qubits: Sequence[cirq.Qid], allow_decompose: bool = True):
         """Acts on the state with a given operation.
 
         Args:
@@ -182,7 +183,7 @@ class ClassicalStateSimulator(
     """A simulator that accepts only gates with classical counterparts."""
 
     def __init__(
-        self, *, noise: 'cirq.NOISE_MODEL_LIKE' = None, split_untangled_states: bool = False
+        self, *, noise: cirq.NOISE_MODEL_LIKE = None, split_untangled_states: bool = False
     ):
         """Initializes a ClassicalStateSimulator.
 
@@ -199,10 +200,10 @@ class ClassicalStateSimulator(
 
     def _create_simulator_trial_result(
         self,
-        params: 'cirq.ParamResolver',
-        measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[ClassicalBasisSimState]',
-    ) -> 'ClassicalStateTrialResult[ClassicalBasisSimState]':
+        params: cirq.ParamResolver,
+        measurements: dict[str, np.ndarray],
+        final_simulator_state: cirq.SimulationStateBase[ClassicalBasisSimState],
+    ) -> ClassicalStateTrialResult[ClassicalBasisSimState]:
         """Creates a trial result for the simulator.
 
         Args:
@@ -217,8 +218,8 @@ class ClassicalStateSimulator(
         )
 
     def _create_step_result(
-        self, sim_state: 'cirq.SimulationStateBase[ClassicalBasisSimState]'
-    ) -> 'ClassicalStateStepResult[ClassicalBasisSimState]':
+        self, sim_state: cirq.SimulationStateBase[ClassicalBasisSimState]
+    ) -> ClassicalStateStepResult[ClassicalBasisSimState]:
         """Creates a step result for the simulator.
 
         Args:
@@ -231,9 +232,9 @@ class ClassicalStateSimulator(
     def _create_partial_simulation_state(
         self,
         initial_state: Any,
-        qubits: Sequence['cirq.Qid'],
-        classical_data: 'cirq.ClassicalDataStore',
-    ) -> 'ClassicalBasisSimState':
+        qubits: Sequence[cirq.Qid],
+        classical_data: cirq.ClassicalDataStore,
+    ) -> ClassicalBasisSimState:
         """Creates a partial simulation state for the simulator.
 
         Args:

cirq/sim/classical_simulator_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from itertools import product
 
 import numpy as np

cirq/sim/clifford/clifford_simulator.py

@@ -30,7 +30,9 @@ The quantum state is specified in two forms:
     to state vector amplitudes.
 """
 
-from typing import Any, Dict, List, Sequence, Union
+from __future__ import annotations
+
+from typing import Any, Sequence
 
 import numpy as np
 
@@ -50,7 +52,7 @@ class CliffordSimulator(
     """An efficient simulator for Clifford circuits."""
 
     def __init__(
-        self, seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None, split_untangled_states: bool = False
+        self, seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None, split_untangled_states: bool = False
     ):
         """Creates instance of `CliffordSimulator`.
 
@@ -63,17 +65,17 @@ class CliffordSimulator(
         super().__init__(seed=seed, split_untangled_states=split_untangled_states)
 
     @staticmethod
-    def is_supported_operation(op: 'cirq.Operation') -> bool:
+    def is_supported_operation(op: cirq.Operation) -> bool:
         """Checks whether given operation can be simulated by this simulator."""
         # TODO: support more general Pauli measurements
         return protocols.has_stabilizer_effect(op)
 
     def _create_partial_simulation_state(
         self,
-        initial_state: Union[int, 'cirq.StabilizerChFormSimulationState'],
-        qubits: Sequence['cirq.Qid'],
-        classical_data: 'cirq.ClassicalDataStore',
-    ) -> 'cirq.StabilizerChFormSimulationState':
+        initial_state: int | cirq.StabilizerChFormSimulationState,
+        qubits: Sequence[cirq.Qid],
+        classical_data: cirq.ClassicalDataStore,
+    ) -> cirq.StabilizerChFormSimulationState:
         """Creates the StabilizerChFormSimulationState for a circuit.
 
         Args:
@@ -101,15 +103,15 @@ class CliffordSimulator(
         )
 
     def _create_step_result(
-        self, sim_state: 'cirq.SimulationStateBase[clifford.StabilizerChFormSimulationState]'
+        self, sim_state: cirq.SimulationStateBase[clifford.StabilizerChFormSimulationState]
     ):
         return CliffordSimulatorStepResult(sim_state=sim_state)
 
     def _create_simulator_trial_result(
         self,
-        params: 'cirq.ParamResolver',
-        measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[cirq.StabilizerChFormSimulationState]',
+        params: cirq.ParamResolver,
+        measurements: dict[str, np.ndarray],
+        final_simulator_state: cirq.SimulationStateBase[cirq.StabilizerChFormSimulationState],
     ):
         return CliffordTrialResult(
             params=params, measurements=measurements, final_simulator_state=final_simulator_state
@@ -121,16 +123,16 @@ class CliffordTrialResult(
 ):
     def __init__(
         self,
-        params: 'cirq.ParamResolver',
-        measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[cirq.StabilizerChFormSimulationState]',
+        params: cirq.ParamResolver,
+        measurements: dict[str, np.ndarray],
+        final_simulator_state: cirq.SimulationStateBase[cirq.StabilizerChFormSimulationState],
     ) -> None:
         super().__init__(
             params=params, measurements=measurements, final_simulator_state=final_simulator_state
         )
 
     @property
-    def final_state(self) -> 'cirq.CliffordState':
+    def final_state(self) -> cirq.CliffordState:
         state = self._get_merged_sim_state()
         clifford_state = CliffordState(state.qubit_map)
         clifford_state.ch_form = state.state.copy()
@@ -152,7 +154,7 @@ class CliffordSimulatorStepResult(
     """A `StepResult` that includes `StateVectorMixin` methods."""
 
     def __init__(
-        self, sim_state: 'cirq.SimulationStateBase[clifford.StabilizerChFormSimulationState]'
+        self, sim_state: cirq.SimulationStateBase[clifford.StabilizerChFormSimulationState]
     ):
         """Results of a step of the simulator.
         Attributes:
@@ -199,7 +201,7 @@ class CliffordState:
     Gates and measurements are applied to each representation in O(n^2) time.
     """
 
-    def __init__(self, qubit_map, initial_state: Union[int, 'cirq.StabilizerStateChForm'] = 0):
+    def __init__(self, qubit_map, initial_state: int | cirq.StabilizerStateChForm = 0):
         self.qubit_map = qubit_map
         self.n = len(qubit_map)
 
@@ -222,7 +224,7 @@ class CliffordState:
     def _value_equality_values_(self) -> Any:
         return self.qubit_map, self.ch_form
 
-    def copy(self) -> 'cirq.CliffordState':
+    def copy(self) -> cirq.CliffordState:
         state = CliffordState(self.qubit_map)
         state.ch_form = self.ch_form.copy()
 
@@ -241,7 +243,7 @@ class CliffordState:
     def state_vector(self):
         return self.ch_form.state_vector()
 
-    def apply_unitary(self, op: 'cirq.Operation'):
+    def apply_unitary(self, op: cirq.Operation):
         ch_form_args = clifford.StabilizerChFormSimulationState(
             prng=np.random.RandomState(), qubits=self.qubit_map.keys(), initial_state=self.ch_form
         )
@@ -253,8 +255,8 @@ class CliffordState:
 
     def apply_measurement(
         self,
-        op: 'cirq.Operation',
-        measurements: Dict[str, List[int]],
+        op: cirq.Operation,
+        measurements: dict[str, list[int]],
         prng: np.random.RandomState,
         collapse_state_vector=True,
     ):