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

cirq/sim/simulator.py

@@ -31,22 +31,7 @@ from __future__ import annotations
 
 import abc
 import collections
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Dict,
-    Generic,
-    Iterator,
-    List,
-    Mapping,
-    Sequence,
-    Set,
-    Tuple,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
-)
+from typing import Any, Callable, cast, Generic, Iterator, Mapping, Sequence, TYPE_CHECKING, TypeVar
 
 import numpy as np
 
@@ -110,7 +95,7 @@ class SimulatesSamples(work.Sampler, metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def _run(
         self, circuit: cirq.AbstractCircuit, param_resolver: cirq.ParamResolver, repetitions: int
-    ) -> Dict[str, np.ndarray]:
+    ) -> dict[str, np.ndarray]:
         """Run a simulation, mimicking quantum hardware.
 
         Args:
@@ -236,7 +221,7 @@ class SimulatesAmplitudes(metaclass=value.ABCMetaImplementAnyOneOf):
         seed: cirq.RANDOM_STATE_OR_SEED_LIKE,
         repetitions: int = 1,
         qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
-    ) -> Dict[int, int]:
+    ) -> dict[int, int]:
         """Uses amplitude simulation to sample from the given circuit.
 
         This implements the algorithm outlined by Bravyi, Gosset, and Liu in
@@ -279,7 +264,7 @@ class SimulatesAmplitudes(metaclass=value.ABCMetaImplementAnyOneOf):
         for m_id, moment in enumerate(solved_circuit[1:]):
             circuit_prefix = solved_circuit[: m_id + 1]
             for t, op in enumerate(moment.operations):
-                new_samples: Dict[Tuple[int, ...], int] = collections.defaultdict(int)
+                new_samples: dict[tuple[int, ...], int] = collections.defaultdict(int)
                 qubit_indices = {qmap[q] for q in op.qubits}
                 subcircuit = circuit_prefix + circuits.Moment(moment.operations[: t + 1])
                 for current_sample, count in current_samples.items():
@@ -315,12 +300,12 @@ class SimulatesExpectationValues(metaclass=value.ABCMetaImplementAnyOneOf):
     def simulate_expectation_values(
         self,
         program: cirq.AbstractCircuit,
-        observables: Union[cirq.PauliSumLike, List[cirq.PauliSumLike]],
+        observables: cirq.PauliSumLike | list[cirq.PauliSumLike],
         param_resolver: cirq.ParamResolverOrSimilarType = None,
         qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
         initial_state: Any = None,
         permit_terminal_measurements: bool = False,
-    ) -> List[float]:
+    ) -> list[float]:
         """Simulates the supplied circuit and calculates exact expectation
         values for the given observables on its final state.
 
@@ -363,12 +348,12 @@ class SimulatesExpectationValues(metaclass=value.ABCMetaImplementAnyOneOf):
     def simulate_expectation_values_sweep(
         self,
         program: cirq.AbstractCircuit,
-        observables: Union[cirq.PauliSumLike, List[cirq.PauliSumLike]],
+        observables: cirq.PauliSumLike | list[cirq.PauliSumLike],
         params: cirq.Sweepable,
         qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
         initial_state: Any = None,
         permit_terminal_measurements: bool = False,
-    ) -> List[List[float]]:
+    ) -> list[list[float]]:
         """Wraps computed expectation values in a list.
 
         Prefer overriding `simulate_expectation_values_sweep_iter`.
@@ -387,12 +372,12 @@ class SimulatesExpectationValues(metaclass=value.ABCMetaImplementAnyOneOf):
     def _simulate_expectation_values_sweep_to_iter(
         self,
         program: cirq.AbstractCircuit,
-        observables: Union[cirq.PauliSumLike, List[cirq.PauliSumLike]],
+        observables: cirq.PauliSumLike | list[cirq.PauliSumLike],
         params: cirq.Sweepable,
         qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
         initial_state: Any = None,
         permit_terminal_measurements: bool = False,
-    ) -> Iterator[List[float]]:
+    ) -> Iterator[list[float]]:
         if (
             type(self).simulate_expectation_values_sweep
             == SimulatesExpectationValues.simulate_expectation_values_sweep
@@ -412,12 +397,12 @@ class SimulatesExpectationValues(metaclass=value.ABCMetaImplementAnyOneOf):
     def simulate_expectation_values_sweep_iter(
         self,
         program: cirq.AbstractCircuit,
-        observables: Union[cirq.PauliSumLike, List[cirq.PauliSumLike]],
+        observables: cirq.PauliSumLike | list[cirq.PauliSumLike],
         params: cirq.Sweepable,
         qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
         initial_state: Any = None,
         permit_terminal_measurements: bool = False,
-    ) -> Iterator[List[float]]:
+    ) -> Iterator[list[float]]:
         """Simulates the supplied circuit and calculates exact expectation
         values for the given observables on its final state, sweeping over the
         given params.
@@ -502,7 +487,7 @@ class SimulatesFinalState(
         params: cirq.Sweepable,
         qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
         initial_state: Any = None,
-    ) -> List[TSimulationTrialResult]:
+    ) -> list[TSimulationTrialResult]:
         """Wraps computed states in a list.
 
         Prefer overriding `simulate_sweep_iter`.
@@ -608,7 +593,7 @@ class SimulatesIntermediateState(
             all_step_results = self.simulate_moment_steps(
                 program, param_resolver, qubit_order, state
             )
-            measurements: Dict[str, np.ndarray] = {}
+            measurements: dict[str, np.ndarray] = {}
             for step_result in all_step_results:
                 for k, v in step_result.measurements.items():
                     measurements[k] = np.array(v, dtype=np.uint8)
@@ -654,7 +639,7 @@ class SimulatesIntermediateState(
 
     @abc.abstractmethod
     def _base_iterator(
-        self, circuit: cirq.AbstractCircuit, qubits: Tuple[cirq.Qid, ...], initial_state: Any
+        self, circuit: cirq.AbstractCircuit, qubits: tuple[cirq.Qid, ...], initial_state: Any
     ) -> Iterator[TStepResult]:
         """Iterator over StepResult from Moments of a Circuit.
 
@@ -675,7 +660,7 @@ class SimulatesIntermediateState(
     def _create_simulator_trial_result(
         self,
         params: cirq.ParamResolver,
-        measurements: Dict[str, np.ndarray],
+        measurements: dict[str, np.ndarray],
         final_simulator_state: TSimulatorState,
     ) -> TSimulationTrialResult:
         """This method can be implemented to create a trial result.
@@ -722,7 +707,7 @@ class StepResult(Generic[TSimulatorState], metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def sample(
         self,
-        qubits: List[cirq.Qid],
+        qubits: list[cirq.Qid],
         repetitions: int = 1,
         seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     ) -> np.ndarray:
@@ -746,12 +731,12 @@ class StepResult(Generic[TSimulatorState], metaclass=abc.ABCMeta):
 
     def sample_measurement_ops(
         self,
-        measurement_ops: List[cirq.GateOperation],
+        measurement_ops: list[cirq.GateOperation],
         repetitions: int = 1,
         seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
         *,
         _allow_repeated=False,
-    ) -> Dict[str, np.ndarray]:
+    ) -> dict[str, np.ndarray]:
         """Samples from the system at this point in the computation.
 
         Note that this does not collapse the state vector.
@@ -797,7 +782,7 @@ class StepResult(Generic[TSimulatorState], metaclass=abc.ABCMeta):
 
         # Find measured qubits, ensuring a consistent ordering.
         measured_qubits = []
-        seen_qubits: Set[cirq.Qid] = set()
+        seen_qubits: set[cirq.Qid] = set()
         for op in measurement_ops:
             for q in op.qubits:
                 if q not in seen_qubits:
@@ -808,7 +793,7 @@ class StepResult(Generic[TSimulatorState], metaclass=abc.ABCMeta):
         indexed_sample = self.sample(measured_qubits, repetitions, seed=seed)
 
         # Extract results for each measurement.
-        results: Dict[str, Any] = {}
+        results: dict[str, Any] = {}
         qubits_to_index = {q: i for i, q in enumerate(measured_qubits)}
         for op in measurement_ops:
             gate = cast(ops.MeasurementGate, op.gate)
@@ -837,7 +822,7 @@ class StepResult(Generic[TSimulatorState], metaclass=abc.ABCMeta):
         self,
         bits: np.ndarray,
         qubits: Sequence[cirq.Qid],
-        confusion_map: Dict[Tuple[int, ...], np.ndarray],
+        confusion_map: dict[tuple[int, ...], np.ndarray],
         seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     ) -> None:
         """Mutates `bits` using the confusion_map.
@@ -937,12 +922,12 @@ class SimulationTrialResult(Generic[TSimulatorState]):
         """
         return self._final_simulator_state.qubit_map
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return _qubit_map_to_shape(self.qubit_map)
 
 
-def _qubit_map_to_shape(qubit_map: Mapping[cirq.Qid, int]) -> Tuple[int, ...]:
-    qid_shape: List[int] = [-1] * len(qubit_map)
+def _qubit_map_to_shape(qubit_map: Mapping[cirq.Qid, int]) -> tuple[int, ...]:
+    qid_shape: list[int] = [-1] * len(qubit_map)
     try:
         for q, i in qubit_map.items():
             qid_shape[i] = q.dimension
@@ -965,7 +950,7 @@ def check_all_resolved(circuit):
 
 def split_into_matching_protocol_then_general(
     circuit: cirq.AbstractCircuit, predicate: Callable[[cirq.Operation], bool]
-) -> Tuple[cirq.AbstractCircuit, cirq.AbstractCircuit]:
+) -> tuple[cirq.AbstractCircuit, cirq.AbstractCircuit]:
     """Splits the circuit into a matching prefix and non-matching suffix.
 
     The splitting happens in a per-qubit fashion. A non-matching operation on
@@ -974,8 +959,8 @@ def split_into_matching_protocol_then_general(
     the matching part (as long as those qubits have had no non-matching operation
     up to that point). Measurement keys are handled equivalently.
     """
-    blocked_qubits: Set[cirq.Qid] = set()
-    blocked_keys: Set[cirq.MeasurementKey] = set()
+    blocked_qubits: set[cirq.Qid] = set()
+    blocked_keys: set[cirq.MeasurementKey] = set()
     matching_prefix = circuits.Circuit()
     general_suffix = circuits.Circuit()
     for moment in circuit:

cirq/sim/simulator_base.py

@@ -18,20 +18,7 @@ from __future__ import annotations
 
 import abc
 import collections
-from typing import (
-    Any,
-    cast,
-    Dict,
-    Generic,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    TYPE_CHECKING,
-    TypeVar,
-)
+from typing import Any, cast, Generic, Iterator, Sequence, TYPE_CHECKING, TypeVar
 
 import numpy as np
 
@@ -93,7 +80,7 @@ class SimulatorBase(
     def __init__(
         self,
         *,
-        dtype: Type[np.complexfloating] = np.complex64,
+        dtype: type[np.complexfloating] = np.complex64,
         noise: cirq.NOISE_MODEL_LIKE = None,
         seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
         split_untangled_states: bool = False,
@@ -173,7 +160,7 @@ class SimulatorBase(
         return protocols.has_unitary(val)
 
     def _base_iterator(
-        self, circuit: cirq.AbstractCircuit, qubits: Tuple[cirq.Qid, ...], initial_state: Any
+        self, circuit: cirq.AbstractCircuit, qubits: tuple[cirq.Qid, ...], initial_state: Any
     ) -> Iterator[TStepResultBase]:
         sim_state = self._create_simulation_state(initial_state, qubits)
         return self._core_iterator(circuit, sim_state)
@@ -206,7 +193,7 @@ class SimulatorBase(
             return
 
         noisy_moments = self.noise.noisy_moments(circuit, sorted(circuit.all_qubits()))
-        measured: Dict[Tuple[cirq.Qid, ...], bool] = collections.defaultdict(bool)
+        measured: dict[tuple[cirq.Qid, ...], bool] = collections.defaultdict(bool)
         for moment in noisy_moments:
             for op in ops.flatten_to_ops(moment):
                 try:
@@ -227,7 +214,7 @@ class SimulatorBase(
 
     def _run(
         self, circuit: cirq.AbstractCircuit, param_resolver: cirq.ParamResolver, repetitions: int
-    ) -> Dict[str, np.ndarray]:
+    ) -> dict[str, np.ndarray]:
         """See definition in `cirq.SimulatesSamples`."""
         param_resolver = param_resolver or study.ParamResolver({})
         resolved_circuit = protocols.resolve_parameters(circuit, param_resolver)
@@ -256,7 +243,7 @@ class SimulatorBase(
                 measurement_ops, repetitions, seed=self._prng, _allow_repeated=True
             )
 
-        records: Dict[cirq.MeasurementKey, List[Sequence[Sequence[int]]]] = {}
+        records: dict[cirq.MeasurementKey, list[Sequence[Sequence[int]]]] = {}
         for i in range(repetitions):
             for step_result in self._core_iterator(
                 general_suffix,
@@ -337,7 +324,7 @@ class SimulatorBase(
 
         classical_data = value.ClassicalDataDictionaryStore()
         if self._split_untangled_states:
-            args_map: Dict[Optional[cirq.Qid], TSimulationState] = {}
+            args_map: dict[cirq.Qid | None, TSimulationState] = {}
             if isinstance(initial_state, int):
                 for q in reversed(qubits):
                     args_map[q] = self._create_partial_simulation_state(
@@ -374,7 +361,7 @@ class StepResultBase(
             sim_state: The `SimulationStateBase` for this step.
         """
         super().__init__(sim_state)
-        self._merged_sim_state_cache: Optional[TSimulationState] = None
+        self._merged_sim_state_cache: TSimulationState | None = None
         qubits = sim_state.qubits
         self._qubits = qubits
         self._qubit_mapping = {q: i for i, q in enumerate(qubits)}
@@ -392,7 +379,7 @@ class StepResultBase(
 
     def sample(
         self,
-        qubits: List[cirq.Qid],
+        qubits: list[cirq.Qid],
         repetitions: int = 1,
         seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     ) -> np.ndarray:
@@ -407,7 +394,7 @@ class SimulationTrialResultBase(
     def __init__(
         self,
         params: study.ParamResolver,
-        measurements: Dict[str, np.ndarray],
+        measurements: dict[str, np.ndarray],
         final_simulator_state: cirq.SimulationStateBase[TSimulationState],
     ) -> None:
         """Initializes the `SimulationTrialResultBase` class.
@@ -422,7 +409,7 @@ class SimulationTrialResultBase(
                 trial finishes.
         """
         super().__init__(params, measurements, final_simulator_state=final_simulator_state)
-        self._merged_sim_state_cache: Optional[TSimulationState] = None
+        self._merged_sim_state_cache: TSimulationState | None = None
 
     def get_state_containing_qubit(self, qubit: cirq.Qid) -> TSimulationState:
         """Returns the independent state space containing the qubit.
@@ -437,7 +424,7 @@ class SimulationTrialResultBase(
     def _get_substates(self) -> Sequence[TSimulationState]:
         state = self._final_simulator_state
         if isinstance(state, SimulationProductState):
-            substates: Dict[TSimulationState, int] = {}
+            substates: dict[TSimulationState, int] = {}
             for q in state.qubits:
                 substates[self.get_state_containing_qubit(q)] = 0
             substates[state[None]] = 0

cirq/sim/simulator_base_test.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import math
-from typing import Any, Dict, List, Sequence, Tuple
+from typing import Any, Sequence
 
 import numpy as np
 import pytest
@@ -33,7 +33,7 @@ class CountingState(cirq.qis.QuantumStateRepresentation):
 
     def measure(
         self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
-    ) -> List[int]:
+    ) -> list[int]:
         self.measurement_count += 1
         return [self.gate_count]
 
@@ -47,7 +47,7 @@ class CountingState(cirq.qis.QuantumStateRepresentation):
 
     def factor(
         self, axes: Sequence[int], *, validate=True, atol=1e-07
-    ) -> Tuple[CountingState, CountingState]:
+    ) -> tuple[CountingState, CountingState]:
         return CountingState(
             self.data, self.gate_count, self.measurement_count, self.copy_count
         ), CountingState(self.data)
@@ -98,11 +98,11 @@ class SplittableCountingSimulationState(CountingSimulationState):
 class CountingStepResult(cirq.StepResultBase[CountingSimulationState]):
     def sample(
         self,
-        qubits: List[cirq.Qid],
+        qubits: list[cirq.Qid],
         repetitions: int = 1,
         seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     ) -> np.ndarray:
-        measurements: List[List[int]] = []
+        measurements: list[list[int]] = []
         for _ in range(repetitions):
             measurements.append(self._merged_sim_state._perform_measurement(qubits))
         return np.array(measurements, dtype=int)
@@ -134,7 +134,7 @@ class CountingSimulator(
     def _create_simulator_trial_result(
         self,
         params: cirq.ParamResolver,
-        measurements: Dict[str, np.ndarray],
+        measurements: dict[str, np.ndarray],
         final_simulator_state: cirq.SimulationStateBase[CountingSimulationState],
     ) -> CountingTrialResult:
         return CountingTrialResult(

cirq/sim/simulator_test.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import abc
-from typing import Any, Dict, Generic, List, Sequence, Union
+from typing import Any, Generic, Sequence
 from unittest import mock
 
 import duet
@@ -41,10 +41,10 @@ from cirq.sim.simulator import (
 class FakeSimulatesSamples(SimulatesSamples):
     """A SimulatesSamples that returns specified values from _run."""
 
-    def __init__(self, run_output: Dict[str, np.ndarray]):
+    def __init__(self, run_output: dict[str, np.ndarray]):
         self._run_output = run_output
 
-    def _run(self, *args, **kwargs) -> Dict[str, np.ndarray]:
+    def _run(self, *args, **kwargs) -> dict[str, np.ndarray]:
         return self._run_output
 
 
@@ -76,7 +76,7 @@ class SimulatesIntermediateStateImpl(
     def _create_simulator_trial_result(
         self,
         params: study.ParamResolver,
-        measurements: Dict[str, np.ndarray],
+        measurements: dict[str, np.ndarray],
         final_simulator_state: cirq.SimulationStateBase[TSimulationState],
     ) -> SimulationTrialResult:
         """This method creates a default trial result.
@@ -469,12 +469,12 @@ def test_iter_definitions():
         def simulate_expectation_values_sweep(
             self,
             program: cirq.AbstractCircuit,
-            observables: Union[cirq.PauliSumLike, List[cirq.PauliSumLike]],
+            observables: cirq.PauliSumLike | list[cirq.PauliSumLike],
             params: study.Sweepable,
             qubit_order: cirq.QubitOrderOrList = cirq.QubitOrder.DEFAULT,
             initial_state: Any = None,
             permit_terminal_measurements: bool = False,
-        ) -> List[List[float]]:
+        ) -> list[list[float]]:
             return [[1.0]]
 
         def simulate_sweep(
@@ -483,7 +483,7 @@ def test_iter_definitions():
             params: study.Sweepable,
             qubit_order: cirq.QubitOrderOrList = cirq.QubitOrder.DEFAULT,
             initial_state: Any = None,
-        ) -> List[SimulationTrialResult]:
+        ) -> list[SimulationTrialResult]:
             return [mock_trial_result]
 
     non_iter_sim = FakeNonIterSimulatorImpl()

cirq/sim/sparse_simulator.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterator, List, Optional, Sequence, Type, TYPE_CHECKING, Union
+from typing import Any, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -127,7 +127,7 @@ class Simulator(
     def __init__(
         self,
         *,
-        dtype: Type[np.complexfloating] = np.complex64,
+        dtype: type[np.complexfloating] = np.complex64,
         noise: cirq.NOISE_MODEL_LIKE = None,
         seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
         split_untangled_states: bool = True,
@@ -154,7 +154,7 @@ class Simulator(
 
     def _create_partial_simulation_state(
         self,
-        initial_state: Union[cirq.STATE_VECTOR_LIKE, cirq.StateVectorSimulationState],
+        initial_state: cirq.STATE_VECTOR_LIKE | cirq.StateVectorSimulationState,
         qubits: Sequence[cirq.Qid],
         classical_data: cirq.ClassicalDataStore,
     ):
@@ -192,12 +192,12 @@ class Simulator(
     def simulate_expectation_values_sweep_iter(
         self,
         program: cirq.AbstractCircuit,
-        observables: Union[cirq.PauliSumLike, List[cirq.PauliSumLike]],
+        observables: cirq.PauliSumLike | list[cirq.PauliSumLike],
         params: cirq.Sweepable,
         qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
         initial_state: Any = None,
         permit_terminal_measurements: bool = False,
-    ) -> Iterator[List[float]]:
+    ) -> Iterator[list[float]]:
         if not permit_terminal_measurements and program.are_any_measurements_terminal():
             raise ValueError(
                 'Provided circuit has terminal measurements, which may '
@@ -206,7 +206,7 @@ class Simulator(
             )
         qubit_order = ops.QubitOrder.as_qubit_order(qubit_order)
         qmap = {q: i for i, q in enumerate(qubit_order.order_for(program.all_qubits()))}
-        if not isinstance(observables, List):
+        if not isinstance(observables, list):
             observables = [observables]
         pslist = [ops.PauliSum.wrap(pslike) for pslike in observables]
         yield from (
@@ -225,7 +225,7 @@ class SparseSimulatorStep(
     def __init__(
         self,
         sim_state: cirq.SimulationStateBase[cirq.StateVectorSimulationState],
-        dtype: Type[np.complexfloating] = np.complex64,
+        dtype: type[np.complexfloating] = np.complex64,
     ):
         """Results of a step of the simulator.
 
@@ -237,7 +237,7 @@ class SparseSimulatorStep(
         qubit_map = {q: i for i, q in enumerate(sim_state.qubits)}
         super().__init__(sim_state=sim_state, qubit_map=qubit_map)
         self._dtype = dtype
-        self._state_vector: Optional[np.ndarray] = None
+        self._state_vector: np.ndarray | None = None
 
     def state_vector(self, copy: bool = False):
         """Return the state vector at this point in the computation.

cirq/sim/state_vector.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import abc
-from typing import List, Mapping, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Mapping, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -34,7 +34,7 @@ if TYPE_CHECKING:
 class StateVectorMixin:
     """A mixin that provide methods for objects that have a state vector."""
 
-    def __init__(self, qubit_map: Optional[Mapping[cirq.Qid, int]] = None, *args, **kwargs):
+    def __init__(self, qubit_map: Mapping[cirq.Qid, int] | None = None, *args, **kwargs):
         """Inits StateVectorMixin.
 
         Args:
@@ -53,7 +53,7 @@ class StateVectorMixin:
     def qubit_map(self) -> Mapping[cirq.Qid, int]:
         return self._qubit_map
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         if self._qid_shape is None:
             return NotImplemented
         return self._qid_shape
@@ -105,7 +105,7 @@ class StateVectorMixin:
             and non-zero floats of the specified accuracy."""
         return qis.dirac_notation(self.state_vector(), decimals, qid_shape=self._qid_shape)
 
-    def density_matrix_of(self, qubits: Optional[List[cirq.Qid]] = None) -> np.ndarray:
+    def density_matrix_of(self, qubits: list[cirq.Qid] | None = None) -> np.ndarray:
         r"""Returns the density matrix of the state.
 
         Calculate the density matrix for the system on the qubits provided.
@@ -172,7 +172,7 @@ def sample_state_vector(
     state_vector: np.ndarray,
     indices: Sequence[int],
     *,  # Force keyword args
-    qid_shape: Optional[Tuple[int, ...]] = None,
+    qid_shape: tuple[int, ...] | None = None,
     repetitions: int = 1,
     seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> np.ndarray:
@@ -237,10 +237,10 @@ def measure_state_vector(
     state_vector: np.ndarray,
     indices: Sequence[int],
     *,  # Force keyword args
-    qid_shape: Optional[Tuple[int, ...]] = None,
-    out: Optional[np.ndarray] = None,
+    qid_shape: tuple[int, ...] | None = None,
+    out: np.ndarray | None = None,
     seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
-) -> Tuple[List[int], np.ndarray]:
+) -> tuple[list[int], np.ndarray]:
     """Performs a measurement of the state in the computational basis.
 
     This does not modify `state` unless the optional `out` is `state`.

cirq/sim/state_vector_simulation_state.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable, List, Optional, Sequence, Tuple, Type, TYPE_CHECKING, Union
+from typing import Any, Callable, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -32,7 +32,7 @@ if TYPE_CHECKING:
 class _BufferedStateVector(qis.QuantumStateRepresentation):
     """Contains the state vector and buffer for efficient state evolution."""
 
-    def __init__(self, state_vector: np.ndarray, buffer: Optional[np.ndarray] = None):
+    def __init__(self, state_vector: np.ndarray, buffer: np.ndarray | None = None):
         """Initializes the object with the inputs.
 
         This initializer creates the buffer if necessary.
@@ -53,10 +53,10 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
     def create(
         cls,
         *,
-        initial_state: Union[np.ndarray, cirq.STATE_VECTOR_LIKE] = 0,
-        qid_shape: Optional[Tuple[int, ...]] = None,
-        dtype: Optional[Type[np.complexfloating]] = None,
-        buffer: Optional[np.ndarray] = None,
+        initial_state: np.ndarray | cirq.STATE_VECTOR_LIKE = 0,
+        qid_shape: tuple[int, ...] | None = None,
+        dtype: type[np.complexfloating] | None = None,
+        buffer: np.ndarray | None = None,
     ):
         """Initializes the object with the inputs.
 
@@ -116,7 +116,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
 
     def factor(
         self, axes: Sequence[int], *, validate=True, atol=1e-07
-    ) -> Tuple[_BufferedStateVector, _BufferedStateVector]:
+    ) -> tuple[_BufferedStateVector, _BufferedStateVector]:
         """Factors a state vector into two independent state vectors.
 
         This function should only be called on state vectors that are known to be separable, such
@@ -179,7 +179,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
         self._swap_target_tensor_for(new_target_tensor)
         return True
 
-    def apply_mixture(self, action: Any, axes: Sequence[int], prng) -> Optional[int]:
+    def apply_mixture(self, action: Any, axes: Sequence[int], prng) -> int | None:
         """Apply mixture to state.
 
         Args:
@@ -201,7 +201,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
         self._swap_target_tensor_for(self._buffer)
         return index
 
-    def apply_channel(self, action: Any, axes: Sequence[int], prng) -> Optional[int]:
+    def apply_channel(self, action: Any, axes: Sequence[int], prng) -> int | None:
         """Apply channel to state.
 
         Args:
@@ -257,7 +257,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
 
     def measure(
         self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
-    ) -> List[int]:
+    ) -> list[int]:
         """Measures the state vector.
 
         Args:
@@ -320,12 +320,12 @@ class StateVectorSimulationState(SimulationState[_BufferedStateVector]):
     def __init__(
         self,
         *,
-        available_buffer: Optional[np.ndarray] = None,
-        prng: Optional[np.random.RandomState] = None,
-        qubits: Optional[Sequence[cirq.Qid]] = None,
-        initial_state: Union[np.ndarray, cirq.STATE_VECTOR_LIKE] = 0,
-        dtype: Type[np.complexfloating] = np.complex64,
-        classical_data: Optional[cirq.ClassicalDataStore] = None,
+        available_buffer: np.ndarray | None = None,
+        prng: np.random.RandomState | None = None,
+        qubits: Sequence[cirq.Qid] | None = None,
+        initial_state: np.ndarray | cirq.STATE_VECTOR_LIKE = 0,
+        dtype: type[np.complexfloating] = np.complex64,
+        classical_data: cirq.ClassicalDataStore | None = None,
     ):
         """Inits StateVectorSimulationState.
 
@@ -375,7 +375,7 @@ class StateVectorSimulationState(SimulationState[_BufferedStateVector]):
     def _act_on_fallback_(
         self, action: Any, qubits: Sequence[cirq.Qid], allow_decompose: bool = True
     ) -> bool:
-        strats: List[Callable[[Any, Any, Sequence[cirq.Qid]], bool]] = [
+        strats: list[Callable[[Any, Any, Sequence[cirq.Qid]], bool]] = [
             _strat_act_on_state_vector_from_apply_unitary,
             _strat_act_on_state_vector_from_mixture,
             _strat_act_on_state_vector_from_channel,