cirq-core 1.7.0.dev20250825174419__py3-none-any.whl → 1.7.0.dev20251203004401__py3-none-any.whl

cirq/sim/simulator_base_test.py

@@ -15,7 +15,8 @@
 from __future__ import annotations
 
 import math
-from typing import Any, Sequence
+from collections.abc import Sequence
+from typing import Any
 
 import numpy as np
 import pytest
@@ -73,25 +74,25 @@ class CountingSimulationState(cirq.SimulationState[CountingState]):
         return True
 
     @property
-    def data(self):
+    def data(self) -> Any:
         return self._state.data
 
     @property
-    def gate_count(self):
+    def gate_count(self) -> int:
         return self._state.gate_count
 
     @property
-    def measurement_count(self):
+    def measurement_count(self) -> int:
         return self._state.measurement_count
 
     @property
-    def copy_count(self):
+    def copy_count(self) -> int:
         return self._state.copy_count
 
 
 class SplittableCountingSimulationState(CountingSimulationState):
     @property
-    def allows_factoring(self):
+    def allows_factoring(self) -> bool:
         return True
 
 
@@ -167,59 +168,64 @@ entangled_state_repr = np.array([[math.sqrt(0.5), 0], [0, math.sqrt(0.5)]])
 
 
 class TestOp(cirq.Operation):
-    def with_qubits(self, *new_qubits):
-        pass
+    def with_qubits(self, *new_qubits) -> cirq.Operation:
+        raise NotImplementedError()
 
     @property
-    def qubits(self):
-        return [q0]
+    def qubits(self) -> tuple[cirq.Qid, ...]:
+        return (q0,)
 
 
-def test_simulate_empty_circuit():
+def test_simulate_empty_circuit() -> None:
     sim = CountingSimulator()
     r = sim.simulate(cirq.Circuit())
+    assert isinstance(r._final_simulator_state, CountingSimulationState)
     assert r._final_simulator_state.gate_count == 0
     assert r._final_simulator_state.measurement_count == 0
     assert r._final_simulator_state.copy_count == 0
 
 
-def test_simulate_one_gate_circuit():
+def test_simulate_one_gate_circuit() -> None:
     sim = CountingSimulator()
     r = sim.simulate(cirq.Circuit(cirq.X(q0)))
+    assert isinstance(r._final_simulator_state, CountingSimulationState)
     assert r._final_simulator_state.gate_count == 1
     assert r._final_simulator_state.copy_count == 0
 
 
-def test_simulate_one_measurement_circuit():
+def test_simulate_one_measurement_circuit() -> None:
     sim = CountingSimulator()
     r = sim.simulate(cirq.Circuit(cirq.measure(q0)))
+    assert isinstance(r._final_simulator_state, CountingSimulationState)
     assert r._final_simulator_state.gate_count == 0
     assert r._final_simulator_state.measurement_count == 1
     assert r._final_simulator_state.copy_count == 0
 
 
-def test_empty_circuit_simulation_has_moment():
+def test_empty_circuit_simulation_has_moment() -> None:
     sim = CountingSimulator()
     steps = list(sim.simulate_moment_steps(cirq.Circuit()))
     assert len(steps) == 1
 
 
-def test_noise_applied():
+def test_noise_applied() -> None:
     sim = CountingSimulator(noise=cirq.X)
     r = sim.simulate(cirq.Circuit(cirq.X(q0)))
+    assert isinstance(r._final_simulator_state, CountingSimulationState)
     assert r._final_simulator_state.gate_count == 2
     assert r._final_simulator_state.copy_count == 0
 
 
-def test_noise_applied_measurement_gate():
+def test_noise_applied_measurement_gate() -> None:
     sim = CountingSimulator(noise=cirq.X)
     r = sim.simulate(cirq.Circuit(cirq.measure(q0)))
+    assert isinstance(r._final_simulator_state, CountingSimulationState)
     assert r._final_simulator_state.gate_count == 1
     assert r._final_simulator_state.measurement_count == 1
     assert r._final_simulator_state.copy_count == 0
 
 
-def test_parameterized_copies_all_but_last():
+def test_parameterized_copies_all_but_last() -> None:
     sim = CountingSimulator()
     n = 4
     rs = sim.simulate_sweep(
@@ -227,12 +233,13 @@ def test_parameterized_copies_all_but_last():
     )
     for i in range(n):
         r = rs[i]
+        assert isinstance(r._final_simulator_state, CountingSimulationState)
         assert r._final_simulator_state.gate_count == 1
         assert r._final_simulator_state.measurement_count == 0
         assert r._final_simulator_state.copy_count == 0 if i == n - 1 else 1
 
 
-def test_cannot_act():
+def test_cannot_act() -> None:
     class BadOp(TestOp):
         def _act_on_(self, sim_state):
             raise TypeError()
@@ -242,25 +249,25 @@ def test_cannot_act():
         sim.simulate(cirq.Circuit(BadOp()))
 
 
-def test_run_one_gate_circuit():
+def test_run_one_gate_circuit() -> None:
     sim = CountingSimulator()
     r = sim.run(cirq.Circuit(cirq.X(q0), cirq.measure(q0)), repetitions=2)
     assert np.allclose(r.measurements['q(0)'], [[1], [1]])
 
 
-def test_run_one_gate_circuit_noise():
+def test_run_one_gate_circuit_noise() -> None:
     sim = CountingSimulator(noise=cirq.X)
     r = sim.run(cirq.Circuit(cirq.X(q0), cirq.measure(q0)), repetitions=2)
     assert np.allclose(r.measurements['q(0)'], [[2], [2]])
 
 
-def test_run_non_unitary_circuit():
+def test_run_non_unitary_circuit() -> None:
     sim = CountingSimulator()
     r = sim.run(cirq.Circuit(cirq.phase_damp(1).on(q0), cirq.measure(q0)), repetitions=2)
     assert np.allclose(r.measurements['q(0)'], [[1], [1]])
 
 
-def test_run_non_unitary_circuit_non_unitary_state():
+def test_run_non_unitary_circuit_non_unitary_state() -> None:
     class DensityCountingSimulator(CountingSimulator):
         def _can_be_in_run_prefix(self, val):
             return not cirq.is_measurement(val)
@@ -270,15 +277,16 @@ def test_run_non_unitary_circuit_non_unitary_state():
     assert np.allclose(r.measurements['q(0)'], [[1], [1]])
 
 
-def test_run_non_terminal_measurement():
+def test_run_non_terminal_measurement() -> None:
     sim = CountingSimulator()
     r = sim.run(cirq.Circuit(cirq.X(q0), cirq.measure(q0), cirq.X(q0)), repetitions=2)
     assert np.allclose(r.measurements['q(0)'], [[1], [1]])
 
 
-def test_integer_initial_state_is_split():
+def test_integer_initial_state_is_split() -> None:
     sim = SplittableCountingSimulator()
     state = sim._create_simulation_state(2, (q0, q1))
+    assert isinstance(state, cirq.SimulationProductState)
     assert len(set(state.values())) == 3
     assert state[q0] is not state[q1]
     assert state[q0].data == 1
@@ -286,7 +294,7 @@ def test_integer_initial_state_is_split():
     assert state[None].data == 0
 
 
-def test_integer_initial_state_is_not_split_if_disabled():
+def test_integer_initial_state_is_not_split_if_disabled() -> None:
     sim = SplittableCountingSimulator(split_untangled_states=False)
     state = sim._create_simulation_state(2, (q0, q1))
     assert isinstance(state, SplittableCountingSimulationState)
@@ -294,7 +302,7 @@ def test_integer_initial_state_is_not_split_if_disabled():
     assert state.data == 2
 
 
-def test_integer_initial_state_is_not_split_if_impossible():
+def test_integer_initial_state_is_not_split_if_impossible() -> None:
     sim = CountingSimulator()
     state = sim._create_simulation_state(2, (q0, q1))
     assert isinstance(state, CountingSimulationState)
@@ -303,18 +311,20 @@ def test_integer_initial_state_is_not_split_if_impossible():
     assert state.data == 2
 
 
-def test_non_integer_initial_state_is_not_split():
+def test_non_integer_initial_state_is_not_split() -> None:
     sim = SplittableCountingSimulator()
     state = sim._create_simulation_state(entangled_state_repr, (q0, q1))
+    assert isinstance(state, cirq.SimulationProductState)
     assert len(set(state.values())) == 2
     assert (state[q0].data == entangled_state_repr).all()
     assert state[q1] is state[q0]
     assert state[None].data == 0
 
 
-def test_entanglement_causes_join():
+def test_entanglement_causes_join() -> None:
     sim = SplittableCountingSimulator()
     state = sim._create_simulation_state(2, (q0, q1))
+    assert isinstance(state, cirq.SimulationProductState)
     assert len(set(state.values())) == 3
     state.apply_operation(cirq.CNOT(q0, q1))
     assert len(set(state.values())) == 2
@@ -322,9 +332,10 @@ def test_entanglement_causes_join():
     assert state[None] is not state[q0]
 
 
-def test_measurement_causes_split():
+def test_measurement_causes_split() -> None:
     sim = SplittableCountingSimulator()
     state = sim._create_simulation_state(entangled_state_repr, (q0, q1))
+    assert isinstance(state, cirq.SimulationProductState)
     assert len(set(state.values())) == 2
     state.apply_operation(cirq.measure(q0))
     assert len(set(state.values())) == 3
@@ -332,7 +343,7 @@ def test_measurement_causes_split():
     assert state[q0] is not state[None]
 
 
-def test_measurement_does_not_split_if_disabled():
+def test_measurement_does_not_split_if_disabled() -> None:
     sim = SplittableCountingSimulator(split_untangled_states=False)
     state = sim._create_simulation_state(2, (q0, q1))
     assert isinstance(state, SplittableCountingSimulationState)
@@ -341,7 +352,7 @@ def test_measurement_does_not_split_if_disabled():
     assert state[q0] is state[q1]
 
 
-def test_measurement_does_not_split_if_impossible():
+def test_measurement_does_not_split_if_impossible() -> None:
     sim = CountingSimulator()
     state = sim._create_simulation_state(2, (q0, q1))
     assert isinstance(state, CountingSimulationState)
@@ -352,7 +363,7 @@ def test_measurement_does_not_split_if_impossible():
     assert state[q0] is state[q1]
 
 
-def test_reorder_succeeds():
+def test_reorder_succeeds() -> None:
     sim = SplittableCountingSimulator()
     state = sim._create_simulation_state(entangled_state_repr, (q0, q1))
     reordered = state[q0].transpose_to_qubit_order([q1, q0])
@@ -360,7 +371,7 @@ def test_reorder_succeeds():
 
 
 @pytest.mark.parametrize('split', [True, False])
-def test_sim_state_instance_unchanged_during_normal_sim(split: bool):
+def test_sim_state_instance_unchanged_during_normal_sim(split: bool) -> None:
     sim = SplittableCountingSimulator(split_untangled_states=split)
     state = sim._create_simulation_state(0, (q0, q1))
     circuit = cirq.Circuit(cirq.H(q0), cirq.CNOT(q0, q1), cirq.reset(q1))
@@ -369,7 +380,7 @@ def test_sim_state_instance_unchanged_during_normal_sim(split: bool):
         assert (step._merged_sim_state is not state) == split
 
 
-def test_measurements_retained_in_step_results():
+def test_measurements_retained_in_step_results() -> None:
     sim = SplittableCountingSimulator()
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'), cirq.measure(q0, key='b'), cirq.measure(q0, key='c')
@@ -381,7 +392,7 @@ def test_measurements_retained_in_step_results():
     assert not any(iterator)
 
 
-def test_sweep_unparameterized_prefix_not_repeated_iff_unitary():
+def test_sweep_unparameterized_prefix_not_repeated_iff_unitary() -> None:
     q = cirq.LineQubit(0)
 
     class TestOp(cirq.Operation):
@@ -410,6 +421,8 @@ def test_sweep_unparameterized_prefix_not_repeated_iff_unitary():
     op2 = TestOp(has_unitary=True)
     circuit = cirq.Circuit(op1, cirq.XPowGate(exponent=sympy.Symbol('a'))(q), op2)
     rs = simulator.simulate_sweep(program=circuit, params=params)
+    assert isinstance(rs[0]._final_simulator_state, CountingSimulationState)
+    assert isinstance(rs[1]._final_simulator_state, CountingSimulationState)
     assert rs[0]._final_simulator_state.copy_count == 1
     assert rs[1]._final_simulator_state.copy_count == 0
     assert op1.count == 1
@@ -419,13 +432,15 @@ def test_sweep_unparameterized_prefix_not_repeated_iff_unitary():
     op2 = TestOp(has_unitary=False)
     circuit = cirq.Circuit(op1, cirq.XPowGate(exponent=sympy.Symbol('a'))(q), op2)
     rs = simulator.simulate_sweep(program=circuit, params=params)
+    assert isinstance(rs[0]._final_simulator_state, CountingSimulationState)
+    assert isinstance(rs[1]._final_simulator_state, CountingSimulationState)
     assert rs[0]._final_simulator_state.copy_count == 1
     assert rs[1]._final_simulator_state.copy_count == 0
     assert op1.count == 2
     assert op2.count == 2
 
 
-def test_inhomogeneous_measurement_count_padding():
+def test_inhomogeneous_measurement_count_padding() -> None:
     q = cirq.LineQubit(0)
     key = cirq.MeasurementKey('m')
     sim = cirq.Simulator()

cirq/sim/simulator_test.py

@@ -17,7 +17,8 @@
 from __future__ import annotations
 
 import abc
-from typing import Any, Generic, Iterator, Sequence
+from collections.abc import Iterator, Sequence
+from typing import Any, Generic
 from unittest import mock
 
 import duet
@@ -56,13 +57,13 @@ class FakeStepResult(cirq.StepResult):
     def _simulator_state(self):
         return self._final_state  # pragma: no cover
 
-    def state_vector(self):
+    def state_vector(self) -> None:
         pass
 
     def __setstate__(self, state):
         pass
 
-    def sample(self, qubits, repetitions=1, seed=None):
+    def sample(self, qubits, repetitions=1, seed=None) -> np.ndarray:
         return np.array([[qubit in self._ones_qubits for qubit in qubits]] * repetitions)
 
 
@@ -99,7 +100,7 @@ class SimulatesIntermediateStateImpl(
         )
 
 
-def test_run_simulator_run():
+def test_run_simulator_run() -> None:
     expected_records = {'a': np.array([[[1]]])}
     simulator = FakeSimulatesSamples(expected_records)
     circuit = cirq.Circuit(cirq.measure(cirq.LineQubit(0), key='k'))
@@ -110,7 +111,7 @@ def test_run_simulator_run():
     )
 
 
-def test_run_simulator_sweeps():
+def test_run_simulator_sweeps() -> None:
     expected_records = {'a': np.array([[[1]]])}
     simulator = FakeSimulatesSamples(expected_records)
     circuit = cirq.Circuit(cirq.measure(cirq.LineQubit(0), key='k'))
@@ -127,8 +128,8 @@ def test_run_simulator_sweeps():
 @mock.patch.multiple(
     SimulatesIntermediateStateImpl, __abstractmethods__=set(), simulate_moment_steps=mock.Mock()
 )
-def test_intermediate_simulator():
-    simulator = SimulatesIntermediateStateImpl()
+def test_intermediate_simulator() -> None:
+    simulator: SimulatesIntermediateStateImpl = SimulatesIntermediateStateImpl()
 
     final_simulator_state = np.array([1, 0, 0, 0])
 
@@ -141,7 +142,7 @@ def test_intermediate_simulator():
         result._simulator_state.return_value = final_simulator_state
         yield result
 
-    simulator.simulate_moment_steps.side_effect = steps
+    simulator.simulate_moment_steps.side_effect = steps  # type: ignore[attr-defined]
     circuit = mock.Mock(cirq.Circuit)
     param_resolver = cirq.ParamResolver({})
     qubit_order = mock.Mock(cirq.QubitOrder)
@@ -158,8 +159,8 @@ def test_intermediate_simulator():
 @mock.patch.multiple(
     SimulatesIntermediateStateImpl, __abstractmethods__=set(), simulate_moment_steps=mock.Mock()
 )
-def test_intermediate_sweeps():
-    simulator = SimulatesIntermediateStateImpl()
+def test_intermediate_sweeps() -> None:
+    simulator: SimulatesIntermediateStateImpl = SimulatesIntermediateStateImpl()
 
     final_state = np.array([1, 0, 0, 0])
 
@@ -169,7 +170,7 @@ def test_intermediate_sweeps():
         result._simulator_state.return_value = final_state
         yield result
 
-    simulator.simulate_moment_steps.side_effect = steps
+    simulator.simulate_moment_steps.side_effect = steps  # type: ignore[attr-defined]
     circuit = mock.Mock(cirq.Circuit)
     param_resolvers = [cirq.ParamResolver({}), cirq.ParamResolver({})]
     qubit_order = mock.Mock(cirq.QubitOrder)
@@ -192,7 +193,7 @@ def test_intermediate_sweeps():
     assert results == expected_results
 
 
-def test_step_sample_measurement_ops():
+def test_step_sample_measurement_ops() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     measurement_ops = [cirq.measure(q0, q1), cirq.measure(q2)]
     step_result = FakeStepResult(ones_qubits=[q1])
@@ -201,7 +202,7 @@ def test_step_sample_measurement_ops():
     np.testing.assert_equal(measurements, {'q(0),q(1)': [[False, True]], 'q(2)': [[False]]})
 
 
-def test_step_sample_measurement_ops_repetitions():
+def test_step_sample_measurement_ops_repetitions() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     measurement_ops = [cirq.measure(q0, q1), cirq.measure(q2)]
     step_result = FakeStepResult(ones_qubits=[q1])
@@ -210,7 +211,7 @@ def test_step_sample_measurement_ops_repetitions():
     np.testing.assert_equal(measurements, {'q(0),q(1)': [[False, True]] * 3, 'q(2)': [[False]] * 3})
 
 
-def test_step_sample_measurement_ops_invert_mask():
+def test_step_sample_measurement_ops_invert_mask() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     measurement_ops = [
         cirq.measure(q0, q1, invert_mask=(True,)),
@@ -222,9 +223,11 @@ def test_step_sample_measurement_ops_invert_mask():
     np.testing.assert_equal(measurements, {'q(0),q(1)': [[True, True]], 'q(2)': [[False]]})
 
 
-def test_step_sample_measurement_ops_confusion_map():
+def test_step_sample_measurement_ops_confusion_map() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
+    cmap_01: dict[tuple[int, ...], np.ndarray]
     cmap_01 = {(0, 1): np.array([[0, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 0]])}
+    cmap_2: dict[tuple[int, ...], np.ndarray]
     cmap_2 = {(0,): np.array([[0, 1], [1, 0]])}
     measurement_ops = [
         cirq.measure(q0, q1, confusion_map=cmap_01),
@@ -236,21 +239,21 @@ def test_step_sample_measurement_ops_confusion_map():
     np.testing.assert_equal(measurements, {'q(0),q(1)': [[False, True]], 'q(2)': [[False]]})
 
 
-def test_step_sample_measurement_ops_no_measurements():
+def test_step_sample_measurement_ops_no_measurements() -> None:
     step_result = FakeStepResult(ones_qubits=[])
 
     measurements = step_result.sample_measurement_ops([])
     assert measurements == {}
 
 
-def test_step_sample_measurement_ops_not_measurement():
+def test_step_sample_measurement_ops_not_measurement() -> None:
     q0 = cirq.LineQubit(0)
     step_result = FakeStepResult(ones_qubits=[q0])
     with pytest.raises(ValueError, match='MeasurementGate'):
         step_result.sample_measurement_ops([cirq.X(q0)])
 
 
-def test_step_sample_measurement_ops_repeated_qubit():
+def test_step_sample_measurement_ops_repeated_qubit() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     step_result = FakeStepResult(ones_qubits=[q0])
     with pytest.raises(ValueError, match=r'Measurement key q\(0\) repeated'):
@@ -259,7 +262,7 @@ def test_step_sample_measurement_ops_repeated_qubit():
         )
 
 
-def test_simulation_trial_result_equality():
+def test_simulation_trial_result_equality() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(
         cirq.SimulationTrialResult(
@@ -290,7 +293,7 @@ def test_simulation_trial_result_equality():
     )
 
 
-def test_simulation_trial_result_repr():
+def test_simulation_trial_result_repr() -> None:
     assert repr(
         cirq.SimulationTrialResult(
             params=cirq.ParamResolver({'s': 1}),
@@ -305,7 +308,7 @@ def test_simulation_trial_result_repr():
     )
 
 
-def test_simulation_trial_result_str():
+def test_simulation_trial_result_str() -> None:
     assert (
         str(
             cirq.SimulationTrialResult(
@@ -349,7 +352,7 @@ def test_simulation_trial_result_str():
     )
 
 
-def test_pretty_print():
+def test_pretty_print() -> None:
     result = cirq.SimulationTrialResult(cirq.ParamResolver(), {}, np.array([1]))
 
     # Test Jupyter console output from
@@ -371,7 +374,7 @@ def test_pretty_print():
 
 
 @duet.sync
-async def test_async_sample():
+async def test_async_sample() -> None:
     m = {'mock': np.array([[[0]], [[1]]])}
     simulator = FakeSimulatesSamples(m)
 
@@ -381,16 +384,16 @@ async def test_async_sample():
     np.testing.assert_equal(result.records, m)
 
 
-def test_simulation_trial_result_qubit_map():
+def test_simulation_trial_result_qubit_map() -> None:
     q = cirq.LineQubit.range(2)
     result = cirq.Simulator().simulate(cirq.Circuit([cirq.CZ(q[0], q[1])]))
     assert result.qubit_map == {q[0]: 0, q[1]: 1}
 
-    result = cirq.DensityMatrixSimulator().simulate(cirq.Circuit([cirq.CZ(q[0], q[1])]))
-    assert result.qubit_map == {q[0]: 0, q[1]: 1}
+    result2 = cirq.DensityMatrixSimulator().simulate(cirq.Circuit([cirq.CZ(q[0], q[1])]))
+    assert result2.qubit_map == {q[0]: 0, q[1]: 1}
 
 
-def test_sample_repeated_measurement_keys():
+def test_sample_repeated_measurement_keys() -> None:
     q = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
     circuit.append(
@@ -408,7 +411,7 @@ def test_sample_repeated_measurement_keys():
     assert len(result.records['b'][0]) == 2
 
 
-def test_classical_controls_go_to_suffix_if_corresponding_measurement_does():
+def test_classical_controls_go_to_suffix_if_corresponding_measurement_does() -> None:
     subcircuit = cirq.CircuitOperation(cirq.FrozenCircuit()).with_classical_controls('a')
     m = cirq.measure(cirq.LineQubit(0), key='a')
     circuit = cirq.Circuit(m, subcircuit)
@@ -419,7 +422,7 @@ def test_classical_controls_go_to_suffix_if_corresponding_measurement_does():
     assert suffix == circuit
 
 
-def test_simulate_with_invert_mask():
+def test_simulate_with_invert_mask() -> None:
     q0, q1, q2, q3, q4 = cirq.LineQid.for_qid_shape((2, 3, 3, 3, 4))
     c = cirq.Circuit(
         cirq.XPowGate(dimension=2)(q0),
@@ -431,7 +434,7 @@ def test_simulate_with_invert_mask():
     assert np.all(cirq.Simulator().run(c).measurements['a'] == [[0, 1, 0, 2, 3]])
 
 
-def test_monte_carlo_on_unknown_channel():
+def test_monte_carlo_on_unknown_channel() -> None:
     class Reset11To00(cirq.Gate):
         def num_qubits(self) -> int:
             return 2
@@ -451,8 +454,10 @@ def test_monte_carlo_on_unknown_channel():
         )
 
 
-def test_iter_definitions():
-    mock_trial_result = SimulationTrialResult(params={}, measurements={}, final_simulator_state=[])
+def test_iter_definitions() -> None:
+    mock_trial_result: SimulationTrialResult = SimulationTrialResult(
+        params=cirq.ParamResolver(), measurements={}, final_simulator_state=[]
+    )
 
     class FakeNonIterSimulatorImpl(
         SimulatesAmplitudes, SimulatesExpectationValues, SimulatesFinalState
@@ -495,7 +500,7 @@ def test_iter_definitions():
     q0 = cirq.LineQubit(0)
     circuit = cirq.Circuit(cirq.X(q0))
     bitstrings = [0b0]
-    params = {}
+    params: cirq.ParamMappingType = {}
     assert non_iter_sim.compute_amplitudes_sweep(circuit, bitstrings, params) == [[1.0]]
     amp_iter = non_iter_sim.compute_amplitudes_sweep_iter(circuit, bitstrings, params)
     assert next(amp_iter) == [1.0]
@@ -510,7 +515,7 @@ def test_iter_definitions():
     assert next(state_iter) == mock_trial_result
 
 
-def test_missing_iter_definitions():
+def test_missing_iter_definitions() -> None:
     class FakeMissingIterSimulatorImpl(
         SimulatesAmplitudes, SimulatesExpectationValues, SimulatesFinalState
     ):
@@ -520,7 +525,7 @@ def test_missing_iter_definitions():
     q0 = cirq.LineQubit(0)
     circuit = cirq.Circuit(cirq.X(q0))
     bitstrings = [0b0]
-    params = {}
+    params: cirq.ParamMappingType = {}
     with pytest.raises(RecursionError):
         missing_iter_sim.compute_amplitudes_sweep(circuit, bitstrings, params)
     with pytest.raises(RecursionError):
@@ -541,7 +546,7 @@ def test_missing_iter_definitions():
         next(state_iter)
 
 
-def test_trial_result_initializer():
+def test_trial_result_initializer() -> None:
     resolver = cirq.ParamResolver()
     state = 3
     x = SimulationTrialResult(resolver, {}, state)

cirq/sim/sparse_simulator.py

@@ -16,7 +16,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterator, Sequence, TYPE_CHECKING
+from collections.abc import Iterator, Sequence
+from typing import Any, TYPE_CHECKING
 
 import numpy as np
 
@@ -239,7 +240,7 @@ class SparseSimulatorStep(
         self._dtype = dtype
         self._state_vector: np.ndarray | None = None
 
-    def state_vector(self, copy: bool = False):
+    def state_vector(self, copy: bool = False) -> np.ndarray:
         """Return the state vector at this point in the computation.
 
         The state is returned in the computational basis with these basis