cirq-core 1.7.0.dev20250915211227__py3-none-any.whl → 1.7.0.dev20250917023732__py3-none-any.whl

cirq/sim/state_vector.py

@@ -105,7 +105,7 @@ class StateVectorMixin:
             and non-zero floats of the specified accuracy."""
         return qis.dirac_notation(self.state_vector(), decimals, qid_shape=self._qid_shape)
 
-    def density_matrix_of(self, qubits: list[cirq.Qid] | None = None) -> np.ndarray:
+    def density_matrix_of(self, qubits: Sequence[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.

cirq/sim/state_vector_simulation_state.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable, Sequence, TYPE_CHECKING
+from typing import Any, Callable, Self, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -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]) -> Self:
         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]) -> Self:
         ret = super().remove_qubits(qubits)
         if ret is not NotImplemented:
             return ret
@@ -406,11 +406,11 @@ class StateVectorSimulationState(SimulationState[_BufferedStateVector]):
         )
 
     @property
-    def target_tensor(self):
+    def target_tensor(self) -> np.ndarray:
         return self._state._state_vector
 
     @property
-    def available_buffer(self):
+    def available_buffer(self) -> np.ndarray:
         return self._state._buffer
 
 
@@ -429,7 +429,7 @@ def _strat_act_on_state_vector_from_mixture(
     if index is None:
         return NotImplemented
     if protocols.is_measurement(action):
-        key = protocols.measurement_key_name(action)
+        key = protocols.measurement_key_obj(action)
         args._classical_data.record_channel_measurement(key, index)
     return True
 
@@ -441,6 +441,6 @@ def _strat_act_on_state_vector_from_channel(
     if index is None:
         return NotImplemented
     if protocols.is_measurement(action):
-        key = protocols.measurement_key_name(action)
+        key = protocols.measurement_key_obj(action)
         args._classical_data.record_channel_measurement(key, index)
     return True

cirq/sim/state_vector_simulator_test.py

@@ -20,7 +20,7 @@ import cirq
 import cirq.testing
 
 
-def test_state_vector_trial_result_repr():
+def test_state_vector_trial_result_repr() -> None:
     q0 = cirq.NamedQubit('a')
     final_simulator_state = cirq.StateVectorSimulationState(
         available_buffer=np.array([0, 1], dtype=np.complex64),
@@ -47,7 +47,7 @@ def test_state_vector_trial_result_repr():
     assert eval(expected_repr) == trial_result
 
 
-def test_state_vector_trial_result_equality():
+def test_state_vector_trial_result_equality() -> None:
     eq = cirq.testing.EqualsTester()
     final_simulator_state = cirq.StateVectorSimulationState(initial_state=np.array([]))
     eq.add_equality_group(
@@ -86,7 +86,7 @@ def test_state_vector_trial_result_equality():
     )
 
 
-def test_state_vector_trial_result_state_mixin():
+def test_state_vector_trial_result_state_mixin() -> None:
     qubits = cirq.LineQubit.range(2)
     final_simulator_state = cirq.StateVectorSimulationState(
         qubits=qubits, initial_state=np.array([0, 1, 0, 0])
@@ -103,7 +103,7 @@ def test_state_vector_trial_result_state_mixin():
     assert result.dirac_notation() == '|01⟩'
 
 
-def test_state_vector_trial_result_qid_shape():
+def test_state_vector_trial_result_qid_shape() -> None:
     final_simulator_state = cirq.StateVectorSimulationState(
         qubits=[cirq.NamedQubit('a')], initial_state=np.array([0, 1])
     )
@@ -125,7 +125,7 @@ def test_state_vector_trial_result_qid_shape():
     assert cirq.qid_shape(trial_result) == (3, 2)
 
 
-def test_state_vector_trial_state_vector_is_copy():
+def test_state_vector_trial_state_vector_is_copy() -> None:
     final_state_vector = np.array([0, 1], dtype=np.complex64)
     qubit_map = {cirq.NamedQubit('a'): 0}
     final_simulator_state = cirq.StateVectorSimulationState(
@@ -137,7 +137,7 @@ def test_state_vector_trial_state_vector_is_copy():
     assert trial_result.state_vector(copy=True) is not final_simulator_state.target_tensor
 
 
-def test_state_vector_trial_result_no_qubits():
+def test_state_vector_trial_result_no_qubits() -> None:
     initial_state_vector = np.array([1], dtype=np.complex64)
     initial_state = initial_state_vector.reshape((2,) * 0)  # reshape as tensor for 0 qubits
     final_simulator_state = cirq.StateVectorSimulationState(qubits=[], initial_state=initial_state)
@@ -149,7 +149,7 @@ def test_state_vector_trial_result_no_qubits():
     assert np.array_equal(state_vector, initial_state_vector)
 
 
-def test_str_big():
+def test_str_big() -> None:
     qs = cirq.LineQubit.range(10)
     final_simulator_state = cirq.StateVectorSimulationState(
         prng=np.random.RandomState(0),
@@ -161,7 +161,7 @@ def test_str_big():
     assert 'output vector: [0.03125+0.j 0.03125+0.j 0.03125+0.j ..' in str(result)
 
 
-def test_str_qudit():
+def test_str_qudit() -> None:
     qutrit = cirq.LineQid(0, dimension=3)
     final_simulator_state = cirq.StateVectorSimulationState(
         prng=np.random.RandomState(0),
@@ -183,7 +183,7 @@ def test_str_qudit():
     assert "|1⟩" in str(result)
 
 
-def test_pretty_print():
+def test_pretty_print() -> None:
     final_simulator_state = cirq.StateVectorSimulationState(
         available_buffer=np.array([1]),
         prng=np.random.RandomState(0),

cirq/sim/state_vector_test.py

@@ -35,7 +35,7 @@ def use_np_transpose(request) -> Iterator[bool]:
         yield value
 
 
-def test_state_mixin():
+def test_state_mixin() -> None:
     class TestClass(cirq.StateVectorMixin):
         def state_vector(self, copy: bool | None = None) -> np.ndarray:
             return np.array([0, 0, 1, 0])
@@ -60,7 +60,7 @@ def test_state_mixin():
         _ = TestClass({qubits[0]: -1, qubits[1]: 1})
 
 
-def test_sample_state_big_endian():
+def test_sample_state_big_endian() -> None:
     results = []
     for x in range(8):
         state = cirq.to_valid_state_vector(x, 3)
@@ -71,7 +71,7 @@ def test_sample_state_big_endian():
         np.testing.assert_equal(result, expected)
 
 
-def test_sample_state_partial_indices():
+def test_sample_state_partial_indices() -> None:
     for index in range(3):
         for x in range(8):
             state = cirq.to_valid_state_vector(x, 3)
@@ -80,14 +80,14 @@ def test_sample_state_partial_indices():
             )
 
 
-def test_sample_state_partial_indices_oder():
+def test_sample_state_partial_indices_oder() -> None:
     for x in range(8):
         state = cirq.to_valid_state_vector(x, 3)
         expected = [[bool(1 & (x >> 0)), bool(1 & (x >> 1))]]
         np.testing.assert_equal(cirq.sample_state_vector(state, [2, 1]), expected)
 
 
-def test_sample_state_partial_indices_all_orders():
+def test_sample_state_partial_indices_all_orders() -> None:
     for perm in itertools.permutations([0, 1, 2]):
         for x in range(8):
             state = cirq.to_valid_state_vector(x, 3)
@@ -95,7 +95,7 @@ def test_sample_state_partial_indices_all_orders():
             np.testing.assert_equal(cirq.sample_state_vector(state, perm), expected)
 
 
-def test_sample_state():
+def test_sample_state() -> None:
     state = np.zeros(8, dtype=np.complex64)
     state[0] = 1 / np.sqrt(2)
     state[2] = 1 / np.sqrt(2)
@@ -110,12 +110,12 @@ def test_sample_state():
         np.testing.assert_equal(cirq.sample_state_vector(state, [0]), [[False]])
 
 
-def test_sample_empty_state():
+def test_sample_empty_state() -> None:
     state = np.array([1.0])
     np.testing.assert_almost_equal(cirq.sample_state_vector(state, []), np.zeros(shape=(1, 0)))
 
 
-def test_sample_no_repetitions():
+def test_sample_no_repetitions() -> None:
     state = cirq.to_valid_state_vector(0, 3)
     np.testing.assert_almost_equal(
         cirq.sample_state_vector(state, [1], repetitions=0), np.zeros(shape=(0, 1))
@@ -125,7 +125,7 @@ def test_sample_no_repetitions():
     )
 
 
-def test_sample_state_repetitions():
+def test_sample_state_repetitions() -> None:
     for perm in itertools.permutations([0, 1, 2]):
         for x in range(8):
             state = cirq.to_valid_state_vector(x, 3)
@@ -135,7 +135,7 @@ def test_sample_state_repetitions():
             np.testing.assert_equal(result, expected)
 
 
-def test_sample_state_seed():
+def test_sample_state_seed() -> None:
     state = np.ones(2) / np.sqrt(2)
 
     samples = cirq.sample_state_vector(state, [0], repetitions=10, seed=1234)
@@ -151,20 +151,20 @@ def test_sample_state_seed():
     )
 
 
-def test_sample_state_negative_repetitions():
+def test_sample_state_negative_repetitions() -> None:
     state = cirq.to_valid_state_vector(0, 3)
     with pytest.raises(ValueError, match='-1'):
         cirq.sample_state_vector(state, [1], repetitions=-1)
 
 
-def test_sample_state_not_power_of_two():
+def test_sample_state_not_power_of_two() -> None:
     with pytest.raises(ValueError, match='3'):
         cirq.sample_state_vector(np.array([1, 0, 0]), [1])
     with pytest.raises(ValueError, match='5'):
         cirq.sample_state_vector(np.array([0, 1, 0, 0, 0]), [1])
 
 
-def test_sample_state_index_out_of_range():
+def test_sample_state_index_out_of_range() -> None:
     state = cirq.to_valid_state_vector(0, 3)
     with pytest.raises(IndexError, match='-2'):
         cirq.sample_state_vector(state, [-2])
@@ -172,12 +172,12 @@ def test_sample_state_index_out_of_range():
         cirq.sample_state_vector(state, [3])
 
 
-def test_sample_no_indices():
+def test_sample_no_indices() -> None:
     state = cirq.to_valid_state_vector(0, 3)
     np.testing.assert_almost_equal(cirq.sample_state_vector(state, []), np.zeros(shape=(1, 0)))
 
 
-def test_sample_no_indices_repetitions():
+def test_sample_no_indices_repetitions() -> None:
     state = cirq.to_valid_state_vector(0, 3)
     np.testing.assert_almost_equal(
         cirq.sample_state_vector(state, [], repetitions=2), np.zeros(shape=(2, 0))
@@ -185,7 +185,7 @@ def test_sample_no_indices_repetitions():
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_computational_basis(use_np_transpose: bool):
+def test_measure_state_computational_basis(use_np_transpose: bool) -> None:
     # verify patching of can_numpy_support_shape in the use_np_transpose fixture
     assert linalg.can_numpy_support_shape([1]) is use_np_transpose
     results = []
@@ -199,7 +199,7 @@ def test_measure_state_computational_basis(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_reshape(use_np_transpose: bool):
+def test_measure_state_reshape(use_np_transpose: bool) -> None:
     results = []
     for x in range(8):
         initial_state = np.reshape(cirq.to_valid_state_vector(x, 3), [2] * 3)
@@ -211,7 +211,7 @@ def test_measure_state_reshape(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_partial_indices(use_np_transpose: bool):
+def test_measure_state_partial_indices(use_np_transpose: bool) -> None:
     for index in range(3):
         for x in range(8):
             initial_state = cirq.to_valid_state_vector(x, 3)
@@ -221,7 +221,7 @@ def test_measure_state_partial_indices(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_partial_indices_order(use_np_transpose: bool):
+def test_measure_state_partial_indices_order(use_np_transpose: bool) -> None:
     for x in range(8):
         initial_state = cirq.to_valid_state_vector(x, 3)
         bits, state = cirq.measure_state_vector(initial_state, [2, 1])
@@ -230,7 +230,7 @@ def test_measure_state_partial_indices_order(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_partial_indices_all_orders(use_np_transpose: bool):
+def test_measure_state_partial_indices_all_orders(use_np_transpose: bool) -> None:
     for perm in itertools.permutations([0, 1, 2]):
         for x in range(8):
             initial_state = cirq.to_valid_state_vector(x, 3)
@@ -240,7 +240,7 @@ def test_measure_state_partial_indices_all_orders(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_collapse(use_np_transpose: bool):
+def test_measure_state_collapse(use_np_transpose: bool) -> None:
     initial_state = np.zeros(8, dtype=np.complex64)
     initial_state[0] = 1 / np.sqrt(2)
     initial_state[2] = 1 / np.sqrt(2)
@@ -264,7 +264,7 @@ def test_measure_state_collapse(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_seed(use_np_transpose: bool):
+def test_measure_state_seed(use_np_transpose: bool) -> None:
     n = 10
     initial_state = np.ones(2**n) / 2 ** (n / 2)
 
@@ -284,7 +284,7 @@ def test_measure_state_seed(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_out_is_state(use_np_transpose: bool):
+def test_measure_state_out_is_state(use_np_transpose: bool) -> None:
     initial_state = np.zeros(8, dtype=np.complex64)
     initial_state[0] = 1 / np.sqrt(2)
     initial_state[2] = 1 / np.sqrt(2)
@@ -296,7 +296,7 @@ def test_measure_state_out_is_state(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_out_is_not_state(use_np_transpose: bool):
+def test_measure_state_out_is_not_state(use_np_transpose: bool) -> None:
     initial_state = np.zeros(8, dtype=np.complex64)
     initial_state[0] = 1 / np.sqrt(2)
     initial_state[2] = 1 / np.sqrt(2)
@@ -307,7 +307,7 @@ def test_measure_state_out_is_not_state(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_not_power_of_two(use_np_transpose: bool):
+def test_measure_state_not_power_of_two(use_np_transpose: bool) -> None:
     with pytest.raises(ValueError, match='3'):
         _, _ = cirq.measure_state_vector(np.array([1, 0, 0]), [1])
     with pytest.raises(ValueError, match='5'):
@@ -315,7 +315,7 @@ def test_measure_state_not_power_of_two(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_index_out_of_range(use_np_transpose: bool):
+def test_measure_state_index_out_of_range(use_np_transpose: bool) -> None:
     state = cirq.to_valid_state_vector(0, 3)
     with pytest.raises(IndexError, match='-2'):
         cirq.measure_state_vector(state, [-2])
@@ -324,7 +324,7 @@ def test_measure_state_index_out_of_range(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_no_indices(use_np_transpose: bool):
+def test_measure_state_no_indices(use_np_transpose: bool) -> None:
     initial_state = cirq.to_valid_state_vector(0, 3)
     bits, state = cirq.measure_state_vector(initial_state, [])
     assert [] == bits
@@ -332,7 +332,7 @@ def test_measure_state_no_indices(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_no_indices_out_is_state(use_np_transpose: bool):
+def test_measure_state_no_indices_out_is_state(use_np_transpose: bool) -> None:
     initial_state = cirq.to_valid_state_vector(0, 3)
     bits, state = cirq.measure_state_vector(initial_state, [], out=initial_state)
     assert [] == bits
@@ -341,7 +341,7 @@ def test_measure_state_no_indices_out_is_state(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_no_indices_out_is_not_state(use_np_transpose: bool):
+def test_measure_state_no_indices_out_is_not_state(use_np_transpose: bool) -> None:
     initial_state = cirq.to_valid_state_vector(0, 3)
     out = np.zeros_like(initial_state)
     bits, state = cirq.measure_state_vector(initial_state, [], out=out)
@@ -352,7 +352,7 @@ def test_measure_state_no_indices_out_is_not_state(use_np_transpose: bool):
 
 
 @pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
-def test_measure_state_empty_state(use_np_transpose: bool):
+def test_measure_state_empty_state(use_np_transpose: bool) -> None:
     initial_state = np.array([1.0])
     bits, state = cirq.measure_state_vector(initial_state, [])
     assert [] == bits
@@ -364,12 +364,12 @@ class BasicStateVector(cirq.StateVectorMixin):
         return np.array([0, 1, 0, 0])
 
 
-def test_step_result_pretty_state():
+def test_step_result_pretty_state() -> None:
     step_result = BasicStateVector()
     assert step_result.dirac_notation() == '|01⟩'
 
 
-def test_step_result_density_matrix():
+def test_step_result_density_matrix() -> None:
     q0, q1 = cirq.LineQubit.range(2)
 
     step_result = BasicStateVector({q0: 0, q1: 1})
@@ -385,7 +385,7 @@ def test_step_result_density_matrix():
     np.testing.assert_array_almost_equal(single_rho, step_result.density_matrix_of([q1]))
 
 
-def test_step_result_density_matrix_invalid():
+def test_step_result_density_matrix_invalid() -> None:
     q0, q1 = cirq.LineQubit.range(2)
 
     step_result = BasicStateVector({q0: 0})
@@ -393,12 +393,12 @@ def test_step_result_density_matrix_invalid():
     with pytest.raises(KeyError):
         step_result.density_matrix_of([q1])
     with pytest.raises(KeyError):
-        step_result.density_matrix_of('junk')
+        step_result.density_matrix_of('junk')  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        step_result.density_matrix_of(0)
+        step_result.density_matrix_of(0)  # type: ignore[arg-type]
 
 
-def test_step_result_bloch_vector():
+def test_step_result_bloch_vector() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     step_result = BasicStateVector({q0: 0, q1: 1})
     bloch1 = np.array([0, 0, -1])
@@ -409,7 +409,7 @@ def test_step_result_bloch_vector():
         step_result.bloch_vector_of(cirq.LineQubit(2))
 
 
-def test_factor_validation():
+def test_factor_validation() -> None:
     args = cirq.Simulator()._create_simulation_state(0, qubits=cirq.LineQubit.range(2))
     args.apply_operation(cirq.H(cirq.LineQubit(0)) ** 0.7)
     t = args.create_merged_state().target_tensor

cirq/study/result_test.py

@@ -25,12 +25,12 @@ import cirq.testing
 from cirq.study.result import _pack_digits
 
 
-def test_result_init():
+def test_result_init() -> None:
     assert cirq.ResultDict(params=cirq.ParamResolver({}), measurements=None).repetitions == 0
     assert cirq.ResultDict(params=cirq.ParamResolver({}), measurements={}).repetitions == 0
 
 
-def test_default_repetitions():
+def test_default_repetitions() -> None:
     class MyResult(cirq.Result):
         def __init__(self, records):
             self._records = records
@@ -55,7 +55,7 @@ def test_default_repetitions():
     assert MyResult({'a': np.zeros((5, 2, 3))}).repetitions == 5
 
 
-def test_repr():
+def test_repr() -> None:
     v = cirq.ResultDict(
         params=cirq.ParamResolver({'a': 2}), measurements={'xy': np.array([[1, 0], [0, 1]])}
     )
@@ -68,7 +68,7 @@ def test_repr():
     cirq.testing.assert_equivalent_repr(v)
 
 
-def test_construct_from_measurements():
+def test_construct_from_measurements() -> None:
     r = cirq.ResultDict(
         params=None,
         measurements={'a': np.array([[0, 0], [1, 1]]), 'b': np.array([[0, 0, 0], [1, 1, 1]])},
@@ -79,7 +79,7 @@ def test_construct_from_measurements():
     assert np.all(r.records['b'] == np.array([[[0, 0, 0]], [[1, 1, 1]]]))
 
 
-def test_construct_from_repeated_measurements():
+def test_construct_from_repeated_measurements() -> None:
     r = cirq.ResultDict(
         params=None,
         records={
@@ -104,13 +104,13 @@ def test_construct_from_repeated_measurements():
     assert r2.repetitions == 2
 
 
-def test_empty_measurements():
+def test_empty_measurements() -> None:
     assert cirq.ResultDict(params=None).repetitions == 0
     assert cirq.ResultDict(params=None, measurements={}).repetitions == 0
     assert cirq.ResultDict(params=None, records={}).repetitions == 0
 
 
-def test_str():
+def test_str() -> None:
     result = cirq.ResultDict(
         params=cirq.ParamResolver({}),
         measurements={
@@ -136,7 +136,7 @@ def test_str():
     assert str(result) == 'c=1, 0\nc=0, 1'
 
 
-def test_df():
+def test_df() -> None:
     result = cirq.ResultDict(
         params=cirq.ParamResolver({}),
         measurements={
@@ -156,7 +156,7 @@ def test_df():
     assert df.c.value_counts().to_dict() == {0: 3, 1: 2}
 
 
-def test_df_large():
+def test_df_large() -> None:
     result = cirq.ResultDict(
         params=cirq.ParamResolver({}),
         measurements={
@@ -171,7 +171,7 @@ def test_df_large():
     assert result.data['d'].dtype == object
 
 
-def test_histogram():
+def test_histogram() -> None:
     result = cirq.ResultDict(
         params=cirq.ParamResolver({}),
         measurements={
@@ -188,7 +188,7 @@ def test_histogram():
     assert result.histogram(key='c') == collections.Counter({0: 3, 1: 2})
 
 
-def test_multi_measurement_histogram():
+def test_multi_measurement_histogram() -> None:
     result = cirq.ResultDict(
         params=cirq.ParamResolver({}),
         measurements={
@@ -222,7 +222,7 @@ def test_multi_measurement_histogram():
     )
 
 
-def test_result_equality():
+def test_result_equality() -> None:
     et = cirq.testing.EqualsTester()
     et.add_equality_group(
         cirq.ResultDict(params=cirq.ParamResolver({}), measurements={'a': np.array([[0]] * 5)}),
@@ -239,7 +239,7 @@ def test_result_equality():
     )
 
 
-def test_result_addition_valid():
+def test_result_addition_valid() -> None:
     a = cirq.ResultDict(
         params=cirq.ParamResolver({'ax': 1}),
         measurements={
@@ -278,7 +278,7 @@ def test_result_addition_valid():
     )
 
 
-def test_result_addition_invalid():
+def test_result_addition_invalid() -> None:
     a = cirq.ResultDict(
         params=cirq.ParamResolver({'ax': 1}),
         measurements={
@@ -324,10 +324,10 @@ def test_result_addition_invalid():
     with pytest.raises(ValueError, match='different measurement shapes'):
         _ = a + e
     with pytest.raises(TypeError):
-        _ = a + 'junk'
+        _ = a + 'junk'  # type: ignore[operator]
 
 
-def test_qubit_keys_for_histogram():
+def test_qubit_keys_for_histogram() -> None:
     a, b, c = cirq.LineQubit.range(3)
     circuit = cirq.Circuit(cirq.measure(a, b), cirq.X(c), cirq.measure(c))
     results = cirq.Simulator().run(program=circuit, repetitions=100)
@@ -339,7 +339,7 @@ def test_qubit_keys_for_histogram():
     assert results.histogram(key=[c]) == collections.Counter({1: 100})
 
 
-def test_text_diagram_jupyter():
+def test_text_diagram_jupyter() -> None:
     result = cirq.ResultDict(
         params=cirq.ParamResolver({}),
         measurements={
@@ -397,12 +397,12 @@ def test_json_bit_packing_and_dtype(use_records: bool) -> None:
     np.testing.assert_allclose(len(bits_json), len(digits_json) / 8, rtol=0.02)
 
 
-def test_json_bit_packing_error():
+def test_json_bit_packing_error() -> None:
     with pytest.raises(ValueError):
         _pack_digits(np.ones(10), pack_bits='hi mom')
 
 
-def test_json_bit_packing_force():
+def test_json_bit_packing_force() -> None:
     assert _pack_digits(np.ones(10, dtype=int), pack_bits='force') == _pack_digits(
         np.ones(10), pack_bits='auto'
     )
@@ -418,7 +418,7 @@ def test_json_bit_packing_force():
     )
 
 
-def test_json_unpack_compat():
+def test_json_unpack_compat() -> None:
     """Test reading old json with serialized measurements array."""
     old_json = """
         {