cirq-core 1.6.0.dev20250521011052__py3-none-any.whl → 1.6.0.dev20250522221502__py3-none-any.whl

cirq/sim/sparse_simulator_test.py

@@ -16,7 +16,6 @@ from __future__ import annotations
 
 import itertools
 import random
-from typing import Type, Union
 from unittest import mock
 
 import numpy as np
@@ -33,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)
 
@@ -44,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)
 
@@ -55,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())
@@ -63,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(
@@ -83,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]:
@@ -97,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:
@@ -123,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:
@@ -143,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:
@@ -164,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:
@@ -185,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:
@@ -209,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:
@@ -234,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]:
@@ -253,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))
@@ -263,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))
@@ -274,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))
@@ -286,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]:
@@ -298,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]:
@@ -324,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):
@@ -342,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()
@@ -353,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))
@@ -375,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)
@@ -388,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))
@@ -406,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(
@@ -432,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]:
@@ -454,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)
@@ -471,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]:
@@ -486,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]:
@@ -500,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]:
@@ -519,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]:
@@ -531,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]:
@@ -558,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)
@@ -571,7 +570,7 @@ 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
@@ -583,7 +582,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)
@@ -605,7 +604,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))
@@ -623,7 +622,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)
@@ -648,7 +647,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)
@@ -686,7 +685,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_simulation_state_test.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import cast, Type
+from typing import cast
 from unittest import mock
 
 import numpy as np
@@ -173,7 +173,7 @@ def test_act_using_adaptive_two_qubit_channel() -> None:
             qubits=cirq.LineQubit.range(4),
             prng=mock_prng,
             initial_state=np.copy(state),
-            dtype=cast(Type[np.complexfloating], state.dtype),
+            dtype=cast(type[np.complexfloating], state.dtype),
         )
         cirq.act_on(Decay11(), args, [cirq.LineQubit(1), cirq.LineQubit(3)])
         return args.target_tensor

cirq/sim/state_vector_test.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import Iterator, Optional
+from typing import Iterator
 from unittest import mock
 
 import numpy as np
@@ -37,7 +37,7 @@ def use_np_transpose(request) -> Iterator[bool]:
 
 def test_state_mixin():
     class TestClass(cirq.StateVectorMixin):
-        def state_vector(self, copy: Optional[bool] = None) -> np.ndarray:
+        def state_vector(self, copy: bool | None = None) -> np.ndarray:
             return np.array([0, 0, 1, 0])
 
     qubits = cirq.LineQubit.range(2)
@@ -360,7 +360,7 @@ def test_measure_state_empty_state(use_np_transpose: bool):
 
 
 class BasicStateVector(cirq.StateVectorMixin):
-    def state_vector(self, copy: Optional[bool] = None) -> np.ndarray:
+    def state_vector(self, copy: bool | None = None) -> np.ndarray:
         return np.array([0, 1, 0, 0])
 
 

cirq/study/sweepable.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import warnings
-from typing import cast, Iterable, Iterator, Sequence, Union
+from typing import cast, Iterable, Iterator, Sequence
 
 from typing_extensions import Protocol
 
@@ -33,7 +33,7 @@ class _Sweepable(Protocol):
     """An intermediate class allowing for recursive definition of Sweepable,
     since recursive union definitions are not yet supported in mypy."""
 
-    def __iter__(self) -> Iterator[Union[SweepLike, _Sweepable]]:
+    def __iter__(self) -> Iterator[SweepLike | _Sweepable]:
         pass
 
 
@@ -73,9 +73,9 @@ def to_sweeps(sweepable: Sweepable, metadata: dict | None = None) -> list[Sweep]
 
 
 def to_sweep(
-    sweep_or_resolver_list: Union[
-        Sweep, ParamResolverOrSimilarType, Iterable[ParamResolverOrSimilarType]
-    ],
+    sweep_or_resolver_list: (
+        Sweep | ParamResolverOrSimilarType | Iterable[ParamResolverOrSimilarType]
+    ),
 ) -> Sweep:
     """Converts the argument into a ``cirq.Sweep``.
 

cirq/testing/consistent_act_on.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, cast, Optional, Type, TYPE_CHECKING
+from typing import Any, cast, TYPE_CHECKING
 
 import numpy as np
 
@@ -52,9 +52,9 @@ def state_vector_has_stabilizer(
     """
 
     qubits = LineQubit.range(protocols.num_qubits(stabilizer))
-    complex_dtype: Type[np.complexfloating] = np.complex64
+    complex_dtype: type[np.complexfloating] = np.complex64
     if np.issubdtype(state_vector.dtype, np.complexfloating):
-        complex_dtype = cast(Type[np.complexfloating], state_vector.dtype)
+        complex_dtype = cast(type[np.complexfloating], state_vector.dtype)
     args = state_vector_simulation_state.StateVectorSimulationState(
         available_buffer=np.empty_like(state_vector),
         qubits=qubits,
@@ -151,9 +151,7 @@ def assert_all_implemented_act_on_effects_match_unitary(
         )
 
 
-def _final_clifford_tableau(
-    circuit: Circuit, qubit_map
-) -> Optional[clifford_tableau.CliffordTableau]:
+def _final_clifford_tableau(circuit: Circuit, qubit_map) -> clifford_tableau.CliffordTableau | None:
     """Evolves a default CliffordTableau through the input circuit.
 
     Initializes a CliffordTableau with default args for the given qubits and
@@ -181,7 +179,7 @@ def _final_clifford_tableau(
 
 def _final_stabilizer_state_ch_form(
     circuit: Circuit, qubit_map
-) -> Optional[stabilizer_state_ch_form.StabilizerStateChForm]:
+) -> stabilizer_state_ch_form.StabilizerStateChForm | None:
     """Evolves a default StabilizerStateChForm through the input circuit.
 
     Initializes a StabilizerStateChForm with default args for the given qubits

cirq/testing/consistent_controlled_gate_op.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Collection, Optional, Sequence, Union
+from typing import Collection, Sequence
 
 import numpy as np
 
@@ -25,7 +25,7 @@ def assert_controlled_and_controlled_by_identical(
     gate: ops.Gate,
     *,
     num_controls: Sequence[int] = (2, 1, 3, 10),
-    control_values: Optional[Sequence[Optional[Sequence[Union[int, Collection[int]]]]]] = None,
+    control_values: Sequence[Sequence[int | Collection[int]] | None] | None = None,
 ) -> None:
     """Checks that gate.on().controlled_by() == gate.controlled().on()"""
     if control_values is not None:
@@ -52,9 +52,7 @@ def assert_controlled_unitary_consistent(gate: ops.Gate):
 
 
 def _assert_gate_consistent(
-    gate: ops.Gate,
-    num_controls: int,
-    control_values: Optional[Sequence[Union[int, Collection[int]]]],
+    gate: ops.Gate, num_controls: int, control_values: Sequence[int | Collection[int]] | None
 ) -> None:
     gate_controlled = gate.controlled(num_controls, control_values)
     qubits = devices.LineQid.for_gate(gate_controlled)

cirq/testing/deprecation.py

@@ -17,13 +17,13 @@ from __future__ import annotations
 import contextlib
 import logging
 import os
-from typing import Iterator, Optional
+from typing import Iterator
 
 from cirq._compat import ALLOW_DEPRECATION_IN_TEST
 
 
 @contextlib.contextmanager
-def assert_deprecated(*msgs: str, deadline: str, count: Optional[int] = 1) -> Iterator[None]:
+def assert_deprecated(*msgs: str, deadline: str, count: int | None = 1) -> Iterator[None]:
     """Allows deprecated functions, classes, decorators in tests.
 
     It acts as a contextmanager that can be used in with statements:

cirq/testing/lin_alg_utils.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -120,7 +120,7 @@ def random_orthogonal(
 
 
 def random_special_unitary(
-    dim: int, *, random_state: Optional[np.random.RandomState] = None
+    dim: int, *, random_state: np.random.RandomState | None = None
 ) -> np.ndarray:
     """Returns a random special unitary distributed with Haar measure.
 

cirq/transformers/align.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from cirq import circuits, ops
 from cirq.transformers import transformer_api
@@ -28,7 +28,7 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer(add_deep_support=True)
 def align_left(
-    circuit: cirq.AbstractCircuit, *, context: Optional[cirq.TransformerContext] = None
+    circuit: cirq.AbstractCircuit, *, context: cirq.TransformerContext | None = None
 ) -> cirq.Circuit:
     """Align gates to the left of the circuit.
 
@@ -60,7 +60,7 @@ def align_left(
 
 @transformer_api.transformer(add_deep_support=True)
 def align_right(
-    circuit: cirq.AbstractCircuit, *, context: Optional[cirq.TransformerContext] = None
+    circuit: cirq.AbstractCircuit, *, context: cirq.TransformerContext | None = None
 ) -> cirq.Circuit:
     """Align gates to the right of the circuit.
 

cirq/transformers/drop_empty_moments.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from cirq.transformers import transformer_api, transformer_primitives
 
@@ -26,7 +26,7 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer
 def drop_empty_moments(
-    circuit: cirq.AbstractCircuit, *, context: Optional[cirq.TransformerContext] = None
+    circuit: cirq.AbstractCircuit, *, context: cirq.TransformerContext | None = None
 ) -> cirq.Circuit:
     """Removes empty moments from a circuit.
 

cirq/transformers/drop_negligible_operations.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from cirq import protocols
 from cirq.transformers import transformer_api, transformer_primitives
@@ -29,7 +29,7 @@ if TYPE_CHECKING:
 def drop_negligible_operations(
     circuit: cirq.AbstractCircuit,
     *,
-    context: Optional[cirq.TransformerContext] = None,
+    context: cirq.TransformerContext | None = None,
     atol: float = 1e-8,
 ) -> cirq.Circuit:
     """Removes operations with tiny effects.

cirq/transformers/expand_composite.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Callable, Optional, TYPE_CHECKING
+from typing import Callable, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
 from cirq.transformers import transformer_api, transformer_primitives
@@ -29,7 +29,7 @@ if TYPE_CHECKING:
 def expand_composite(
     circuit: cirq.AbstractCircuit,
     *,
-    context: Optional[cirq.TransformerContext] = None,
+    context: cirq.TransformerContext | None = None,
     no_decomp: Callable[[ops.Operation], bool] = (lambda _: False),
 ):
     """A transformer that expands composite operations via `cirq.decompose`.

cirq/transformers/heuristic_decompositions/gate_tabulation_math_utils.py

@@ -3,13 +3,13 @@
 from __future__ import annotations
 
 import itertools
-from typing import Optional, Sequence, Union
+from typing import Sequence
 
 import numpy as np
 
 from cirq.value import random_state
 
-_RealArraylike = Union[np.ndarray, float]
+_RealArraylike = np.ndarray | float
 
 
 def _single_qubit_unitary(
@@ -48,7 +48,7 @@ def _single_qubit_unitary(
 def random_qubit_unitary(
     shape: Sequence[int] = (),
     randomize_global_phase: bool = False,
-    rng: Optional[np.random.RandomState] = None,
+    rng: np.random.RandomState | None = None,
 ) -> np.ndarray:
     """Random qubit unitary distributed over the Haar measure.
 

cirq/transformers/merge_k_qubit_gates.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Callable, cast, Optional, TYPE_CHECKING
+from typing import Callable, cast, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
 from cirq.transformers import transformer_api, transformer_primitives
@@ -28,9 +28,9 @@ if TYPE_CHECKING:
 def _rewrite_merged_k_qubit_unitaries(
     circuit: cirq.AbstractCircuit,
     *,
-    context: Optional[cirq.TransformerContext] = None,
+    context: cirq.TransformerContext | None = None,
     k: int = 0,
-    rewriter: Optional[Callable[[cirq.CircuitOperation], cirq.OP_TREE]] = None,
+    rewriter: Callable[[cirq.CircuitOperation], cirq.OP_TREE] | None = None,
     merged_circuit_op_tag: str = "_merged_k_qubit_unitaries_component",
 ) -> cirq.Circuit:
     deep = context.deep if context else False
@@ -70,9 +70,9 @@ def _rewrite_merged_k_qubit_unitaries(
 def merge_k_qubit_unitaries(
     circuit: cirq.AbstractCircuit,
     *,
-    context: Optional[cirq.TransformerContext] = None,
+    context: cirq.TransformerContext | None = None,
     k: int = 0,
-    rewriter: Optional[Callable[[cirq.CircuitOperation], cirq.OP_TREE]] = None,
+    rewriter: Callable[[cirq.CircuitOperation], cirq.OP_TREE] | None = None,
 ) -> cirq.Circuit:
     """Merges connected components of unitary operations, acting on <= k qubits.