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

cirq/sim/sparse_simulator_test.py

@@ -11,9 +11,11 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import itertools
 import random
-from typing import Type, Union
 from unittest import mock
 
 import numpy as np
@@ -30,7 +32,7 @@ def test_invalid_dtype():
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_no_measurements(dtype: Type[np.complexfloating], split: bool):
+def test_run_no_measurements(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
 
@@ -41,7 +43,7 @@ def test_run_no_measurements(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_no_results(dtype: Type[np.complexfloating], split: bool):
+def test_run_no_results(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
 
@@ -52,7 +54,7 @@ def test_run_no_results(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_empty_circuit(dtype: Type[np.complexfloating], split: bool):
+def test_run_empty_circuit(dtype: type[np.complexfloating], split: bool):
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     with pytest.raises(ValueError, match="no measurements"):
         simulator.run(cirq.Circuit())
@@ -60,7 +62,7 @@ def test_run_empty_circuit(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_reset(dtype: Type[np.complexfloating], split: bool):
+def test_run_reset(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQid.for_qid_shape((2, 3))
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     circuit = cirq.Circuit(
@@ -80,7 +82,7 @@ def test_run_reset(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_bit_flips(dtype: Type[np.complexfloating], split: bool):
+def test_run_bit_flips(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:
@@ -94,7 +96,7 @@ def test_run_bit_flips(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_measure_at_end_no_repetitions(dtype: Type[np.complexfloating], split: bool):
+def test_run_measure_at_end_no_repetitions(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     with mock.patch.object(simulator, '_core_iterator', wraps=simulator._core_iterator) as mock_sim:
@@ -120,7 +122,7 @@ def test_run_repetitions_terminal_measurement_stochastic():
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_repetitions_measure_at_end(dtype: Type[np.complexfloating], split: bool):
+def test_run_repetitions_measure_at_end(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     with mock.patch.object(simulator, '_core_iterator', wraps=simulator._core_iterator) as mock_sim:
@@ -140,7 +142,7 @@ def test_run_repetitions_measure_at_end(dtype: Type[np.complexfloating], split:
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_invert_mask_measure_not_terminal(dtype: Type[np.complexfloating], split: bool):
+def test_run_invert_mask_measure_not_terminal(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     with mock.patch.object(simulator, '_core_iterator', wraps=simulator._core_iterator) as mock_sim:
@@ -161,7 +163,7 @@ def test_run_invert_mask_measure_not_terminal(dtype: Type[np.complexfloating], s
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_partial_invert_mask_measure_not_terminal(dtype: Type[np.complexfloating], split: bool):
+def test_run_partial_invert_mask_measure_not_terminal(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     with mock.patch.object(simulator, '_core_iterator', wraps=simulator._core_iterator) as mock_sim:
@@ -182,7 +184,7 @@ def test_run_partial_invert_mask_measure_not_terminal(dtype: Type[np.complexfloa
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_measurement_not_terminal_no_repetitions(dtype: Type[np.complexfloating], split: bool):
+def test_run_measurement_not_terminal_no_repetitions(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     with mock.patch.object(simulator, '_core_iterator', wraps=simulator._core_iterator) as mock_sim:
@@ -206,7 +208,7 @@ def test_run_measurement_not_terminal_no_repetitions(dtype: Type[np.complexfloat
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_repetitions_measurement_not_terminal(dtype: Type[np.complexfloating], split: bool):
+def test_run_repetitions_measurement_not_terminal(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     with mock.patch.object(simulator, '_core_iterator', wraps=simulator._core_iterator) as mock_sim:
@@ -231,7 +233,7 @@ def test_run_repetitions_measurement_not_terminal(dtype: Type[np.complexfloating
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_param_resolver(dtype: Type[np.complexfloating], split: bool):
+def test_run_param_resolver(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:
@@ -250,7 +252,7 @@ def test_run_param_resolver(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_mixture(dtype: Type[np.complexfloating], split: bool):
+def test_run_mixture(dtype: type[np.complexfloating], split: bool):
     q0 = cirq.LineQubit(0)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     circuit = cirq.Circuit(cirq.bit_flip(0.5)(q0), cirq.measure(q0))
@@ -260,7 +262,7 @@ def test_run_mixture(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_mixture_with_gates(dtype: Type[np.complexfloating], split: bool):
+def test_run_mixture_with_gates(dtype: type[np.complexfloating], split: bool):
     q0 = cirq.LineQubit(0)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split, seed=23)
     circuit = cirq.Circuit(cirq.H(q0), cirq.phase_flip(0.5)(q0), cirq.H(q0), cirq.measure(q0))
@@ -271,7 +273,7 @@ def test_run_mixture_with_gates(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_correlations(dtype: Type[np.complexfloating], split: bool):
+def test_run_correlations(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     circuit = cirq.Circuit(cirq.H(q0), cirq.CNOT(q0, q1), cirq.measure(q0, q1))
@@ -283,7 +285,7 @@ def test_run_correlations(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_measure_multiple_qubits(dtype: Type[np.complexfloating], split: bool):
+def test_run_measure_multiple_qubits(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:
@@ -295,7 +297,7 @@ def test_run_measure_multiple_qubits(dtype: Type[np.complexfloating], split: boo
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_run_sweeps_param_resolvers(dtype: Type[np.complexfloating], split: bool):
+def test_run_sweeps_param_resolvers(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:
@@ -321,7 +323,7 @@ def test_run_sweeps_param_resolvers(dtype: Type[np.complexfloating], split: bool
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_random_unitary(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_random_unitary(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     for _ in range(10):
@@ -339,7 +341,7 @@ def test_simulate_random_unitary(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_no_circuit(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_no_circuit(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     circuit = cirq.Circuit()
@@ -350,7 +352,7 @@ def test_simulate_no_circuit(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate(dtype: Type[np.complexfloating], split: bool):
+def test_simulate(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     circuit = cirq.Circuit(cirq.H(q0), cirq.H(q1))
@@ -372,7 +374,7 @@ class _TestMixture(cirq.Gate):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_qudits(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_qudits(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQid.for_qid_shape((3, 4))
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     circuit = cirq.Circuit(cirq.XPowGate(dimension=3)(q0), cirq.XPowGate(dimension=4)(q1) ** 3)
@@ -385,7 +387,7 @@ def test_simulate_qudits(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_mixtures(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_mixtures(dtype: type[np.complexfloating], split: bool):
     q0 = cirq.LineQubit(0)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     circuit = cirq.Circuit(cirq.bit_flip(0.5)(q0), cirq.measure(q0))
@@ -403,7 +405,7 @@ def test_simulate_mixtures(dtype: Type[np.complexfloating], split: bool):
 @pytest.mark.parametrize(
     'dtype, split', itertools.product([np.complex64, np.complex128], [True, False])
 )
-def test_simulate_qudit_mixtures(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_qudit_mixtures(dtype: type[np.complexfloating], split: bool):
     q0 = cirq.LineQid(0, 3)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     mixture = _TestMixture(
@@ -429,7 +431,7 @@ def test_simulate_qudit_mixtures(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_bit_flips(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_bit_flips(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:
@@ -451,9 +453,9 @@ def test_simulate_bit_flips(dtype: Type[np.complexfloating], split: bool):
     [1, cirq.StateVectorSimulationState(initial_state=1, qubits=cirq.LineQubit.range(2))],
 )
 def test_simulate_initial_state(
-    dtype: Type[np.complexfloating],
+    dtype: type[np.complexfloating],
     split: bool,
-    initial_state: Union[int, cirq.StateVectorSimulationState],
+    initial_state: int | cirq.StateVectorSimulationState,
 ):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
@@ -468,7 +470,7 @@ def test_simulate_initial_state(
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulation_state(dtype: Type[np.complexfloating], split: bool):
+def test_simulation_state(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:
@@ -483,7 +485,7 @@ def test_simulation_state(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_qubit_order(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_qubit_order(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:
@@ -497,7 +499,7 @@ def test_simulate_qubit_order(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_param_resolver(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_param_resolver(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:
@@ -516,7 +518,7 @@ def test_simulate_param_resolver(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_measure_multiple_qubits(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_measure_multiple_qubits(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:
@@ -528,7 +530,7 @@ def test_simulate_measure_multiple_qubits(dtype: Type[np.complexfloating], split
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_sweeps_param_resolver(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_sweeps_param_resolver(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
     for b0 in [0, 1]:
@@ -555,7 +557,7 @@ def test_simulate_sweeps_param_resolver(dtype: Type[np.complexfloating], split:
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_moment_steps(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_moment_steps(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(cirq.H(q0), cirq.H(q1), cirq.H(q0), cirq.H(q1))
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
@@ -568,10 +570,9 @@ def test_simulate_moment_steps(dtype: Type[np.complexfloating], split: bool):
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_moment_steps_empty_circuit(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_moment_steps_empty_circuit(dtype: type[np.complexfloating], split: bool):
     circuit = cirq.Circuit()
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
-    step = None
     for step in simulator.simulate_moment_steps(circuit):
         pass
     assert np.allclose(step.state_vector(copy=True), np.array([1]))
@@ -580,7 +581,7 @@ def test_simulate_moment_steps_empty_circuit(dtype: Type[np.complexfloating], sp
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_moment_steps_sample(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_moment_steps_sample(dtype: type[np.complexfloating], split: bool):
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(cirq.H(q0), cirq.CNOT(q0, q1))
     simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split)
@@ -602,7 +603,7 @@ def test_simulate_moment_steps_sample(dtype: Type[np.complexfloating], split: bo
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
 def test_simulate_moment_steps_intermediate_measurement(
-    dtype: Type[np.complexfloating], split: bool
+    dtype: type[np.complexfloating], split: bool
 ):
     q0 = cirq.LineQubit(0)
     circuit = cirq.Circuit(cirq.H(q0), cirq.measure(q0), cirq.H(q0))
@@ -620,7 +621,7 @@ def test_simulate_moment_steps_intermediate_measurement(
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_expectation_values(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_expectation_values(dtype: type[np.complexfloating], split: bool):
     # Compare with test_expectation_from_state_vector_two_qubit_states
     # in file: cirq/ops/linear_combinations_test.py
     q0, q1 = cirq.LineQubit.range(2)
@@ -645,7 +646,7 @@ def test_simulate_expectation_values(dtype: Type[np.complexfloating], split: boo
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_expectation_values_terminal_measure(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_expectation_values_terminal_measure(dtype: type[np.complexfloating], split: bool):
     q0 = cirq.LineQubit(0)
     circuit = cirq.Circuit(cirq.H(q0), cirq.measure(q0))
     obs = cirq.Z(q0)
@@ -683,7 +684,7 @@ def test_simulate_expectation_values_terminal_measure(dtype: Type[np.complexfloa
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [True, False])
-def test_simulate_expectation_values_qubit_order(dtype: Type[np.complexfloating], split: bool):
+def test_simulate_expectation_values_qubit_order(dtype: type[np.complexfloating], split: bool):
     q0, q1, q2 = cirq.LineQubit.range(3)
     circuit = cirq.Circuit(cirq.H(q0), cirq.H(q1), cirq.X(q2))
     obs = cirq.X(q0) + cirq.X(q1) - cirq.Z(q2)

cirq/sim/state_vector.py

@@ -11,10 +11,13 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
 """Helpers for handling quantum state vectors."""
 
+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
 
@@ -31,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:
@@ -47,10 +50,10 @@ class StateVectorMixin:
         self._qid_shape = None if qubit_map is None else qid_shape
 
     @property
-    def qubit_map(self) -> Mapping['cirq.Qid', int]:
+    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
@@ -102,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.
@@ -141,7 +144,7 @@ class StateVectorMixin:
             qid_shape=self._qid_shape,
         )
 
-    def bloch_vector_of(self, qubit: 'cirq.Qid') -> np.ndarray:
+    def bloch_vector_of(self, qubit: cirq.Qid) -> np.ndarray:
         """Returns the bloch vector of a qubit in the state.
 
         Calculates the bloch vector of the given qubit
@@ -169,9 +172,9 @@ 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,
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> np.ndarray:
     """Samples repeatedly from measurements in the computational basis.
 
@@ -234,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,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
-) -> Tuple[List[int], np.ndarray]:
+    qid_shape: tuple[int, ...] | None = None,
+    out: np.ndarray | None = None,
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
+) -> 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

@@ -13,7 +13,10 @@
 # limitations under the License.
 
 """Objects and methods for acting efficiently on a state vector."""
-from typing import Any, Callable, List, Optional, Sequence, Tuple, Type, TYPE_CHECKING, Union
+
+from __future__ import annotations
+
+from typing import Any, Callable, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -29,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.
@@ -50,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.
 
@@ -85,7 +88,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
         state_vector = state_vector.astype(dtype, copy=False)
         return cls(state_vector, buffer)
 
-    def copy(self, deep_copy_buffers: bool = True) -> '_BufferedStateVector':
+    def copy(self, deep_copy_buffers: bool = True) -> _BufferedStateVector:
         """Copies the object.
 
         Args:
@@ -98,7 +101,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
             buffer=self._buffer.copy() if deep_copy_buffers else self._buffer,
         )
 
-    def kron(self, other: '_BufferedStateVector') -> '_BufferedStateVector':
+    def kron(self, other: _BufferedStateVector) -> _BufferedStateVector:
         """Creates the Kronecker product with the other state vector.
 
         Args:
@@ -113,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
@@ -143,7 +146,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
         )
         return extracted, remainder
 
-    def reindex(self, axes: Sequence[int]) -> '_BufferedStateVector':
+    def reindex(self, axes: Sequence[int]) -> _BufferedStateVector:
         """Transposes the axes of a state vector to a specified order.
 
         Args:
@@ -176,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:
@@ -198,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:
@@ -253,8 +256,8 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
         return index
 
     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 vector.
 
         Args:
@@ -269,10 +272,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
         return bits
 
     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 vector.
 
@@ -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.
 
@@ -356,7 +356,7 @@ class StateVectorSimulationState(SimulationState[_BufferedStateVector]):
         )
         super().__init__(state=state, prng=prng, qubits=qubits, classical_data=classical_data)
 
-    def add_qubits(self, qubits: Sequence['cirq.Qid']):
+    def add_qubits(self, qubits: Sequence[cirq.Qid]):
         ret = super().add_qubits(qubits)
         return (
             self.kronecker_product(type(self)(qubits=qubits), inplace=True)
@@ -364,7 +364,7 @@ class StateVectorSimulationState(SimulationState[_BufferedStateVector]):
             else ret
         )
 
-    def remove_qubits(self, qubits: Sequence['cirq.Qid']):
+    def remove_qubits(self, qubits: Sequence[cirq.Qid]):
         ret = super().remove_qubits(qubits)
         if ret is not NotImplemented:
             return ret
@@ -373,9 +373,9 @@ class StateVectorSimulationState(SimulationState[_BufferedStateVector]):
         return remainder
 
     def _act_on_fallback_(
-        self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
+        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,
@@ -415,7 +415,7 @@ class StateVectorSimulationState(SimulationState[_BufferedStateVector]):
 
 
 def _strat_act_on_state_vector_from_apply_unitary(
-    action: Any, args: 'cirq.StateVectorSimulationState', qubits: Sequence['cirq.Qid']
+    action: Any, args: cirq.StateVectorSimulationState, qubits: Sequence[cirq.Qid]
 ) -> bool:
     if not args._state.apply_unitary(action, args.get_axes(qubits)):
         return NotImplemented
@@ -423,7 +423,7 @@ def _strat_act_on_state_vector_from_apply_unitary(
 
 
 def _strat_act_on_state_vector_from_mixture(
-    action: Any, args: 'cirq.StateVectorSimulationState', qubits: Sequence['cirq.Qid']
+    action: Any, args: cirq.StateVectorSimulationState, qubits: Sequence[cirq.Qid]
 ) -> bool:
     index = args._state.apply_mixture(action, args.get_axes(qubits), args.prng)
     if index is None:
@@ -435,7 +435,7 @@ def _strat_act_on_state_vector_from_mixture(
 
 
 def _strat_act_on_state_vector_from_channel(
-    action: Any, args: 'cirq.StateVectorSimulationState', qubits: Sequence['cirq.Qid']
+    action: Any, args: cirq.StateVectorSimulationState, qubits: Sequence[cirq.Qid]
 ) -> bool:
     index = args._state.apply_channel(action, args.get_axes(qubits), args.prng)
     if index is None: