cirq-core 1.6.0.dev20250515174529__py3-none-any.whl → 1.6.0.dev20250516154249__py3-none-any.whl

cirq/value/timestamp_test.py

@@ -20,7 +20,7 @@ import cirq
 from cirq import Duration, Timestamp
 
 
-def test_init():
+def test_init() -> None:
     assert Timestamp().raw_picos() == 0
     assert Timestamp(picos=513).raw_picos() == 513
     assert Timestamp(picos=-5).raw_picos() == -5
@@ -33,13 +33,13 @@ def test_init():
     assert isinstance(Timestamp(nanos=1.0).raw_picos(), float)
 
 
-def test_str():
+def test_str() -> None:
     assert str(Timestamp(picos=1000, nanos=1000)) == 't=1001000'
     assert str(Timestamp(nanos=5.0)) == 't=5000.0'
     assert str(Timestamp(picos=-100)) == 't=-100'
 
 
-def test_repr():
+def test_repr() -> None:
     a = Timestamp(picos=1000, nanos=1000)
     cirq.testing.assert_equivalent_repr(a)
     b = Timestamp(nanos=5.0)
@@ -48,14 +48,14 @@ def test_repr():
     cirq.testing.assert_equivalent_repr(c)
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(Timestamp(), Timestamp(picos=0), Timestamp(nanos=0.0))
     eq.add_equality_group(Timestamp(picos=1000), Timestamp(nanos=1))
     eq.make_equality_group(lambda: Timestamp(picos=-1))
 
 
-def test_cmp():
+def test_cmp() -> None:
     ordered_groups = [
         Timestamp(picos=-1),
         Timestamp(),
@@ -81,7 +81,7 @@ def test_cmp():
     assert Timestamp() != Duration()
 
 
-def test_cmp_vs_other_type():
+def test_cmp_vs_other_type() -> None:
     with pytest.raises(TypeError):
         _ = Timestamp() < Duration()
     with pytest.raises(TypeError):
@@ -94,7 +94,7 @@ def test_cmp_vs_other_type():
         _ = Timestamp() > 0
 
 
-def test_add():
+def test_add() -> None:
     assert Timestamp(picos=1) + Duration(picos=2) == Timestamp(picos=3)
     assert Duration(picos=3) + Timestamp(picos=-5) == Timestamp(picos=-2)
 
@@ -109,7 +109,7 @@ def test_add():
         _ = Timestamp() + 1
 
 
-def test_sub():
+def test_sub() -> None:
     assert Timestamp() - Timestamp() == Duration()
     assert Timestamp(picos=1) - Timestamp(picos=2) == Duration(picos=-1)
     assert Timestamp(picos=5) - Duration(picos=2) == Timestamp(picos=3)
@@ -118,6 +118,6 @@ def test_sub():
     with pytest.raises(TypeError):
         _ = Duration() - Timestamp()
     with pytest.raises(TypeError):
-        _ = 1 - Timestamp()
+        _ = 1 - Timestamp()  # type: ignore[operator]
     with pytest.raises(TypeError):
-        _ = Timestamp() - 1
+        _ = Timestamp() - 1  # type: ignore[operator]

cirq/vis/density_matrix_test.py

@@ -24,7 +24,7 @@ from cirq.vis.density_matrix import _plot_element_of_density_matrix, plot_densit
 @pytest.mark.usefixtures('closefigures')
 @pytest.mark.parametrize('show_text', [True, False])
 @pytest.mark.parametrize('size', [2, 4, 8, 16])
-def test_density_matrix_plotter(size, show_text):
+def test_density_matrix_plotter(size, show_text) -> None:
     matrix = cirq.testing.random_density_matrix(size)
     # Check that the title shows back up
     ax = plot_density_matrix(matrix, show_text=show_text, title='Test Density Matrix Plot')
@@ -48,16 +48,16 @@ def test_density_matrix_plotter(size, show_text):
 @pytest.mark.usefixtures('closefigures')
 @pytest.mark.parametrize('show_text', [True, False])
 @pytest.mark.parametrize('size', [2, 4, 8, 16])
-def test_density_matrix_circle_rectangle_sizes(size, show_text):
+def test_density_matrix_circle_rectangle_sizes(size, show_text) -> None:
     matrix = cirq.testing.random_density_matrix(size)
     ax = plot_density_matrix(matrix, show_text=show_text, title='Test Density Matrix Plot')
     # Check that the radius of all the circles in the matrix is correct
-    circles = [c for c in ax.get_children() if isinstance(c, patches.Circle)]
-    mean_radius = np.mean([c.radius for c in circles if c.fill])
+    circle_list = [c for c in ax.get_children() if isinstance(c, patches.Circle)]
+    mean_radius = np.mean([c.radius for c in circle_list if c.fill])
     mean_value = np.mean(np.abs(matrix))
-    circles = np.array(sorted(circles, key=lambda x: (x.fill, x.center[0], -x.center[1]))).reshape(
-        (2, size, size)
-    )
+    circles = np.array(
+        sorted(circle_list, key=lambda x: (x.fill, x.center[0], -x.center[1]))
+    ).reshape((2, size, size))
     for i in range(size):
         for j in range(size):
             assert np.isclose(
@@ -65,15 +65,15 @@ def test_density_matrix_circle_rectangle_sizes(size, show_text):
             )
 
     # Check that all the rectangles are of the right height, and only on the diagonal elements
-    rects = [
+    rect_list = [
         r
         for r in ax.get_children()
         if isinstance(r, patches.Rectangle) and r.get_alpha() is not None
     ]
-    assert len(rects) == size
-    mean_size = np.mean([r.get_height() for r in rects])
+    assert len(rect_list) == size
+    mean_size = np.mean([r.get_height() for r in rect_list])
     mean_value = np.trace(np.abs(matrix)) / size
-    rects = np.array(sorted(rects, key=lambda x: x.get_x()))
+    rects = np.array(sorted(rect_list, key=lambda x: x.get_x()))
     for i in range(size):
         # Ensuring that the rectangle is the right height
         assert np.isclose(np.abs(matrix[i, i]) * mean_size / mean_value, rects[i].get_height())
@@ -90,7 +90,7 @@ def test_density_matrix_circle_rectangle_sizes(size, show_text):
 @pytest.mark.usefixtures('closefigures')
 @pytest.mark.parametrize('show_text', [True, False])
 @pytest.mark.parametrize('size', [2, 4, 8, 16])
-def test_density_matrix_sizes_upper_bounds(size, show_text):
+def test_density_matrix_sizes_upper_bounds(size, show_text) -> None:
     matrix = cirq.testing.random_density_matrix(size)
     ax = plot_density_matrix(matrix, show_text=show_text, title='Test Density Matrix Plot')
 
@@ -113,7 +113,7 @@ def test_density_matrix_sizes_upper_bounds(size, show_text):
 @pytest.mark.usefixtures('closefigures')
 @pytest.mark.parametrize('show_rect', [True, False])
 @pytest.mark.parametrize('value', [0.0, 1.0, 0.5 + 0.3j, 0.2 + 0.1j, 0.5 + 0.5j])
-def test_density_element_plot(value, show_rect):
+def test_density_element_plot(value, show_rect) -> None:
     _, ax = plt.subplots(figsize=(10, 10))
     _plot_element_of_density_matrix(
         ax, 0, 0, np.abs(value), np.angle(value), show_rect=False, show_text=False
@@ -122,9 +122,9 @@ def test_density_element_plot(value, show_rect):
     plotted_lines = [c for c in ax.get_children() if isinstance(c, lines.Line2D)]
     assert len(plotted_lines) == 1
     line_position = plotted_lines[0].get_xydata()
-    angle = np.arctan(
-        (line_position[1, 1] - line_position[0, 1]) / (line_position[1, 0] - line_position[0, 0])
-    )
+    numerator = line_position[1, 1] - line_position[0, 1]  # type: ignore
+    denumerator = line_position[1, 0] - line_position[0, 0]  # type: ignore
+    angle = np.arctan(numerator / denumerator)
     assert np.isclose(np.angle(value), angle)
     # Check if the circles are the right size ratio, given the value of the element
     circles_in = [c for c in ax.get_children() if isinstance(c, patches.Circle) and c.fill]
@@ -151,6 +151,6 @@ def test_density_element_plot(value, show_rect):
         np.random.random((4, 8)) * np.exp(np.random.random((4, 8)) * 2 * np.pi * 1j),
     ],
 )
-def test_density_matrix_type_error(matrix):
+def test_density_matrix_type_error(matrix) -> None:
     with pytest.raises(ValueError, match="Incorrect shape for density matrix:*"):
         plot_density_matrix(matrix)

cirq/work/collector_test.py

@@ -18,7 +18,7 @@ import pytest
 import cirq
 
 
-def test_circuit_sample_job_equality():
+def test_circuit_sample_job_equality() -> None:
     eq = cirq.testing.EqualsTester()
     c1 = cirq.Circuit()
     c2 = cirq.Circuit(cirq.measure(cirq.LineQubit(0)))
@@ -32,14 +32,14 @@ def test_circuit_sample_job_equality():
     eq.add_equality_group(cirq.CircuitSampleJob(c1, repetitions=10, tag='test'))
 
 
-def test_circuit_sample_job_repr():
+def test_circuit_sample_job_repr() -> None:
     cirq.testing.assert_equivalent_repr(
         cirq.CircuitSampleJob(cirq.Circuit(cirq.H(cirq.LineQubit(0))), repetitions=10, tag='guess')
     )
 
 
 @duet.sync
-async def test_async_collect():
+async def test_async_collect() -> None:
     received = []
 
     class TestCollector(cirq.Collector):
@@ -51,14 +51,13 @@ async def test_async_collect():
         def on_job_result(self, job, result):
             received.append(job.tag)
 
-    result = await TestCollector().collect_async(
+    await TestCollector().collect_async(
         sampler=cirq.Simulator(), max_total_samples=100, concurrency=5
     )
-    assert result is None
     assert received == ['test'] * 10
 
 
-def test_collect():
+def test_collect() -> None:
     received = []
 
     class TestCollector(cirq.Collector):
@@ -74,7 +73,7 @@ def test_collect():
     assert received == ['test'] * 10
 
 
-def test_failed_job():
+def test_failed_job() -> None:
     class FailingSampler:
         async def run_async(self, circuit, repetitions):
             await duet.completed_future(None)
@@ -90,10 +89,14 @@ def test_failed_job():
             pass
 
     with pytest.raises(Exception, match='job failed!'):
-        TestCollector().collect(sampler=FailingSampler(), max_total_samples=100, concurrency=5)
+        TestCollector().collect(
+            sampler=FailingSampler(),  # type:ignore
+            max_total_samples=100,
+            concurrency=5,
+        )
 
 
-def test_collect_with_reaction():
+def test_collect_with_reaction() -> None:
     events = [0]
     sent = 0
     received = 0
@@ -123,7 +126,7 @@ def test_collect_with_reaction():
     assert all(events.index(-k) > events.index(k) for k in range(1, 11))
 
 
-def test_flatten_jobs_terminate_from_collector():
+def test_flatten_jobs_terminate_from_collector() -> None:
     sent = False
     received = []
 

cirq/work/observable_measurement.py

@@ -20,7 +20,19 @@ import itertools
 import os
 import tempfile
 import warnings
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
+from typing import (
+    Any,
+    Dict,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    TYPE_CHECKING,
+    Union,
+)
 
 import numpy as np
 import pandas as pd
@@ -246,7 +258,7 @@ def _aggregate_n_repetitions(next_chunk_repetitions: Set[int]) -> int:
 
 def _check_meas_specs_still_todo(
     meas_specs: List[_MeasurementSpec],
-    accumulators: Dict[_MeasurementSpec, BitstringAccumulator],
+    accumulators: Mapping[_MeasurementSpec, BitstringAccumulator],
     stopping_criteria: StoppingCriteria,
 ) -> Tuple[List[_MeasurementSpec], int]:
     """Filter `meas_specs` in case some are done.

cirq/work/observable_measurement_data.py

@@ -45,7 +45,7 @@ def _check_and_get_real_coef(observable: cirq.PauliString, atol: float):
 
 def _obs_vals_from_measurements(
     bitstrings: np.ndarray,
-    qubit_to_index: Dict[cirq.Qid, int],
+    qubit_to_index: Mapping[cirq.Qid, int],
     observable: cirq.PauliString,
     atol: float,
 ):
@@ -63,7 +63,7 @@ def _obs_vals_from_measurements(
 
 def _stats_from_measurements(
     bitstrings: np.ndarray,
-    qubit_to_index: Dict[cirq.Qid, int],
+    qubit_to_index: Mapping[cirq.Qid, int],
     observable: cirq.PauliString,
     atol: float,
 ) -> Tuple[float, float]:
@@ -216,7 +216,7 @@ class BitstringAccumulator:
         self,
         meas_spec: _MeasurementSpec,
         simul_settings: List[InitObsSetting],
-        qubit_to_index: Dict[cirq.Qid, int],
+        qubit_to_index: Mapping[cirq.Qid, int],
         bitstrings: Optional[np.ndarray] = None,
         chunksizes: Optional[np.ndarray] = None,
         timestamps: Optional[np.ndarray] = None,

cirq/work/observable_measurement_test.py

@@ -16,6 +16,7 @@ from typing import Dict, Iterable, List
 
 import numpy as np
 import pytest
+import sympy
 
 import cirq
 import cirq.work as cw
@@ -37,7 +38,7 @@ from cirq.work.observable_measurement import (
 )
 
 
-def test_with_parameterized_layers():
+def test_with_parameterized_layers() -> None:
     qs = cirq.LineQubit.range(3)
     circuit = cirq.Circuit([cirq.H.on_each(*qs), cirq.CZ(qs[0], qs[1]), cirq.CZ(qs[1], qs[2])])
     circuit2 = _with_parameterized_layers(circuit, qubits=qs, needs_init_layer=False)
@@ -46,9 +47,11 @@ def test_with_parameterized_layers():
     *_, xlayer, ylayer, measurelayer = circuit2.moments
     for op in xlayer.operations:
         assert isinstance(op.gate, cirq.XPowGate)
+        assert isinstance(op.gate.exponent, sympy.Symbol)
         assert op.gate.exponent.name.endswith('-Xf')
     for op in ylayer.operations:
         assert isinstance(op.gate, cirq.YPowGate)
+        assert isinstance(op.gate.exponent, sympy.Symbol)
         assert op.gate.exponent.name.endswith('-Yf')
     for op in measurelayer:
         assert isinstance(op.gate, cirq.MeasurementGate)
@@ -60,13 +63,15 @@ def test_with_parameterized_layers():
     xlayer, ylayer, *_ = circuit3.moments
     for op in xlayer.operations:
         assert isinstance(op.gate, cirq.XPowGate)
+        assert isinstance(op.gate.exponent, sympy.Symbol)
         assert op.gate.exponent.name.endswith('-Xi')
     for op in ylayer.operations:
         assert isinstance(op.gate, cirq.YPowGate)
+        assert isinstance(op.gate.exponent, sympy.Symbol)
         assert op.gate.exponent.name.endswith('-Yi')
 
 
-def test_get_params_for_setting():
+def test_get_params_for_setting() -> None:
     qubits = cirq.LineQubit.range(3)
     a, b, c = qubits
 
@@ -82,10 +87,10 @@ def test_get_params_for_setting():
     needs_init_layer = True
     with pytest.raises(ValueError):
         _get_params_for_setting(
-            padded_setting, flips=[0, 0], qubits=qubits, needs_init_layer=needs_init_layer
+            padded_setting, flips=[False, False], qubits=qubits, needs_init_layer=needs_init_layer
         )
     params = _get_params_for_setting(
-        padded_setting, flips=[0, 0, 1], qubits=qubits, needs_init_layer=needs_init_layer
+        padded_setting, flips=[False, False, True], qubits=qubits, needs_init_layer=needs_init_layer
     )
     assert all(
         x in params
@@ -116,7 +121,7 @@ def test_get_params_for_setting():
     np.testing.assert_allclose([ma, mb, mc], [1, 0, -1])
 
 
-def test_params_and_settings():
+def test_params_and_settings() -> None:
     qubits = cirq.LineQubit.range(1)
     (q,) = qubits
     tests = [
@@ -143,7 +148,7 @@ def test_params_and_settings():
         assert np.abs(coef - z) < 1e-2, f'{init} {obs} {coef}'
 
 
-def test_subdivide_meas_specs():
+def test_subdivide_meas_specs() -> None:
     qubits = cirq.LineQubit.range(2)
     q0, q1 = qubits
     setting = cw.InitObsSetting(
@@ -177,7 +182,7 @@ def test_subdivide_meas_specs():
     ]
 
 
-def test_aggregate_n_repetitions():
+def test_aggregate_n_repetitions() -> None:
     with pytest.warns(UserWarning):
         reps = _aggregate_n_repetitions({5, 6})
     assert reps == 6
@@ -197,7 +202,7 @@ class _MockBitstringAccumulator(BitstringAccumulator):
         return cov / len(self.bitstrings)
 
 
-def test_variance_stopping_criteria():
+def test_variance_stopping_criteria() -> None:
     stop = cw.VarianceStoppingCriteria(variance_bound=1e-6)
     acc = _MockBitstringAccumulator()
     assert stop.more_repetitions(acc) == 10_000
@@ -222,22 +227,30 @@ class _WildVarianceStoppingCriteria(StoppingCriteria):
         return [5, 6][self._state % 2]
 
 
-def test_variance_stopping_criteria_aggregate_n_repetitions():
+def test_variance_stopping_criteria_aggregate_n_repetitions() -> None:
+    q0, q1 = cirq.LineQubit.range(2)
     stop = _WildVarianceStoppingCriteria()
     acc1 = _MockBitstringAccumulator()
     acc2 = _MockBitstringAccumulator()
-    accumulators = {'FakeMeasSpec1': acc1, 'FakeMeasSpec2': acc2}
+    setting = InitObsSetting(
+        init_state=cirq.KET_ZERO(q0) * cirq.KET_ZERO(q1), observable=cirq.X(q0) * cirq.Y(q1)
+    )
+    meas_spec = _MeasurementSpec(
+        max_setting=setting, circuit_params={'beta': 0.123, 'gamma': 0.456}
+    )
+    meas_spec2 = _MeasurementSpec(
+        max_setting=setting, circuit_params={'beta': 0.123, 'gamma': 0.456}
+    )
+    accumulators = {meas_spec: acc1, meas_spec2: acc2}
     with pytest.warns(UserWarning, match='the largest value will be used: 6.'):
         still_todo, reps = _check_meas_specs_still_todo(
-            meas_specs=sorted(accumulators.keys()),
-            accumulators=accumulators,
-            stopping_criteria=stop,
+            meas_specs=[meas_spec, meas_spec2], accumulators=accumulators, stopping_criteria=stop
         )
-    assert still_todo == ['FakeMeasSpec1', 'FakeMeasSpec2']
+    assert still_todo == [meas_spec, meas_spec2]
     assert reps == 6
 
 
-def test_repetitions_stopping_criteria():
+def test_repetitions_stopping_criteria() -> None:
     stop = cw.RepetitionsStoppingCriteria(total_repetitions=50_000)
     acc = _MockBitstringAccumulator()
 
@@ -248,7 +261,7 @@ def test_repetitions_stopping_criteria():
     assert todos == [10_000] * 5 + [0, 0]
 
 
-def test_repetitions_stopping_criteria_partial():
+def test_repetitions_stopping_criteria_partial() -> None:
     stop = cw.RepetitionsStoppingCriteria(total_repetitions=5_000, repetitions_per_chunk=1_000_000)
     acc = _MockBitstringAccumulator()
     assert stop.more_repetitions(acc) == 5_000
@@ -268,7 +281,7 @@ def _set_up_meas_specs_for_testing():
     return bsa, meas_spec
 
 
-def test_meas_specs_still_todo():
+def test_meas_specs_still_todo() -> None:
     bsa, meas_spec = _set_up_meas_specs_for_testing()
     stop = cw.RepetitionsStoppingCriteria(1_000)
 
@@ -296,7 +309,7 @@ def test_meas_specs_still_todo():
     assert reps == 0
 
 
-def test_meas_spec_still_todo_bad_spec():
+def test_meas_spec_still_todo_bad_spec() -> None:
     bsa, meas_spec = _set_up_meas_specs_for_testing()
 
     class BadStopping(StoppingCriteria):
@@ -310,7 +323,7 @@ def test_meas_spec_still_todo_bad_spec():
         )
 
 
-def test_meas_spec_still_todo_too_many_params(monkeypatch):
+def test_meas_spec_still_todo_too_many_params(monkeypatch) -> None:
     monkeypatch.setattr(cw.observable_measurement, 'MAX_REPETITIONS_PER_JOB', 30_000)
     bsa, meas_spec = _set_up_meas_specs_for_testing()
     lots_of_meas_spec = [meas_spec] * 3_001
@@ -321,7 +334,7 @@ def test_meas_spec_still_todo_too_many_params(monkeypatch):
         )
 
 
-def test_meas_spec_still_todo_lots_of_params(monkeypatch):
+def test_meas_spec_still_todo_lots_of_params(monkeypatch) -> None:
     monkeypatch.setattr(cw.observable_measurement, 'MAX_REPETITIONS_PER_JOB', 30_000)
     bsa, meas_spec = _set_up_meas_specs_for_testing()
     lots_of_meas_spec = [meas_spec] * 4
@@ -332,7 +345,7 @@ def test_meas_spec_still_todo_lots_of_params(monkeypatch):
         )
 
 
-def test_checkpoint_options():
+def test_checkpoint_options() -> None:
     # There are three ~binary options (the latter two can be either specified or `None`. We
     # test those 2^3 cases.
 
@@ -345,12 +358,15 @@ def test_checkpoint_options():
         _parse_checkpoint_options(False, 'test1', 'test2')
 
     chk, chkprev = _parse_checkpoint_options(True, None, None)
+    assert chk is not None
+    assert chkprev is not None
     assert chk.startswith(tempfile.gettempdir())
     assert chk.endswith('observables.json')
     assert chkprev.startswith(tempfile.gettempdir())
     assert chkprev.endswith('observables.prev.json')
 
     chk, chkprev = _parse_checkpoint_options(True, None, 'prev.json')
+    assert chk is not None
     assert chk.startswith(tempfile.gettempdir())
     assert chk.endswith('observables.json')
     assert chkprev == 'prev.json'
@@ -381,7 +397,7 @@ def test_checkpoint_options():
 
 
 @pytest.mark.parametrize(('with_circuit_sweep', 'checkpoint'), [(True, True), (False, False)])
-def test_measure_grouped_settings(with_circuit_sweep, checkpoint, tmpdir):
+def test_measure_grouped_settings(with_circuit_sweep, checkpoint, tmpdir) -> None:
     qubits = cirq.LineQubit.range(1)
     (q,) = qubits
     tests = [
@@ -431,7 +447,7 @@ def _get_some_grouped_settings():
     return grouped_settings, qubits
 
 
-def test_measure_grouped_settings_calibration_validation():
+def test_measure_grouped_settings_calibration_validation() -> None:
     mock_ro_calib = _MockBitstringAccumulator()
     grouped_settings, qubits = _get_some_grouped_settings()
 
@@ -448,7 +464,7 @@ def test_measure_grouped_settings_calibration_validation():
         )
 
 
-def test_measure_grouped_settings_read_checkpoint(tmpdir):
+def test_measure_grouped_settings_read_checkpoint(tmpdir) -> None:
     qubits = cirq.LineQubit.range(1)
     (q,) = qubits
 
@@ -495,7 +511,7 @@ Q = cirq.NamedQubit('q')
         (cirq.Circuit(cirq.Y(Q) ** 0.5, cirq.Z(Q) ** 0.2), cirq.X(Q)),
     ],
 )
-def test_XYZ_point8(circuit, observable):
+def test_XYZ_point8(circuit, observable) -> None:
     # each circuit, observable combination should result in the observable value of 0.8
     df = measure_observables_df(
         circuit,
@@ -517,7 +533,7 @@ def _each_in_its_own_group_grouper(
 @pytest.mark.parametrize(
     'grouper', ['greedy', group_settings_greedy, _each_in_its_own_group_grouper]
 )
-def test_measure_observable_grouper(grouper):
+def test_measure_observable_grouper(grouper) -> None:
     circuit = cirq.Circuit(cirq.X(Q) ** 0.2)
     observables = [cirq.Z(Q), cirq.Z(cirq.NamedQubit('q2'))]
     results = measure_observables(
@@ -532,7 +548,7 @@ def test_measure_observable_grouper(grouper):
     np.testing.assert_allclose(1, results[1].mean, atol=1e-9)
 
 
-def test_measure_observable_bad_grouper():
+def test_measure_observable_bad_grouper() -> None:
     circuit = cirq.Circuit(cirq.X(Q) ** 0.2)
     observables = [cirq.Z(Q), cirq.Z(cirq.NamedQubit('q2'))]
     with pytest.raises(ValueError, match=r'Unknown grouping function'):

cirq/work/observable_settings.py

@@ -16,17 +16,7 @@ from __future__ import annotations
 
 import dataclasses
 import numbers
-from typing import (
-    AbstractSet,
-    Dict,
-    FrozenSet,
-    Iterable,
-    Mapping,
-    Optional,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Dict, FrozenSet, Iterable, Mapping, Optional, Tuple, TYPE_CHECKING, Union
 
 import sympy
 
@@ -156,7 +146,7 @@ def _fix_precision(val: Union[value.Scalar, sympy.Expr], precision) -> Union[int
 
 
 def _hashable_param(
-    param_tuples: AbstractSet[Tuple[Union[str, sympy.Expr], Union[value.Scalar, sympy.Expr]]],
+    param_tuples: Iterable[Tuple[Union[str, sympy.Expr], Union[value.Scalar, sympy.Expr]]],
     precision=1e7,
 ) -> FrozenSet[Tuple[str, Union[int, Tuple[int, int]]]]:
     """Hash circuit parameters using fixed precision.

cirq/work/observable_settings_test.py

@@ -20,7 +20,7 @@ from cirq.work import _MeasurementSpec, InitObsSetting, observables_to_settings
 from cirq.work.observable_settings import _hashable_param, _max_weight_observable, _max_weight_state
 
 
-def test_init_obs_setting():
+def test_init_obs_setting() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     setting = InitObsSetting(
         init_state=cirq.KET_ZERO(q0) * cirq.KET_ZERO(q1), observable=cirq.X(q0) * cirq.Y(q1)
@@ -32,7 +32,7 @@ def test_init_obs_setting():
         setting = InitObsSetting(init_state=cirq.KET_ZERO(q0), observable=cirq.X(q0) * cirq.Y(q1))
 
 
-def test_max_weight_observable():
+def test_max_weight_observable() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     observables = [cirq.X(q0), cirq.X(q1)]
     assert _max_weight_observable(observables) == cirq.X(q0) * cirq.X(q1)
@@ -41,7 +41,7 @@ def test_max_weight_observable():
     assert _max_weight_observable(observables) is None
 
 
-def test_max_weight_state():
+def test_max_weight_state() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     states = [cirq.KET_PLUS(q0), cirq.KET_PLUS(q1)]
     assert _max_weight_state(states) == cirq.KET_PLUS(q0) * cirq.KET_PLUS(q1)
@@ -50,7 +50,7 @@ def test_max_weight_state():
     assert _max_weight_state(states) is None
 
 
-def test_observable_to_setting():
+def test_observable_to_setting() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     observables = [cirq.X(q0) * cirq.Y(q1), cirq.Z(q2) * 1]
 
@@ -62,7 +62,7 @@ def test_observable_to_setting():
     assert list(observables_to_settings(observables, qubits=[q0, q1, q2])) == settings_should_be
 
 
-def test_param_hash():
+def test_param_hash() -> None:
     params1 = [('beta', 1.23), ('gamma', 4.56)]
     params2 = [('beta', 1.23), ('gamma', 4.56)]
     params3 = [('beta', 1.24), ('gamma', 4.57)]
@@ -81,7 +81,7 @@ def test_param_hash():
     assert hash(_hashable_param(params4)) == hash(_hashable_param(params5))
 
 
-def test_measurement_spec():
+def test_measurement_spec() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     setting = InitObsSetting(
         init_state=cirq.KET_ZERO(q0) * cirq.KET_ZERO(q1), observable=cirq.X(q0) * cirq.Y(q1)
@@ -96,7 +96,7 @@ def test_measurement_spec():
     cirq.testing.assert_equivalent_repr(meas_spec)
 
 
-def test_measurement_spec_no_symbols():
+def test_measurement_spec_no_symbols() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     setting = InitObsSetting(
         init_state=cirq.KET_ZERO(q0) * cirq.KET_ZERO(q1), observable=cirq.X(q0) * cirq.Y(q1)