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

cirq/sim/density_matrix_utils.py

@@ -14,7 +14,9 @@
 
 """Code to handle density matrices."""
 
-from typing import List, Optional, Sequence, Tuple, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -29,9 +31,9 @@ def sample_density_matrix(
     density_matrix: np.ndarray,
     indices: Sequence[int],
     *,  # Force keyword arguments
-    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.
 
@@ -94,10 +96,10 @@ def sample_density_matrix(
 def measure_density_matrix(
     density_matrix: np.ndarray,
     indices: Sequence[int],
-    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 density matrix in the computational basis.
 
     This does not modify `density_matrix` unless the optional `out` is
@@ -185,7 +187,7 @@ def measure_density_matrix(
 
 
 def _probs(
-    density_matrix: np.ndarray, indices: Sequence[int], qid_shape: Tuple[int, ...]
+    density_matrix: np.ndarray, indices: Sequence[int], qid_shape: tuple[int, ...]
 ) -> np.ndarray:
     """Returns the probabilities for a measurement on the given indices."""
     # Only diagonal elements matter.
@@ -195,8 +197,8 @@ def _probs(
 
 
 def _validate_density_matrix_qid_shape(
-    density_matrix: np.ndarray, qid_shape: Tuple[int, ...]
-) -> Tuple[int, ...]:
+    density_matrix: np.ndarray, qid_shape: tuple[int, ...]
+) -> tuple[int, ...]:
     """Validates that a tensor's shape is a valid shape for qids and returns the
     qid shape.
     """
@@ -242,7 +244,7 @@ def _validate_num_qubits(density_matrix: np.ndarray) -> int:
     return int(row_size).bit_length() - 1
 
 
-def _indices_shape(qid_shape: Tuple[int, ...], indices: Sequence[int]) -> Tuple[int, ...]:
+def _indices_shape(qid_shape: tuple[int, ...], indices: Sequence[int]) -> tuple[int, ...]:
     """Validates that the indices have values within range of `len(qid_shape)`."""
     if any(index < 0 for index in indices):
         raise IndexError(f'Negative index in indices: {indices}')

cirq/sim/density_matrix_utils_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 itertools
 
 import numpy as np
@@ -21,7 +23,7 @@ import cirq
 import cirq.testing
 
 
-def test_sample_density_matrix_big_endian():
+def test_sample_density_matrix_big_endian() -> None:
     results = []
     for x in range(8):
         matrix = cirq.to_valid_density_matrix(x, 3)
@@ -32,7 +34,7 @@ def test_sample_density_matrix_big_endian():
         np.testing.assert_equal(result, expected)
 
 
-def test_sample_density_matrix_partial_indices():
+def test_sample_density_matrix_partial_indices() -> None:
     for index in range(3):
         for x in range(8):
             matrix = cirq.to_valid_density_matrix(x, 3)
@@ -41,14 +43,14 @@ def test_sample_density_matrix_partial_indices():
             )
 
 
-def test_sample_density_matrix_partial_indices_oder():
+def test_sample_density_matrix_partial_indices_oder() -> None:
     for x in range(8):
         matrix = cirq.to_valid_density_matrix(x, 3)
         expected = [[bool(1 & (x >> 0)), bool(1 & (x >> 1))]]
         np.testing.assert_equal(cirq.sample_density_matrix(matrix, [2, 1]), expected)
 
 
-def test_sample_density_matrix_partial_indices_all_orders():
+def test_sample_density_matrix_partial_indices_all_orders() -> None:
     for perm in itertools.permutations([0, 1, 2]):
         for x in range(8):
             matrix = cirq.to_valid_density_matrix(x, 3)
@@ -56,7 +58,7 @@ def test_sample_density_matrix_partial_indices_all_orders():
             np.testing.assert_equal(cirq.sample_density_matrix(matrix, perm), expected)
 
 
-def test_sample_density_matrix():
+def test_sample_density_matrix() -> None:
     state = np.zeros(8, dtype=np.complex64)
     state[0] = 1 / np.sqrt(2)
     state[2] = 1 / np.sqrt(2)
@@ -72,7 +74,7 @@ def test_sample_density_matrix():
         np.testing.assert_equal(cirq.sample_density_matrix(matrix, [0]), [[False]])
 
 
-def test_sample_density_matrix_seed():
+def test_sample_density_matrix_seed() -> None:
     density_matrix = 0.5 * np.eye(2)
 
     samples = cirq.sample_density_matrix(density_matrix, [0], repetitions=10, seed=1234)
@@ -90,12 +92,12 @@ def test_sample_density_matrix_seed():
     )
 
 
-def test_sample_empty_density_matrix():
+def test_sample_empty_density_matrix() -> None:
     matrix = np.zeros(shape=())
     np.testing.assert_almost_equal(cirq.sample_density_matrix(matrix, []), [[]])
 
 
-def test_sample_density_matrix_no_repetitions():
+def test_sample_density_matrix_no_repetitions() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     np.testing.assert_almost_equal(
         cirq.sample_density_matrix(matrix, [1], repetitions=0), np.zeros(shape=(0, 1))
@@ -105,7 +107,7 @@ def test_sample_density_matrix_no_repetitions():
     )
 
 
-def test_sample_density_matrix_repetitions():
+def test_sample_density_matrix_repetitions() -> None:
     for perm in itertools.permutations([0, 1, 2]):
         for x in range(8):
             matrix = cirq.to_valid_density_matrix(x, 3)
@@ -115,30 +117,30 @@ def test_sample_density_matrix_repetitions():
             np.testing.assert_equal(result, expected)
 
 
-def test_sample_density_matrix_negative_repetitions():
+def test_sample_density_matrix_negative_repetitions() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     with pytest.raises(ValueError, match='-1'):
         cirq.sample_density_matrix(matrix, [1], repetitions=-1)
 
 
-def test_sample_density_matrix_not_square():
+def test_sample_density_matrix_not_square() -> None:
     with pytest.raises(ValueError, match='not square'):
         cirq.sample_density_matrix(np.array([1, 0, 0]), [1])
 
 
-def test_sample_density_matrix_not_power_of_two():
+def test_sample_density_matrix_not_power_of_two() -> None:
     with pytest.raises(ValueError, match='power of two'):
         cirq.sample_density_matrix(np.ones((3, 3)) / 3, [1])
     with pytest.raises(ValueError, match='power of two'):
         cirq.sample_density_matrix(np.ones((2, 3, 2, 3)) / 6, [1])
 
 
-def test_sample_density_matrix_higher_powers_of_two():
+def test_sample_density_matrix_higher_powers_of_two() -> None:
     with pytest.raises(ValueError, match='powers of two'):
         cirq.sample_density_matrix(np.ones((2, 4, 2, 4)) / 8, [1])
 
 
-def test_sample_density_matrix_out_of_range():
+def test_sample_density_matrix_out_of_range() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     with pytest.raises(IndexError, match='-2'):
         cirq.sample_density_matrix(matrix, [-2])
@@ -146,13 +148,13 @@ def test_sample_density_matrix_out_of_range():
         cirq.sample_density_matrix(matrix, [3])
 
 
-def test_sample_density_matrix_no_indices():
+def test_sample_density_matrix_no_indices() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     bits = cirq.sample_density_matrix(matrix, [])
     np.testing.assert_almost_equal(bits, np.zeros(shape=(1, 0)))
 
 
-def test_sample_density_matrix_validate_qid_shape():
+def test_sample_density_matrix_validate_qid_shape() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     cirq.sample_density_matrix(matrix, [], qid_shape=(2, 2, 2))
     with pytest.raises(ValueError, match='Matrix size does not match qid shape'):
@@ -163,7 +165,7 @@ def test_sample_density_matrix_validate_qid_shape():
         cirq.sample_density_matrix(matrix2, [], qid_shape=(2, 2, 2))
 
 
-def test_measure_density_matrix_computational_basis():
+def test_measure_density_matrix_computational_basis() -> None:
     results = []
     for x in range(8):
         matrix = cirq.to_valid_density_matrix(x, 3)
@@ -174,7 +176,7 @@ def test_measure_density_matrix_computational_basis():
     assert results == expected
 
 
-def test_measure_density_matrix_computational_basis_reversed():
+def test_measure_density_matrix_computational_basis_reversed() -> None:
     results = []
     for x in range(8):
         matrix = cirq.to_valid_density_matrix(x, 3)
@@ -185,7 +187,7 @@ def test_measure_density_matrix_computational_basis_reversed():
     assert results == expected
 
 
-def test_measure_density_matrix_computational_basis_reshaped():
+def test_measure_density_matrix_computational_basis_reshaped() -> None:
     results = []
     for x in range(8):
         matrix = np.reshape(cirq.to_valid_density_matrix(x, 3), (2,) * 6)
@@ -196,7 +198,7 @@ def test_measure_density_matrix_computational_basis_reshaped():
     assert results == expected
 
 
-def test_measure_density_matrix_partial_indices():
+def test_measure_density_matrix_partial_indices() -> None:
     for index in range(3):
         for x in range(8):
             matrix = cirq.to_valid_density_matrix(x, 3)
@@ -205,7 +207,7 @@ def test_measure_density_matrix_partial_indices():
             assert bits == [bool(1 & (x >> (2 - index)))]
 
 
-def test_measure_density_matrix_partial_indices_all_orders():
+def test_measure_density_matrix_partial_indices_all_orders() -> None:
     for perm in itertools.permutations([0, 1, 2]):
         for x in range(8):
             matrix = cirq.to_valid_density_matrix(x, 3)
@@ -221,7 +223,7 @@ def matrix_000_plus_010():
     return cirq.to_valid_density_matrix(state, num_qubits=3)
 
 
-def test_measure_density_matrix_collapse():
+def test_measure_density_matrix_collapse() -> None:
     matrix = matrix_000_plus_010()
     for _ in range(10):
         bits, out_matrix = cirq.measure_density_matrix(matrix, [2, 1, 0])
@@ -246,7 +248,7 @@ def test_measure_density_matrix_collapse():
         assert bits == [False]
 
 
-def test_measure_density_matrix_seed():
+def test_measure_density_matrix_seed() -> None:
     n = 5
     matrix = np.eye(2**n) / 2**n
 
@@ -261,7 +263,7 @@ def test_measure_density_matrix_seed():
     np.testing.assert_allclose(out_matrix1, out_matrix2)
 
 
-def test_measure_density_matrix_out_is_matrix():
+def test_measure_density_matrix_out_is_matrix() -> None:
     matrix = matrix_000_plus_010()
     bits, out_matrix = cirq.measure_density_matrix(matrix, [2, 1, 0], out=matrix)
     expected_state = np.zeros(8, dtype=np.complex64)
@@ -271,7 +273,7 @@ def test_measure_density_matrix_out_is_matrix():
     assert out_matrix is matrix
 
 
-def test_measure_state_out_is_not_matrix():
+def test_measure_state_out_is_not_matrix() -> None:
     matrix = matrix_000_plus_010()
     out = np.zeros_like(matrix)
     _, out_matrix = cirq.measure_density_matrix(matrix, [2, 1, 0], out=out)
@@ -279,7 +281,7 @@ def test_measure_state_out_is_not_matrix():
     assert out is out_matrix
 
 
-def test_measure_density_matrix_not_square():
+def test_measure_density_matrix_not_square() -> None:
     with pytest.raises(ValueError, match='not square'):
         cirq.measure_density_matrix(np.array([1, 0, 0]), [1])
     with pytest.raises(ValueError, match='not square'):
@@ -288,26 +290,26 @@ def test_measure_density_matrix_not_square():
         )
 
 
-def test_measure_density_matrix_not_power_of_two():
+def test_measure_density_matrix_not_power_of_two() -> None:
     with pytest.raises(ValueError, match='power of two'):
         cirq.measure_density_matrix(np.ones((3, 3)) / 3, [1])
     with pytest.raises(ValueError, match='power of two'):
         cirq.measure_density_matrix(np.ones((2, 3, 2, 3)) / 6, [1])
 
 
-def test_measure_density_matrix_higher_powers_of_two():
+def test_measure_density_matrix_higher_powers_of_two() -> None:
     with pytest.raises(ValueError, match='powers of two'):
         cirq.measure_density_matrix(np.ones((2, 4, 2, 4)) / 8, [1])
 
 
-def test_measure_density_matrix_tensor_different_left_right_shape():
+def test_measure_density_matrix_tensor_different_left_right_shape() -> None:
     with pytest.raises(ValueError, match='not equal'):
         cirq.measure_density_matrix(
             np.array([1, 0, 0, 0]).reshape((2, 2, 1, 1)), [1], qid_shape=(2, 1)
         )
 
 
-def test_measure_density_matrix_out_of_range():
+def test_measure_density_matrix_out_of_range() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     with pytest.raises(IndexError, match='-2'):
         cirq.measure_density_matrix(matrix, [-2])
@@ -315,14 +317,14 @@ def test_measure_density_matrix_out_of_range():
         cirq.measure_density_matrix(matrix, [3])
 
 
-def test_measure_state_no_indices():
+def test_measure_state_no_indices() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     bits, out_matrix = cirq.measure_density_matrix(matrix, [])
     assert [] == bits
     np.testing.assert_almost_equal(out_matrix, matrix)
 
 
-def test_measure_state_no_indices_out_is_matrix():
+def test_measure_state_no_indices_out_is_matrix() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     bits, out_matrix = cirq.measure_density_matrix(matrix, [], out=matrix)
     assert [] == bits
@@ -330,7 +332,7 @@ def test_measure_state_no_indices_out_is_matrix():
     assert out_matrix is matrix
 
 
-def test_measure_state_no_indices_out_is_not_matrix():
+def test_measure_state_no_indices_out_is_not_matrix() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     out = np.zeros_like(matrix)
     bits, out_matrix = cirq.measure_density_matrix(matrix, [], out=out)
@@ -340,7 +342,7 @@ def test_measure_state_no_indices_out_is_not_matrix():
     assert out is not matrix
 
 
-def test_measure_state_empty_density_matrix():
+def test_measure_state_empty_density_matrix() -> None:
     matrix = np.zeros(shape=())
     bits, out_matrix = cirq.measure_density_matrix(matrix, [])
     assert [] == bits
@@ -350,14 +352,14 @@ def test_measure_state_empty_density_matrix():
 @pytest.mark.parametrize('seed', [17, 35, 48])
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [False, True])
-def test_to_valid_density_matrix_on_simulator_output(seed, dtype, split):
+def test_to_valid_density_matrix_on_simulator_output(seed, dtype, split) -> None:
     circuit = cirq.testing.random_circuit(qubits=5, n_moments=20, op_density=0.9, random_state=seed)
     simulator = cirq.DensityMatrixSimulator(split_untangled_states=split, dtype=dtype)
     result = simulator.simulate(circuit)
     _ = cirq.to_valid_density_matrix(result.final_density_matrix, num_qubits=5, atol=1e-6)
 
 
-def test_factor_validation():
+def test_factor_validation() -> None:
     args = cirq.DensityMatrixSimulator()._create_simulation_state(0, qubits=cirq.LineQubit.range(2))
     args.apply_operation(cirq.H(cirq.LineQubit(0)))
     t = args.create_merged_state().target_tensor

cirq/sim/mux.py

@@ -17,7 +17,9 @@
 Filename is a reference to multiplexing.
 """
 
-from typing import List, Optional, Sequence, Type, TYPE_CHECKING, Union
+from __future__ import annotations
+
+from typing import Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -30,7 +32,7 @@ from cirq.transformers import measurement_transformers
 if TYPE_CHECKING:
     import cirq
 
-CIRCUIT_LIKE = Union[circuits.Circuit, ops.Gate, ops.OP_TREE]
+CIRCUIT_LIKE = circuits.Circuit | ops.Gate | ops.OP_TREE
 document(
     CIRCUIT_LIKE,
     """A `circuits.Circuit` or a value that can be trivially converted into it:
@@ -39,7 +41,7 @@ document(
 )
 
 
-def _is_clifford_circuit(program: 'cirq.Circuit') -> bool:
+def _is_clifford_circuit(program: cirq.Circuit) -> bool:
     return all(
         clifford_simulator.CliffordSimulator.is_supported_operation(op)
         for op in program.all_operations()
@@ -47,14 +49,14 @@ def _is_clifford_circuit(program: 'cirq.Circuit') -> bool:
 
 
 def sample(
-    program: 'cirq.Circuit',
+    program: cirq.Circuit,
     *,
-    noise: 'cirq.NOISE_MODEL_LIKE' = None,
-    param_resolver: Optional['cirq.ParamResolver'] = None,
+    noise: cirq.NOISE_MODEL_LIKE = None,
+    param_resolver: cirq.ParamResolver | None = None,
     repetitions: int = 1,
-    dtype: Type[np.complexfloating] = np.complex64,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
-) -> 'cirq.Result':
+    dtype: type[np.complexfloating] = np.complex64,
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
+) -> cirq.Result:
     """Simulates sampling from the given circuit.
 
     Args:
@@ -90,7 +92,7 @@ def sample(
     ).run(program=program, param_resolver=param_resolver, repetitions=repetitions)
 
 
-def _to_circuit(program: 'cirq.CIRCUIT_LIKE') -> 'cirq.Circuit':
+def _to_circuit(program: cirq.CIRCUIT_LIKE) -> cirq.Circuit:
     if isinstance(program, circuits.Circuit):
         # No change needed.
         result = program
@@ -103,14 +105,14 @@ def _to_circuit(program: 'cirq.CIRCUIT_LIKE') -> 'cirq.Circuit':
 
 
 def final_state_vector(
-    program: 'cirq.CIRCUIT_LIKE',
+    program: cirq.CIRCUIT_LIKE,
     *,
-    initial_state: 'cirq.STATE_VECTOR_LIKE' = 0,
-    param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
-    qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT,
+    initial_state: cirq.STATE_VECTOR_LIKE = 0,
+    param_resolver: cirq.ParamResolverOrSimilarType = None,
+    qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
     ignore_terminal_measurements: bool = False,
-    dtype: Type[np.complexfloating] = np.complex64,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    dtype: type[np.complexfloating] = np.complex64,
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> np.ndarray:
     """Returns the state vector resulting from acting operations on a state.
 
@@ -174,14 +176,14 @@ def final_state_vector(
 
 
 def sample_sweep(
-    program: 'cirq.Circuit',
-    params: 'cirq.Sweepable',
+    program: cirq.Circuit,
+    params: cirq.Sweepable,
     *,
-    noise: 'cirq.NOISE_MODEL_LIKE' = None,
+    noise: cirq.NOISE_MODEL_LIKE = None,
     repetitions: int = 1,
-    dtype: Type[np.complexfloating] = np.complex64,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
-) -> Sequence['cirq.Result']:
+    dtype: type[np.complexfloating] = np.complex64,
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
+) -> Sequence[cirq.Result]:
     """Runs the supplied Circuit, mimicking quantum hardware.
 
     In contrast to run, this allows for sweeping over different parameter
@@ -204,7 +206,7 @@ def sample_sweep(
     """
     prng = value.parse_random_state(seed)
 
-    trial_results: List[study.Result] = []
+    trial_results: list[study.Result] = []
     for param_resolver in study.to_resolvers(params):
         measurements = sample(
             program,
@@ -219,16 +221,16 @@ def sample_sweep(
 
 
 def final_density_matrix(
-    program: 'cirq.CIRCUIT_LIKE',
+    program: cirq.CIRCUIT_LIKE,
     *,
-    noise: 'cirq.NOISE_MODEL_LIKE' = None,
-    initial_state: 'cirq.STATE_VECTOR_LIKE' = 0,
-    param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
-    qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT,
-    dtype: Type[np.complexfloating] = np.complex64,
-    seed: Optional[Union[int, np.random.RandomState]] = None,
+    noise: cirq.NOISE_MODEL_LIKE = None,
+    initial_state: cirq.STATE_VECTOR_LIKE = 0,
+    param_resolver: cirq.ParamResolverOrSimilarType = None,
+    qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
+    dtype: type[np.complexfloating] = np.complex64,
+    seed: int | np.random.RandomState | None = None,
     ignore_measurement_results: bool = True,
-) -> 'np.ndarray':
+) -> np.ndarray:
     """Returns the density matrix resulting from simulating the circuit.
 
     Note that, unlike `cirq.final_state_vector`, terminal measurements

cirq/sim/mux_test.py

@@ -13,6 +13,9 @@
 # limitations under the License.
 
 """Tests sampling/simulation methods that delegate to appropriate simulators."""
+
+from __future__ import annotations
+
 import collections
 
 import numpy as np

cirq/sim/simulation_product_state.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from collections import abc
-from typing import Any, Dict, Generic, Iterator, List, Mapping, Optional, Sequence, TYPE_CHECKING
+from typing import Any, Generic, Iterator, Mapping, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -32,10 +34,10 @@ class SimulationProductState(
 
     def __init__(
         self,
-        sim_states: Dict[Optional['cirq.Qid'], TSimulationState],
-        qubits: Sequence['cirq.Qid'],
+        sim_states: dict[cirq.Qid | None, TSimulationState],
+        qubits: Sequence[cirq.Qid],
         split_untangled_states: bool,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        classical_data: cirq.ClassicalDataStore | None = None,
     ):
         """Initializes the class.
 
@@ -55,7 +57,7 @@ class SimulationProductState(
         self._split_untangled_states = split_untangled_states
 
     @property
-    def sim_states(self) -> Mapping[Optional['cirq.Qid'], TSimulationState]:
+    def sim_states(self) -> Mapping[cirq.Qid | None, TSimulationState]:
         return self._sim_states
 
     @property
@@ -78,7 +80,7 @@ class SimulationProductState(
         return merged_state.transpose_to_qubit_order(self.qubits, inplace=True)
 
     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:
         gate_opt = (
             action
@@ -106,7 +108,7 @@ class SimulationProductState(
 
         # Go through the op's qubits and join any disparate SimulationState states
         # into a new combined state.
-        op_args_opt: Optional[TSimulationState] = None
+        op_args_opt: TSimulationState | None = None
         for q in qubits:
             if op_args_opt is None:
                 op_args_opt = self.sim_states[q]
@@ -136,9 +138,7 @@ class SimulationProductState(
                 self._sim_states[q] = op_args
         return True
 
-    def copy(
-        self, deep_copy_buffers: bool = True
-    ) -> 'cirq.SimulationProductState[TSimulationState]':
+    def copy(self, deep_copy_buffers: bool = True) -> cirq.SimulationProductState[TSimulationState]:
         classical_data = self._classical_data.copy()
         copies = {}
         for sim_state in set(self.sim_states.values()):
@@ -152,12 +152,12 @@ class SimulationProductState(
 
     def sample(
         self,
-        qubits: List['cirq.Qid'],
+        qubits: list[cirq.Qid],
         repetitions: int = 1,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     ) -> np.ndarray:
         columns = []
-        selected_order: List[ops.Qid] = []
+        selected_order: list[ops.Qid] = []
         q_set = set(qubits)
         for v in dict.fromkeys(self.sim_states.values()):
             qs = [q for q in v.qubits if q in q_set]
@@ -170,11 +170,11 @@ class SimulationProductState(
         index_order = [qubit_map[q] for q in qubits]
         return stacked[:, index_order]
 
-    def __getitem__(self, item: Optional['cirq.Qid']) -> TSimulationState:
+    def __getitem__(self, item: cirq.Qid | None) -> TSimulationState:
         return self.sim_states[item]
 
     def __len__(self) -> int:
         return len(self.sim_states)
 
-    def __iter__(self) -> Iterator[Optional['cirq.Qid']]:
+    def __iter__(self) -> Iterator[cirq.Qid | None]:
         return iter(self.sim_states)